Merge branch 'develop' into rlpx

alethzero/CMakeLists.txt

@@ -7,6 +7,11 @@ if (${CMAKE_MAJOR_VERSION} GREATER 2)
 	cmake_policy(SET CMP0043 OLD)
 endif()
 
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	# Supress warnings for qt headers for clang+ccache
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-inconsistent-missing-override")
+endif ()
+
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 aux_source_directory(. SRC_LIST)
 

alethzero/DownloadView.cpp

@@ -30,56 +30,176 @@ using namespace std;
 using namespace dev;
 using namespace dev::eth;
 
-DownloadView::DownloadView(QWidget* _p): QWidget(_p)
+SyncView::SyncView(QWidget* _p): QWidget(_p)
 {
 }
 
-void DownloadView::paintEvent(QPaintEvent*)
+void SyncView::paintEvent(QPaintEvent*)
 {
-	QPainter p(this);
+	QPainter painter(this);
+	painter.fillRect(rect(), Qt::white);
+	painter.setRenderHint(QPainter::Antialiasing, true);
+	painter.setRenderHint(QPainter::HighQualityAntialiasing, true);
 
-	p.fillRect(rect(), Qt::white);
-	if (!m_man || m_man->chainEmpty() || !m_man->subCount())
+	if (!m_client || !isVisible() || !rect().width() || !rect().height())
 		return;
 
-	double ratio = (double)rect().width() / rect().height();
-	if (ratio < 1)
-		ratio = 1 / ratio;
-	double n = min(16.0, min(rect().width(), rect().height()) / ceil(sqrt(m_man->chainSize() / ratio)));
+	DownloadMan const* man = m_client->downloadMan();
+	BlockQueueStatus bqs = m_client->blockQueueStatus();
+	SyncStatus sync = m_client->syncStatus();
 
-//	QSizeF area(rect().width() / floor(rect().width() / n), rect().height() / floor(rect().height() / n));
-	QSizeF area(n, n);
-	QPointF pos(0, 0);
+	unsigned syncFrom = m_client->numberFromHash(PendingBlockHash);
+	unsigned syncImported = syncFrom;
+	unsigned syncImporting = syncImported + bqs.importing;
+	unsigned syncVerified = syncImporting + bqs.verified;
+	unsigned syncVerifying = syncVerified + bqs.verifying;
+	unsigned syncUnverified = syncVerifying + bqs.unverified;
+	unsigned syncCount = syncUnverified + bqs.unknown - syncFrom;
 
-	auto bg = m_man->blocksGot();
-	unsigned subCount = m_man->subCount();
-	if (subCount == 0)
-		return;
-	unsigned dh = 360 / subCount;
-	for (unsigned i = bg.all().first, ei = bg.all().second; i < ei; ++i)
+	// best effort guess. assumes there's no forks.
+	unsigned downloadFrom = sync.state == SyncState::Idle ? m_lastSyncFrom : m_client->numberFromHash(m_client->isKnown(man->firstBlock()) ? man->firstBlock() : PendingBlockHash);
+	unsigned downloadCount = sync.state == SyncState::Idle ? m_lastSyncCount : sync.blocksTotal;
+	unsigned downloadDone = downloadFrom + (sync.state == SyncState::Idle ? m_lastSyncCount : sync.blocksReceived);
+	unsigned downloadPoint = downloadFrom + (sync.state == SyncState::Idle ? m_lastSyncCount : man->overview().lastComplete);
+
+	unsigned hashFrom = sync.state == SyncState::Hashes ? m_client->numberFromHash(PendingBlockHash) : downloadFrom;
+	unsigned hashCount = sync.state == SyncState::Hashes ? sync.hashesTotal : downloadCount;
+	unsigned hashDone = hashFrom + (sync.state == SyncState::Hashes ? sync.hashesReceived : hashCount);
+
+	QString labelText = QString("PV%1").arg(sync.protocolVersion);
+	QColor labelBack = QColor::fromHsv(sync.protocolVersion == 60 ? 30 : sync.protocolVersion == 61 ? 120 : 240, 25, 200);
+	QColor labelFore = labelBack.darker();
+	switch (sync.state)
 	{
-		int s = -2;
-		if (bg.contains(i))
-			s = -1;
-		else
+	case SyncState::Hashes:
+		if (!syncCount || !sync.hashesEstimated)
+		{
+			m_lastSyncFrom = min(hashFrom, m_lastSyncFrom);
+			m_lastSyncCount = max(hashFrom + hashCount, m_lastSyncFrom + m_lastSyncCount) - m_lastSyncFrom;
+			m_wasEstimate = sync.hashesEstimated;
+		}
+		break;
+	case SyncState::Blocks:
+		if (m_wasEstimate)
+		{
+			m_lastSyncFrom = downloadFrom;
+			m_lastSyncCount = downloadCount;
+			m_wasEstimate = false;
+		}
+		break;
+	case SyncState::Idle:
+		if (!syncCount)
 		{
-			unsigned h = 0;
-			m_man->foreachSub([&](DownloadSub const& sub)
-			{
-				if (sub.askedContains(i))
-					s = h;
-				h++;
-			});
+			m_lastSyncFrom = (unsigned)-1;
+			m_lastSyncCount = 0;
+			labelBack = QColor::fromHsv(0, 0, 200);
+			labelFore = Qt::white;
+			labelText = "Idle";
 		}
-		if (s == -2)
-			p.fillRect(QRectF(QPointF(pos) + QPointF(3 * area.width() / 8, 3 * area.height() / 8), area / 4), Qt::black);
-		else if (s == -1)
-			p.fillRect(QRectF(QPointF(pos) + QPointF(1 * area.width() / 8, 1 * area.height() / 8), area * 3 / 4), Qt::black);
-		else
-			p.fillRect(QRectF(QPointF(pos) + QPointF(1 * area.width() / 8, 1 * area.height() / 8), area * 3 / 4), QColor::fromHsv(s * dh, 64, 128));
-
-		pos.setX(pos.x() + n);
-		if (pos.x() >= rect().width() - n)
-			pos = QPoint(0, pos.y() + n);
+	default: break;
+	}
+
+	unsigned from = min(min(hashFrom, downloadFrom), min(syncFrom, m_lastSyncFrom));
+	unsigned count = max(max(hashFrom + hashCount, downloadFrom + downloadCount), max(syncFrom + syncCount, m_lastSyncFrom + m_lastSyncCount)) - from;
+
+/*	cnote << "Range " << from << "-" << (from + count) << "(" << hashFrom << "+" << hashCount << "," << downloadFrom << "+" << downloadCount << "," << syncFrom << "+" << syncCount << ")";
+	auto r = [&](unsigned u) {
+		return toString((u - from) * 100 / count) + "%";
+	};
+
+	if (count)
+	{
+		cnote << "Hashes:" << r(hashDone) << "   Blocks:" << r(downloadFlank) << r(downloadDone) << r(downloadPoint);
+		cnote << "Importing:" << r(syncFrom) << r(syncImported) << r(syncImporting) << r(syncVerified) << r(syncVerifying) << r(syncUnverified);
+	}
+*/
+	float const squareSize = min(rect().width(), rect().height());
+	auto middleRect = [&](float w, float h) {
+		return QRectF(rect().width() / 2 - w / 2, rect().height() / 2 - h / 2, w, h);
+	};
+	auto middle = [&](float x) {
+		return middleRect(squareSize * x, squareSize * x);
+	};
+	auto pieProgress = [&](unsigned h, unsigned s, unsigned v, float row, float thickness, unsigned nfrom, unsigned ncount) {
+		auto arcLen = [&](unsigned x) {
+			return x * -5760.f / count;
+		};
+		auto arcPos = [&](unsigned x) {
+			return int(90 * 16.f + arcLen(x - from)) % 5760;
+		};
+		painter.setPen(QPen(QColor::fromHsv(h, s, v), squareSize * thickness, Qt::SolidLine, Qt::FlatCap));
+		painter.setBrush(Qt::NoBrush);
+		painter.drawArc(middle(0.5 + row / 2), arcPos(nfrom), arcLen(ncount));
+	};
+	auto pieProgress2 = [&](unsigned h, unsigned s, unsigned v, float row, float orbit, float thickness, unsigned nfrom, unsigned ncount) {
+		pieProgress(h, s, v, row - orbit, thickness, nfrom, ncount);
+		pieProgress(h, s, v, row + orbit, thickness, nfrom, ncount);
+	};
+	auto pieLabel = [&](QString text, float points, QColor fore, QColor back) {
+		painter.setBrush(QBrush(back));
+		painter.setFont(QFont("Helvetica", points, QFont::Bold));
+		QRectF r = painter.boundingRect(middle(1.f), Qt::AlignCenter, text);
+		r.adjust(-r.width() / 4, -r.height() / 8, r.width() / 4, r.height() / 8);
+		painter.setPen(QPen(fore, r.height() / 20));
+		painter.drawRoundedRect(r, r.height() / 4, r.height() / 4);
+		painter.drawText(r, Qt::AlignCenter, text);
+	};
+
+	float lineHeight = painter.boundingRect(rect(), Qt::AlignTop | Qt::AlignHCenter, "Ay").height();
+	auto hProgress = [&](unsigned h, unsigned s, unsigned v, float row, float thickness, unsigned nfrom, unsigned ncount) {
+		QRectF r = rect();
+		painter.setPen(QPen(QColor::fromHsv(h, s, v), r.height() * thickness * 3, Qt::SolidLine, Qt::FlatCap));
+		painter.setBrush(Qt::NoBrush);
+		auto y = row * (r.height() - lineHeight) + lineHeight;
+		painter.drawLine(QPointF((nfrom - from) * r.width() / count, y), QPointF((nfrom + ncount - from) * r.width() / count, y));
+	};
+	auto hProgress2 = [&](unsigned h, unsigned s, unsigned v, float row, float orbit, float thickness, unsigned nfrom, unsigned ncount) {
+		hProgress(h, s, v, row - orbit * 3, thickness, nfrom, ncount);
+		hProgress(h, s, v, row + orbit * 3, thickness, nfrom, ncount);
+	};
+	auto hLabel = [&](QString text, float points, QColor fore, QColor back) {
+		painter.setBrush(QBrush(back));
+		painter.setFont(QFont("Helvetica", points, QFont::Bold));
+		QRectF r = painter.boundingRect(rect(), Qt::AlignTop | Qt::AlignHCenter, text);
+		r.adjust(-r.width() / 4, r.height() / 8, r.width() / 4, 3 * r.height() / 8);
+		painter.setPen(QPen(fore, r.height() / 20));
+		painter.drawRoundedRect(r, r.height() / 4, r.height() / 4);
+		painter.drawText(r, Qt::AlignCenter, text);
+	};
+
+	function<void(unsigned h, unsigned s, unsigned v, float row, float thickness, unsigned nfrom, unsigned ncount)> progress;
+	function<void(unsigned h, unsigned s, unsigned v, float row, float orbit, float thickness, unsigned nfrom, unsigned ncount)> progress2;
+	function<void(QString text, float points, QColor fore, QColor back)> label;
+	if (rect().width() / rect().height() > 5)
+	{
+		progress = hProgress;
+		progress2 = hProgress2;
+		label = hLabel;
 	}
+	else if (rect().height() / rect().width() > 5)
+	{
+	}
+	else
+	{
+		progress = pieProgress;
+		progress2 = pieProgress2;
+		label = pieLabel;
+	}
+
+	if (sync.state != SyncState::Idle)
+	{
+		progress(0, 0, 220, 0.4f, 0.02f, from, hashDone - from);							// Download rail
+		progress(240, 25, 170, 0.4f, 0.02f, downloadDone, downloadPoint - downloadDone);	// Latest download point
+		progress(240, 50, 120, 0.4f, 0.04f, from, downloadDone - from);						// Downloaded
+	}
+
+	progress(0, 0, 220, 0.8f, 0.01f, from, count);								// Sync rail
+	progress(0, 0, 170, 0.8f, 0.02f, from, syncUnverified - from);				// Verification rail
+	progress2(60, 25, 170, 0.8f, 0.06f, 0.005f, from, syncVerifying - from);	// Verifying.
+	progress2(120, 25, 170, 0.8f, 0.06f, 0.005f, from, syncVerified - from);	// Verified.
+	progress(120, 50, 120, 0.8f, 0.05f, from, syncFrom - from);					// Imported.
+	progress(0, 0, 120, 0.8f, 0.02f, syncFrom, syncImporting - syncFrom);		// Importing.
+
+	if (sync.state != SyncState::Idle || (sync.state == SyncState::Idle && !syncCount))
+		label(labelText, 11, labelFore, labelBack);
 }

alethzero/DownloadView.h

@@ -32,21 +32,25 @@
 #endif
 
 namespace dev { namespace eth {
-class DownloadMan;
+class Client;
 }}
 
-class DownloadView: public QWidget
+class SyncView: public QWidget
 {
 	Q_OBJECT
 
 public:
-	DownloadView(QWidget* _p = nullptr);
+	SyncView(QWidget* _p = nullptr);
 
-	void setDownloadMan(dev::eth::DownloadMan const* _man) { m_man = _man; }
+	void setEthereum(dev::eth::Client const* _c) { m_client = _c; }
 
 protected:
 	virtual void paintEvent(QPaintEvent*);
 
 private:
-	dev::eth::DownloadMan const* m_man = nullptr;
+	dev::eth::Client const* m_client = nullptr;
+
+	unsigned m_lastSyncFrom = (unsigned)-1;
+	unsigned m_lastSyncCount = 0;
+	bool m_wasEstimate = false;
 };

alethzero/ExportState.cpp

@@ -127,11 +127,21 @@ void ExportStateDialog::fillContracts()
 	ui->contracts->clear();
 	ui->accounts->setEnabled(true);
 	ui->contracts->setEnabled(true);
-	for (auto i: ethereum()->addresses(m_block))
+	try
 	{
-		string r = m_main->render(i);
-		(new QListWidgetItem(QString("%2: %1 [%3]").arg(formatBalance(ethereum()->balanceAt(i)).c_str()).arg(QString::fromStdString(r)).arg((unsigned)ethereum()->countAt(i)), ethereum()->codeAt(i).empty() ? ui->accounts : ui->contracts))
-			->setData(Qt::UserRole, QByteArray((char const*)i.data(), Address::size));
+		for (auto i: ethereum()->addresses(m_block))
+		{
+			string r = m_main->render(i);
+			(new QListWidgetItem(QString("%2: %1 [%3]").arg(formatBalance(ethereum()->balanceAt(i)).c_str()).arg(QString::fromStdString(r)).arg((unsigned)ethereum()->countAt(i)), ethereum()->codeAt(i).empty() ? ui->accounts : ui->contracts))
+				->setData(Qt::UserRole, QByteArray((char const*)i.data(), Address::size));
+		}
+	}
+	catch (InterfaceNotSupported const&)
+	{
+		ui->accounts->setEnabled(false);
+		ui->contracts->setEnabled(false);
+		ui->json->setEnabled(false);
+		ui->json->setText(QString("This feature requires compilation with FATDB support."));
 	}
 }
 

alethzero/Main.ui

@@ -11,7 +11,7 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>AlethZero Ethereum Client</string>
+   <string>AlethZero ++Ethereum</string>
   </property>
   <property name="dockNestingEnabled">
    <bool>true</bool>
@@ -132,7 +132,7 @@
      <x>0</x>
      <y>0</y>
      <width>1617</width>
-     <height>25</height>
+     <height>24</height>
     </rect>
    </property>
    <widget class="QMenu" name="menu_File">
@@ -199,6 +199,7 @@
     <addaction name="usePrivate"/>
     <addaction name="retryUnknown"/>
     <addaction name="confirm"/>
+    <addaction name="rewindChain"/>
    </widget>
    <widget class="QMenu" name="menu_View">
     <property name="title">
@@ -1149,7 +1150,7 @@ font-size: 14pt</string>
       <number>0</number>
      </property>
      <item>
-      <widget class="DownloadView" name="downloadView" native="true"/>
+      <widget class="SyncView" name="downloadView" native="true"/>
      </item>
     </layout>
    </widget>
@@ -1804,6 +1805,11 @@ font-size: 14pt</string>
     <string>&amp;Sentinel...</string>
    </property>
   </action>
+  <action name="rewindChain">
+   <property name="text">
+    <string>&amp;Rewind Chain...</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
@@ -1814,7 +1820,7 @@ font-size: 14pt</string>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>DownloadView</class>
+   <class>SyncView</class>
    <extends>QWidget</extends>
    <header>DownloadView.h</header>
    <container>1</container>

alethzero/MainWin.cpp

@@ -136,6 +136,12 @@ Main::Main(QWidget *parent) :
 	QtWebEngine::initialize();
 	setWindowFlags(Qt::Window);
 	ui->setupUi(this);
+
+	if (c_network == eth::Network::Olympic)
+		setWindowTitle("AlethZero Olympic");
+	else if (c_network == eth::Network::Frontier)
+		setWindowTitle("AlethZero Frontier");
+
 	g_logPost = [=](string const& s, char const* c)
 	{
 		simpleDebugOut(s, c);
@@ -1038,6 +1044,17 @@ void Main::on_vmInterpreter_triggered() { VMFactory::setKind(VMKind::Interpreter
 void Main::on_vmJIT_triggered() { VMFactory::setKind(VMKind::JIT); }
 void Main::on_vmSmart_triggered() { VMFactory::setKind(VMKind::Smart); }
 
+void Main::on_rewindChain_triggered()
+{
+	bool ok;
+	int n = QInputDialog::getInt(this, "Rewind Chain", "Enter the number of the new chain head.", ethereum()->number() * 9 / 10, 1, ethereum()->number(), 1, &ok);
+	if (ok)
+	{
+		ethereum()->rewind(n);
+		refreshAll();
+	}
+}
+
 void Main::on_urlEdit_returnPressed()
 {
 	QString s = ui->urlEdit->text();
@@ -1987,12 +2004,12 @@ void Main::on_net_triggered()
 		web3()->setNetworkPreferences(netPrefs(), ui->dropPeers->isChecked());
 		ethereum()->setNetworkId(m_privateChain.size() ? sha3(m_privateChain.toStdString()) : h256());
 		web3()->startNetwork();
-		ui->downloadView->setDownloadMan(ethereum()->downloadMan());
+		ui->downloadView->setEthereum(ethereum());
 		ui->enode->setText(QString::fromStdString(web3()->enode()));
 	}
 	else
 	{
-		ui->downloadView->setDownloadMan(nullptr);
+		ui->downloadView->setEthereum(nullptr);
 		writeSettings();
 		web3()->stopNetwork();
 	}

alethzero/MainWin.h

@@ -187,6 +187,7 @@ private slots:
 	void on_vmInterpreter_triggered();
 	void on_vmJIT_triggered();
 	void on_vmSmart_triggered();
+	void on_rewindChain_triggered();
 
 	// Debugger
 	void on_debugCurrent_triggered();

alethzero/OurWebThreeStubServer.cpp

@@ -99,10 +99,11 @@ bool OurAccountHolder::showUnknownCallNotice(TransactionSkeleton const& _t, bool
 		"REJECT UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!");
 }
 
-void OurAccountHolder::authenticate(TransactionSkeleton const& _t)
+h256 OurAccountHolder::authenticate(TransactionSkeleton const& _t)
 {
 	Guard l(x_queued);
 	m_queued.push(_t);
+	return h256();
 }
 
 void OurAccountHolder::doValidations()

alethzero/OurWebThreeStubServer.h

@@ -43,7 +43,7 @@ protected:
 	// easiest to return keyManager.addresses();
 	virtual dev::AddressHash realAccounts() const override;
 	// use web3 to submit a signed transaction to accept
-	virtual void authenticate(dev::eth::TransactionSkeleton const& _t) override;
+	virtual dev::h256 authenticate(dev::eth::TransactionSkeleton const& _t) override;
 
 private:
 	bool showAuthenticationPopup(std::string const& _title, std::string const& _text);

cmake/EthCompilerSettings.cmake

@@ -47,9 +47,10 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	add_compile_options(/MP /EHsc /wd4068 /wd4996 /wd4503 /wd4267 /wd4180 /wd4290 /wd4244 /wd4800 -D_WIN32_WINNT=0x0501 /DNOMINMAX /DMINIUPNP_STATICLIB)
 	# disable empty object file warning
 	set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
-	# warning LNK4075: ignoring '/EDITANDCONTINUE' due to '/SAFESEH' specification 
+	# warning LNK4075: ignoring '/EDITANDCONTINUE' due to '/SAFESEH' specification
 	# warning LNK4099: pdb was not found with lib
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4099,4075")
+	# stack size 16MB
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4099,4075 /STACK:16777216")
 
 	# windows likes static
 	if (NOT ETH_STATIC)

cmake/Findv8.cmake

@@ -31,12 +31,32 @@ set(V8_LIBRARIES ${V8_LIBRARY})
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 
 	find_library(
-		V8_LIBRARY_DEBUG
-		NAMES v8d
-		DOC "v8 debug library"
+		V8_LIBRARY
+		NAMES v8_base
+		DOC "v8 base library"
+	)
+
+	find_library(
+		V8_NO_SNAPSHOT_LIBRARY
+		NAMES v8_nosnapshot
+		DOC "v8 nosnapshot library"
 	)
 	
-	set(V8_LIBRARIES optimized ${V8_LIBRARIES} debug ${V8_LIBRARY_DEBUG})
+	set(V8_LIBRARIES ${V8_LIBRARY} ${V8_NO_SNAPSHOT_LIBRARY})
+
+	find_library(
+		V8_LIBRARY_DEBUG
+		NAMES v8_based
+		DOC "v8 base library"
+	)
+
+	find_library(
+		V8_NO_SNAPSHOT_LIBRARY_DEBUG
+		NAMES v8_nosnapshotd
+		DOC "v8 nosnapshot library"
+	)
+
+	set(V8_LIBRARIES "ws2_32" "winmm" optimized ${V8_LIBRARIES} debug ${V8_LIBRARY_DEBUG} ${V8_NO_SNAPSHOT_LIBRARY_DEBUG})
 
 endif()
 

eth/main.cpp

@@ -75,12 +75,8 @@ void interactiveHelp()
 		<< "Commands:" << endl
 		<< "    netstart <port>  Starts the network subsystem on a specific port." << endl
 		<< "    netstop  Stops the network subsystem." << endl
-		<< "    jsonstart <port>  Starts the JSON-RPC server." << endl
-		<< "    jsonstop  Stops the JSON-RPC server." << endl
 		<< "    connect <addr> <port>  Connects to a specific peer." << endl
 		<< "    verbosity (<level>)  Gets or sets verbosity level." << endl
-		<< "    setetherprice <p>  Resets the ether price." << endl
-		<< "    setpriority <p>  Resets the transaction priority." << endl
 		<< "    minestart  Starts mining." << endl
 		<< "    minestop  Stops mining." << endl
 		<< "    mineforce <enable>  Forces mining, even when there are no transactions." << endl
@@ -135,6 +131,7 @@ void help()
 #endif
 		<< "    -K,--kill  First kill the blockchain." << endl
 		<< "    -R,--rebuild  Rebuild the blockchain from the existing database." << endl
+		<< "    --rescue  Attempt to rescue a corrupt database." << endl
 		<< "    --genesis-nonce <nonce>  Set the Genesis Nonce to the given hex nonce." << endl
 		<< "    -s,--import-secret <secret>  Import a secret key into the key store and use as the default." << endl
 		<< "    -S,--import-session-secret <secret>  Import a secret key into the key store and use as the default for this session only." << endl
@@ -1026,9 +1023,7 @@ void interactiveMode(eth::Client* c, std::shared_ptr<eth::TrivialGasPricer> gasP
 			{
 				string path;
 				iss >> path;
-				RLPStream config(2);
-				config << signingKey << beneficiary;
-				writeFile(path, config.out());
+				writeFile(path, rlpList(signingKey, beneficiary));
 			}
 			else
 				cwarn << "Require parameter: exportConfig PATH";
@@ -1089,7 +1084,7 @@ int main(int argc, char** argv)
 #endif
 	string jsonAdmin;
 	bool upnp = true;
-	WithExisting killChain = WithExisting::Trust;
+	WithExisting withExisting = WithExisting::Trust;
 	bool jit = false;
 	string sentinel;
 
@@ -1256,9 +1251,11 @@ int main(int argc, char** argv)
 				return -1;
 			}
 		else if (arg == "-K" || arg == "--kill-blockchain" || arg == "--kill")
-			killChain = WithExisting::Kill;
+			withExisting = WithExisting::Kill;
 		else if (arg == "-R" || arg == "--rebuild")
-			killChain = WithExisting::Verify;
+			withExisting = WithExisting::Verify;
+		else if (arg == "-R" || arg == "--rescue")
+			withExisting = WithExisting::Rescue;
 		else if ((arg == "-c" || arg == "--client-name") && i + 1 < argc)
 		{
 			if (arg == "-c")
@@ -1471,17 +1468,22 @@ int main(int argc, char** argv)
 		}
 	}
 
+	if (g_logVerbosity > 0)
+	{
+		cout << EthGrayBold "(++)Ethereum" EthReset << endl;
+		if (c_network == eth::Network::Olympic)
+			cout << "Welcome to Olympic!" << endl;
+		else if (c_network == eth::Network::Frontier)
+			cout << "Welcome to the " EthMaroonBold "Frontier" EthReset "!" << endl;
+	}
+
 	m.execute();
 
 	KeyManager keyManager;
 	for (auto const& s: passwordsToNote)
 		keyManager.notePassword(s);
 
-	{
-		RLPStream config(2);
-		config << signingKey << beneficiary;
-		writeFile(configFile, config.out());
-	}
+	writeFile(configFile, rlpList(signingKey, beneficiary));
 
 	if (sessionKey)
 		signingKey = sessionKey;
@@ -1531,7 +1533,7 @@ int main(int argc, char** argv)
 	dev::WebThreeDirect web3(
 		WebThreeDirect::composeClientVersion("++eth", clientName),
 		dbPath,
-		killChain,
+		withExisting,
 		nodeMode == NodeMode::Full ? set<string>{"eth"/*, "shh"*/} : set<string>(),
 		netPrefs,
 		&nodesState);
@@ -1703,7 +1705,7 @@ int main(int argc, char** argv)
 	cout << "Transaction Signer: " << signingKey << endl;
 	cout << "Mining Benefactor: " << beneficiary << endl;
 
-	if (bootstrap || !remoteHost.empty())
+	if (bootstrap || !remoteHost.empty() || disableDiscovery)
 	{
 		web3.startNetwork();
 		cout << "Node ID: " << web3.enode() << endl;

ethconsole/CMakeLists.txt

@@ -13,9 +13,7 @@ set(EXECUTABLE ethconsole)
 file(GLOB HEADERS "*.h")
 
 add_executable(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
-
 target_link_libraries(${EXECUTABLE} ${Boost_REGEX_LIBRARIES})
-target_link_libraries(${EXECUTABLE} ${READLINE_LIBRARIES})
 target_link_libraries(${EXECUTABLE} ${CURL_LIBRARIES})
 
 if (DEFINED WIN32 AND NOT DEFINED CMAKE_COMPILER_IS_MINGW)

ethminer/MinerAux.h

@@ -40,6 +40,9 @@
 #include <libethcore/ProofOfWork.h>
 #include <libethcore/EthashAux.h>
 #include <libethcore/Farm.h>
+#if ETH_ETHASHCL || !ETH_TRUE
+#include <libethash-cl/ethash_cl_miner.h>
+#endif
 #if ETH_JSONRPC || !ETH_TRUE
 #include <libweb3jsonrpc/WebThreeStubServer.h>
 #include <jsonrpccpp/server/connectors/httpserver.h>
@@ -78,6 +81,12 @@ inline std::string credits()
 }
 
 class BadArgument: public Exception {};
+struct MiningChannel: public LogChannel
+{
+	static const char* name() { return EthGreen "miner"; }
+	static const int verbosity = 2;
+};
+#define minelog clog(MiningChannel)
 
 class MinerCLI
 {
@@ -128,6 +137,7 @@ public:
 				cerr << "Bad " << arg << " option: " << argv[i] << endl;
 				BOOST_THROW_EXCEPTION(BadArgument());
 			}
+#if ETH_ETHASHCL || !ETH_TRUE
 		else if (arg == "--cl-global-work" && i + 1 < argc)
 			try {
 				m_globalWorkSizeMultiplier = stol(argv[++i]);
@@ -155,6 +165,7 @@ public:
 				cerr << "Bad " << arg << " option: " << argv[i] << endl;
 				BOOST_THROW_EXCEPTION(BadArgument());
 			}
+#endif
 		else if (arg == "--list-devices")
 			m_shouldListDevices = true;
 		else if (arg == "--allow-opencl-cpu")
@@ -292,6 +303,7 @@ public:
 			ProofOfWork::CPUMiner::setNumInstances(m_miningThreads);
 		else if (m_minerType == MinerType::GPU)
 		{
+#if ETH_ETHASHCL || !ETH_TRUE
 			if (!ProofOfWork::GPUMiner::configureGPU(
 					m_localWorkSize,
 					m_globalWorkSizeMultiplier,
@@ -304,6 +316,10 @@ public:
 				))
 				exit(1);
 			ProofOfWork::GPUMiner::setNumInstances(m_miningThreads);
+#else
+			cerr << "Selected GPU mining without having compiled with -DETHASHCL=1" << endl;
+			exit(1);
+#endif
 		}
 		if (mode == OperationMode::DAGInit)
 			doInitDAG(m_initDAG);
@@ -344,10 +360,12 @@ public:
 			<< "    --allow-opencl-cpu Allows CPU to be considered as an OpenCL device if the OpenCL platform supports it." << endl
 			<< "    --list-devices List the detected OpenCL devices and exit." << endl
 			<< "    --current-block Let the miner know the current block number at configuration time. Will help determine DAG size and required GPU memory." << endl
+#if ETH_ETHASHCL || !ETH_TRUE
 			<< "    --cl-extragpu-mem Set the memory (in MB) you believe your GPU requires for stuff other than mining. Windows rendering e.t.c.." << endl
-			<< "    --cl-local-work Set the OpenCL local work size. Default is " << toString(dev::eth::Ethash::defaultLocalWorkSize) << endl
-			<< "    --cl-global-work Set the OpenCL global work size as a multiple of the local work size. Default is " << toString(dev::eth::Ethash::defaultGlobalWorkSizeMultiplier) << " * " << toString(dev::eth::Ethash::defaultLocalWorkSize) << endl
-			<< "    --cl-ms-per-batch Set the OpenCL target milliseconds per batch (global workgroup size). Default is " << toString(dev::eth::Ethash::defaultMSPerBatch) << ". If 0 is given then no autoadjustment of global work size will happen" << endl
+			<< "    --cl-local-work Set the OpenCL local work size. Default is " << toString(ethash_cl_miner::c_defaultLocalWorkSize) << endl
+			<< "    --cl-global-work Set the OpenCL global work size as a multiple of the local work size. Default is " << toString(ethash_cl_miner::c_defaultGlobalWorkSizeMultiplier) << " * " << toString(ethash_cl_miner::c_defaultLocalWorkSize) << endl
+			<< "    --cl-ms-per-batch Set the OpenCL target milliseconds per batch (global workgroup size). Default is " << toString(ethash_cl_miner::c_defaultMSPerBatch) << ". If 0 is given then no autoadjustment of global work size will happen" << endl
+#endif
 			;
 	}
 
@@ -472,14 +490,14 @@ private:
 				for (unsigned i = 0; !completed; ++i)
 				{
 					if (current)
-						cnote << "Mining on PoWhash" << current.headerHash << ": " << f.miningProgress();
+						minelog << "Mining on PoWhash" << current.headerHash << ": " << f.miningProgress();
 					else
-						cnote << "Getting work package...";
+						minelog << "Getting work package...";
 					Json::Value v = rpc.eth_getWork();
 					h256 hh(v[0].asString());
 					h256 newSeedHash(v[1].asString());
 					if (current.seedHash != newSeedHash)
-						cnote << "Grabbing DAG for" << newSeedHash;
+						minelog << "Grabbing DAG for" << newSeedHash;
 					if (!(dag = EthashAux::full(newSeedHash, true, [&](unsigned _pc){ cout << "\rCreating DAG. " << _pc << "% done..." << flush; return 0; })))
 						BOOST_THROW_EXCEPTION(DAGCreationFailure());
 					if (m_precompute)
@@ -489,10 +507,10 @@ private:
 						current.headerHash = hh;
 						current.seedHash = newSeedHash;
 						current.boundary = h256(fromHex(v[2].asString()), h256::AlignRight);
-						cnote << "Got work package:";
-						cnote << "  Header-hash:" << current.headerHash.hex();
-						cnote << "  Seedhash:" << current.seedHash.hex();
-						cnote << "  Target: " << h256(current.boundary).hex();
+						minelog << "Got work package:";
+						minelog << "  Header-hash:" << current.headerHash.hex();
+						minelog << "  Seedhash:" << current.seedHash.hex();
+						minelog << "  Target: " << h256(current.boundary).hex();
 						f.setWork(current);
 					}
 					this_thread::sleep_for(chrono::milliseconds(_recheckPeriod));
@@ -536,10 +554,12 @@ private:
 	unsigned m_miningThreads = UINT_MAX;
 	bool m_shouldListDevices = false;
 	bool m_clAllowCPU = false;
-	unsigned m_globalWorkSizeMultiplier = dev::eth::Ethash::defaultGlobalWorkSizeMultiplier;
-	unsigned m_localWorkSize = dev::eth::Ethash::defaultLocalWorkSize;
-	unsigned m_msPerBatch = dev::eth::Ethash::defaultMSPerBatch;
-	boost::optional<uint64_t> m_currentBlock;
+#if ETH_ETHASHCL || !ETH_TRUE
+	unsigned m_globalWorkSizeMultiplier = ethash_cl_miner::c_defaultGlobalWorkSizeMultiplier;
+	unsigned m_localWorkSize = ethash_cl_miner::c_defaultLocalWorkSize;
+	unsigned m_msPerBatch = ethash_cl_miner::c_defaultMSPerBatch;
+#endif
+	uint64_t m_currentBlock = 0;
 	// default value is 350MB of GPU memory for other stuff (windows system rendering, e.t.c.)
 	unsigned m_extraGPUMemory = 350000000;
 

exp/main.cpp

@@ -135,7 +135,7 @@ int main()
 	DownloadSub s0(man);
 	DownloadSub s1(man);
 	DownloadSub s2(man);
-	man.resetToChain(h256s({u256(0), u256(1), u256(2), u256(3), u256(4), u256(5), u256(6), u256(7), u256(8)}));
+	man.resetToChain(h256s({u256(0), u256(1), u256(2), u256(3), u256(4), u256(5), u256(6), u256(7), u256(8)}), 0);
 	assert((s0.nextFetch(2) == h256Set{(u256)7, (u256)8}));
 	assert((s1.nextFetch(2) == h256Set{(u256)5, (u256)6}));
 	assert((s2.nextFetch(2) == h256Set{(u256)3, (u256)4}));

extdep/getstuff.bat

@@ -14,6 +14,7 @@ call :download leveldb 1.2
 call :download microhttpd 0.9.2
 call :download qt 5.4.1
 call :download miniupnpc 1.9
+call :download v8 3.15.9
 
 goto :EOF
 

libdevcore/Base64.cpp

@@ -27,6 +27,8 @@
 /// Originally by René Nyffenegger, modified by some other guy and then devified by Gav Wood.
 
 #include "Base64.h"
+
+using namespace std;
 using namespace dev;
 
 static inline bool is_base64(byte c)
@@ -44,14 +46,14 @@ static inline byte find_base64_char_index(byte c)
 	else return 1 + find_base64_char_index('/');
 }
 
-std::string dev::toBase64(bytesConstRef _in)
+string dev::toBase64(bytesConstRef _in)
 {
 	static const char base64_chars[] =
-			"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-			"abcdefghijklmnopqrstuvwxyz"
-			"0123456789+/";
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"0123456789+/";
 
-	std::string ret;
+	string ret;
 	int i = 0;
 	int j = 0;
 	byte char_array_3[3];
@@ -60,15 +62,17 @@ std::string dev::toBase64(bytesConstRef _in)
 	auto buf = _in.data();
 	auto bufLen = _in.size();
 
-	while (bufLen--) {
+	while (bufLen--)
+	{
 		char_array_3[i++] = *(buf++);
-		if (i == 3) {
+		if (i == 3)
+		{
 			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
 			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
 			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 			char_array_4[3] = char_array_3[2] & 0x3f;
 
-			for(i = 0; (i <4) ; i++)
+			for (i = 0; i < 4; i++)
 				ret += base64_chars[char_array_4[i]];
 			i = 0;
 		}
@@ -76,7 +80,7 @@ std::string dev::toBase64(bytesConstRef _in)
 
 	if (i)
 	{
-		for(j = i; j < 3; j++)
+		for (j = i; j < 3; j++)
 			char_array_3[j] = '\0';
 
 		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
@@ -84,28 +88,31 @@ std::string dev::toBase64(bytesConstRef _in)
 		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 		char_array_4[3] = char_array_3[2] & 0x3f;
 
-		for (j = 0; (j < i + 1); j++)
+		for (j = 0; j < i + 1; j++)
 			ret += base64_chars[char_array_4[j]];
 
-		while((i++ < 3))
+		while (i++ < 3)
 			ret += '=';
 	}
 
 	return ret;
 }
 
-bytes dev::fromBase64(std::string const& encoded_string)
+bytes dev::fromBase64(string const& encoded_string)
 {
 	auto in_len = encoded_string.size();
 	int i = 0;
 	int j = 0;
 	int in_ = 0;
-	byte char_array_4[4], char_array_3[3];
+	byte char_array_3[3];
+	byte char_array_4[4];
 	bytes ret;
 
-	while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+	while (in_len-- && encoded_string[in_] != '=' && is_base64(encoded_string[in_]))
+	{
 		char_array_4[i++] = encoded_string[in_]; in_++;
-		if (i == 4) {
+		if (i == 4)
+		{
 			for (i = 0; i < 4; i++)
 				char_array_4[i] = find_base64_char_index(char_array_4[i]);
 
@@ -119,7 +126,8 @@ bytes dev::fromBase64(std::string const& encoded_string)
 		}
 	}
 
-	if (i) {
+	if (i)
+	{
 		for (j = i; j < 4; j++)
 			char_array_4[j] = 0;
 
@@ -130,7 +138,8 @@ bytes dev::fromBase64(std::string const& encoded_string)
 		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
 		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
-		for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]);
+		for (j = 0; j < i - 1; j++)
+			ret.push_back(char_array_3[j]);
 	}
 
 	return ret;

libdevcore/Common.cpp

@@ -28,7 +28,7 @@ using namespace dev;
 namespace dev
 {
 
-char const* Version = "0.9.28";
+char const* Version = "0.9.29";
 
 const u256 UndefinedU256 = ~(u256)0;
 

libdevcore/Common.h

@@ -189,7 +189,7 @@ private:
 
 /// Scope guard for invariant check in a class derived from HasInvariants.
 #if ETH_DEBUG
-#define DEV_INVARIANT_CHECK { ::dev::InvariantChecker __dev_invariantCheck(this, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__); }
+#define DEV_INVARIANT_CHECK ::dev::InvariantChecker __dev_invariantCheck(this, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)
 #else
 #define DEV_INVARIANT_CHECK (void)0;
 #endif
@@ -240,6 +240,7 @@ enum class WithExisting: int
 {
 	Trust = 0,
 	Verify,
+	Rescue,
 	Kill
 };
 

libdevcore/FixedHash.h

@@ -24,6 +24,7 @@
 #pragma once
 
 #include <array>
+#include <cstdint>
 #include <random>
 #include <algorithm>
 #include "CommonData.h"
@@ -81,7 +82,7 @@ public:
 	explicit FixedHash(byte const* _bs, ConstructFromPointerType) { memcpy(m_data.data(), _bs, N); }
 
 	/// Explicitly construct, copying from a  string.
-	explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex, ConstructFromHashType _ht = FailIfDifferent): FixedHash(_t == FromHex ? fromHex(_s) : dev::asBytes(_s), _ht) {}
+	explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex, ConstructFromHashType _ht = FailIfDifferent): FixedHash(_t == FromHex ? fromHex(_s, WhenError::Throw) : dev::asBytes(_s), _ht) {}
 
 	/// Convert to arithmetic type.
 	operator Arith() const { return fromBigEndian<Arith>(m_data); }
@@ -106,6 +107,9 @@ public:
 	FixedHash operator&(FixedHash const& _c) const { return FixedHash(*this) &= _c; }
 	FixedHash operator~() const { FixedHash ret; for (unsigned i = 0; i < N; ++i) ret[i] = ~m_data[i]; return ret; }
 
+	// Big-endian increment.
+	FixedHash& operator++() { for (unsigned i = size; i > 0 && !++m_data[--i]; ) {} return *this; }
+
 	/// @returns true if all one-bits in @a _c are set in this object.
 	bool contains(FixedHash const& _c) const { return (*this & _c) == _c; }
 
@@ -150,7 +154,7 @@ public:
 	{
 		FixedHash ret;
 		for (auto& i: ret.m_data)
-			i = std::uniform_int_distribution<uint16_t>(0, 255)(_eng);
+			i = (uint8_t)std::uniform_int_distribution<uint16_t>(0, 255)(_eng);
 		return ret;
 	}
 

libdevcore/Guards.h

@@ -95,7 +95,7 @@ using SpinGuard = std::lock_guard<SpinLock>;
  * Mutex m;
  * int d;
  * ...
- * ETH_(m)
+ * ETH_GUARDED(m)
  * {
  *   for (auto d = 50; d > 25; --d)
  *     foo(d);

libdevcore/RangeMask.h

@@ -200,6 +200,20 @@ public:
 		return c;
 	}
 
+	size_t firstOut() const
+	{
+		if (m_ranges.empty() || !m_ranges.count(m_all.first))
+			return m_all.first;
+		return m_ranges.at(m_all.first);
+	}
+
+	size_t lastIn() const
+	{
+		if (m_ranges.empty())
+			return m_all.first;
+		return m_ranges.rbegin()->second - 1;
+	}
+
 private:
 	/// The ground range.
 	UnsignedRange m_all;

libdevcore/TrieDB.h

@@ -66,7 +66,7 @@ class GenericTrieDB
 public:
 	using DB = _DB;
 
-	GenericTrieDB(DB* _db = nullptr): m_db(_db) {}
+	explicit GenericTrieDB(DB* _db = nullptr): m_db(_db) {}
 	GenericTrieDB(DB* _db, h256 const& _root, Verification _v = Verification::Normal) { open(_db, _root, _v); }
 	~GenericTrieDB() {}
 
@@ -96,11 +96,72 @@ public:
 	/// True if the trie is initialised but empty (i.e. that the DB contains the root node which is empty).
 	bool isEmpty() const { return m_root == c_shaNull && node(m_root).size(); }
 
-	h256 const& root() const { if (!node(m_root).size()) BOOST_THROW_EXCEPTION(BadRoot()); /*std::cout << "Returning root as " << ret << " (really " << m_root << ")" << std::endl;*/ return m_root; }	// patch the root in the case of the empty trie. TODO: handle this properly.
+	h256 const& root() const { if (node(m_root).empty()) BOOST_THROW_EXCEPTION(BadRoot()); /*std::cout << "Returning root as " << ret << " (really " << m_root << ")" << std::endl;*/ return m_root; }	// patch the root in the case of the empty trie. TODO: handle this properly.
+
+	std::string at(bytes const& _key) const { return at(&_key); }
+	std::string at(bytesConstRef _key) const;
+	void insert(bytes const& _key, bytes const& _value) { insert(&_key, &_value); }
+	void insert(bytesConstRef _key, bytes const& _value) { insert(_key, &_value); }
+	void insert(bytes const& _key, bytesConstRef _value) { insert(&_key, _value); }
+	void insert(bytesConstRef _key, bytesConstRef _value);
+	void remove(bytes const& _key) { remove(&_key); }
+	void remove(bytesConstRef _key);
+	bool contains(bytes const& _key) { return contains(&_key); }
+	bool contains(bytesConstRef _key) { return !at(_key).empty(); }
+
+	class iterator
+	{
+	public:
+		using value_type = std::pair<bytesConstRef, bytesConstRef>;
+
+		iterator() {}
+		explicit iterator(GenericTrieDB const* _db);
+		iterator(GenericTrieDB const* _db, bytesConstRef _key);
+
+		iterator& operator++() { next(); return *this; }
+
+		value_type operator*() const { return at(); }
+		value_type operator->() const { return at(); }
+
+		bool operator==(iterator const& _c) const { return _c.m_trail == m_trail; }
+		bool operator!=(iterator const& _c) const { return _c.m_trail != m_trail; }
+
+		value_type at() const;
+
+	private:
+		void next();
+		void next(NibbleSlice _key);
+
+		struct Node
+		{
+			std::string rlp;
+			std::string key;		// as hexPrefixEncoding.
+			byte child;				// 255 -> entering, 16 -> actually at the node, 17 -> exiting, 0-15 -> actual children.
+
+			// 255 -> 16 -> 0 -> 1 -> ... -> 15 -> 17
+
+			void setChild(unsigned _i) { child = _i; }
+			void setFirstChild() { child = 16; }
+			void incrementChild() { child = child == 16 ? 0 : child == 15 ? 17 : (child + 1); }
+
+			bool operator==(Node const& _c) const { return rlp == _c.rlp && key == _c.key && child == _c.child; }
+			bool operator!=(Node const& _c) const { return !operator==(_c); }
+		};
+
+	protected:
+		std::vector<Node> m_trail;
+		GenericTrieDB<DB> const* m_that;
+	};
+
+	iterator begin() const { return iterator(this); }
+	iterator end() const { return iterator(); }
+
+	iterator lower_bound(bytesConstRef _key) const { return iterator(this, _key); }
 
 	void debugPrint() {}
 
-	void descendKey(h256 _k, h256Hash& _keyMask, bool _wasExt, std::ostream* _out, int _indent = 0) const
+	/// Used for debugging, scans the whole trie.
+	void descendKey(h256 const& _k, h256Hash& _keyMask, bool _wasExt, std::ostream* _out, int _indent = 0) const
 	{
 		_keyMask.erase(_k);
 		if (_k == m_root && _k == c_shaNull)	// root allowed to be empty
@@ -108,6 +169,7 @@ public:
 		descendList(RLP(node(_k)), _keyMask, _wasExt, _out, _indent);	// if not, it must be a list
 	}
 
+	/// Used for debugging, scans the whole trie.
 	void descendEntry(RLP const& _r, h256Hash& _keyMask, bool _wasExt, std::ostream* _out, int _indent) const
 	{
 		if (_r.isData() && _r.size() == 32)
@@ -118,6 +180,7 @@ public:
 			BOOST_THROW_EXCEPTION(InvalidTrie());
 	}
 
+	/// Used for debugging, scans the whole trie.
 	void descendList(RLP const& _r, h256Hash& _keyMask, bool _wasExt, std::ostream* _out, int _indent) const
 	{
 		if (_r.isList() && _r.itemCount() == 2 && (!_wasExt || _out))
@@ -139,6 +202,7 @@ public:
 			BOOST_THROW_EXCEPTION(InvalidTrie());
 	}
 
+	/// Used for debugging, scans the whole trie.
 	h256Hash leftOvers(std::ostream* _out = nullptr) const
 	{
 		h256Hash k = m_db->keys();
@@ -146,11 +210,14 @@ public:
 		return k;
 	}
 
+	/// Used for debugging, scans the whole trie.
 	void debugStructure(std::ostream& _out) const
 	{
 		leftOvers(&_out);
 	}
 
+	/// Used for debugging, scans the whole trie.
+	/// @param _requireNoLeftOvers if true, requires that all keys are reachable.
 	bool check(bool _requireNoLeftOvers) const
 	{
 		try
@@ -164,66 +231,6 @@ public:
 		}
 	}
 
-	std::string at(bytes const& _key) const { return at(&_key); }
-	std::string at(bytesConstRef _key) const;
-	void insert(bytes const& _key, bytes const& _value) { insert(&_key, &_value); }
-	void insert(bytesConstRef _key, bytes const& _value) { insert(_key, &_value); }
-	void insert(bytes const& _key, bytesConstRef _value) { insert(&_key, _value); }
-	void insert(bytesConstRef _key, bytesConstRef _value);
-	void remove(bytes const& _key) { remove(&_key); }
-	void remove(bytesConstRef _key);
-	bool contains(bytes const& _key) { return contains(&_key); }
-	bool contains(bytesConstRef _key) { return !at(_key).empty(); }
-
-	class iterator
-	{
-	public:
-		using value_type = std::pair<bytesConstRef, bytesConstRef>;
-
-		iterator() {}
-		iterator(GenericTrieDB const* _db);
-		iterator(GenericTrieDB const* _db, bytesConstRef _key);
-
-		iterator& operator++() { next(); return *this; }
-
-		value_type operator*() const { return at(); }
-		value_type operator->() const { return at(); }
-
-		bool operator==(iterator const& _c) const { return _c.m_trail == m_trail; }
-		bool operator!=(iterator const& _c) const { return _c.m_trail != m_trail; }
-
-		value_type at() const;
-
-	private:
-		void next();
-		void next(NibbleSlice _key);
-
-		struct Node
-		{
-			std::string rlp;
-			std::string key;		// as hexPrefixEncoding.
-			byte child;				// 255 -> entering, 16 -> actually at the node, 17 -> exiting, 0-15 -> actual children.
-
-			// 255 -> 16 -> 0 -> 1 -> ... -> 15 -> 17
-
-			void setChild(unsigned _i) { child = _i; }
-			void setFirstChild() { child = 16; }
-			void incrementChild() { child = child == 16 ? 0 : child == 15 ? 17 : (child + 1); }
-
-			bool operator==(Node const& _c) const { return rlp == _c.rlp && key == _c.key && child == _c.child; }
-			bool operator!=(Node const& _c) const { return !operator==(_c); }
-		};
-
-	protected:
-		std::vector<Node> m_trail;
-		GenericTrieDB<DB> const* m_that;
-	};
-
-	iterator begin() const { return this; }
-	iterator end() const { return iterator(); }
-
-	iterator lower_bound(bytesConstRef _key) const { return iterator(this, _key); }
-
 protected:
 	DB* db() const { return m_db; }
 
@@ -279,12 +286,12 @@ private:
 	bool isTwoItemNode(RLP const& _n) const;
 	std::string deref(RLP const& _n) const;
 
-	std::string node(h256 _h) const { return m_db->lookup(_h); }
+	std::string node(h256 const& _h) const { return m_db->lookup(_h); }
 
 	// These are low-level node insertion functions that just go straight through into the DB.
 	h256 forceInsertNode(bytesConstRef _v) { auto h = sha3(_v); forceInsertNode(h, _v); return h; }
-	void forceInsertNode(h256 _h, bytesConstRef _v) { m_db->insert(_h, _v); }
-	void forceKillNode(h256 _h) { m_db->kill(_h); }
+	void forceInsertNode(h256 const& _h, bytesConstRef _v) { m_db->insert(_h, _v); }
+	void forceKillNode(h256 const& _h) { m_db->kill(_h); }
 
 	// This are semantically-aware node insertion functions that only kills when the node's
 	// data is < 32 bytes. It can safely be used when pruning the trie but won't work correctly
@@ -305,6 +312,9 @@ std::ostream& operator<<(std::ostream& _out, GenericTrieDB<DB> const& _db)
 	return _out;
 }
 
+/**
+ * Different view on a GenericTrieDB that can use different key types.
+ */
 template <class Generic, class _KeyType>
 class SpecificTrieDB: public Generic
 {
@@ -753,14 +763,14 @@ template <class DB> void GenericTrieDB<DB>::insert(bytesConstRef _key, bytesCons
 	tdebug << "Insert" << toHex(_key.cropped(0, 4)) << "=>" << toHex(_value);
 #endif
 
-	std::string rv = node(m_root);
-	assert(rv.size());
-	bytes b = mergeAt(RLP(rv), m_root, NibbleSlice(_key), _value);
+	std::string rootValue = node(m_root);
+	assert(rootValue.size());
+	bytes b = mergeAt(RLP(rootValue), m_root, NibbleSlice(_key), _value);
 
 	// mergeAt won't attempt to delete the node if it's less than 32 bytes
 	// However, we know it's the root node and thus always hashed.
 	// So, if it's less than 32 (and thus should have been deleted but wasn't) then we delete it here.
-	if (rv.size() < 32)
+	if (rootValue.size() < 32)
 		forceKillNode(m_root);
 	m_root = forceInsertNode(&b);
 }
@@ -1066,11 +1076,11 @@ template <class DB> bytes GenericTrieDB<DB>::place(RLP const& _orig, NibbleSlice
 
 	killNode(_orig);
 	if (_orig.isEmpty())
-		return (RLPStream(2) << hexPrefixEncode(_k, true) << _s).out();
+		return rlpList(hexPrefixEncode(_k, true), _s);
 
 	assert(_orig.isList() && (_orig.itemCount() == 2 || _orig.itemCount() == 17));
 	if (_orig.itemCount() == 2)
-		return (RLPStream(2) << _orig[0] << _s).out();
+		return rlpList(_orig[0], _s);
 
 	auto s = RLPStream(17);
 	for (unsigned i = 0; i < 16; ++i)
@@ -1152,7 +1162,7 @@ template <class DB> bytes GenericTrieDB<DB>::graft(RLP const& _orig)
 	}
 	assert(n.itemCount() == 2);
 
-	return (RLPStream(2) << hexPrefixEncode(keyOf(_orig), keyOf(n), isLeaf(n)) << n[1]).out();
+	return rlpList(hexPrefixEncode(keyOf(_orig), keyOf(n), isLeaf(n)), n[1]);
 //	auto ret =
 //	std::cout << keyOf(_orig) << " ++ " << keyOf(n) << " == " << keyOf(RLP(ret)) << std::endl;
 //	return ret;
@@ -1201,11 +1211,7 @@ template <class DB> bytes GenericTrieDB<DB>::branch(RLP const& _orig)
 		for (unsigned i = 0; i < 16; ++i)
 			if (i == b)
 				if (isLeaf(_orig) || k.size() > 1)
-				{
-					RLPStream bottom(2);
-					bottom << hexPrefixEncode(k.mid(1), isLeaf(_orig)) << _orig[1];
-					streamNode(r, bottom.out());
-				}
+					streamNode(r, rlpList(hexPrefixEncode(k.mid(1), isLeaf(_orig)), _orig[1]));
 				else
 					r << _orig[1];
 			else

libdevcrypto/Common.cpp

@@ -22,6 +22,7 @@
 
 #include "Common.h"
 #include <random>
+#include <cstdint>
 #include <chrono>
 #include <thread>
 #include <mutex>
@@ -29,6 +30,7 @@
 #include <libdevcore/Guards.h>
 #include <libdevcore/SHA3.h>
 #include <libdevcore/FileSystem.h>
+#include <libdevcore/RLP.h>
 #if ETH_HAVE_SECP256K1
 #include <secp256k1/secp256k1.h>
 #endif
@@ -90,6 +92,11 @@ Address dev::toAddress(Secret const& _secret)
 	return toAddress(p);
 }
 
+Address dev::toAddress(Address const& _from, u256 const& _nonce)
+{
+	return right160(sha3(rlpList(_from, _nonce)));
+}
+
 void dev::encrypt(Public const& _k, bytesConstRef _plain, bytes& o_cipher)
 {
 	bytes io = _plain.toBytes();
@@ -256,16 +263,9 @@ bytes dev::scrypt(std::string const& _pass, bytes const& _salt, uint64_t _n, uin
 
 KeyPair KeyPair::create()
 {
-	static boost::thread_specific_ptr<mt19937_64> s_eng;
-	static unsigned s_id = 0;
-	if (!s_eng.get())
-		s_eng.reset(new mt19937_64(time(0) + chrono::high_resolution_clock::now().time_since_epoch().count() + ++s_id));
-
-	uniform_int_distribution<uint16_t> d(0, 255);
-
 	for (int i = 0; i < 100; ++i)
 	{
-		KeyPair ret(FixedHash<32>::random(*s_eng.get()));
+		KeyPair ret(FixedHash<32>::random());
 		if (ret.address())
 			return ret;
 	}
@@ -347,7 +347,7 @@ void Nonce::initialiseIfNeeded()
 		std::mt19937_64 s_eng(time(0) + chrono::high_resolution_clock::now().time_since_epoch().count());
 		std::uniform_int_distribution<uint16_t> d(0, 255);
 		for (unsigned i = 0; i < 32; ++i)
-			m_value[i] = byte(d(s_eng));
+			m_value[i] = (uint8_t)d(s_eng);
 	}
 	if (!m_value)
 		BOOST_THROW_EXCEPTION(InvalidState());

libdevcrypto/Common.h

@@ -85,6 +85,9 @@ Address toAddress(Public const& _public);
 /// @returns 0 if it's not a valid secret key.
 Address toAddress(Secret const& _secret);
 
+// Convert transaction from and nonce to address.
+Address toAddress(Address const& _from, u256 const& _nonce);
+
 /// Encrypts plain text using Public key.
 void encrypt(Public const& _k, bytesConstRef _plain, bytes& o_cipher);
 

libethash-cl/ethash_cl_miner.cpp

@@ -33,7 +33,6 @@
 #include <vector>
 #include <libethash/util.h>
 #include <libethash/ethash.h>
-#include <libethcore/Ethash.h>
 #include <libethash/internal.h>
 #include "ethash_cl_miner.h"
 #include "ethash_cl_miner_kernel.h"
@@ -50,7 +49,10 @@
 #undef max
 
 using namespace std;
-using namespace dev::eth;
+
+unsigned const ethash_cl_miner::c_defaultLocalWorkSize = 64;
+unsigned const ethash_cl_miner::c_defaultGlobalWorkSizeMultiplier = 4096; // * CL_DEFAULT_LOCAL_WORK_SIZE
+unsigned const ethash_cl_miner::c_defaultMSPerBatch = 0;
 
 // TODO: If at any point we can use libdevcore in here then we should switch to using a LogChannel
 #define ETHCL_LOG(_contents) cout << "[OPENCL]:" << _contents << endl
@@ -147,7 +149,7 @@ bool ethash_cl_miner::configureGPU(
 	unsigned _msPerBatch,
 	bool _allowCPU,
 	unsigned _extraGPUMemory,
-	boost::optional<uint64_t> _currentBlock
+	uint64_t _currentBlock
 )
 {
 	s_workgroupSize = _localWorkSize;
@@ -156,7 +158,7 @@ bool ethash_cl_miner::configureGPU(
 	s_allowCPU = _allowCPU;
 	s_extraRequiredGPUMem = _extraGPUMemory;
 	// by default let's only consider the DAG of the first epoch
-	uint64_t dagSize = _currentBlock ? ethash_get_datasize(*_currentBlock) : 1073739904U;
+	uint64_t dagSize = ethash_get_datasize(_currentBlock);
 	uint64_t requiredSize =  dagSize + _extraGPUMemory;
 	return searchForAllDevices(_platformId, [&requiredSize](cl::Device const _device) -> bool
 		{
@@ -183,9 +185,9 @@ bool ethash_cl_miner::configureGPU(
 
 bool ethash_cl_miner::s_allowCPU = false;
 unsigned ethash_cl_miner::s_extraRequiredGPUMem;
-unsigned ethash_cl_miner::s_msPerBatch = Ethash::defaultMSPerBatch;
-unsigned ethash_cl_miner::s_workgroupSize = Ethash::defaultLocalWorkSize;
-unsigned ethash_cl_miner::s_initialGlobalWorkSize = Ethash::defaultGlobalWorkSizeMultiplier * Ethash::defaultLocalWorkSize;
+unsigned ethash_cl_miner::s_msPerBatch = ethash_cl_miner::c_defaultMSPerBatch;
+unsigned ethash_cl_miner::s_workgroupSize = ethash_cl_miner::c_defaultLocalWorkSize;
+unsigned ethash_cl_miner::s_initialGlobalWorkSize = ethash_cl_miner::c_defaultGlobalWorkSizeMultiplier * ethash_cl_miner::c_defaultLocalWorkSize;
 
 bool ethash_cl_miner::searchForAllDevices(function<bool(cl::Device const&)> _callback)
 {

libethash-cl/ethash_cl_miner.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#define __CL_ENABLE_EXCEPTIONS 
+#define __CL_ENABLE_EXCEPTIONS
 #define CL_USE_DEPRECATED_OPENCL_2_0_APIS
 
 #if defined(__clang__)
@@ -12,7 +12,6 @@
 #include "cl.hpp"
 #endif
 
-#include <boost/optional.hpp>
 #include <time.h>
 #include <functional>
 #include <libethash/ethash.h>
@@ -20,7 +19,7 @@
 class ethash_cl_miner
 {
 private:
-	enum { c_maxSearchResults = 63, c_bufferCount = 2, c_hashBatchSize = 1024, c_searchBatchSize = 1024 * 16 };
+	enum { c_maxSearchResults = 63, c_bufferCount = 2, c_hashBatchSize = 1024 };
 
 public:
 	struct search_hook
@@ -50,7 +49,7 @@ public:
 		unsigned _msPerBatch,
 		bool _allowCPU,
 		unsigned _extraGPUMemory,
-		boost::optional<uint64_t> _currentBlock
+		uint64_t _currentBlock
 	);
 
 	bool init(
@@ -65,6 +64,14 @@ public:
 	void hash_chunk(uint8_t* _ret, uint8_t const* _header, uint64_t _nonce, unsigned _count);
 	void search_chunk(uint8_t const*_header, uint64_t _target, search_hook& _hook);
 
+	/* -- default values -- */
+	/// Default value of the local work size. Also known as workgroup size.
+	static unsigned const c_defaultLocalWorkSize;
+	/// Default value of the global work size as a multiplier of the local work size
+	static unsigned const c_defaultGlobalWorkSizeMultiplier;
+	/// Default value of the milliseconds per global work size (per batch)
+	static unsigned const c_defaultMSPerBatch;
+
 private:
 
 	static std::vector<cl::Device> getDevices(std::vector<cl::Platform> const& _platforms, unsigned _platformId);

libethcore/Common.h

@@ -157,7 +157,8 @@ public:
 	~Signal()
 	{
 		for (auto const& h : m_fire)
-			h.second->reset();
+			if (auto l = h.second.lock())
+				l->reset();
 	}
 
 	std::shared_ptr<HandlerAux> add(Callback const& _h)
@@ -168,10 +169,15 @@ public:
 		return h;
 	}
 
-	void operator()(Args&... _args) { for (auto const& f: m_fire) f.second->fire(std::forward<Args>(_args)...); }
+	void operator()(Args&... _args)
+	{
+		for (auto const& f: m_fire)
+			if (auto h = f.second.lock())
+				h->fire(std::forward<Args>(_args)...);
+	}
 
 private:
-	std::map<unsigned, std::shared_ptr<typename Signal::HandlerAux>> m_fire;
+	std::map<unsigned, std::weak_ptr<typename Signal::HandlerAux>> m_fire;
 };
 
 template<class... Args> using Handler = std::shared_ptr<typename Signal<Args...>::HandlerAux>;

libethcore/Ethash.cpp

@@ -54,9 +54,6 @@ namespace dev
 namespace eth
 {
 
-const unsigned Ethash::defaultLocalWorkSize = 64;
-const unsigned Ethash::defaultGlobalWorkSizeMultiplier = 512; // * CL_DEFAULT_LOCAL_WORK_SIZE
-const unsigned Ethash::defaultMSPerBatch = 100;
 const Ethash::WorkPackage Ethash::NullWorkPackage = Ethash::WorkPackage();
 
 std::string Ethash::name()
@@ -419,7 +416,7 @@ bool Ethash::GPUMiner::configureGPU(
 	unsigned _deviceId,
 	bool _allowCPU,
 	unsigned _extraGPUMemory,
-	boost::optional<uint64_t> _currentBlock
+	uint64_t _currentBlock
 )
 {
 	s_platformId = _platformId;

libethcore/Ethash.h

@@ -88,7 +88,7 @@ public:
 		static unsigned instances() { return s_numInstances > 0 ? s_numInstances : std::thread::hardware_concurrency(); }
 		static std::string platformInfo();
 		static void listDevices() {}
-		static bool configureGPU(unsigned, unsigned, unsigned, unsigned, unsigned, bool, unsigned,  boost::optional<uint64_t>) { return false; }
+		static bool configureGPU(unsigned, unsigned, unsigned, unsigned, unsigned, bool, unsigned, uint64_t) { return false; }
 		static void setNumInstances(unsigned _instances) { s_numInstances = std::min<unsigned>(_instances, std::thread::hardware_concurrency()); }
 	protected:
 		void kickOff() override
@@ -125,7 +125,7 @@ public:
 			unsigned _deviceId,
 			bool _allowCPU,
 			unsigned _extraGPUMemory,
-			boost::optional<uint64_t> _currentBlock
+			uint64_t _currentBlock
 		);
 		static void setNumInstances(unsigned _instances) { s_numInstances = std::min<unsigned>(_instances, getNumDevices()); }
 
@@ -150,12 +150,6 @@ public:
 #else
 	using GPUMiner = CPUMiner;
 #endif
-	/// Default value of the local work size. Also known as workgroup size.
-	static const unsigned defaultLocalWorkSize;
-	/// Default value of the global work size as a multiplier of the local work size
-	static const unsigned defaultGlobalWorkSizeMultiplier;
-	/// Default value of the milliseconds per global work size (per batch)
-	static const unsigned defaultMSPerBatch;
 };
 
 }

libethereum/BlockChain.cpp

@@ -192,6 +192,8 @@ unsigned BlockChain::open(std::string const& _path, WithExisting _we)
 		}
 	}
 
+	m_writeOptions.sync = true;
+
 	if (_we != WithExisting::Verify && !details(m_genesisHash))
 	{
 		// Insert details of genesis block.
@@ -273,7 +275,7 @@ void BlockChain::rebuild(std::string const& _path, std::function<void(unsigned,
 
 	h256 lastHash = m_lastBlockHash;
 	Timer t;
-	for (unsigned d = 1; d < originalNumber; ++d)
+	for (unsigned d = 1; d <= originalNumber; ++d)
 	{
 		if (!(d % 1000))
 		{
@@ -799,6 +801,75 @@ void BlockChain::clearBlockBlooms(unsigned _begin, unsigned _end)
 	}
 }
 
+void BlockChain::rescue(OverlayDB& _db)
+{
+	cout << "Rescuing database..." << endl;
+
+	unsigned u = 1;
+	while (true)
+	{
+		try {
+			if (isKnown(numberHash(u)))
+				u *= 2;
+			else
+				break;
+		}
+		catch (...)
+		{
+			break;
+		}
+	}
+	unsigned l = u / 2;
+	cout << "Finding last likely block number..." << endl;
+	while (u - l > 1)
+	{
+		unsigned m = (u + l) / 2;
+		cout << " " << m << flush;
+		if (isKnown(numberHash(m)))
+			l = m;
+		else
+			u = m;
+	}
+	cout << "  lowest is " << l << endl;
+	for (;; --l)
+	{
+		h256 h = numberHash(l);
+		cout << "Checking validity of " << l << " (" << h << ")..." << flush;
+		try
+		{
+			cout << "block..." << flush;
+			BlockInfo bi = info(h);
+			cout << "details..." << flush;
+			BlockDetails bd = details(h);
+			cout << "state..." << flush;
+			if (_db.exists(bi.stateRoot))
+				break;
+		}
+		catch (...) {}
+	}
+	cout << "OK." << endl;
+	rewind(l);
+}
+
+void BlockChain::rewind(unsigned _newHead)
+{
+	DEV_WRITE_GUARDED(x_lastBlockHash)
+	{
+		if (_newHead >= m_lastBlockNumber)
+			return;
+		m_lastBlockHash = numberHash(_newHead);
+		m_lastBlockNumber = _newHead;
+		auto o = m_extrasDB->Put(m_writeOptions, ldb::Slice("best"), ldb::Slice((char const*)&m_lastBlockHash, 32));
+		if (!o.ok())
+		{
+			cwarn << "Error writing to extras database: " << o.ToString();
+			cout << "Put" << toHex(bytesConstRef(ldb::Slice("best"))) << "=>" << toHex(bytesConstRef(ldb::Slice((char const*)&m_lastBlockHash, 32)));
+			cwarn << "Fail writing to extras database. Bombing out.";
+			exit(-1);
+		}
+	}
+}
+
 tuple<h256s, h256, unsigned> BlockChain::treeRoute(h256 const& _from, h256 const& _to, bool _common, bool _pre, bool _post) const
 {
 //	cdebug << "treeRoute" << _from << "..." << _to;
@@ -871,33 +942,21 @@ template <class T> static unsigned getHashSize(unordered_map<h256, T> const& _ma
 
 void BlockChain::updateStats() const
 {
-	{
-		ReadGuard l(x_blocks);
-		m_lastStats.memBlocks = 0;
+	m_lastStats.memBlocks = 0;
+	DEV_READ_GUARDED(x_blocks)
 		for (auto const& i: m_blocks)
 			m_lastStats.memBlocks += i.second.size() + 64;
-	}
-	{
-		ReadGuard l(x_details);
+	DEV_READ_GUARDED(x_details)
 		m_lastStats.memDetails = getHashSize(m_details);
-	}
-	{
-		ReadGuard l1(x_logBlooms);
-		ReadGuard l2(x_blocksBlooms);
-		m_lastStats.memLogBlooms = getHashSize(m_logBlooms) + getHashSize(m_blocksBlooms);
-	}
-	{
-		ReadGuard l(x_receipts);
+	DEV_READ_GUARDED(x_logBlooms)
+		DEV_READ_GUARDED(x_blocksBlooms)
+			m_lastStats.memLogBlooms = getHashSize(m_logBlooms) + getHashSize(m_blocksBlooms);
+	DEV_READ_GUARDED(x_receipts)
 		m_lastStats.memReceipts = getHashSize(m_receipts);
-	}
-	{
-		ReadGuard l(x_blockHashes);
+	DEV_READ_GUARDED(x_blockHashes)
 		m_lastStats.memBlockHashes = getHashSize(m_blockHashes);
-	}
-	{
-		ReadGuard l(x_transactionAddresses);
+	DEV_READ_GUARDED(x_transactionAddresses)
 		m_lastStats.memTransactionAddresses = getHashSize(m_transactionAddresses);
-	}
 }
 
 void BlockChain::garbageCollect(bool _force)
@@ -954,10 +1013,8 @@ void BlockChain::garbageCollect(bool _force)
 
 void BlockChain::checkConsistency()
 {
-	{
-		WriteGuard l(x_details);
+	DEV_WRITE_GUARDED(x_details)
 		m_details.clear();
-	}
 	ldb::Iterator* it = m_blocksDB->NewIterator(m_readOptions);
 	for (it->SeekToFirst(); it->Valid(); it->Next())
 		if (it->key().size() == 32)
@@ -969,13 +1026,9 @@ void BlockChain::checkConsistency()
 			{
 				auto dp = details(p);
 				if (asserts(contains(dp.children, h)))
-				{
 					cnote << "Apparently the database is corrupt. Not much we can do at this stage...";
-				}
 				if (assertsEqual(dp.number, dh.number - 1))
-				{
 					cnote << "Apparently the database is corrupt. Not much we can do at this stage...";
-				}
 			}
 		}
 	delete it;
@@ -1088,7 +1141,8 @@ bool BlockChain::isKnown(h256 const& _hash) const
 			if (d.empty())
 				return false;
 		}
-	return true;
+//	return true;
+	return details(_hash).number <= m_lastBlockNumber;		// to allow rewind functionality.
 }
 
 bytes BlockChain::block(h256 const& _hash) const

libethereum/BlockChain.h

@@ -142,6 +142,9 @@ public:
 	BlockReceipts receipts(h256 const& _hash) const { return queryExtras<BlockReceipts, ExtraReceipts>(_hash, m_receipts, x_receipts, NullBlockReceipts); }
 	BlockReceipts receipts() const { return receipts(currentHash()); }
 
+	/// Get the transaction receipt by transaction hash. Thread-safe.
+	TransactionReceipt transactionReceipt(h256 const& _transactionHash) const {TransactionAddress ta = queryExtras<TransactionAddress, ExtraTransactionAddress>(_transactionHash, m_transactionAddresses, x_transactionAddresses, NullTransactionAddress); if (!ta) return bytesConstRef(); return receipts(ta.blockHash).receipts[ta.index]; }
+
 	/// Get a list of transaction hashes for a given block. Thread-safe.
 	TransactionHashes transactionHashes(h256 const& _hash) const { auto b = block(_hash); RLP rlp(b); h256s ret; for (auto t: rlp[1]) ret.push_back(sha3(t.data())); return ret; }
 	TransactionHashes transactionHashes() const { return transactionHashes(currentHash()); }
@@ -212,6 +215,12 @@ public:
 	/// Will call _progress with the progress in this operation first param done, second total.
 	void rebuild(std::string const& _path, ProgressCallback const& _progress = std::function<void(unsigned, unsigned)>(), bool _prepPoW = false);
 
+	/// Alter the head of the chain to some prior block along it.
+	void rewind(unsigned _newHead);
+
+	/// Rescue the database.
+	void rescue(OverlayDB& _db);
+
 	/** @returns a tuple of:
 	 * - an vector of hashes of all blocks between @a _from and @a _to, all blocks are ordered first by a number of
 	 * blocks that are parent-to-child, then two sibling blocks, then a number of blocks that are child-to-parent;

libethereum/BlockChainSync.cpp

@@ -80,7 +80,7 @@ DownloadMan& BlockChainSync::downloadMan()
 
 void BlockChainSync::abortSync()
 {
-	downloadMan().resetToChain(h256s());
+	downloadMan().reset();
 }
 
 void BlockChainSync::onPeerStatus(std::shared_ptr<EthereumPeer> _peer)
@@ -296,10 +296,16 @@ void BlockChainSync::onPeerNewBlock(std::shared_ptr<EthereumPeer> _peer, RLP con
 
 		case ImportResult::FutureTimeUnknown:
 		case ImportResult::UnknownParent:
+		{
 			logNewBlock(h);
-			clog(NetMessageDetail) << "Received block with no known parent. Resyncing...";
-			resetSyncFor(_peer, h, _r[1].toInt<u256>());
+			u256 totalDifficulty = _r[1].toInt<u256>();
+			if (totalDifficulty > _peer->m_totalDifficulty)
+			{
+				clog(NetMessageDetail) << "Received block with no known parent. Resyncing...";
+				resetSyncFor(_peer, h, totalDifficulty);
+			}
 			break;
+		}
 		default:;
 		}
 
@@ -397,7 +403,6 @@ void PV60Sync::transition(std::shared_ptr<EthereumPeer> _peer, SyncState _s, boo
 	if (m_state == SyncState::Idle && _s != SyncState::Idle)
 		_peer->m_requireTransactions = true;
 
-	RLPStream s;
 	if (_s == SyncState::Hashes)
 	{
 		if (m_state == SyncState::Idle || m_state == SyncState::Hashes)
@@ -1165,9 +1170,9 @@ SyncStatus PV61Sync::status() const
 {
 	RecursiveGuard l(x_sync);
 	SyncStatus res = PV60Sync::status();
+	res.protocolVersion = 61;
 	if (m_state == SyncState::Hashes && isPV61Syncing())
 	{
-		res.protocolVersion = 61;
 		res.hashesReceived = 0;
 		for (auto const& d : m_readyChainMap)
 			res.hashesReceived += d.second.size();

libethereum/BlockChainSync.h

@@ -58,6 +58,9 @@ public:
 	/// @returns true is Sync is in progress
 	virtual bool isSyncing() const = 0;
 
+	/// Restart sync
+	virtual void restartSync() = 0;
+
 	/// Called by peer to report status
 	virtual void onPeerStatus(std::shared_ptr<EthereumPeer> _peer);
 
@@ -92,9 +95,6 @@ protected:
 	/// Resume downloading after witing state
 	virtual void continueSync() = 0;
 
-	/// Restart sync
-	virtual void restartSync() = 0;
-
 	/// Called after all blocks have been donloaded
 	virtual void completeSync() = 0;
 

libethereum/BlockDetails.h

@@ -59,7 +59,7 @@ struct BlockLogBlooms
 {
 	BlockLogBlooms() {}
 	BlockLogBlooms(RLP const& _r) { blooms = _r.toVector<LogBloom>(); size = _r.data().size(); }
-	bytes rlp() const { RLPStream s; s << blooms; size = s.out().size(); return s.out(); }
+	bytes rlp() const { bytes r = dev::rlp(blooms); size = r.size(); return r; }
 
 	LogBlooms blooms;
 	mutable unsigned size;
@@ -69,7 +69,7 @@ struct BlocksBlooms
 {
 	BlocksBlooms() {}
 	BlocksBlooms(RLP const& _r) { blooms = _r.toArray<LogBloom, c_bloomIndexSize>(); size = _r.data().size(); }
-	bytes rlp() const { RLPStream s; s << blooms; size = s.out().size(); return s.out(); }
+	bytes rlp() const { bytes r = dev::rlp(blooms); size = r.size(); return r; }
 
 	std::array<LogBloom, c_bloomIndexSize> blooms;
 	mutable unsigned size;

libethereum/BlockQueue.cpp

@@ -215,8 +215,10 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 		return ImportResult::Malformed;
 	}
 
+	clog(BlockQueueTraceChannel) << "Block" << h << "is" << bi.number << "parent is" << bi.parentHash;
+
 	// Check block doesn't already exist first!
-	if (_bc.details(h))
+	if (_bc.isKnown(h))
 	{
 		cblockq << "Already known in chain.";
 		return ImportResult::AlreadyInChain;

libethereum/Client.cpp

@@ -67,7 +67,7 @@ static const Addresses c_canaries =
 	Address("4bb7e8ae99b645c2b7860b8f3a2328aae28bd80a"),		// gav
 	Address("1baf27b88c48dd02b744999cf3522766929d2b2a"),		// vitalik
 	Address("a8edb1ac2c86d3d9d78f96cd18001f60df29e52c"),		// jeff
-	Address("60d11b58744784dc97f878f7e3749c0f1381a004")			// christoph
+	Address("ace7813896a84d3f5f80223916a5353ab16e46e6")			// christoph
 };
 
 VersionChecker::VersionChecker(string const& _dbPath)
@@ -90,6 +90,9 @@ Client::Client(p2p::Host* _extNet, std::shared_ptr<GasPricer> _gp, std::string c
 	m_preMine(m_stateDB, BaseState::CanonGenesis),
 	m_postMine(m_stateDB)
 {
+	if (_forceAction == WithExisting::Rescue)
+		m_bc.rescue(m_stateDB);
+
 	m_lastGetWork = std::chrono::system_clock::now() - chrono::seconds(30);
 	m_tqReady = m_tq.onReady([=](){ this->onTransactionQueueReady(); });	// TODO: should read m_tq->onReady(thisThread, syncTransactionQueue);
 	m_bqReady = m_bq.onReady([=](){ this->onBlockQueueReady(); });			// TODO: should read m_bq->onReady(thisThread, syncBlockQueue);

libethereum/Client.h

@@ -217,6 +217,8 @@ public:
 	std::string const& sentinel() const { return m_sentinel; }
 	/// Set the extra data that goes into mined blocks.
 	void setExtraData(bytes const& _extraData) { m_extraData = _extraData; }
+	/// Rewind to a prior head.
+	void rewind(unsigned _n) { m_bc.rewind(_n); }
 
 protected:
 	/// InterfaceStub methods

libethereum/ClientBase.cpp

@@ -45,7 +45,7 @@ State ClientBase::asOf(BlockNumber _h) const
 	return asOf(bc().numberHash(_h));
 }
 
-Address ClientBase::submitTransaction(TransactionSkeleton const& _t, Secret const& _secret)
+pair<h256, Address> ClientBase::submitTransaction(TransactionSkeleton const& _t, Secret const& _secret)
 {
 	prepareForTransaction();
 	
@@ -59,7 +59,7 @@ Address ClientBase::submitTransaction(TransactionSkeleton const& _t, Secret cons
 	StructuredLogger::transactionReceived(t.sha3().abridged(), t.sender().abridged());
 	cnote << "New transaction " << t;
 	
-	return _t.creation ? right160(sha3(rlpList(ts.from, ts.nonce))) : Address();
+	return make_pair(t.sha3(), toAddress(ts.from, ts.nonce));
 }
 
 // TODO: remove try/catch, allow exceptions
@@ -327,6 +327,11 @@ Transaction ClientBase::transaction(h256 _blockHash, unsigned _i) const
 		return Transaction();
 }
 
+TransactionReceipt ClientBase::transactionReceipt(h256 const& _transactionHash) const
+{
+	return bc().transactionReceipt(_transactionHash);
+}
+
 pair<h256, unsigned> ClientBase::transactionLocation(h256 const& _transactionHash) const
 {
 	return bc().transactionLocation(_transactionHash);

libethereum/ClientBase.h

@@ -76,8 +76,8 @@ public:
 	virtual ~ClientBase() {}
 
 	/// Submits the given transaction.
-	/// @returns the new contract's address (assuming it all goes through).
-	virtual Address submitTransaction(TransactionSkeleton const& _t, Secret const& _secret) override;
+	/// @returns the new transaction's hash.
+	virtual std::pair<h256, Address> submitTransaction(TransactionSkeleton const& _t, Secret const& _secret) override;
 	using Interface::submitTransaction;
 
 	/// Makes the given call. Nothing is recorded into the state.
@@ -119,6 +119,7 @@ public:
 	virtual BlockDetails blockDetails(h256 _hash) const override;
 	virtual Transaction transaction(h256 _transactionHash) const override;
 	virtual Transaction transaction(h256 _blockHash, unsigned _i) const override;
+	virtual TransactionReceipt transactionReceipt(h256 const& _transactionHash) const override;
 	virtual std::pair<h256, unsigned> transactionLocation(h256 const& _transactionHash) const override;
 	virtual Transactions transactions(h256 _blockHash) const override;
 	virtual TransactionHashes transactionHashes(h256 _blockHash) const override;

libethereum/DownloadMan.cpp

@@ -24,6 +24,16 @@ using namespace std;
 using namespace dev;
 using namespace dev::eth;
 
+DownloadMan::Overview DownloadMan::overview() const
+{
+	ReadGuard l(m_lock);
+	Overview ret;
+	ret.firstIncomplete = m_blocksGot.firstOut();
+	ret.lastComplete = ret.lastStarted = m_blocksGot.lastIn();// TODO: lastStarted properly
+	ret.total = m_blocksGot.size();
+	return ret;
+}
+
 DownloadSub::DownloadSub(DownloadMan& _man): m_man(&_man)
 {
 	WriteGuard l(m_man->x_subs);

libethereum/DownloadMan.h

@@ -82,6 +82,14 @@ class DownloadMan
 	friend class DownloadSub;
 
 public:
+	struct Overview
+	{
+		size_t total;
+		size_t firstIncomplete;
+		size_t lastComplete;
+		size_t lastStarted;
+	};
+
 	~DownloadMan()
 	{
 		for (auto i: m_subs)
@@ -97,11 +105,9 @@ public:
 
 	void resetToChain(h256s const& _chain)
 	{
-		{
-			ReadGuard l(x_subs);
+		DEV_READ_GUARDED(x_subs)
 			for (auto i: m_subs)
 				i->resetFetch();
-		}
 		WriteGuard l(m_lock);
 		m_chain.clear();
 		m_chain.reserve(_chain.size());
@@ -112,11 +118,9 @@ public:
 
 	void reset()
 	{
-		{
-			ReadGuard l(x_subs);
+		DEV_READ_GUARDED(x_subs)
 			for (auto i: m_subs)
 				i->resetFetch();
-		}
 		WriteGuard l(m_lock);
 		m_chain.clear();
 		m_blocksGot.reset();
@@ -127,11 +131,9 @@ public:
 		ReadGuard l(m_lock);
 		auto ret = m_blocksGot;
 		if (!_desperate)
-		{
-			ReadGuard l(x_subs);
-			for (auto i: m_subs)
-				ret += i->m_asked;
-		}
+			DEV_READ_GUARDED(x_subs)
+				for (auto i: m_subs)
+					ret += i->m_asked;
 		return ret;
 	}
 
@@ -144,12 +146,15 @@ public:
 	h256s remaining() const
 	{
 		h256s ret;
-		ReadGuard l(m_lock);
-		for (auto i: m_blocksGot.inverted())
-			ret.push_back(m_chain[i]);
+		DEV_READ_GUARDED(m_lock)
+			for (auto i: m_blocksGot.inverted())
+				ret.push_back(m_chain[i]);
 		return ret;
 	}
 
+	h256 firstBlock() const { return m_chain.empty() ? h256() : m_chain[0]; }
+	Overview overview() const;
+
 	size_t chainSize() const { ReadGuard l(m_lock); return m_chain.size(); }
 	size_t chainEmpty() const { ReadGuard l(m_lock); return m_chain.empty(); }
 	void foreachSub(std::function<void(DownloadSub const&)> const& _f) const { ReadGuard l(x_subs); for(auto i: m_subs) _f(*i); }

libethereum/EthereumHost.cpp

@@ -45,6 +45,12 @@ static unsigned const c_maxSendTransactions = 256;
 
 char const* const EthereumHost::s_stateNames[static_cast<int>(SyncState::Size)] = {"Idle", "Waiting", "Hashes", "Blocks", "NewBlocks" };
 
+#ifdef _WIN32
+const char* EthereumHostTrace::name() { return EthPurple "^" EthGray "  "; }
+#else
+const char* EthereumHostTrace::name() { return EthPurple "⧫" EthGray " "; }
+#endif
+
 EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQueue& _bq, u256 _networkId):
 	HostCapability<EthereumPeer>(),
 	Worker		("ethsync"),
@@ -67,7 +73,7 @@ bool EthereumHost::ensureInitialised()
 	{
 		// First time - just initialise.
 		m_latestBlockSent = m_chain.currentHash();
-		clog(NetNote) << "Initialising: latest=" << m_latestBlockSent;
+		clog(EthereumHostTrace) << "Initialising: latest=" << m_latestBlockSent;
 
 		Guard l(x_transactions);
 		m_transactionsSent = m_tq.knownTransactions();
@@ -82,6 +88,7 @@ void EthereumHost::reset()
 	if (m_sync)
 		m_sync->abortSync();
 	m_sync.reset();
+	m_syncStart = 0;
 
 	m_latestBlockSent = h256();
 	Guard tl(x_transactions);
@@ -109,6 +116,21 @@ void EthereumHost::doWork()
 
 	foreachPeer([](std::shared_ptr<EthereumPeer> _p) { _p->tick(); return true; });
 
+	if (m_syncStart)
+	{
+		DEV_GUARDED(x_sync)
+			if (!m_sync)
+			{
+				time_t now = std::chrono::system_clock::to_time_t(chrono::system_clock::now());
+				if (now - m_syncStart > 10)
+				{
+					m_sync.reset(new PV60Sync(*this));
+					m_syncStart = 0;
+					m_sync->restartSync();
+				}
+			}
+	}
+
 //	return netChange;
 	// TODO: Figure out what to do with netChange.
 	(void)netChange;
@@ -150,7 +172,7 @@ void EthereumHost::maintainTransactions()
 			RLPStream ts;
 			_p->prep(ts, TransactionsPacket, n).appendRaw(b, n);
 			_p->sealAndSend(ts);
-			cnote << "Sent" << n << "transactions to " << _p->session()->info().clientVersion;
+			clog(EthereumHostTrace) << "Sent" << n << "transactions to " << _p->session()->info().clientVersion;
 		}
 		_p->m_requireTransactions = false;
 		return true;
@@ -206,11 +228,15 @@ void EthereumHost::maintainBlocks(h256 const& _currentHash)
 		if (diff(detailsFrom.number, detailsTo.number) < 20)
 		{
 			// don't be sending more than 20 "new" blocks. if there are any more we were probably waaaay behind.
-			clog(NetMessageSummary) << "Sending a new block (current is" << _currentHash << ", was" << m_latestBlockSent << ")";
+			clog(EthereumHostTrace) << "Sending a new block (current is" << _currentHash << ", was" << m_latestBlockSent << ")";
 
 			h256s blocks = get<0>(m_chain.treeRoute(m_latestBlockSent, _currentHash, false, false, true));
 
-			auto s = randomSelection(25, [&](EthereumPeer* p){ DEV_GUARDED(p->x_knownBlocks) return !p->m_knownBlocks.count(_currentHash); return false; });
+			auto s = randomSelection(25, [&](EthereumPeer* p){
+				DEV_GUARDED(p->x_knownBlocks)
+					return !p->m_knownBlocks.count(_currentHash);
+				return false;
+			});
 			for (shared_ptr<EthereumPeer> const& p: get<0>(s))
 				for (auto const& b: blocks)
 				{
@@ -249,7 +275,14 @@ BlockChainSync* EthereumHost::sync()
 			pv61 = true;
 		return !pv61;
 	});
-	m_sync.reset(pv61 ? new PV61Sync(*this) : new PV60Sync(*this));
+	if (pv61)
+	{
+		m_syncStart = 0;
+		m_sync.reset(new PV61Sync(*this));
+	}
+	else if (!m_syncStart)
+		m_syncStart = std::chrono::system_clock::to_time_t(chrono::system_clock::now());
+
 	return m_sync.get();
 }
 
@@ -292,11 +325,11 @@ void EthereumHost::onPeerTransactions(std::shared_ptr<EthereumPeer> _peer, RLP c
 {
 	if (_peer->isCriticalSyncing())
 	{
-		clog(NetAllDetail) << "Ignoring transaction from peer we are syncing with";
+		clog(EthereumHostTrace) << "Ignoring transaction from peer we are syncing with";
 		return;
 	}
 	unsigned itemCount = _r.itemCount();
-	clog(NetAllDetail) << "Transactions (" << dec << itemCount << "entries)";
+	clog(EthereumHostTrace) << "Transactions (" << dec << itemCount << "entries)";
 	m_tq.enqueue(_r, _peer->session()->id());
 }
 
@@ -351,10 +384,8 @@ void EthereumHost::onTransactionImported(ImportResult _ir, h256 const& _h, h512
 		break;
 	case ImportResult::AlreadyKnown:
 		// if we already had the transaction, then don't bother sending it on.
-		{
-			Guard l(x_transactions);
+		DEV_GUARDED(x_transactions)
 			m_transactionsSent.insert(_h);
-		}
 		peer->addRating(0);
 		break;
 	case ImportResult::Success:

libethereum/EthereumHost.h

@@ -49,6 +49,8 @@ class TransactionQueue;
 class BlockQueue;
 class BlockChainSync;
 
+struct EthereumHostTrace: public LogChannel { static const char* name(); static const int verbosity = 6; };
+
 /**
  * @brief The EthereumHost class
  * @warning None of this is thread-safe. You have been warned.
@@ -136,6 +138,7 @@ private:
 	mutable Mutex x_transactions;
 	DownloadMan m_man;
 	std::unique_ptr<BlockChainSync> m_sync;
+	std::atomic<time_t> m_syncStart = { 0 };
 };
 
 }

libethereum/ExtVM.cpp

@@ -33,13 +33,21 @@ namespace
 static unsigned const c_depthLimit = 1024;
 
 /// Upper bound of stack space needed by single CALL/CREATE execution. Set experimentally.
-static size_t const c_singleExecutionStackSize = 12 * 1024;
+static size_t const c_singleExecutionStackSize =
+#ifdef NDEBUG
+	12 * 1024;
+#else
+	33 * 1024;
+#endif
 
 /// Standard OSX thread stack limit. Should be reasonable for other platforms too.
 static size_t const c_defaultStackSize = 512 * 1024;
 
+/// Stack overhead prior to allocation.
+static size_t const c_entryOverhead = 128 * 1024;
+
 /// On what depth execution should be offloaded to additional separated stack space.
-static unsigned const c_offloadPoint = c_defaultStackSize / c_singleExecutionStackSize;
+static unsigned const c_offloadPoint = (c_defaultStackSize - c_entryOverhead) / c_singleExecutionStackSize;
 
 void goOnOffloadedStack(Executive& _e, OnOpFunc const& _onOp)
 {
@@ -68,13 +76,12 @@ void go(unsigned _depth, Executive& _e, OnOpFunc const& _onOp)
 {
 	// If in the offloading point we need to switch to additional separated stack space.
 	// Current stack is too small to handle more CALL/CREATE executions.
-	// It needs to be done only once as newly allocated stack space it enough to handle 
+	// It needs to be done only once as newly allocated stack space it enough to handle
 	// the rest of the calls up to the depth limit (c_depthLimit).
-#if __GNUC__
+
 	if (_depth == c_offloadPoint)
 		goOnOffloadedStack(_e, _onOp);
 	else
-#endif
 		_e.go(_onOp);
 }
 }
@@ -84,7 +91,11 @@ bool ExtVM::call(CallParameters& _p)
 	Executive e(m_s, lastHashes, depth + 1);
 	if (!e.call(_p, gasPrice, origin))
 	{
+	#if __clang__ // Enabled for clang only as the problem affects OSX
 		go(depth, e, _p.onOp);
+	#else
+		e.go(_p.onOp);
+	#endif
 		e.accrueSubState(sub);
 	}
 	_p.gas = e.gas();
@@ -106,4 +117,3 @@ h160 ExtVM::create(u256 _endowment, u256& io_gas, bytesConstRef _code, OnOpFunc
 	io_gas = e.gas();
 	return e.newAddress();
 }
-

libethereum/Interface.cpp

@@ -46,5 +46,5 @@ Address Interface::submitTransaction(Secret const& _secret, u256 const& _endowme
 	ts.gas = _gas;
 	ts.gasPrice = _gasPrice;
 	ts.nonce = _nonce;
-	return submitTransaction(ts, _secret);
+	return submitTransaction(ts, _secret).second;
 }

libethereum/Interface.h

@@ -66,8 +66,8 @@ public:
 	// [TRANSACTION API]
 
 	/// Submits a new transaction.
-	/// @returns the new contract's address (assuming it all goes through and it's contract creation).
-	virtual Address submitTransaction(TransactionSkeleton const& _t, Secret const& _secret) = 0;
+	/// @returns the transaction's hash.
+	virtual std::pair<h256, Address> submitTransaction(TransactionSkeleton const& _t, Secret const& _secret) = 0;
 
 	/// Submits the given message-call transaction.
 	void submitTransaction(Secret const& _secret, u256 const& _value, Address const& _dest, bytes const& _data = bytes(), u256 const& _gas = 10000, u256 const& _gasPrice = 10 * szabo, u256 const& _nonce = UndefinedU256);
@@ -135,6 +135,7 @@ public:
 
 	virtual bool isKnownTransaction(h256 const& _transactionHash) const = 0;
 	virtual Transaction transaction(h256 _transactionHash) const = 0;
+	virtual TransactionReceipt transactionReceipt(h256 const& _transactionHash) const = 0;
 	virtual std::pair<h256, unsigned> transactionLocation(h256 const& _transactionHash) const = 0;
 	virtual h256 hashFromNumber(BlockNumber _number) const = 0;
 	virtual BlockNumber numberFromHash(h256 _blockHash) const = 0;

libethereum/State.cpp

@@ -445,7 +445,8 @@ u256 State::enactOn(VerifiedBlockRef const& _block, BlockChain const& _bc, Impor
 
 #if ETH_TIMED_ENACTMENTS
 	enactment = t.elapsed();
-	cnote << "popVer/popGrand/syncReset/enactment = " << populateVerify << "/" << populateGrand << "/" << syncReset << "/" << enactment;
+	if (populateVerify + populateGrand + syncReset + enactment > 0.5)
+		clog(StateChat) << "popVer/popGrand/syncReset/enactment = " << populateVerify << "/" << populateGrand << "/" << syncReset << "/" << enactment;
 #endif
 	return ret;
 }
@@ -513,18 +514,17 @@ pair<TransactionReceipts, bool> State::sync(BlockChain const& _bc, TransactionQu
 				{
 					if (t.gasPrice() >= _gp.ask(*this))
 					{
-	//					Timer t;
+//						Timer t;
 						if (lh.empty())
 							lh = _bc.lastHashes();
 						execute(lh, t);
 						ret.first.push_back(m_receipts.back());
 						++goodTxs;
-	//					cnote << "TX took:" << t.elapsed() * 1000;
+//						cnote << "TX took:" << t.elapsed() * 1000;
 					}
 					else if (t.gasPrice() < _gp.ask(*this) * 9 / 10)
 					{
-						// less than 90% of our ask price for gas. drop.
-						cnote << t.sha3() << "Dropping El Cheapo transaction (<90% of ask price)";
+						clog(StateTrace) << t.sha3() << "Dropping El Cheapo transaction (<90% of ask price)";
 						_tq.drop(t.sha3());
 					}
 				}
@@ -536,22 +536,13 @@ pair<TransactionReceipts, bool> State::sync(BlockChain const& _bc, TransactionQu
 					if (req > got)
 					{
 						// too old
-/*						for (Transaction const& mt: m_transactions)
-						{
-							if (mt.from() == t.from())
-							{
-								if (mt.nonce() < t.nonce())
-									cnote << t.sha3() << "Dropping old transaction (nonce too low)";
-								else if (mt.nonce() == t.nonce() && mt.gasPrice() <= t.gasPrice())
-									cnote << t.sha3() << "Dropping old transaction (gas price lower)";
-							}
-						}*/
+						clog(StateTrace) << t.sha3() << "Dropping old transaction (nonce too low)";
 						_tq.drop(t.sha3());
 					}
 					else if (got > req + _tq.waiting(t.sender()))
 					{
 						// too new
-						cnote << t.sha3() << "Dropping new transaction (too many nonces ahead)";
+						clog(StateTrace) << t.sha3() << "Dropping new transaction (too many nonces ahead)";
 						_tq.drop(t.sha3());
 					}
 					else
@@ -562,7 +553,7 @@ pair<TransactionReceipts, bool> State::sync(BlockChain const& _bc, TransactionQu
 					bigint const& got = *boost::get_error_info<errinfo_got>(e);
 					if (got > m_currentBlock.gasLimit)
 					{
-						cnote << t.sha3() << "Dropping over-gassy transaction (gas > block's gas limit)";
+						clog(StateTrace) << t.sha3() << "Dropping over-gassy transaction (gas > block's gas limit)";
 						_tq.drop(t.sha3());
 					}
 					else
@@ -576,14 +567,14 @@ pair<TransactionReceipts, bool> State::sync(BlockChain const& _bc, TransactionQu
 				catch (Exception const& _e)
 				{
 					// Something else went wrong - drop it.
-					cnote << t.sha3() << "Dropping invalid transaction:" << diagnostic_information(_e);
+					clog(StateTrace) << t.sha3() << "Dropping invalid transaction:" << diagnostic_information(_e);
 					_tq.drop(t.sha3());
 				}
 				catch (std::exception const&)
 				{
 					// Something else went wrong - drop it.
 					_tq.drop(t.sha3());
-					cnote << t.sha3() << "Transaction caused low-level exception :(";
+					cwarn << t.sha3() << "Transaction caused low-level exception :(";
 				}
 			}
 		if (chrono::steady_clock::now() > deadline)
@@ -965,6 +956,8 @@ void State::commitToMine(BlockChain const& _bc, bytes const& _extraData)
 	m_currentBlock.stateRoot = m_state.root();
 	m_currentBlock.parentHash = m_previousBlock.hash();
 	m_currentBlock.extraData = _extraData;
+	if (m_currentBlock.extraData.size() > 32)
+		m_currentBlock.extraData.resize(32);
 
 	m_committedToMine = true;
 }
@@ -1269,7 +1262,6 @@ ExecutionResult State::execute(LastHashes const& _lh, Transaction const& _t, Per
 	
 		// Add to the user-originated transactions that we've executed.
 		m_transactions.push_back(e.t());
-//		m_receipts.push_back(TransactionReceipt(rootHash(), startGasUsed + e.gasUsedNoRefunds(), e.logs()));	// TODO: Switch in to be compliant with YP.
 		m_receipts.push_back(TransactionReceipt(rootHash(), startGasUsed + e.gasUsed(), e.logs()));
 		m_transactionSet.insert(e.t().sha3());
 	}

libethereum/TransactionQueue.cpp

@@ -36,12 +36,12 @@ TransactionQueue::TransactionQueue(unsigned _limit, unsigned _futureLimit):
 	m_limit(_limit),
 	m_futureLimit(_futureLimit)
 {
-		unsigned verifierThreads = std::max(thread::hardware_concurrency(), 3U) - 2U;
-		for (unsigned i = 0; i < verifierThreads; ++i)
-			m_verifiers.emplace_back([=](){
-				setThreadName("txcheck" + toString(i));
-				this->verifierBody();
-			});
+	unsigned verifierThreads = std::max(thread::hardware_concurrency(), 3U) - 2U;
+	for (unsigned i = 0; i < verifierThreads; ++i)
+		m_verifiers.emplace_back([=](){
+			setThreadName("txcheck" + toString(i));
+			this->verifierBody();
+		});
 }
 
 TransactionQueue::~TransactionQueue()
@@ -68,6 +68,9 @@ ImportResult TransactionQueue::import(bytesConstRef _transactionRLP, IfDropped _
 
 		try
 		{
+			// Check validity of _transactionRLP as a transaction. To do this we just deserialise and attempt to determine the sender.
+			// If it doesn't work, the signature is bad.
+			// The transaction's nonce may yet be invalid (or, it could be "valid" but we may be missing a marginally older transaction).
 			t = Transaction(_transactionRLP, CheckTransaction::Everything);
 			UpgradeGuard ul(l);
 			ir = manageImport_WITH_LOCK(h, t);
@@ -99,7 +102,6 @@ ImportResult TransactionQueue::import(Transaction const& _transaction, IfDropped
 	ImportResult ret;
 	{
 		UpgradableGuard l(m_lock);
-		// TODO: keep old transactions around and check in State for nonce validity
 		auto ir = check_WITH_LOCK(h, _ik);
 		if (ir != ImportResult::Success)
 			return ir;
@@ -132,11 +134,7 @@ ImportResult TransactionQueue::manageImport_WITH_LOCK(h256 const& _h, Transactio
 {
 	try
 	{
-		// Check validity of _transactionRLP as a transaction. To do this we just deserialise and attempt to determine the sender.
-		// If it doesn't work, the signature is bad.
-		// The transaction's nonce may yet be invalid (or, it could be "valid" but we may be missing a marginally older transaction).
 		assert(_h == _transaction.sha3());
-
 		// Remove any prior transaction with the same nonce but a lower gas price.
 		// Bomb out if there's a prior transaction with higher gas price.
 		auto cs = m_currentByAddressAndNonce.find(_transaction.from());
@@ -263,7 +261,6 @@ unsigned TransactionQueue::waiting(Address const& _a) const
 
 void TransactionQueue::setFuture(h256 const& _txHash)
 {
-//	cdebug << "txQ::setFuture" << _t.first;
 	WriteGuard l(m_lock);
 	auto it = m_currentByHash.find(_txHash);
 	if (it == m_currentByHash.end())

libethereum/TransactionQueue.h

@@ -42,39 +42,84 @@ struct TransactionQueueChannel: public LogChannel { static const char* name(); s
 struct TransactionQueueTraceChannel: public LogChannel { static const char* name(); static const int verbosity = 7; };
 #define ctxq dev::LogOutputStream<dev::eth::TransactionQueueTraceChannel, true>()
 
-enum class IfDropped { Ignore, Retry };
+/// Import transaction policy
+enum class IfDropped
+{
+	Ignore, ///< Don't import transaction that was previously dropped.
+	Retry 	///< Import transaction even if it was dropped before.
+};
 
 /**
  * @brief A queue of Transactions, each stored as RLP.
- * Maintains a transaction queue sorted by nonce diff and gas price
+ * Maintains a transaction queue sorted by nonce diff and gas price.
  * @threadsafe
  */
 class TransactionQueue
 {
 public:
 	/// @brief TransactionQueue
-	/// @param _limit Maximum number of pending transactions in the queue
-	/// @param _futureLimit Maximum number of future nonce transactions
+	/// @param _limit Maximum number of pending transactions in the queue.
+	/// @param _futureLimit Maximum number of future nonce transactions.
 	TransactionQueue(unsigned _limit = 1024, unsigned _futureLimit = 1024);
 	~TransactionQueue();
+	/// Add transaction to the queue to be verified and imported.
+	/// @param _data RLP encoded transaction data.
+	/// @param _nodeId Optional network identified of a node transaction comes from.
 	void enqueue(RLP const& _data, h512 const& _nodeId);
+
+	/// Verify and add transaction to the queue synchronously.
+	/// @param _tx RLP encoded transaction data.
+	/// @param _ik Set to Retry to force re-addinga transaction that was previously dropped.
+	/// @returns Import result code.
 	ImportResult import(bytes const& _tx, IfDropped _ik = IfDropped::Ignore) { return import(&_tx, _ik); }
+
+	/// Verify and add transaction to the queue synchronously.
+	/// @param _tx Trasnaction data.
+	/// @param _ik Set to Retry to force re-addinga transaction that was previously dropped.
+	/// @returns Import result code.
 	ImportResult import(Transaction const& _tx, IfDropped _ik = IfDropped::Ignore);
 
+	/// Remove transaction from the queue
+	/// @param _txHash Trasnaction hash
 	void drop(h256 const& _txHash);
 
+	/// Get number of pending transactions for account.
+	/// @returns Pending transaction count.
 	unsigned waiting(Address const& _a) const;
+
+	/// Get top transactions from the queue. Returned transactions are not removed from the queue automatically.
+	/// @param _limit Max number of transactions to return.
+	/// @returns up to _limit transactions ordered by nonce and gas price.
 	Transactions topTransactions(unsigned _limit) const;
+
+	/// Get a hash set of transactions in the queue
+	/// @returns A hash set of all transactions in the queue
 	h256Hash knownTransactions() const;
+
+	/// Get max nonce for an account
+	/// @returns Max transaction nonce for account in the queue
 	u256 maxNonce(Address const& _a) const;
+
+	/// Mark transaction as future. It wont be retured in topTransactions list until a transaction with a preceeding nonce is imported or marked with dropGood
+	/// @param _t Transaction hash
 	void setFuture(h256 const& _t);
+
+	/// Drop a trasnaction from the list if exists and move following future trasnactions to current (if any)
+	/// @param _t Transaction hash
 	void dropGood(Transaction const& _t);
 
+	/// Clear the queue
 	void clear();
+
+	/// Register a handler that will be called once there is a new transaction imported
 	template <class T> Handler<> onReady(T const& _t) { return m_onReady.add(_t); }
+
+	/// Register a handler that will be called once asynchronous verification is comeplte an transaction has been imported
 	template <class T> Handler<ImportResult, h256 const&, h512 const&> onImport(T const& _t) { return m_onImport.add(_t); }
 
 private:
+
+	/// Verified and imported transaction
 	struct VerifiedTransaction
 	{
 		VerifiedTransaction(Transaction const& _t): transaction(_t) {}
@@ -83,26 +128,28 @@ private:
 		VerifiedTransaction(VerifiedTransaction const&) = delete;
 		VerifiedTransaction& operator=(VerifiedTransaction const&) = delete;
 
-		Transaction transaction;
+		Transaction transaction; ///< Transaction data
 	};
 
+	/// Trasnaction pending verification
 	struct UnverifiedTransaction
 	{
 		UnverifiedTransaction() {}
-		UnverifiedTransaction(bytesConstRef const& _t, h512 const& _nodeId): transaction(std::move(_t.toBytes())), nodeId(_nodeId) {}
+		UnverifiedTransaction(bytesConstRef const& _t, h512 const& _nodeId): transaction(_t.toBytes()), nodeId(_nodeId) {}
 		UnverifiedTransaction(UnverifiedTransaction&& _t): transaction(std::move(_t.transaction)) {}
 		UnverifiedTransaction& operator=(UnverifiedTransaction&& _other) { transaction = std::move(_other.transaction); nodeId = std::move(_other.nodeId); return *this; }
 
 		UnverifiedTransaction(UnverifiedTransaction const&) = delete;
 		UnverifiedTransaction& operator=(UnverifiedTransaction const&) = delete;
 
-		bytes transaction;
-		h512 nodeId;
+		bytes transaction;	///< RLP encoded transaction data
+		h512 nodeId;		///< Network Id of the peer transaction comes from
 	};
 
 	struct PriorityCompare
 	{
 		TransactionQueue& queue;
+		/// Compare transaction by nonce height and gas price.
 		bool operator()(VerifiedTransaction const& _first, VerifiedTransaction const& _second) const
 		{
 			u256 const& height1 = _first.transaction.nonce() - queue.m_currentByAddressAndNonce[_first.transaction.sender()].begin()->first;

libjsconsole/CMakeLists.txt

@@ -12,7 +12,9 @@ aux_source_directory(. SRC_LIST)
 
 include_directories(BEFORE ${V8_INCLUDE_DIRS})
 include_directories(BEFORE ..)
-include_directories(${READLINE_INCLUDE_DIRS})
+if (READLINE_FOUND)
+	include_directories(${READLINE_INCLUDE_DIRS})
+endif()
 include_directories(${JSON_RPC_CPP_INCLUDE_DIRS})
 include_directories(${CURL_INCLUDE_DIRS})
 
@@ -24,7 +26,9 @@ add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
 
 target_link_libraries(${EXECUTABLE} jsengine)
 target_link_libraries(${EXECUTABLE} devcore)
-target_link_libraries(${EXECUTABLE} ${READLINE_LIBRARIES})
+if (READLINE_FOUND)
+	target_link_libraries(${EXECUTABLE} ${READLINE_LIBRARIES})
+endif()
 target_link_libraries(${EXECUTABLE} ${JSON_RPC_CPP_SERVER_LIBRARIES})
 
 target_link_libraries(${EXECUTABLE} ${CURL_LIBRARIES})

libjsconsole/JSConsole.h

@@ -23,9 +23,11 @@
 #pragma once
 
 #include <libdevcore/Log.h>
-// TODO! make readline optional!
+
+#if ETH_READLINE
 #include <readline/readline.h>
 #include <readline/history.h>
+#endif
 
 namespace dev
 {
@@ -42,18 +44,35 @@ public:
 	void readExpression() const
 	{
 		std::string cmd = "";
-		g_logPost = [](std::string const& a, char const*) { std::cout << "\r           \r" << a << std::endl << std::flush; rl_forced_update_display(); };
+		g_logPost = [](std::string const& a, char const*)
+		{
+		    std::cout << "\r           \r" << a << std::endl << std::flush;
+#if ETH_READLINE
+		    rl_forced_update_display();
+#endif
+		};
 
 		bool isEmpty = true;
 		int openBrackets = 0;
 		do {
+			std::string rl;
+#if ETH_READLINE
 			char* buff = readline(promptForIndentionLevel(openBrackets).c_str());
-			isEmpty = !(buff && *buff);
+			isEmpty = !buff;
 			if (!isEmpty)
 			{
-				cmd += std::string(buff);
-				cmd += " ";
+				rl = std::string(buff);
 				free(buff);
+			}
+#else
+			std::cout << promptForIndentionLevel(openBrackets) << std::flush;
+			std::getline(std::cin, rl);
+			isEmpty = rl.length() == 0;
+#endif
+			if (!isEmpty)
+			{
+				cmd += rl;
+				cmd += " ";
 				int open = std::count(cmd.begin(), cmd.end(), '{');
 				open += std::count(cmd.begin(), cmd.end(), '(');
 				int closed = std::count(cmd.begin(), cmd.end(), '}');
@@ -64,7 +83,9 @@ public:
 
 		if (!isEmpty)
 		{
+#if ETH_READLINE
 			add_history(cmd.c_str());
+#endif
 			auto value = m_engine.eval(cmd.c_str());
 			std::string result = m_printer.prettyPrint(value).cstr();
 			std::cout << result << std::endl;

libjsengine/CMakeLists.txt

@@ -21,6 +21,8 @@ include(EthUtils)
 eth_add_resources("${CMAKE_CURRENT_SOURCE_DIR}/JSResources.cmake" "JSRES")
 add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS} ${JSRES})
 
+add_dependencies(${EXECUTABLE} BuildInfo.h)
+
 # macos brew version of v8 needs to be compiled with libstdc++
 # it also needs to be dynamic library
 # xcode needs libstdc++ to be explicitly set as it's attribute

libjsengine/JSEngine.h

@@ -29,7 +29,11 @@ namespace eth
 {
 
 class JSException: public std::exception {};
+#if defined(_MSC_VER)
+class JSPrintException: public JSException { char const* what() const { return "Cannot print expression!"; } };
+#else
 class JSPrintException: public JSException { char const* what() const noexcept { return "Cannot print expression!"; } };
+#endif
 
 class JSString
 {

libjsengine/JSV8Engine.cpp

@@ -23,6 +23,10 @@
 #include <memory>
 #include "JSV8Engine.h"
 #include "libjsengine/JSEngineResources.hpp"
+#include "BuildInfo.h"
+
+#define TO_STRING_HELPER(s) #s
+#define TO_STRING(s) TO_STRING_HELPER(s)
 
 using namespace std;
 using namespace dev;
@@ -87,15 +91,6 @@ void reportException(v8::TryCatch* _tryCatch)
 	}
 }
 
-class JSV8Env
-{
-public:
-	~JSV8Env()
-	{
-		v8::V8::Dispose();
-	}
-};
-
 class JSV8Scope
 {
 public:
@@ -124,8 +119,6 @@ private:
 }
 }
 
-JSV8Env JSV8Engine::s_env = JSV8Env();
-
 JSString JSV8Value::toString() const
 {
 	if (m_value.IsEmpty())
@@ -141,6 +134,7 @@ JSString JSV8Value::toString() const
 JSV8Engine::JSV8Engine(): m_scope(new JSV8Scope())
 {
 	JSEngineResources resources;
+	eval("env = typeof(env) === 'undefined' ? {} : env; env.os = '" TO_STRING(ETH_BUILD_PLATFORM) "'");
 	string common = resources.loadResourceAsString("common");
 	string web3 = resources.loadResourceAsString("web3");
 	string admin = resources.loadResourceAsString("admin");
@@ -157,7 +151,6 @@ JSV8Engine::~JSV8Engine()
 
 JSV8Value JSV8Engine::eval(char const* _cstr) const
 {
-	v8::HandleScope handleScope;
 	v8::TryCatch tryCatch;
 	v8::Local<v8::String> source = v8::String::New(_cstr);
 	v8::Local<v8::String> name(v8::String::New("(shell)"));

libjsengine/JSV8Engine.h

@@ -56,7 +56,6 @@ public:
 	v8::Handle<v8::Context> const& context() const;
 
 private:
-	static JSV8Env s_env;
 	JSV8Scope* m_scope;
 };
 

libjsengine/JSV8Printer.cpp

@@ -37,7 +37,6 @@ JSV8Printer::JSV8Printer(JSV8Engine const& _engine): m_engine(_engine)
 
 JSString JSV8Printer::prettyPrint(JSV8Value const& _value) const
 {
-	v8::HandleScope handleScope;
 	v8::Local<v8::String> pp = v8::String::New("prettyPrint");
 	v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(m_engine.context()->Global()->Get(pp));
 	v8::Local<v8::Value> values[1] = {v8::Local<v8::Value>::New(_value.value())};

libjsengine/PrettyPrint.js

@@ -1,4 +1,14 @@
 var prettyPrint = (function () {
+    var onlyDecentPlatform = function (x) {
+        return env.os.indexOf('Windows') === -1 ? x : '';
+    };
+
+    var color_red = onlyDecentPlatform('\033[31m');
+    var color_green = onlyDecentPlatform('\033[32m');
+    var color_pink = onlyDecentPlatform('\033[35m');
+    var color_white = onlyDecentPlatform('\033[0m');
+    var color_blue = onlyDecentPlatform('\033[30m');
+
     function pp(object, indent) {
         try {
             JSON.stringify(object)
@@ -16,13 +26,13 @@ var prettyPrint = (function () {
             }
             str += " ]";
         } else if (object instanceof Error) {
-            str += "\033[31m" + "Error:\033[0m " + object.message;
+            str += color_red + "Error: " + color_white + object.message;
         }  else if (object === null) {
-            str += "\033[1m\033[30m" + "null";
+            str += color_blue + "null";
         } else if(typeof(object) === "undefined") {
-            str += "\033[1m\033[30m" + object;
+            str += color_blue + object;
         } else if (isBigNumber(object)) {
-            str += "\033[32m'" + object.toString(10) + "'";
+            str += color_green + object.toString(10) + "'";
         } else if(typeof(object) === "object") {
             str += "{\n";
             indent += "  ";
@@ -41,15 +51,15 @@ var prettyPrint = (function () {
             });
             str += indent.substr(2, indent.length) + "}";
         } else if(typeof(object) === "string") {
-            str += "\033[32m'" + object + "'";
+            str += color_green + object + "'";
         } else if(typeof(object) === "number") {
-            str += "\033[31m" + object;
+            str += color_red + object;
         } else if(typeof(object) === "function") {
-            str += "\033[35m[Function]";
+            str += color_pink + "[Function]";
         } else {
             str += object;
         }
-        str += "\033[0m";
+        str += color_white;
         return str;
     }
     var redundantFields = [

libsolidity/CompilerUtils.cpp

@@ -113,6 +113,16 @@ void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBound
 		solAssert(ref->location() == DataLocation::Memory, "");
 		storeInMemoryDynamic(IntegerType(256), _padToWordBoundaries);
 	}
+	else if (auto str = dynamic_cast<StringLiteralType const*>(&_type))
+	{
+		m_context << eth::Instruction::DUP1;
+		storeStringData(bytesConstRef(str->value()));
+		if (_padToWordBoundaries)
+			m_context << u256(((str->value().size() + 31) / 32) * 32);
+		else
+			m_context << u256(str->value().size());
+		m_context << eth::Instruction::ADD;
+	}
 	else
 	{
 		unsigned numBytes = prepareMemoryStore(_type, _padToWordBoundaries);
@@ -169,7 +179,8 @@ void CompilerUtils::encodeToMemory(
 			TypePointer type = targetType;
 			if (
 				_givenTypes[i]->dataStoredIn(DataLocation::Storage) ||
-				_givenTypes[i]->dataStoredIn(DataLocation::CallData)
+				_givenTypes[i]->dataStoredIn(DataLocation::CallData) ||
+				_givenTypes[i]->getCategory() == Type::Category::StringLiteral
 			)
 				type = _givenTypes[i]; // delay conversion
 			else
@@ -192,36 +203,48 @@ void CompilerUtils::encodeToMemory(
 		solAssert(!!targetType, "Externalable type expected.");
 		if (targetType->isDynamicallySized() && !_copyDynamicDataInPlace)
 		{
-			solAssert(_givenTypes[i]->getCategory() == Type::Category::Array, "Unknown dynamic type.");
-			auto const& arrayType = dynamic_cast<ArrayType const&>(*_givenTypes[i]);
 			// copy tail pointer (=mem_end - mem_start) to memory
 			m_context << eth::dupInstruction(2 + dynPointers) << eth::Instruction::DUP2;
 			m_context << eth::Instruction::SUB;
 			m_context << eth::dupInstruction(2 + dynPointers - thisDynPointer);
 			m_context << eth::Instruction::MSTORE;
-			// now copy the array
-			copyToStackTop(argSize - stackPos + dynPointers + 2, arrayType.getSizeOnStack());
-			// stack: ... <end_of_mem> <value...>
-			// copy length to memory
-			m_context << eth::dupInstruction(1 + arrayType.getSizeOnStack());
-			if (arrayType.location() == DataLocation::CallData)
-				m_context << eth::Instruction::DUP2; // length is on stack
-			else if (arrayType.location() == DataLocation::Storage)
-				m_context << eth::Instruction::DUP3 << eth::Instruction::SLOAD;
+			// stack: ... <end_of_mem>
+			if (_givenTypes[i]->getCategory() == Type::Category::StringLiteral)
+			{
+				auto const& strType = dynamic_cast<StringLiteralType const&>(*_givenTypes[i]);
+				m_context << u256(strType.value().size());
+				storeInMemoryDynamic(IntegerType(256), true);
+				// stack: ... <end_of_mem'>
+				storeInMemoryDynamic(strType, _padToWordBoundaries);
+			}
 			else
 			{
-				solAssert(arrayType.location() == DataLocation::Memory, "");
-				m_context << eth::Instruction::DUP2 << eth::Instruction::MLOAD;
+				solAssert(_givenTypes[i]->getCategory() == Type::Category::Array, "Unknown dynamic type.");
+				auto const& arrayType = dynamic_cast<ArrayType const&>(*_givenTypes[i]);
+				// now copy the array
+				copyToStackTop(argSize - stackPos + dynPointers + 2, arrayType.getSizeOnStack());
+				// stack: ... <end_of_mem> <value...>
+				// copy length to memory
+				m_context << eth::dupInstruction(1 + arrayType.getSizeOnStack());
+				if (arrayType.location() == DataLocation::CallData)
+					m_context << eth::Instruction::DUP2; // length is on stack
+				else if (arrayType.location() == DataLocation::Storage)
+					m_context << eth::Instruction::DUP3 << eth::Instruction::SLOAD;
+				else
+				{
+					solAssert(arrayType.location() == DataLocation::Memory, "");
+					m_context << eth::Instruction::DUP2 << eth::Instruction::MLOAD;
+				}
+				// stack: ... <end_of_mem> <value...> <end_of_mem'> <length>
+				storeInMemoryDynamic(IntegerType(256), true);
+				// stack: ... <end_of_mem> <value...> <end_of_mem''>
+				// copy the new memory pointer
+				m_context << eth::swapInstruction(arrayType.getSizeOnStack() + 1) << eth::Instruction::POP;
+				// stack: ... <end_of_mem''> <value...>
+				// copy data part
+				ArrayUtils(m_context).copyArrayToMemory(arrayType, _padToWordBoundaries);
+				// stack: ... <end_of_mem'''>
 			}
-			// stack: ... <end_of_mem> <value...> <end_of_mem'> <length>
-			storeInMemoryDynamic(IntegerType(256), true);
-			// stack: ... <end_of_mem> <value...> <end_of_mem''>
-			// copy the new memory pointer
-			m_context << eth::swapInstruction(arrayType.getSizeOnStack() + 1) << eth::Instruction::POP;
-			// stack: ... <end_of_mem''> <value...>
-			// copy data part
-			ArrayUtils(m_context).copyArrayToMemory(arrayType, _padToWordBoundaries);
-			// stack: ... <end_of_mem'''>
 
 			thisDynPointer++;
 		}
@@ -269,22 +292,22 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			// conversion from bytes to integer. no need to clean the high bit
 			// only to shift right because of opposite alignment
 			IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
-			m_context << (u256(1) << (256 - typeOnStack.getNumBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV;
-			if (targetIntegerType.getNumBits() < typeOnStack.getNumBytes() * 8)
-				convertType(IntegerType(typeOnStack.getNumBytes() * 8), _targetType, _cleanupNeeded);
+			m_context << (u256(1) << (256 - typeOnStack.numBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV;
+			if (targetIntegerType.getNumBits() < typeOnStack.numBytes() * 8)
+				convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded);
 		}
 		else
 		{
 			// clear lower-order bytes for conversion to shorter bytes - we always clean
 			solAssert(targetTypeCategory == Type::Category::FixedBytes, "Invalid type conversion requested.");
 			FixedBytesType const& targetType = dynamic_cast<FixedBytesType const&>(_targetType);
-			if (targetType.getNumBytes() < typeOnStack.getNumBytes())
+			if (targetType.numBytes() < typeOnStack.numBytes())
 			{
-				if (targetType.getNumBytes() == 0)
+				if (targetType.numBytes() == 0)
 					m_context << eth::Instruction::DUP1 << eth::Instruction::XOR;
 				else
 				{
-					m_context << (u256(1) << (256 - targetType.getNumBytes() * 8));
+					m_context << (u256(1) << (256 - targetType.numBytes() * 8));
 					m_context << eth::Instruction::DUP1 << eth::Instruction::SWAP2;
 					m_context << eth::Instruction::DIV << eth::Instruction::MUL;
 				}
@@ -306,9 +329,9 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			// only to shift left because of opposite alignment
 			FixedBytesType const& targetBytesType = dynamic_cast<FixedBytesType const&>(_targetType);
 			if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack))
-				if (targetBytesType.getNumBytes() * 8 > typeOnStack->getNumBits())
+				if (targetBytesType.numBytes() * 8 > typeOnStack->getNumBits())
 					cleanHigherOrderBits(*typeOnStack);
-			m_context << (u256(1) << (256 - targetBytesType.getNumBytes() * 8)) << eth::Instruction::MUL;
+			m_context << (u256(1) << (256 - targetBytesType.numBytes() * 8)) << eth::Instruction::MUL;
 		}
 		else if (targetTypeCategory == Type::Category::Enum)
 			// just clean
@@ -340,6 +363,37 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			}
 		}
 		break;
+	case Type::Category::StringLiteral:
+	{
+		auto const& literalType = dynamic_cast<StringLiteralType const&>(_typeOnStack);
+		string const& value = literalType.value();
+		bytesConstRef data(value);
+		if (targetTypeCategory == Type::Category::FixedBytes)
+		{
+			solAssert(data.size() <= 32, "");
+			m_context << h256::Arith(h256(data, h256::AlignLeft));
+		}
+		else if (targetTypeCategory == Type::Category::Array)
+		{
+			auto const& arrayType = dynamic_cast<ArrayType const&>(_targetType);
+			solAssert(arrayType.isByteArray(), "");
+			u256 storageSize(32 + ((data.size() + 31) / 32) * 32);
+			m_context << storageSize;
+			allocateMemory();
+			// stack: mempos
+			m_context << eth::Instruction::DUP1 << u256(data.size());
+			storeInMemoryDynamic(IntegerType(256));
+			// stack: mempos datapos
+			storeStringData(data);
+			break;
+		}
+		else
+			solAssert(
+				false,
+				"Invalid conversion from string literal to " + _targetType.toString(false) + " requested."
+			);
+		break;
+	}
 	case Type::Category::Array:
 	{
 		solAssert(targetTypeCategory == stackTypeCategory, "");
@@ -606,6 +660,28 @@ void CompilerUtils::computeHashStatic()
 	m_context << u256(32) << u256(0) << eth::Instruction::SHA3;
 }
 
+void CompilerUtils::storeStringData(bytesConstRef _data)
+{
+	//@todo provide both alternatives to the optimiser
+	// stack: mempos
+	if (_data.size() <= 128)
+	{
+		for (unsigned i = 0; i < _data.size(); i += 32)
+		{
+			m_context << h256::Arith(h256(_data.cropped(i), h256::AlignLeft));
+			storeInMemoryDynamic(IntegerType(256));
+		}
+		m_context << eth::Instruction::POP;
+	}
+	else
+	{
+		// stack: mempos mempos_data
+		m_context.appendData(_data.toBytes());
+		m_context << u256(_data.size()) << eth::Instruction::SWAP2;
+		m_context << eth::Instruction::CODECOPY;
+	}
+}
+
 unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCalldata, bool _padToWordBoundaries)
 {
 	unsigned numBytes = _type.getCalldataEncodedSize(_padToWordBoundaries);

libsolidity/CompilerUtils.h

@@ -148,7 +148,12 @@ private:
 	/// Address of the precompiled identity contract.
 	static const unsigned identityContractAddress;
 
-	//// Appends code that cleans higher-order bits for integer types.
+	/// Stores the given string in memory.
+	/// Stack pre: mempos
+	/// Stack post:
+	void storeStringData(bytesConstRef _data);
+
+	/// Appends code that cleans higher-order bits for integer types.
 	void cleanHigherOrderBits(IntegerType const& _typeOnStack);
 
 	/// Prepares the given type for storing in memory by shifting it if necessary.

libsolidity/ExpressionCompiler.cpp

@@ -158,6 +158,11 @@ bool ExpressionCompiler::visit(Assignment const& _assignment)
 		utils().convertType(*type, *_assignment.getType());
 		type = _assignment.getType();
 	}
+	else
+	{
+		utils().convertType(*type, *type->mobileType());
+		type = type->mobileType();
+	}
 
 	_assignment.getLeftHandSide().accept(*this);
 	solAssert(!!m_currentLValue, "LValue not retrieved.");
@@ -898,13 +903,15 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier)
 void ExpressionCompiler::endVisit(Literal const& _literal)
 {
 	CompilerContext::LocationSetter locationSetter(m_context, _literal);
-	switch (_literal.getType()->getCategory())
+	TypePointer type = _literal.getType();
+	switch (type->getCategory())
 	{
 	case Type::Category::IntegerConstant:
 	case Type::Category::Bool:
-	case Type::Category::FixedBytes:
-		m_context << _literal.getType()->literalValue(&_literal);
+		m_context << type->literalValue(&_literal);
 		break;
+	case Type::Category::StringLiteral:
+		break; // will be done during conversion
 	default:
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Only integer, boolean and string literals implemented for now."));
 	}

libsolidity/LValue.cpp

@@ -209,7 +209,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
 			// stack: value storage_ref cleared_value multiplier value
 			if (m_dataType.getCategory() == Type::Category::FixedBytes)
 				m_context
-					<< (u256(0x1) << (256 - 8 * dynamic_cast<FixedBytesType const&>(m_dataType).getNumBytes()))
+					<< (u256(0x1) << (256 - 8 * dynamic_cast<FixedBytesType const&>(m_dataType).numBytes()))
 					<< eth::Instruction::SWAP1 << eth::Instruction::DIV;
 			else if (
 				m_dataType.getCategory() == Type::Category::Integer &&

libsolidity/Types.cpp

@@ -212,8 +212,7 @@ TypePointer Type::forLiteral(Literal const& _literal)
 	case Token::Number:
 		return make_shared<IntegerConstantType>(_literal);
 	case Token::StringLiteral:
-		//@todo put larger strings into dynamic strings
-		return FixedBytesType::smallestTypeForLiteral(_literal.getValue());
+		return make_shared<StringLiteralType>(_literal);
 	default:
 		return shared_ptr<Type>();
 	}
@@ -378,7 +377,7 @@ bool IntegerConstantType::isImplicitlyConvertibleTo(Type const& _convertTo) cons
 	else if (_convertTo.getCategory() == Category::FixedBytes)
 	{
 		FixedBytesType const& fixedBytes = dynamic_cast<FixedBytesType const&>(_convertTo);
-		return fixedBytes.getNumBytes() * 8 >= getIntegerType()->getNumBits();
+		return fixedBytes.numBytes() * 8 >= getIntegerType()->getNumBits();
 	}
 	else
 		return false;
@@ -530,6 +529,33 @@ shared_ptr<IntegerType const> IntegerConstantType::getIntegerType() const
 		);
 }
 
+StringLiteralType::StringLiteralType(Literal const& _literal):
+	m_value(_literal.getValue())
+{
+}
+
+bool StringLiteralType::isImplicitlyConvertibleTo(Type const& _convertTo) const
+{
+	if (auto fixedBytes = dynamic_cast<FixedBytesType const*>(&_convertTo))
+		return size_t(fixedBytes->numBytes()) >= m_value.size();
+	else if (auto arrayType = dynamic_cast<ArrayType const*>(&_convertTo))
+		return arrayType->isByteArray();
+	else
+		return false;
+}
+
+bool StringLiteralType::operator==(const Type& _other) const
+{
+	if (_other.getCategory() != getCategory())
+		return false;
+	return m_value == dynamic_cast<StringLiteralType const&>(_other).m_value;
+}
+
+TypePointer StringLiteralType::mobileType() const
+{
+	return make_shared<ArrayType>(DataLocation::Memory, true);
+}
+
 shared_ptr<FixedBytesType> FixedBytesType::smallestTypeForLiteral(string const& _literal)
 {
 	if (_literal.length() <= 32)
@@ -590,15 +616,6 @@ bool FixedBytesType::operator==(Type const& _other) const
 	return other.m_bytes == m_bytes;
 }
 
-u256 FixedBytesType::literalValue(const Literal* _literal) const
-{
-	solAssert(_literal, "");
-	u256 value = 0;
-	for (char c: _literal->getValue())
-		value = (value << 8) | byte(c);
-	return value << ((32 - _literal->getValue().length()) * 8);
-}
-
 bool BoolType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
 	// conversion to integer is fine, but not to address

libsolidity/Types.h

@@ -131,7 +131,7 @@ class Type: private boost::noncopyable, public std::enable_shared_from_this<Type
 public:
 	enum class Category
 	{
-		Integer, IntegerConstant, Bool, Real, Array,
+		Integer, IntegerConstant, StringLiteral, Bool, Real, Array,
 		FixedBytes, Contract, Struct, Function, Enum,
 		Mapping, Void, TypeType, Modifier, Magic
 	};
@@ -311,6 +311,37 @@ private:
 	bigint m_value;
 };
 
+/**
+ * Literal string, can be converted to bytes, bytesX or string.
+ */
+class StringLiteralType: public Type
+{
+public:
+	virtual Category getCategory() const override { return Category::StringLiteral; }
+
+	explicit StringLiteralType(Literal const& _literal);
+
+	virtual bool isImplicitlyConvertibleTo(Type const& _convertTo) const override;
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override
+	{
+		return TypePointer();
+	}
+
+	virtual bool operator==(Type const& _other) const override;
+
+	virtual bool canBeStored() const override { return false; }
+	virtual bool canLiveOutsideStorage() const override { return false; }
+	virtual unsigned getSizeOnStack() const override { return 0; }
+
+	virtual std::string toString(bool) const override { return "literal_string \"" + m_value + "\""; }
+	virtual TypePointer mobileType() const override;
+
+	std::string const& value() const { return m_value; }
+
+private:
+	std::string m_value;
+};
+
 /**
  * Bytes type with fixed length of up to 32 bytes.
  */
@@ -336,10 +367,9 @@ public:
 	virtual bool isValueType() const override { return true; }
 
 	virtual std::string toString(bool) const override { return "bytes" + dev::toString(m_bytes); }
-	virtual u256 literalValue(Literal const* _literal) const override;
 	virtual TypePointer externalType() const override { return shared_from_this(); }
 
-	int getNumBytes() const { return m_bytes; }
+	int numBytes() const { return m_bytes; }
 
 private:
 	int m_bytes;

libsolidity/Version.cpp

@@ -0,0 +1,39 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	cpp-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Versioning.
+ */
+
+#include <libsolidity/Version.h>
+#include <string>
+#include <BuildInfo.h>
+#include <libdevcore/Common.h>
+
+using namespace dev;
+using namespace dev::solidity;
+using namespace std;
+
+char const* dev::solidity::VersionNumber = "0.1.0";
+extern string const dev::solidity::VersionString =
+	string(dev::solidity::VersionNumber) +
+	"-" +
+	string(DEV_QUOTED(ETH_COMMIT_HASH)).substr(0, 8) +
+	(ETH_CLEAN_REPO ? "" : "*") +
+	"/" DEV_QUOTED(ETH_BUILD_TYPE) "-" DEV_QUOTED(ETH_BUILD_PLATFORM);
+

libsolidity/Version.h

@@ -0,0 +1,36 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	cpp-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Versioning.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace dev
+{
+namespace solidity
+{
+
+extern char const* VersionNumber;
+extern std::string const VersionString;
+
+}
+}

libweb3jsonrpc/AccountHolder.cpp

@@ -106,20 +106,22 @@ AddressHash SimpleAccountHolder::realAccounts() const
 	return m_keyManager.accountsHash();
 }
 
-void SimpleAccountHolder::authenticate(dev::eth::TransactionSkeleton const& _t)
+h256 SimpleAccountHolder::authenticate(dev::eth::TransactionSkeleton const& _t)
 {
 	if (isRealAccount(_t.from))
-		m_client()->submitTransaction(_t, m_keyManager.secret(_t.from, [&](){ return m_getPassword(_t.from); }));
+		return m_client()->submitTransaction(_t, m_keyManager.secret(_t.from, [&](){ return m_getPassword(_t.from); })).first;
 	else if (isProxyAccount(_t.from))
 		queueTransaction(_t);
+	return h256();
 }
 
-void FixedAccountHolder::authenticate(dev::eth::TransactionSkeleton const& _t)
+h256 FixedAccountHolder::authenticate(dev::eth::TransactionSkeleton const& _t)
 {
 	if (isRealAccount(_t.from))
-		m_client()->submitTransaction(_t, m_accounts[_t.from]);
+		return m_client()->submitTransaction(_t, m_accounts[_t.from]).first;
 	else if (isProxyAccount(_t.from))
 		queueTransaction(_t);
+	return h256();
 }
 
 

libweb3jsonrpc/AccountHolder.h

@@ -51,7 +51,7 @@ public:
 	virtual AddressHash realAccounts() const = 0;
 	// use m_web3's submitTransaction
 	// or use AccountHolder::queueTransaction(_t) to accept
-	virtual void authenticate(dev::eth::TransactionSkeleton const& _t) = 0;
+	virtual h256 authenticate(dev::eth::TransactionSkeleton const& _t) = 0;
 
 	Addresses allAccounts() const;
 	bool isRealAccount(Address const& _account) const { return realAccounts().count(_account) > 0; }
@@ -85,7 +85,7 @@ public:
 	{}
 
 	AddressHash realAccounts() const override;
-	void authenticate(dev::eth::TransactionSkeleton const& _t) override;
+	h256 authenticate(dev::eth::TransactionSkeleton const& _t) override;
 
 private:
 	std::function<std::string(Address)> m_getPassword;
@@ -117,7 +117,7 @@ public:
 
 	// use m_web3's submitTransaction
 	// or use AccountHolder::queueTransaction(_t) to accept
-	void authenticate(dev::eth::TransactionSkeleton const& _t) override;
+	h256 authenticate(dev::eth::TransactionSkeleton const& _t) override;
 
 private:
 	std::unordered_map<dev::Address, dev::Secret> m_accounts;

libweb3jsonrpc/JsonHelper.cpp

@@ -182,6 +182,33 @@ Json::Value toJson(dev::eth::TransactionReceipt const& _t)
 	return res;
 }
 
+Json::Value toJson(dev::eth::TransactionReceipt const& _tr, std::pair<h256, unsigned> _location, BlockNumber _blockNumber, Transaction const& _t)
+{
+	Json::Value res;
+	h256 h = _t.sha3();
+	res["transactionHash"] = toJS(h);
+	res["transactionIndex"] = _location.second;
+	res["blockHash"] = toJS(_location.first);
+	res["blockNumber"] = _blockNumber;
+	res["cumulativeGasUsed"] = toJS(_tr.gasUsed()); // TODO: check if this is fine
+	res["gasUsed"] = toJS(_tr.gasUsed());
+	res["contractAddress"] = toJS(toAddress(_t.from(), _t.nonce()));
+	res["logs"] = Json::Value(Json::arrayValue);
+	for (unsigned i = 0; i < _tr.log().size(); i++)
+	{
+		LogEntry e = _tr.log()[i];
+		Json::Value l = toJson(e);
+		l["type"] = "mined";
+		l["blockNumber"] = _blockNumber;
+		l["blockHash"] = toJS(_location.first);
+		l["logIndex"] = i;
+		l["transactionHash"] = toJS(h);
+		l["transactionIndex"] = _location.second;
+		res["logs"].append(l);
+	}
+	return res;
+}
+
 Json::Value toJson(dev::eth::Transaction const& _t)
 {
 	Json::Value res;

libweb3jsonrpc/JsonHelper.h

@@ -50,12 +50,15 @@ using UncleHashes = h256s;
 using TransactionHashes = h256s;
 
 Json::Value toJson(BlockInfo const& _bi);
+//TODO: wrap these params into one structure eg. "LocalisedTransaction"
 Json::Value toJson(Transaction const& _t, std::pair<h256, unsigned> _location, BlockNumber _blockNumber);
 Json::Value toJson(BlockInfo const& _bi, BlockDetails const& _bd, UncleHashes const& _us, Transactions const& _ts);
 Json::Value toJson(BlockInfo const& _bi, BlockDetails const& _bd, UncleHashes const& _us, TransactionHashes const& _ts);
 Json::Value toJson(TransactionSkeleton const& _t);
 Json::Value toJson(Transaction const& _t);
 Json::Value toJson(TransactionReceipt const& _t);
+//TODO: wrap these params into one structure eg. "LocalisedTransactionReceipt"
+Json::Value toJson(TransactionReceipt const& _tr, std::pair<h256, unsigned> _location, BlockNumber _blockNumber, Transaction const& _t);
 Json::Value toJson(LocalisedLogEntry const& _e);
 Json::Value toJson(LogEntry const& _e);
 TransactionSkeleton toTransactionSkeleton(Json::Value const& _json);

libweb3jsonrpc/WebThreeStubServerBase.cpp

@@ -242,21 +242,16 @@ string WebThreeStubServerBase::eth_sendTransaction(Json::Value const& _json)
 {
 	try
 	{
-		string ret;
 		TransactionSkeleton t = toTransactionSkeleton(_json);
 	
 		if (!t.from)
 			t.from = m_ethAccounts->defaultTransactAccount();
-		if (t.creation)
-			ret = toJS(right160(sha3(rlpList(t.from, client()->countAt(t.from)))));
 		if (t.gasPrice == UndefinedU256)
 			t.gasPrice = 10 * dev::eth::szabo;		// TODO: should be determined by user somehow.
 		if (t.gas == UndefinedU256)
 			t.gas = min<u256>(client()->gasLimitRemaining() / 5, client()->balanceAt(t.from) / t.gasPrice);
 
-		m_ethAccounts->authenticate(t);
-	
-		return ret;
+		return toJS(m_ethAccounts->authenticate(t));
 	}
 	catch (...)
 	{
@@ -268,13 +263,10 @@ string WebThreeStubServerBase::eth_signTransaction(Json::Value const& _json)
 {
 	try
 	{
-		string ret;
 		TransactionSkeleton t = toTransactionSkeleton(_json);
 
 		if (!t.from)
 			t.from = m_ethAccounts->defaultTransactAccount();
-		if (t.creation)
-			ret = toJS(right160(sha3(rlpList(t.from, client()->countAt(t.from)))));;
 		if (t.gasPrice == UndefinedU256)
 			t.gasPrice = 10 * dev::eth::szabo;		// TODO: should be determined by user somehow.
 		if (t.gas == UndefinedU256)
@@ -427,6 +419,23 @@ Json::Value WebThreeStubServerBase::eth_getTransactionByBlockNumberAndIndex(stri
 	}
 }
 
+Json::Value WebThreeStubServerBase::eth_getTransactionReceipt(string const& _transactionHash)
+{
+	try
+	{
+		h256 h = jsToFixed<32>(_transactionHash);
+		if (!client()->isKnownTransaction(h))
+			return Json::Value(Json::nullValue);
+
+		auto l = client()->transactionLocation(h);
+		return toJson(client()->transactionReceipt(h), l, client()->numberFromHash(l.first), client()->transaction(h));
+	}
+	catch (...)
+	{
+		BOOST_THROW_EXCEPTION(JsonRpcException(Errors::ERROR_RPC_INVALID_PARAMS));
+	}
+}
+
 Json::Value WebThreeStubServerBase::eth_getUncleByBlockHashAndIndex(string const& _blockHash, string const& _uncleIndex)
 {
 	try

libweb3jsonrpc/WebThreeStubServerBase.h

@@ -119,6 +119,7 @@ public:
 	virtual Json::Value eth_getTransactionByHash(std::string const& _transactionHash);
 	virtual Json::Value eth_getTransactionByBlockHashAndIndex(std::string const& _blockHash, std::string const& _transactionIndex);
 	virtual Json::Value eth_getTransactionByBlockNumberAndIndex(std::string const& _blockNumber, std::string const& _transactionIndex);
+	virtual Json::Value eth_getTransactionReceipt(std::string const& _transactionHash);
 	virtual Json::Value eth_getUncleByBlockHashAndIndex(std::string const& _blockHash, std::string const& _uncleIndex);
 	virtual Json::Value eth_getUncleByBlockNumberAndIndex(std::string const& _blockNumber, std::string const& _uncleIndex);
 	virtual Json::Value eth_getCompilers();

libweb3jsonrpc/abstractwebthreestubserver.h

@@ -40,6 +40,7 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getTransactionByHash", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getTransactionByHashI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getTransactionByBlockHashAndIndex", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getTransactionByBlockHashAndIndexI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getTransactionByBlockNumberAndIndex", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getTransactionByBlockNumberAndIndexI);
+            this->bindAndAddMethod(jsonrpc::Procedure("eth_getTransactionReceipt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getTransactionReceiptI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getUncleByBlockHashAndIndex", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getUncleByBlockHashAndIndexI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getUncleByBlockNumberAndIndex", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::eth_getUncleByBlockNumberAndIndexI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_getCompilers", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_ARRAY,  NULL), &AbstractWebThreeStubServer::eth_getCompilersI);
@@ -224,6 +225,10 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
         {
             response = this->eth_getTransactionByBlockNumberAndIndex(request[0u].asString(), request[1u].asString());
         }
+        inline virtual void eth_getTransactionReceiptI(const Json::Value &request, Json::Value &response)
+        {
+            response = this->eth_getTransactionReceipt(request[0u].asString());
+        }
         inline virtual void eth_getUncleByBlockHashAndIndexI(const Json::Value &request, Json::Value &response)
         {
             response = this->eth_getUncleByBlockHashAndIndex(request[0u].asString(), request[1u].asString());
@@ -489,6 +494,7 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
         virtual Json::Value eth_getTransactionByHash(const std::string& param1) = 0;
         virtual Json::Value eth_getTransactionByBlockHashAndIndex(const std::string& param1, const std::string& param2) = 0;
         virtual Json::Value eth_getTransactionByBlockNumberAndIndex(const std::string& param1, const std::string& param2) = 0;
+        virtual Json::Value eth_getTransactionReceipt(const std::string& param1) = 0;
         virtual Json::Value eth_getUncleByBlockHashAndIndex(const std::string& param1, const std::string& param2) = 0;
         virtual Json::Value eth_getUncleByBlockNumberAndIndex(const std::string& param1, const std::string& param2) = 0;
         virtual Json::Value eth_getCompilers() = 0;

libweb3jsonrpc/spec.json

@@ -29,6 +29,7 @@
 { "name": "eth_getTransactionByHash", "params": [""], "order": [], "returns": {}},
 { "name": "eth_getTransactionByBlockHashAndIndex", "params": ["", ""], "order": [], "returns": {}},
 { "name": "eth_getTransactionByBlockNumberAndIndex", "params": ["", ""], "order": [], "returns": {}},
+{ "name": "eth_getTransactionReceipt", "params": [""], "order": [], "returns": {}},
 { "name": "eth_getUncleByBlockHashAndIndex", "params": ["", ""], "order": [], "returns": {}},
 { "name": "eth_getUncleByBlockNumberAndIndex", "params": ["", ""], "order": [], "returns": {}},
 { "name": "eth_getCompilers", "params": [], "order": [], "returns": []},

libwhisper/BloomFilter.h

@@ -88,7 +88,7 @@ template <unsigned N>
 bool TopicBloomFilterBase<N>::isBitSet(FixedHash<N> const& _h, unsigned _index)
 {
 	unsigned iByte = _index / 8;
-	unsigned iBit = _index & 0x7;
+	unsigned iBit = _index % 8;
 	return (_h[iByte] & c_powerOfTwoBitMmask[iBit]) != 0;
 }
 
@@ -96,7 +96,7 @@ template <unsigned N>
 void TopicBloomFilterBase<N>::setBit(FixedHash<N>& _h, unsigned _index)
 {
 	unsigned iByte = _index / 8;
-	unsigned iBit = _index & 0x7;
+	unsigned iBit = _index % 8;
 	_h[iByte] |= c_powerOfTwoBitMmask[iBit];
 }
 

libwhisper/Message.cpp

@@ -170,7 +170,7 @@ void Envelope::proveWork(unsigned _ms)
 	chrono::high_resolution_clock::time_point then = chrono::high_resolution_clock::now() + chrono::milliseconds(_ms);
 	while (chrono::high_resolution_clock::now() < then)
 		// do it rounds of 1024 for efficiency
-		for (unsigned i = 0; i < 1024; ++i)
+		for (unsigned i = 0; i < 1024; ++i, ++d[1])
 		{
 			auto fbs = dev::sha3(chuck).firstBitSet();
 			if (fbs > bestBitSet)
@@ -178,8 +178,6 @@ void Envelope::proveWork(unsigned _ms)
 				bestBitSet = fbs;
 				m_nonce = (h256::Arith)d[1];
 			}
-
-			incrementHash(d[1]);
 		}
 }
 

libwhisper/Message.h

@@ -81,7 +81,6 @@ public:
 	void proveWork(unsigned _ms);
 
 	bool matchesBloomFilter(TopicBloomFilterHash const& f) const;
-	static void incrementHash(h256& _h) { for (unsigned i = h256::size; i > 0 && !++_h[--i]; ) {} }
 
 private:
 	Envelope(unsigned _exp, unsigned _ttl, AbridgedTopics const& _topic): m_expiry(_exp), m_ttl(_ttl), m_topic(_topic) {}

mix/CMakeLists.txt

@@ -15,6 +15,11 @@ include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS})
 include_directories(${Boost_INCLUDE_DIRS})
 include_directories(BEFORE ..)
 
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	# Supress warnings for qt headers for clang+ccache
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-inconsistent-missing-override")
+endif ()
+
 find_package (Qt5WebEngine QUIET)
 qt5_add_resources(UI_RESOURCES res.qrc qml.qrc)
 

mix/ClientModel.cpp

@@ -674,8 +674,7 @@ void ClientModel::debugRecord(unsigned _index)
 
 Address ClientModel::deployContract(bytes const& _code, TransactionSettings const& _ctrTransaction)
 {
-	Address newAddress = m_client->submitTransaction(_ctrTransaction.sender, _ctrTransaction.value, _code, _ctrTransaction.gas, _ctrTransaction.gasPrice, _ctrTransaction.gasAuto);
-	return newAddress;
+	return m_client->submitTransaction(_ctrTransaction.sender, _ctrTransaction.value, _code, _ctrTransaction.gas, _ctrTransaction.gasPrice, _ctrTransaction.gasAuto);
 }
 
 void ClientModel::callAddress(Address const& _contract, bytes const& _data, TransactionSettings const& _tr)

mix/ClientModel.h

@@ -252,7 +252,7 @@ private:
 	QVariantMap contractAddresses() const;
 	QVariantList gasCosts() const;
 	void executeSequence(std::vector<TransactionSettings> const& _sequence);
-	dev::Address deployContract(bytes const& _code, TransactionSettings const& _tr = TransactionSettings());
+	Address deployContract(bytes const& _code, TransactionSettings const& _tr = TransactionSettings());
 	void callAddress(Address const& _contract, bytes const& _data, TransactionSettings const& _tr);
 	void onNewTransaction();
 	void onStateReset();

mix/CodeModel.cpp

@@ -562,7 +562,7 @@ SolidityType CodeModel::nodeType(dev::solidity::Type const* _type)
 	{
 		FixedBytesType const* b = dynamic_cast<FixedBytesType const*>(_type);
 		r.type = SolidityType::Type::Bytes;
-		r.size = static_cast<unsigned>(b->getNumBytes());
+		r.size = static_cast<unsigned>(b->numBytes());
 	}
 		break;
 	case Type::Category::Contract:
@@ -608,6 +608,7 @@ SolidityType CodeModel::nodeType(dev::solidity::Type const* _type)
 		break;
 	case Type::Category::Function:
 	case Type::Category::IntegerConstant:
+	case Type::Category::StringLiteral:
 	case Type::Category::Magic:
 	case Type::Category::Mapping:
 	case Type::Category::Modifier:

mix/MixClient.cpp

@@ -303,14 +303,15 @@ State MixClient::asOf(h256 const& _block) const
 	return ret;
 }
 
-Address MixClient::submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret, bool _gasAuto)
+pair<h256, Address> MixClient::submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret, bool _gasAuto)
 {
 	WriteGuard l(x_state);
 	TransactionSkeleton ts = _ts;
-	ts.nonce = m_state.transactionsFrom(toAddress(_secret));
+	ts.from = toAddress(_secret);
+	ts.nonce = m_state.transactionsFrom(ts.from);
 	eth::Transaction t(ts, _secret);
 	executeTransaction(t, m_state, false, _gasAuto, _secret);
-	return _ts.creation ? right160(sha3(rlpList(ts.to, ts.nonce))) : Address();
+	return make_pair(t.sha3(), toAddress(ts.from, ts.nonce));
 }
 
 dev::eth::ExecutionResult MixClient::call(Address const& _from, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice, BlockNumber _blockNumber, bool _gasAuto, FudgeFactor _ff)

mix/MixClient.h

@@ -58,8 +58,8 @@ public:
 	dev::eth::ExecutionResult create(Address const& _secret, u256 _value, bytes const& _data = bytes(), u256 _gas = 10000, u256 _gasPrice = 10 * eth::szabo, eth::BlockNumber _blockNumber = eth::PendingBlock, eth::FudgeFactor _ff = eth::FudgeFactor::Strict) override;
 
 	using ClientBase::submitTransaction;
-	virtual Address submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret) override { return submitTransaction(_ts, _secret, false); }
-	Address submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret, bool _gasAuto);
+	virtual std::pair<h256, Address> submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret) override { return submitTransaction(_ts, _secret, false); }
+	std::pair<h256, Address> submitTransaction(eth::TransactionSkeleton const& _ts, Secret const& _secret, bool _gasAuto);
 	dev::eth::ExecutionResult call(Address const& _secret, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice, eth::BlockNumber _blockNumber, bool _gasAuto, eth::FudgeFactor _ff = eth::FudgeFactor::Strict);
 
 	void setAddress(Address _us) override;
@@ -76,6 +76,9 @@ public:
 	using Interface::blockInfo; // to remove warning about hiding virtual function
 	eth::BlockInfo blockInfo() const;
 
+	/// return the new address generated by the last tr (if creation). returns empty address if other cases.
+	Address lastCreatedContractAddr() const;
+
 protected:
 	/// ClientBase methods
 	using ClientBase::asOf;

neth/main.cpp

@@ -363,11 +363,7 @@ int main(int argc, char** argv)
 		coinbase = config[1].toHash<Address>();
 	}
 	else
-	{
-		RLPStream config(2);
-		config << us.secret() << coinbase;
-		writeFile(configFile, config.out());
-	}
+		writeFile(configFile, rlpList(us.secret(), coinbase));
 
 	for (int i = 1; i < argc; ++i)
 	{
@@ -1061,9 +1057,7 @@ int main(int argc, char** argv)
 				else if (gas < minGas)
 					cwarn << "Minimum gas amount is" << minGas;
 				else
-				{
 					c->submitTransaction(us.secret(), endowment, init, gas);
-				}
 			}
 		}
 		else if (c && cmd == "inspect")

solc/CommandLineInterface.cpp

@@ -35,6 +35,7 @@
 #include <libdevcore/CommonIO.h>
 #include <libevmcore/Instruction.h>
 #include <libevmcore/Params.h>
+#include <libsolidity/Version.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Parser.h>
 #include <libsolidity/ASTPrinter.h>
@@ -81,9 +82,12 @@ static set<string> const g_combinedJsonArgs{
 
 static void version()
 {
-	cout << "solc, the solidity compiler commandline interface " << dev::Version << endl
-		 << "  by Christian <c@ethdev.com> and Lefteris <lefteris@ethdev.com>, (c) 2014." << endl
-		 << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl;
+	cout <<
+		"solc, the solidity compiler commandline interface" <<
+		endl <<
+		"Version: " <<
+		dev::solidity::VersionString <<
+		endl;
 	exit(0);
 }
 

test/fuzzTesting/fuzzHelper.cpp

@@ -74,7 +74,7 @@ std::string RandomCode::generate(int _maxOpNumber, RandomCodeOptions _options)
 		uint8_t opcode = weightsDefined ? randOpCodeWeight() : randOpCodeGen();
 		dev::eth::InstructionInfo info = dev::eth::instructionInfo((dev::eth::Instruction) opcode);
 
-		if (info.name.find_first_of("INVALID_INSTRUCTION") > 0)
+		if (info.name.find("INVALID_INSTRUCTION") != std::string::npos)
 		{
 			//Byte code is yet not implemented
 			if (_options.useUndefinedOpCodes == false)
@@ -85,12 +85,12 @@ std::string RandomCode::generate(int _maxOpNumber, RandomCodeOptions _options)
 		}
 		else
 		{
-			if (info.name.find_first_of("PUSH") > 0)
+			if (info.name.find("PUSH") != std::string::npos)
 				code += toCompactHex(opcode);
 			code += fillArguments((dev::eth::Instruction) opcode, _options);
 		}
 
-		if (info.name.find_first_of("PUSH") <= 0)
+		if (info.name.find("PUSH") == std::string::npos)
 		{
 			std::string byte = toCompactHex(opcode);
 			code += (byte == "") ? "00" : byte;
@@ -149,113 +149,34 @@ std::string RandomCode::fillArguments(dev::eth::Instruction _opcode, RandomCodeO
 
 	if (smart)
 	{
-		switch (_opcode)
+		//PUSH1 ... PUSH32
+		if (dev::eth::Instruction::PUSH1 <= _opcode && _opcode <= dev::eth::Instruction::PUSH32)
 		{
-		case dev::eth::Instruction::PUSH1:	code += rndByteSequence(1);	break;
-		case dev::eth::Instruction::PUSH2:	code += rndByteSequence(2);	break;
-		case dev::eth::Instruction::PUSH3:	code += rndByteSequence(3);	break;
-		case dev::eth::Instruction::PUSH4:	code += rndByteSequence(4);	break;
-		case dev::eth::Instruction::PUSH5:	code += rndByteSequence(5);	break;
-		case dev::eth::Instruction::PUSH6:	code += rndByteSequence(6);	break;
-		case dev::eth::Instruction::PUSH7:	code += rndByteSequence(7);	break;
-		case dev::eth::Instruction::PUSH8:	code += rndByteSequence(8);	break;
-		case dev::eth::Instruction::PUSH9:	code += rndByteSequence(9);	break;
-		case dev::eth::Instruction::PUSH10:	code += rndByteSequence(10); break;
-		case dev::eth::Instruction::PUSH11:	code += rndByteSequence(11); break;
-		case dev::eth::Instruction::PUSH12:	code += rndByteSequence(12); break;
-		case dev::eth::Instruction::PUSH13:	code += rndByteSequence(13); break;
-		case dev::eth::Instruction::PUSH14:	code += rndByteSequence(14); break;
-		case dev::eth::Instruction::PUSH15:	code += rndByteSequence(15); break;
-		case dev::eth::Instruction::PUSH16:	code += rndByteSequence(16); break;
-		case dev::eth::Instruction::PUSH17:	code += rndByteSequence(17); break;
-		case dev::eth::Instruction::PUSH18:	code += rndByteSequence(18); break;
-		case dev::eth::Instruction::PUSH19:	code += rndByteSequence(19); break;
-		case dev::eth::Instruction::PUSH20:	code += rndByteSequence(20); break;
-		case dev::eth::Instruction::PUSH21:	code += rndByteSequence(21); break;
-		case dev::eth::Instruction::PUSH22:	code += rndByteSequence(22); break;
-		case dev::eth::Instruction::PUSH23:	code += rndByteSequence(23); break;
-		case dev::eth::Instruction::PUSH24:	code += rndByteSequence(24); break;
-		case dev::eth::Instruction::PUSH25:	code += rndByteSequence(25); break;
-		case dev::eth::Instruction::PUSH26:	code += rndByteSequence(26); break;
-		case dev::eth::Instruction::PUSH27:	code += rndByteSequence(27); break;
-		case dev::eth::Instruction::PUSH28:	code += rndByteSequence(28); break;
-		case dev::eth::Instruction::PUSH29:	code += rndByteSequence(29); break;
-		case dev::eth::Instruction::PUSH30:	code += rndByteSequence(30); break;
-		case dev::eth::Instruction::PUSH31:	code += rndByteSequence(31); break;
-		case dev::eth::Instruction::PUSH32:	code += rndByteSequence(32); break;
-		case dev::eth::Instruction::SWAP1:
-		case dev::eth::Instruction::SWAP2:
-		case dev::eth::Instruction::SWAP3:
-		case dev::eth::Instruction::SWAP4:
-		case dev::eth::Instruction::SWAP5:
-		case dev::eth::Instruction::SWAP6:
-		case dev::eth::Instruction::SWAP7:
-		case dev::eth::Instruction::SWAP8:
-		case dev::eth::Instruction::SWAP9:
-		case dev::eth::Instruction::SWAP10:
-		case dev::eth::Instruction::SWAP11:
-		case dev::eth::Instruction::SWAP12:
-		case dev::eth::Instruction::SWAP13:
-		case dev::eth::Instruction::SWAP14:
-		case dev::eth::Instruction::SWAP15:
-		case dev::eth::Instruction::SWAP16:
-		case dev::eth::Instruction::DUP1:
-		case dev::eth::Instruction::DUP2:
-		case dev::eth::Instruction::DUP3:
-		case dev::eth::Instruction::DUP4:
-		case dev::eth::Instruction::DUP5:
-		case dev::eth::Instruction::DUP6:
-		case dev::eth::Instruction::DUP7:
-		case dev::eth::Instruction::DUP8:
-		case dev::eth::Instruction::DUP9:
-		case dev::eth::Instruction::DUP10:
-		case dev::eth::Instruction::DUP11:
-		case dev::eth::Instruction::DUP12:
-		case dev::eth::Instruction::DUP13:
-		case dev::eth::Instruction::DUP14:
-		case dev::eth::Instruction::DUP15:
-		case dev::eth::Instruction::DUP16:
-			int times;
-			switch (_opcode)
-			{
-				case dev::eth::Instruction::DUP1:	times = 1; break;
-				case dev::eth::Instruction::SWAP1:
-				case dev::eth::Instruction::DUP2:	times = 2; break;
-				case dev::eth::Instruction::SWAP2:
-				case dev::eth::Instruction::DUP3:	times = 3; break;
-				case dev::eth::Instruction::SWAP3:
-				case dev::eth::Instruction::DUP4:	times = 4; break;
-				case dev::eth::Instruction::SWAP4:
-				case dev::eth::Instruction::DUP5:	times = 5; break;
-				case dev::eth::Instruction::SWAP5:
-				case dev::eth::Instruction::DUP6:	times = 6; break;
-				case dev::eth::Instruction::SWAP6:
-				case dev::eth::Instruction::DUP7:	times = 7; break;
-				case dev::eth::Instruction::SWAP7:
-				case dev::eth::Instruction::DUP8:	times = 8; break;
-				case dev::eth::Instruction::SWAP8:
-				case dev::eth::Instruction::DUP9:	times = 9; break;
-				case dev::eth::Instruction::SWAP9:
-				case dev::eth::Instruction::DUP10:	times = 10; break;
-				case dev::eth::Instruction::SWAP10:
-				case dev::eth::Instruction::DUP11:	times = 11; break;
-				case dev::eth::Instruction::SWAP11:
-				case dev::eth::Instruction::DUP12:	times = 12; break;
-				case dev::eth::Instruction::SWAP12:
-				case dev::eth::Instruction::DUP13:	times = 13; break;
-				case dev::eth::Instruction::SWAP13:
-				case dev::eth::Instruction::DUP14:	times = 14; break;
-				case dev::eth::Instruction::SWAP14:
-				case dev::eth::Instruction::DUP15:	times = 15; break;
-				case dev::eth::Instruction::SWAP15:
-				case dev::eth::Instruction::DUP16:	times = 16; break;
-				case dev::eth::Instruction::SWAP16:	times = 17; break;
-				default: times = 1;
-			}
+		  code += rndByteSequence(int(_opcode) - int(dev::eth::Instruction::PUSH1) + 1);
+		  return code;
+		}
+
+		//SWAP1 ... SWAP16 || DUP1 ... DUP16
+		bool isSWAP = (dev::eth::Instruction::SWAP1 <= _opcode && _opcode <= dev::eth::Instruction::SWAP16);
+		bool isDUP = (dev::eth::Instruction::DUP1 <= _opcode && _opcode <= dev::eth::Instruction::DUP16);
+
+		if (isSWAP || isDUP)
+		{
+			int times = 0;
+			if (isSWAP)
+				times = int(_opcode) - int(dev::eth::Instruction::SWAP1) + 2;
+			else
+			if (isDUP)
+				times = int(_opcode) - int(dev::eth::Instruction::DUP1) + 1;
+
 			for (int i = 0; i < times; i ++)
 				code += getPushCode(randUniIntGen() % 32);
 
-		break;
+			return code;
+		}
+
+		switch (_opcode)
+		{
 		case dev::eth::Instruction::CREATE:
 			//(CREATE value mem1 mem2)
 			code += getPushCode(randUniIntGen() % 128);  //memlen1

test/libdevcore/FixedHash.cpp

@@ -100,6 +100,46 @@ BOOST_AUTO_TEST_CASE(FixedHashContains)
 	BOOST_CHECK(!h1.contains(h3));
 }
 
+void incrementSingleIteration(unsigned seed)
+{
+	unsigned next = seed + 1;
+
+	FixedHash<4> h1(seed);
+	FixedHash<4> h2 = h1;
+	FixedHash<4> h3(next);
+
+	FixedHash<32> hh1(seed);
+	FixedHash<32> hh2 = hh1;
+	FixedHash<32> hh3(next);
+
+	BOOST_CHECK_EQUAL(++h2, h3);
+	BOOST_CHECK_EQUAL(++hh2, hh3);
+
+	BOOST_CHECK(h2 > h1);
+	BOOST_CHECK(hh2 > hh1);
+
+	unsigned reverse1 = ((FixedHash<4>::Arith)h2).convert_to<unsigned>();
+	unsigned reverse2 = ((FixedHash<32>::Arith)hh2).convert_to<unsigned>();
+
+	BOOST_CHECK_EQUAL(next, reverse1);
+	BOOST_CHECK_EQUAL(next, reverse2);
+}
+
+BOOST_AUTO_TEST_CASE(FixedHashIncrement)
+{
+	incrementSingleIteration(0);
+	incrementSingleIteration(1);
+	incrementSingleIteration(0xBAD);
+	incrementSingleIteration(0xBEEF);
+	incrementSingleIteration(0xFFFF);
+	incrementSingleIteration(0xFEDCBA);
+	incrementSingleIteration(0x7FFFFFFF);
+
+	FixedHash<4> h(0xFFFFFFFF);
+	FixedHash<4> zero;
+	BOOST_CHECK_EQUAL(++h, zero);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/libdevcore/core.cpp

@@ -0,0 +1,41 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	cpp-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file core.cpp
+ * @author Dimitry Khokhlov <winsvega@mail.ru>
+ * @date 2014
+ * CORE test functions.
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <libdevcore/CommonIO.h>
+#include <test/TestHelper.h>
+
+BOOST_AUTO_TEST_SUITE(CoreLibTests)
+
+BOOST_AUTO_TEST_CASE(byteRef)
+{	
+	cnote << "bytesRef copyTo and toString...";
+	dev::bytes originalSequence = dev::fromHex("0102030405060708091011121314151617181920212223242526272829303132");
+	dev::bytesRef out(&originalSequence.at(0), 32);
+	dev::h256 hash32("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347");
+	hash32.ref().copyTo(out);
+
+	BOOST_CHECK_MESSAGE(out.size() == 32, "Error wrong result size when h256::ref().copyTo(dev::bytesRef out)");
+	BOOST_CHECK_MESSAGE(out.toBytes() == originalSequence, "Error when h256::ref().copyTo(dev::bytesRef out)");
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/libdevcrypto/AES.cpp

@@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(AuthenticatedStreamConstructor)
 {
 	cout << "AuthenticatedStreamConstructor" << endl;
 
-	Secret const sec("test");
+	Secret const sec(dev::sha3("test"));
 	crypto::aes::AuthenticatedStream as(crypto::aes::Encrypt, sec, 0);
 	BOOST_CHECK(as.getMacInterval() == 0);
 	as.adjustInterval(1);

test/libethereum/BlockchainTestsFiller/bcBlockGasLimitTestFiller.json

@@ -0,0 +1,277 @@
+{
+    "SuicideTransaction" : {
+        "genesisBlockHeader" : {
+            "bloom" : "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+            "coinbase" : "0x8888f1f195afa192cfee860698584c030f4c9db1",
+            "difficulty" : "131072",
+            "extraData" : "0x42",
+            "gasLimit" : "125000",
+            "gasUsed" : "0",
+            "mixHash" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "nonce" : "0x0102030405060708",
+            "number" : "0",
+            "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "receiptTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "stateRoot" : "0xf99eb1626cfa6db435c0836235942d7ccaa935f1ae247d3f1c21e495685f903a",
+            "timestamp" : "0x54c98c81",
+            "transactionsTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "uncleHash" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
+        },
+        "expect" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000"
+            }
+        },
+        "pre" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "90000000000000000000000000",
+                "nonce" : "0",
+                "code" : "",
+                "storage": {}
+            },
+            "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000",
+                "nonce" : "0",
+                "code" : "0x73a94f5374fce5edbc8e2a8697c15331677e6ebf0bff",
+                "storage": {}
+            }
+        },
+        "blocks" : [
+            {
+                "transactions" : [
+                    {
+                        "data" : "",
+                        "gasLimit" : "100000",
+                        "gasPrice" : "10",
+                        "nonce" : "0",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    }
+                ],
+                "uncleHeaders" : [
+                ]
+            }
+        ]
+    },
+
+    "GasUsedHigherThanBlockGasLimitButNotWithRefundsSuicideLast" : {
+        "genesisBlockHeader" : {
+            "bloom" : "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+            "coinbase" : "0x8888f1f195afa192cfee860698584c030f4c9db1",
+            "difficulty" : "131072",
+            "extraData" : "0x42",
+            "gasLimit" : "147000",
+            "gasUsed" : "0",
+            "mixHash" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "nonce" : "0x0102030405060708",
+            "number" : "0",
+            "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "receiptTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "stateRoot" : "0xf99eb1626cfa6db435c0836235942d7ccaa935f1ae247d3f1c21e495685f903a",
+            "timestamp" : "0x54c98c81",
+            "transactionsTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "uncleHash" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
+        },
+        "expect" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000"
+            }
+        },
+        "pre" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "90000000000000000000000000",
+                "nonce" : "0",
+                "code" : "",
+                "storage": {}
+            },
+            "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000",
+                "nonce" : "0",
+                "code" : "0x73a94f5374fce5edbc8e2a8697c15331677e6ebf0bff",
+                "storage": {}
+            }
+        },
+        "blocks" : [
+            {
+                "transactions" : [
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "0",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "1",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "2",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "3",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "4",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "5",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "22000",
+                        "gasPrice" : "10",
+                        "nonce" : "6",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    }
+                ],
+                "uncleHeaders" : [
+                ]
+            }
+        ]
+    },
+
+    "GasUsedHigherThanBlockGasLimitButNotWithRefundsSuicideFirst" : {
+        "genesisBlockHeader" : {
+            "bloom" : "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+            "coinbase" : "0x8888f1f195afa192cfee860698584c030f4c9db1",
+            "difficulty" : "131072",
+            "extraData" : "0x42",
+            "gasLimit" : "147000",
+            "gasUsed" : "0",
+            "mixHash" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "nonce" : "0x0102030405060708",
+            "number" : "0",
+            "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "receiptTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "stateRoot" : "0xf99eb1626cfa6db435c0836235942d7ccaa935f1ae247d3f1c21e495685f903a",
+            "timestamp" : "0x54c98c81",
+            "transactionsTrie" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "uncleHash" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
+        },
+        "expect" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000"
+            }
+        },
+        "pre" : {
+            "a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "90000000000000000000000000",
+                "nonce" : "0",
+                "code" : "",
+                "storage": {}
+            },
+            "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+                "balance" : "10000000000",
+                "nonce" : "0",
+                "code" : "0x73a94f5374fce5edbc8e2a8697c15331677e6ebf0bff",
+                "storage": {}
+            }
+        },
+        "blocks" : [
+            {
+                "transactions" : [
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "6",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "1",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "2",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "3",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "4",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "21000",
+                        "gasPrice" : "10",
+                        "nonce" : "5",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "bbbf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    },
+                    {
+                        "data" : "",
+                        "gasLimit" : "22000",
+                        "gasPrice" : "10",
+                        "nonce" : "0",
+                        "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+                        "to" : "aaaf5374fce5edbc8e2a8697c15331677e6ebf0b",
+                        "value" : "10"
+                    }
+                ],
+                "uncleHeaders" : [
+                ]
+            }
+        ]
+    }
+}

test/libethereum/blockchain.cpp

@@ -837,6 +837,11 @@ BOOST_AUTO_TEST_CASE(bcBruncleTest)
 	dev::test::executeTests("bcBruncleTest", "/BlockchainTests",dev::test::getFolder(__FILE__) + "/BlockchainTestsFiller", dev::test::doBlockchainTests);
 }
 
+BOOST_AUTO_TEST_CASE(bcBlockGasLimitTest)
+{
+	dev::test::executeTests("bcBlockGasLimitTest", "/BlockchainTests",dev::test::getFolder(__FILE__) + "/BlockchainTestsFiller", dev::test::doBlockchainTests);
+}
+
 BOOST_AUTO_TEST_CASE(bcWalletTest)
 {
 	if (test::Options::get().wallet)

test/libsolidity/SolidityEndToEndTest.cpp

@@ -564,20 +564,6 @@ BOOST_AUTO_TEST_CASE(strings)
 	BOOST_CHECK(callContractFunction("pipeThrough(bytes2,bool)", string("\0\x02", 2), true) == encodeArgs(string("\0\x2", 2), true));
 }
 
-BOOST_AUTO_TEST_CASE(empty_string_on_stack)
-{
-	char const* sourceCode = R"(
-		contract test {
-			function run() external returns(bytes2 ret) {
-				var y = "";
-				ret = y;
-			}
-		}
-	)";
-	compileAndRun(sourceCode);
-	BOOST_CHECK(callContractFunction("run()") == encodeArgs(byte(0x00)));
-}
-
 BOOST_AUTO_TEST_CASE(inc_dec_operators)
 {
 	char const* sourceCode = R"(
@@ -5001,6 +4987,37 @@ BOOST_AUTO_TEST_CASE(struct_named_constructor)
 	BOOST_CHECK(callContractFunction("s()") == encodeArgs(u256(1), true));
 }
 
+BOOST_AUTO_TEST_CASE(literal_strings)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			string public long;
+			string public medium;
+			string public short;
+			string public empty;
+			function f() returns (string) {
+				long = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+				medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
+				short = "123";
+				empty = "";
+				return "Hello, World!";
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+	string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+	string medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
+	string shortStr = "123";
+	string hello = "Hello, World!";
+
+	BOOST_CHECK(callContractFunction("f()") == encodeDyn(hello));
+	BOOST_CHECK(callContractFunction("long()") == encodeDyn(longStr));
+	BOOST_CHECK(callContractFunction("medium()") == encodeDyn(medium));
+	BOOST_CHECK(callContractFunction("short()") == encodeDyn(shortStr));
+	BOOST_CHECK(callContractFunction("empty()") == encodeDyn(string()));
+}
+
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/libsolidity/SolidityNameAndTypeResolution.cpp

@@ -283,7 +283,7 @@ BOOST_AUTO_TEST_CASE(large_string_literal)
 	char const* text = "contract test {\n"
 					   "  function f() { var x = \"123456789012345678901234567890123\"; }"
 					   "}\n";
-	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
 }
 
 BOOST_AUTO_TEST_CASE(balance)
@@ -2097,6 +2097,19 @@ BOOST_AUTO_TEST_CASE(struct_named_constructor)
 	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(sourceCode));
 }
 
+BOOST_AUTO_TEST_CASE(literal_strings)
+{
+	char const* text = R"(
+		contract Foo {
+			function f() {
+				string memory long = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+				string memory short = "123";
+			}
+		}
+	)";
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/libsolidity/solidityExecutionFramework.h

@@ -145,6 +145,12 @@ public:
 	{
 		return bytes();
 	}
+	//@todo might be extended in the future
+	template <class Arg>
+	static bytes encodeDyn(Arg const& _arg)
+	{
+		return encodeArgs(u256(0x20), u256(_arg.size()), _arg);
+	}
 
 private:
 	template <class CppFunction, class... Args>

test/libweb3jsonrpc/webthreestubclient.h

@@ -302,6 +302,16 @@ class WebThreeStubClient : public jsonrpc::Client
             else
                 throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
         }
+        Json::Value eth_getTransactionReceipt(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+            Json::Value result = this->CallMethod("eth_getTransactionReceipt",p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
         Json::Value eth_getUncleByBlockHashAndIndex(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
         {
             Json::Value p;