Merge branch 'stateTests' into NewStateTests

Conflicts:
	test/TestHelper.cpp
	test/vm.cpp

11 files changed, 1059 insertions, 352 deletions

diff --git a/TestHelper.cpp b/TestHelper.cpp
index e2ea2d8d..ab9dbee3 100644
--- a/TestHelper.cpp
+++ b/TestHelper.cpp
@@ -27,7 +27,7 @@
 #include <libethereum/Client.h>
 #include <liblll/Compiler.h>
 
-//#define FILL_TESTS
+#define FILL_TESTS
 
 using namespace std;
 using namespace dev::eth;
@@ -65,7 +65,7 @@ void connectClients(Client& c1, Client& c2)
 namespace test
 {
 
-ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller):m_TestObject(_o)
+ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller): m_TestObject(_o)
 {
 	importEnv(_o["env"].get_obj());
 	importState(_o["pre"].get_obj(), m_statePre);
@@ -79,12 +79,12 @@ ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller):m_TestObject(_o)
 
 void ImportTest::importEnv(json_spirit::mObject& _o)
 {
-	assert(_o.count("previousHash") > 0);
-	assert(_o.count("currentGasLimit") > 0);
-	assert(_o.count("currentDifficulty") > 0);
-	assert(_o.count("currentTimestamp") > 0);
-	assert(_o.count("currentCoinbase") > 0);
-	assert(_o.count("currentNumber") > 0);
+	BOOST_REQUIRE(_o.count("previousHash") > 0);
+	BOOST_REQUIRE(_o.count("currentGasLimit") > 0);
+	BOOST_REQUIRE(_o.count("currentDifficulty") > 0);
+	BOOST_REQUIRE(_o.count("currentTimestamp") > 0);
+	BOOST_REQUIRE(_o.count("currentCoinbase") > 0);
+	BOOST_REQUIRE(_o.count("currentNumber") > 0);
 
 	m_environment.previousBlock.hash = h256(_o["previousHash"].get_str());
 	m_environment.currentBlock.number = toInt(_o["currentNumber"]);
@@ -103,10 +103,10 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
 	{
 		json_spirit::mObject o = i.second.get_obj();
 
-		assert(o.count("balance") > 0);
-		assert(o.count("nonce") > 0);
-		assert(o.count("storage") > 0);
-		assert(o.count("code") > 0);
+		BOOST_REQUIRE(o.count("balance") > 0);
+		BOOST_REQUIRE(o.count("nonce") > 0);
+		BOOST_REQUIRE(o.count("storage") > 0);
+		BOOST_REQUIRE(o.count("code") > 0);
 
 		Address address = Address(i.first);
 
@@ -115,11 +115,9 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
 
 		bytes code = importCode(o);
 
-		toInt(o["nonce"]);
-		if (toHex(code).size())
+		if (code.size())
 		{
 			_state.m_cache[address] = Account(toInt(o["balance"]), Account::ContractConception);
-			i.second.get_obj()["code"] = "0x" + toHex(code); //preperation for export
 			_state.m_cache[address].setCode(bytesConstRef(&code));
 		}
 		else
@@ -134,23 +132,17 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
 
 void ImportTest::importTransaction(json_spirit::mObject& _o)
 {
-	assert(_o.count("nonce")> 0);
-	assert(_o.count("gasPrice") > 0);
-	assert(_o.count("gasLimit") > 0);
-	assert(_o.count("to") > 0);
-	assert(_o.count("value") > 0);
-	assert(_o.count("secretKey") > 0);
-	assert(_o.count("data") > 0);
-
-	m_transaction.nonce = toInt(_o["nonce"]);
-	m_transaction.gasPrice = toInt(_o["gasPrice"]);
-	m_transaction.gas = toInt(_o["gasLimit"]);
-	m_transaction.receiveAddress = Address(_o["to"].get_str());
-	m_transaction.type = m_transaction.receiveAddress ? Transaction::MessageCall : Transaction::ContractCreation;
-	m_transaction.value = toInt(_o["value"]);
-	Secret secretKey = Secret(_o["secretKey"].get_str());
-	m_transaction.data = importData(_o);
-	m_transaction.sign(secretKey);
+	BOOST_REQUIRE(_o.count("nonce")> 0);
+	BOOST_REQUIRE(_o.count("gasPrice") > 0);
+	BOOST_REQUIRE(_o.count("gasLimit") > 0);
+	BOOST_REQUIRE(_o.count("to") > 0);
+	BOOST_REQUIRE(_o.count("value") > 0);
+	BOOST_REQUIRE(_o.count("secretKey") > 0);
+	BOOST_REQUIRE(_o.count("data") > 0);
+
+	m_transaction = _o["to"].get_str().empty() ?
+		Transaction(toInt(_o["value"]), toInt(_o["gasPrice"]), toInt(_o["gasLimit"]), importData(_o), toInt(_o["nonce"]), Secret(_o["secretKey"].get_str())) :
+		Transaction(toInt(_o["value"]), toInt(_o["gasPrice"]), toInt(_o["gasLimit"]), Address(_o["to"].get_str()), importData(_o), toInt(_o["nonce"]), Secret(_o["secretKey"].get_str()));
 }
 
 void ImportTest::exportTest(bytes _output, State& _statePost)
@@ -182,6 +174,29 @@ void ImportTest::exportTest(bytes _output, State& _statePost)
 		postState[toString(a.first)] = o;
 	}
 	m_TestObject["post"] = json_spirit::mValue(postState);
+
+	// export pre state
+	json_spirit::mObject preState;
+
+	for (auto const& a: m_statePre.addresses())
+	{
+		if (genesis.count(a.first))
+			continue;
+
+		json_spirit::mObject o;
+		o["balance"] = toString(m_statePre.balance(a.first));
+		o["nonce"] = toString(m_statePre.transactionsFrom(a.first));
+		{
+			json_spirit::mObject store;
+			for (auto const& s: m_statePre.storage(a.first))
+				store["0x"+toHex(toCompactBigEndian(s.first))] = "0x"+toHex(toCompactBigEndian(s.second));
+			o["storage"] = store;
+		}
+		o["code"] = "0x" + toHex(m_statePre.code(a.first));
+
+		preState[toString(a.first)] = o;
+	}
+	m_TestObject["pre"] = json_spirit::mValue(preState);
 }
 
 u256 toInt(json_spirit::mValue const& _v)
@@ -210,7 +225,7 @@ byte toByte(json_spirit::mValue const& _v)
 	return 0;
 }
 
-bytes importData(json_spirit::mObject & _o)
+bytes importData(json_spirit::mObject& _o)
 {
 	bytes data;
 	if (_o["data"].type() == json_spirit::str_type)
@@ -225,7 +240,7 @@ bytes importData(json_spirit::mObject & _o)
 	return data;
 }
 
-bytes importCode(json_spirit::mObject & _o)
+bytes importCode(json_spirit::mObject& _o)
 {
 	bytes code;
 	if (_o["code"].type() == json_spirit::str_type)
@@ -242,7 +257,7 @@ bytes importCode(json_spirit::mObject & _o)
 	return code;
 }
 
-void checkOutput(bytes const& _output, json_spirit::mObject & _o)
+void checkOutput(bytes const& _output, json_spirit::mObject& _o)
 {
 	int j = 0;
 	if (_o["out"].type() == json_spirit::array_type)
diff --git a/TestHelper.h b/TestHelper.h
index d7ffe5cb..622b83ac 100644
--- a/TestHelper.h
+++ b/TestHelper.h
@@ -66,9 +66,9 @@ private:
 // helping functions
 u256 toInt(json_spirit::mValue const& _v);
 byte toByte(json_spirit::mValue const& _v);
-bytes importCode(json_spirit::mObject &_o);
-bytes importData(json_spirit::mObject &_o);
-void checkOutput(bytes const& _output, json_spirit::mObject &_o);
+bytes importCode(json_spirit::mObject& _o);
+bytes importData(json_spirit::mObject& _o);
+void checkOutput(bytes const& _output, json_spirit::mObject& _o);
 void checkStorage(std::map<u256, u256> _expectedStore, std::map<u256, u256> _resultStore, Address _expectedAddr);
 void executeTests(const std::string& _name, const std::string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests);
 std::string getTestPath();
diff --git a/crypto.cpp b/crypto.cpp
index 67286bfc..06e55658 100644
--- a/crypto.cpp
+++ b/crypto.cpp
@@ -28,6 +28,7 @@
 #include <libethereum/Transaction.h>
 #include <boost/test/unit_test.hpp>
 #include <libdevcrypto/EC.h>
+#include <libdevcrypto/SHA3MAC.h>
 #include "TestHelperCrypto.h"
 
 using namespace std;
@@ -46,107 +47,220 @@ BOOST_AUTO_TEST_CASE(common_encrypt_decrypt)
 	KeyPair k = KeyPair::create();
 	bytes cipher;
 	encrypt(k.pub(), bcr, cipher);
-	assert(cipher != asBytes(message) && cipher.size() > 0);
+	BOOST_REQUIRE(cipher != asBytes(message) && cipher.size() > 0);
 	
 	bytes plain;
 	decrypt(k.sec(), bytesConstRef(&cipher), plain);
 	
-	assert(asString(plain) == message);
-	assert(plain == asBytes(message));
+	BOOST_REQUIRE(asString(plain) == message);
+	BOOST_REQUIRE(plain == asBytes(message));
 }
 
 BOOST_AUTO_TEST_CASE(cryptopp_vs_secp256k1)
 {
-	ECIES<ECP>::Decryptor d(pp::PRNG(), pp::secp256k1());
+	ECIES<ECP>::Decryptor d(pp::PRNG, pp::secp256k1Curve);
 	ECIES<ECP>::Encryptor e(d.GetKey());
 	
 	Secret s;
-	pp::SecretFromDL_PrivateKey_EC(d.GetKey(), s);
+	pp::exportPrivateKey(d.GetKey(), s);
 	
 	Public p;
-	pp::PublicFromDL_PublicKey_EC(e.GetKey(), p);
+	pp::exportPublicKey(e.GetKey(), p);
 	
-	assert(dev::toAddress(s) == right160(dev::sha3(p.ref())));
+	BOOST_REQUIRE(dev::toAddress(s) == right160(dev::sha3(p.ref())));
 	
 	Secret previous = s;
-	for (auto i = 0; i < 30; i++)
+	for (auto i = 0; i < 2; i++)
 	{
-		ECIES<ECP>::Decryptor d(pp::PRNG(), pp::secp256k1());
+		ECIES<ECP>::Decryptor d(pp::PRNG, pp::secp256k1Curve);
 		ECIES<ECP>::Encryptor e(d.GetKey());
 		
 		Secret s;
-		pp::SecretFromDL_PrivateKey_EC(d.GetKey(), s);
-		assert(s != previous);
+		pp::exportPrivateKey(d.GetKey(), s);
+		BOOST_REQUIRE(s != previous);
 		
 		Public p;
-		pp::PublicFromDL_PublicKey_EC(e.GetKey(), p);
-
-		assert(dev::toAddress(s) == right160(dev::sha3(p.ref())));
+		pp::exportPublicKey(e.GetKey(), p);
+
+		h160 secp256k1Addr = dev::toAddress(s);
+		h160 cryptoppAddr = right160(dev::sha3(p.ref()));
+		if (secp256k1Addr != cryptoppAddr)
+		{
+			BOOST_REQUIRE(secp256k1Addr == cryptoppAddr);
+			break;
+		}
 	}
 }
 
-BOOST_AUTO_TEST_CASE(cryptopp_keys_cryptor_sipaseckp256k1)
+BOOST_AUTO_TEST_CASE(cryptopp_cryptopp_secp256k1libport)
 {
-	KeyPair k = KeyPair::create();
-	Secret s = k.sec();
-	
-	// Convert secret to exponent used by pp
-	Integer e = pp::ExponentFromSecret(s);
+	// cryptopp implementation of secp256k1lib sign_compact w/recid parameter and recovery of public key from signature
+		
+	// base secret
+	Secret secret(sha3("privacy"));
+	
+	// we get ec params from signer
+	const CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> params = pp::secp256k1Params;
+	ECDSA<ECP, SHA3_256>::Signer signer;
+	
+	// e := sha3(msg)
+	bytes e(fromHex("0x01"));
+	e.resize(32);
+	int tests = 2; // Oct 29: successful @ 1500
+	while (sha3(&e, &e), secret = sha3(secret.asBytes()), tests--)
+	{
+		KeyPair key(secret);
+		Public pkey = key.pub();
+		pp::initializeDLScheme(secret, signer);
+		
+		h256 he(sha3(e));
+		Integer heInt(he.asBytes().data(), 32);
+		h256 k(crypto::kdf(secret, he));
+		Integer kInt(k.asBytes().data(), 32);
+		kInt %= params.GetSubgroupOrder()-1;
+
+		ECP::Point rp = params.ExponentiateBase(kInt);
+		Integer const& q = params.GetGroupOrder();
+		Integer r = params.ConvertElementToInteger(rp);
+		int recid = ((r >= q) ? 2 : 0) | (rp.y.IsOdd() ? 1 : 0);
+
+		Integer kInv = kInt.InverseMod(q);
+		Integer s = (kInv * (Integer(secret.asBytes().data(), 32)*r + heInt)) % q;
+		BOOST_REQUIRE(!!r && !!s);
+		
+/*
+		// For future reference:
+		// According to maths, this codepath can't be reached, however, it's in secp256k1.
+		// Commenting this out diverges from codebase implementation.
+		// To be removed after upstream PR and proof are evaulated.
+ 
+		if (s > params.GetSubgroupOrder())
+		{
+			// note: this rarely happens
+			s = params.GetGroupOrder() - s;
+			if (recid)
+				recid ^= 1;
+		}
+ */
 
-	// Test that exported DL_EC private is same as exponent from Secret
-	CryptoPP::DL_PrivateKey_EC<CryptoPP::ECP> privatek;
-	privatek.AccessGroupParameters().Initialize(pp::secp256k1());
-	privatek.SetPrivateExponent(e);
-	assert(e == privatek.GetPrivateExponent());
-	
-	// Test that exported secret is same as decryptor(privatek) secret
-	ECIES<ECP>::Decryptor d;
-	d.AccessKey().AccessGroupParameters().Initialize(pp::secp256k1());
-	d.AccessKey().SetPrivateExponent(e);
-	assert(d.AccessKey().GetPrivateExponent() == e);
-	
-	// Test that decryptor->encryptor->public == private->makepublic->public
-	CryptoPP::DL_PublicKey_EC<CryptoPP::ECP> pubk;
-	pubk.AccessGroupParameters().Initialize(pp::secp256k1());
-	privatek.MakePublicKey(pubk);
-	
-	ECIES<ECP>::Encryptor enc(d);
-	assert(pubk.GetPublicElement() == enc.AccessKey().GetPublicElement());
-	
-	// Test against sipa/seckp256k1
-	Public p;
-	pp::PublicFromExponent(pp::ExponentFromSecret(s), p);
-	assert(toAddress(s) == dev::right160(dev::sha3(p.ref())));
-	assert(k.pub() == p);
+		Signature sig;
+		r.Encode(sig.data(), 32);
+		s.Encode(sig.data() + 32, 32);
+		sig[64] = recid;
+
+		Public p = dev::recover(sig, he);
+		BOOST_REQUIRE(p == pkey);
+		
+		// verify w/cryptopp
+		BOOST_REQUIRE(crypto::verify(pkey, sig, bytesConstRef(&e)));
+		
+		// verify with secp256k1lib
+		byte encpub[65] = {0x04};
+		memcpy(&encpub[1], pkey.data(), 64);
+		byte dersig[72];
+		size_t cssz = DSAConvertSignatureFormat(dersig, 72, DSA_DER, sig.data(), 64, DSA_P1363);
+		BOOST_CHECK(cssz <= 72);
+		BOOST_REQUIRE(1 == secp256k1_ecdsa_verify(he.data(), sizeof(he), dersig, cssz, encpub, 65));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(cryptopp_ecdsa_sipaseckp256k1)
+{
+	// cryptopp integer encoding
+	Integer nHex("f2ee15ea639b73fa3db9b34a245bdfa015c260c598b211bf05a1ecc4b3e3b4f2H");
+	Integer nB(fromHex("f2ee15ea639b73fa3db9b34a245bdfa015c260c598b211bf05a1ecc4b3e3b4f2").data(), 32);
+	BOOST_REQUIRE(nHex == nB);
+	
+	bytes sbytes(fromHex("0x01"));
+	Secret secret(sha3(sbytes)); // 5fe7f977e71dba2ea1a68e21057beebb9be2ac30c6410aa38d4f3fbe41dcffd2
+	KeyPair key(secret);
+	
+	bytes m(fromHex("0x01"));
+	int tests = 2;
+	while (m[0]++, tests--)
+	{
+		h256 hm(sha3(m));
+		Integer hInt(hm.asBytes().data(), 32);
+		h256 k(hm ^ key.sec());
+		Integer kInt(k.asBytes().data(), 32);
+		
+		// raw sign w/cryptopp (doesn't pass through cryptopp hash filter)
+		ECDSA<ECP, SHA3_256>::Signer signer;
+		pp::initializeDLScheme(key.sec(), signer);
+		Integer r, s;
+		signer.RawSign(kInt, hInt, r, s);
+
+		// verify cryptopp raw-signature w/cryptopp
+		ECDSA<ECP, SHA3_256>::Verifier verifier;
+		pp::initializeDLScheme(key.pub(), verifier);
+		Signature sigppraw;
+		r.Encode(sigppraw.data(), 32);
+		s.Encode(sigppraw.data() + 32, 32);
+		BOOST_REQUIRE(verifier.VerifyMessage(m.data(), m.size(), sigppraw.data(), 64));
+		BOOST_REQUIRE(crypto::verify(key.pub(), sigppraw, bytesConstRef(&m)));
+		BOOST_REQUIRE(dev::verify(key.pub(), sigppraw, hm));
+		
+		// sign with cryptopp, verify, recover w/sec256lib
+		Signature seclibsig(dev::sign(key.sec(), hm));
+		BOOST_REQUIRE(verifier.VerifyMessage(m.data(), m.size(), seclibsig.data(), 64));
+		BOOST_REQUIRE(crypto::verify(key.pub(), seclibsig, bytesConstRef(&m)));
+		BOOST_REQUIRE(dev::verify(key.pub(), seclibsig, hm));
+		BOOST_REQUIRE(dev::recover(seclibsig, hm) == key.pub());
+
+		// sign with cryptopp (w/hash filter?), verify with cryptopp
+		bytes sigppb(signer.MaxSignatureLength());
+		size_t ssz = signer.SignMessage(pp::PRNG, m.data(), m.size(), sigppb.data());
+		Signature sigpp;
+		memcpy(sigpp.data(), sigppb.data(), 64);
+		BOOST_REQUIRE(verifier.VerifyMessage(m.data(), m.size(), sigppb.data(), ssz));
+		BOOST_REQUIRE(crypto::verify(key.pub(), sigpp, bytesConstRef(&m)));
+		BOOST_REQUIRE(dev::verify(key.pub(), sigpp, hm));
+
+		// sign with cryptopp and stringsource hash filter
+		string sigstr;
+		StringSource ssrc(asString(m), true, new SignerFilter(pp::PRNG, signer, new StringSink(sigstr)));
+		FixedHash<sizeof(Signature)> retsig((byte const*)sigstr.data(), Signature::ConstructFromPointer);
+		BOOST_REQUIRE(verifier.VerifyMessage(m.data(), m.size(), retsig.data(), 64));
+		BOOST_REQUIRE(crypto::verify(key.pub(), retsig, bytesConstRef(&m)));
+		BOOST_REQUIRE(dev::verify(key.pub(), retsig, hm));
+		
+		/// verification w/sec256lib
+		// requires public key and sig in standard format
+		byte encpub[65] = {0x04};
+		memcpy(&encpub[1], key.pub().data(), 64);
+		byte dersig[72];
+		
+		// verify sec256lib sig w/sec256lib
+		size_t cssz = DSAConvertSignatureFormat(dersig, 72, DSA_DER, seclibsig.data(), 64, DSA_P1363);
+		BOOST_CHECK(cssz <= 72);
+		BOOST_REQUIRE(1 == secp256k1_ecdsa_verify(hm.data(), sizeof(hm), dersig, cssz, encpub, 65));
+		
+		// verify cryptopp-raw sig w/sec256lib
+		cssz = DSAConvertSignatureFormat(dersig, 72, DSA_DER, sigppraw.data(), 64, DSA_P1363);
+		BOOST_CHECK(cssz <= 72);
+		BOOST_REQUIRE(1 == secp256k1_ecdsa_verify(hm.data(), sizeof(hm), dersig, cssz, encpub, 65));
+
+		// verify cryptopp sig w/sec256lib
+		cssz = DSAConvertSignatureFormat(dersig, 72, DSA_DER, sigppb.data(), 64, DSA_P1363);
+		BOOST_CHECK(cssz <= 72);
+		BOOST_REQUIRE(1 == secp256k1_ecdsa_verify(hm.data(), sizeof(hm), dersig, cssz, encpub, 65));
+	}
 }
 
 BOOST_AUTO_TEST_CASE(cryptopp_public_export_import)
 {
-	ECIES<ECP>::Decryptor d(pp::PRNG(), pp::secp256k1());
+	ECIES<ECP>::Decryptor d(pp::PRNG, pp::secp256k1Curve);
 	ECIES<ECP>::Encryptor e(d.GetKey());
 
 	Secret s;
-	pp::SecretFromDL_PrivateKey_EC(d.GetKey(), s);
+	pp::exportPrivateKey(d.GetKey(), s);
 	Public p;
-	pp::PublicFromDL_PublicKey_EC(e.GetKey(), p);
+	pp::exportPublicKey(e.GetKey(), p);
 	Address addr = right160(dev::sha3(p.ref()));
-	assert(toAddress(s) == addr);
+	BOOST_REQUIRE(toAddress(s) == addr);
 	
 	KeyPair l(s);
-	assert(l.address() == addr);
-	
-	DL_PublicKey_EC<ECP> pub;
-	pub.Initialize(pp::secp256k1(), pp::PointFromPublic(p));
-	assert(pub.GetPublicElement() == e.GetKey().GetPublicElement());
-
-	KeyPair k = KeyPair::create();
-	Public p2;
-	pp::PublicFromExponent(pp::ExponentFromSecret(k.sec()), p2);
-	assert(k.pub() == p2);
-	
-	Address a = k.address();
-	Address a2 = toAddress(k.sec());
-	assert(a2 == a);
+	BOOST_REQUIRE(l.address() == addr);
 }
 
 BOOST_AUTO_TEST_CASE(ecies_eckeypair)
@@ -158,10 +272,10 @@ BOOST_AUTO_TEST_CASE(ecies_eckeypair)
 	
 	bytes b = asBytes(message);
 	encrypt(k.pub(), b);
-	assert(b != asBytes(original));
+	BOOST_REQUIRE(b != asBytes(original));
 
 	decrypt(k.sec(), b);
-	assert(b == asBytes(original));
+	BOOST_REQUIRE(b == asBytes(original));
 }
 
 BOOST_AUTO_TEST_CASE(ecdhe_aes128_ctr_sha3mac)
@@ -172,9 +286,6 @@ BOOST_AUTO_TEST_CASE(ecdhe_aes128_ctr_sha3mac)
 	// All connections should share seed for PRF (or PRNG) for nonces
 	
 	
-	
-	
-	
 }
 
 BOOST_AUTO_TEST_CASE(cryptopp_ecies_message)
@@ -183,7 +294,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_ecies_message)
 
 	string const message("Now is the time for all good persons to come to the aide of humanity.");
 
-	ECIES<ECP>::Decryptor localDecryptor(pp::PRNG(), pp::secp256k1());
+	ECIES<ECP>::Decryptor localDecryptor(pp::PRNG, pp::secp256k1Curve);
 	SavePrivateKey(localDecryptor.GetPrivateKey());
 	
 	ECIES<ECP>::Encryptor localEncryptor(localDecryptor);
@@ -191,43 +302,43 @@ BOOST_AUTO_TEST_CASE(cryptopp_ecies_message)
 
 	ECIES<ECP>::Decryptor futureDecryptor;
 	LoadPrivateKey(futureDecryptor.AccessPrivateKey());
-	futureDecryptor.GetPrivateKey().ThrowIfInvalid(pp::PRNG(), 3);
+	futureDecryptor.GetPrivateKey().ThrowIfInvalid(pp::PRNG, 3);
 	
 	ECIES<ECP>::Encryptor futureEncryptor;
 	LoadPublicKey(futureEncryptor.AccessPublicKey());
-	futureEncryptor.GetPublicKey().ThrowIfInvalid(pp::PRNG(), 3);
+	futureEncryptor.GetPublicKey().ThrowIfInvalid(pp::PRNG, 3);
 
 	// encrypt/decrypt with local
 	string cipherLocal;
-	StringSource ss1 (message, true, new PK_EncryptorFilter(pp::PRNG(), localEncryptor, new StringSink(cipherLocal) ) );
+	StringSource ss1 (message, true, new PK_EncryptorFilter(pp::PRNG, localEncryptor, new StringSink(cipherLocal) ) );
 	string plainLocal;
-	StringSource ss2 (cipherLocal, true, new PK_DecryptorFilter(pp::PRNG(), localDecryptor, new StringSink(plainLocal) ) );
+	StringSource ss2 (cipherLocal, true, new PK_DecryptorFilter(pp::PRNG, localDecryptor, new StringSink(plainLocal) ) );
 
 	// encrypt/decrypt with future
 	string cipherFuture;
-	StringSource ss3 (message, true, new PK_EncryptorFilter(pp::PRNG(), futureEncryptor, new StringSink(cipherFuture) ) );
+	StringSource ss3 (message, true, new PK_EncryptorFilter(pp::PRNG, futureEncryptor, new StringSink(cipherFuture) ) );
 	string plainFuture;
-	StringSource ss4 (cipherFuture, true, new PK_DecryptorFilter(pp::PRNG(), futureDecryptor, new StringSink(plainFuture) ) );
+	StringSource ss4 (cipherFuture, true, new PK_DecryptorFilter(pp::PRNG, futureDecryptor, new StringSink(plainFuture) ) );
 	
 	// decrypt local w/future
 	string plainFutureFromLocal;
-	StringSource ss5 (cipherLocal, true, new PK_DecryptorFilter(pp::PRNG(), futureDecryptor, new StringSink(plainFutureFromLocal) ) );
+	StringSource ss5 (cipherLocal, true, new PK_DecryptorFilter(pp::PRNG, futureDecryptor, new StringSink(plainFutureFromLocal) ) );
 	
 	// decrypt future w/local
 	string plainLocalFromFuture;
-	StringSource ss6 (cipherFuture, true, new PK_DecryptorFilter(pp::PRNG(), localDecryptor, new StringSink(plainLocalFromFuture) ) );
+	StringSource ss6 (cipherFuture, true, new PK_DecryptorFilter(pp::PRNG, localDecryptor, new StringSink(plainLocalFromFuture) ) );
 	
 	
-	assert(plainLocal == message);
-	assert(plainFuture == plainLocal);
-	assert(plainFutureFromLocal == plainLocal);
-	assert(plainLocalFromFuture == plainLocal);
+	BOOST_REQUIRE(plainLocal == message);
+	BOOST_REQUIRE(plainFuture == plainLocal);
+	BOOST_REQUIRE(plainFutureFromLocal == plainLocal);
+	BOOST_REQUIRE(plainLocalFromFuture == plainLocal);
 }
 
 BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 {
 	const int aesKeyLen = 16;
-	assert(sizeof(char) == sizeof(byte));
+	BOOST_REQUIRE(sizeof(char) == sizeof(byte));
 	
 	// generate test key
 	AutoSeededRandomPool rng;
@@ -250,7 +361,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 		CTR_Mode<AES>::Encryption e;
 		e.SetKeyWithIV(key, key.size(), ctr);
 		e.ProcessData(out, in, text.size());
-		assert(text != original);
+		BOOST_REQUIRE(text != original);
 		cipherCopy = text;
 	}
 	catch(CryptoPP::Exception& e)
@@ -263,7 +374,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 		CTR_Mode< AES >::Decryption d;
 		d.SetKeyWithIV(key, key.size(), ctr);
 		d.ProcessData(out, in, text.size());
-		assert(text == original);
+		BOOST_REQUIRE(text == original);
 	}
 	catch(CryptoPP::Exception& e)
 	{
@@ -274,7 +385,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 	// reencrypt ciphertext...
 	try
 	{
-		assert(cipherCopy != text);
+		BOOST_REQUIRE(cipherCopy != text);
 		in = (unsigned char*)&cipherCopy[0];
 		out = (unsigned char*)&cipherCopy[0];
 		
@@ -283,7 +394,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 		e.ProcessData(out, in, text.size());
 		
 		// yep, ctr mode.
-		assert(cipherCopy == original);
+		BOOST_REQUIRE(cipherCopy == original);
 	}
 	catch(CryptoPP::Exception& e)
 	{
@@ -295,7 +406,7 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_ctr)
 BOOST_AUTO_TEST_CASE(cryptopp_aes128_cbc)
 {
 	const int aesKeyLen = 16;
-	assert(sizeof(char) == sizeof(byte));
+	BOOST_REQUIRE(sizeof(char) == sizeof(byte));
 	
 	AutoSeededRandomPool rng;
 	SecByteBlock key(0x00, aesKeyLen);
@@ -310,11 +421,11 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_cbc)
 	
 	CryptoPP::CBC_Mode<Rijndael>::Encryption cbcEncryption(key, key.size(), iv);
 	cbcEncryption.ProcessData((byte*)&string128[0], (byte*)&string128[0], string128.size());
-	assert(string128 != plainOriginal);
+	BOOST_REQUIRE(string128 != plainOriginal);
 	
 	CBC_Mode<Rijndael>::Decryption cbcDecryption(key, key.size(), iv);
 	cbcDecryption.ProcessData((byte*)&string128[0], (byte*)&string128[0], string128.size());
-	assert(plainOriginal == string128);
+	BOOST_REQUIRE(plainOriginal == string128);
 	
 	
 	// plaintext whose size isn't divisible by block size must use stream filter for padding
@@ -324,10 +435,10 @@ BOOST_AUTO_TEST_CASE(cryptopp_aes128_cbc)
 	string cipher;
 	StreamTransformationFilter* aesStream = new StreamTransformationFilter(cbcEncryption, new StringSink(cipher));
 	StringSource source(string192, true, aesStream);
-	assert(cipher.size() == 32);
+	BOOST_REQUIRE(cipher.size() == 32);
 
 	cbcDecryption.ProcessData((byte*)&cipher[0], (byte*)&string192[0], cipher.size());
-	assert(string192 == plainOriginal);
+	BOOST_REQUIRE(string192 == plainOriginal);
 }
 
 BOOST_AUTO_TEST_CASE(eth_keypairs)
@@ -339,20 +450,15 @@ BOOST_AUTO_TEST_CASE(eth_keypairs)
 	BOOST_REQUIRE(p.pub() == Public(fromHex("97466f2b32bc3bb76d4741ae51cd1d8578b48d3f1e68da206d47321aec267ce78549b514e4453d74ef11b0cd5e4e4c364effddac8b51bcfc8de80682f952896f")));
 	BOOST_REQUIRE(p.address() == Address(fromHex("8a40bfaa73256b60764c1bf40675a99083efb075")));
 	{
-		eth::Transaction t;
-		t.nonce = 0;
-		t.type = eth::Transaction::MessageCall;
-		t.receiveAddress = h160(fromHex("944400f4b88ac9589a0f17ed4671da26bddb668b"));
-		t.value = 1000;
-		auto rlp = t.rlp(false);
+		eth::Transaction t(1000, 0, 0, h160(fromHex("944400f4b88ac9589a0f17ed4671da26bddb668b")), bytes(), 0, p.secret());
+		auto rlp = t.rlp(eth::WithoutSignature);
 		cnote << RLP(rlp);
 		cnote << toHex(rlp);
-		cnote << t.sha3(false);
-		t.sign(p.secret());
-		rlp = t.rlp(true);
+		cnote << t.sha3(eth::WithoutSignature);
+		rlp = t.rlp(eth::WithSignature);
 		cnote << RLP(rlp);
 		cnote << toHex(rlp);
-		cnote << t.sha3(true);
+		cnote << t.sha3(eth::WithSignature);
 		BOOST_REQUIRE(t.sender() == p.address());
 	}
 
@@ -365,23 +471,18 @@ int cryptoTest()
 	secp256k1_start();
 
 	KeyPair p(Secret(fromHex("3ecb44df2159c26e0f995712d4f39b6f6e499b40749b1cf1246c37f9516cb6a4")));
-	assert(p.pub() == Public(fromHex("97466f2b32bc3bb76d4741ae51cd1d8578b48d3f1e68da206d47321aec267ce78549b514e4453d74ef11b0cd5e4e4c364effddac8b51bcfc8de80682f952896f")));
-	assert(p.address() == Address(fromHex("8a40bfaa73256b60764c1bf40675a99083efb075")));
+	BOOST_REQUIRE(p.pub() == Public(fromHex("97466f2b32bc3bb76d4741ae51cd1d8578b48d3f1e68da206d47321aec267ce78549b514e4453d74ef11b0cd5e4e4c364effddac8b51bcfc8de80682f952896f")));
+	BOOST_REQUIRE(p.address() == Address(fromHex("8a40bfaa73256b60764c1bf40675a99083efb075")));
 	{
-		eth::Transaction t;
-		t.nonce = 0;
-		t.type = eth::Transaction::MessageCall;
-		t.receiveAddress = h160(fromHex("944400f4b88ac9589a0f17ed4671da26bddb668b"));
-		t.value = 1000;
-		auto rlp = t.rlp(false);
+		eth::Transaction t(1000, 0, 0, h160(fromHex("944400f4b88ac9589a0f17ed4671da26bddb668b")), bytes(), 0, p.secret());
+		auto rlp = t.rlp(eth::WithoutSignature);
 		cnote << RLP(rlp);
 		cnote << toHex(rlp);
-		cnote << t.sha3(false);
-		t.sign(p.secret());
-		rlp = t.rlp(true);
+		cnote << t.sha3(eth::WithoutSignature);
+		rlp = t.rlp(eth::WithSignature);
 		cnote << RLP(rlp);
 		cnote << toHex(rlp);
-		cnote << t.sha3(true);
+		cnote << t.sha3(eth::WithSignature);
 		assert(t.sender() == p.address());
 	}
 
@@ -407,8 +508,8 @@ int cryptoTest()
 
 	auto msg = t.rlp(false);
 	cout << "TX w/o SIG: " << RLP(msg) << endl;
-	cout << "RLP(TX w/o SIG): " << toHex(t.rlpString(false)) << endl;
-	std::string hmsg = sha3(t.rlpString(false), false);
+	cout << "RLP(TX w/o SIG): " << toHex(t.rlp(false)) << endl;
+	std::string hmsg = sha3(t.rlp(false), false);
 	cout << "SHA256(RLP(TX w/o SIG)): 0x" << toHex(hmsg) << endl;
 
 	bytes privkey = sha3Bytes("123");
diff --git a/solidityCompiler.cpp b/solidityCompiler.cpp
index e024043e..69d33133 100644
--- a/solidityCompiler.cpp
+++ b/solidityCompiler.cpp
@@ -1,4 +1,3 @@
-
 /*
 	This file is part of cpp-ethereum.
 
@@ -18,18 +17,21 @@
 /**
  * @author Christian <c@ethdev.com>
  * @date 2014
- * Unit tests for the name and type resolution of the solidity parser.
+ * Unit tests for the solidity compiler.
  */
 
 #include <string>
-
+#include <iostream>
+#include <boost/test/unit_test.hpp>
 #include <libdevcore/Log.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Parser.h>
 #include <libsolidity/NameAndTypeResolver.h>
 #include <libsolidity/Compiler.h>
 #include <libsolidity/AST.h>
-#include <boost/test/unit_test.hpp>
+
+using namespace std;
+using namespace dev::eth;
 
 namespace dev
 {
@@ -41,186 +43,187 @@ namespace test
 namespace
 {
 
-/**
- * Helper class that extracts the first expression in an AST.
- */
-class FirstExpressionExtractor: private ASTVisitor
-{
-public:
-	FirstExpressionExtractor(ASTNode& _node): m_expression(nullptr) { _node.accept(*this); }
-	Expression* getExpression() const { return m_expression; }
-private:
-	virtual bool visit(Expression& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(Assignment& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(UnaryOperation& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(BinaryOperation& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(FunctionCall& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(MemberAccess& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(IndexAccess& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(PrimaryExpression& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(Identifier& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(ElementaryTypeNameExpression& _expression) override { return checkExpression(_expression); }
-	virtual bool visit(Literal& _expression) override { return checkExpression(_expression); }
-	bool checkExpression(Expression& _expression)
-	{
-		if (m_expression == nullptr)
-			m_expression = &_expression;
-		return false;
-	}
-private:
-	Expression* m_expression;
-};
-
-bytes compileFirstExpression(std::string const& _sourceCode)
+bytes compileContract(const string& _sourceCode)
 {
 	Parser parser;
 	ASTPointer<ContractDefinition> contract;
-	BOOST_REQUIRE_NO_THROW(contract = parser.parse(std::make_shared<Scanner>(CharStream(_sourceCode))));
+	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
 	NameAndTypeResolver resolver;
 	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
-	FirstExpressionExtractor extractor(*contract);
-	BOOST_REQUIRE(extractor.getExpression() != nullptr);
 
-	CompilerContext context;
-	ExpressionCompiler compiler(context);
-	compiler.compile(*extractor.getExpression());
-	bytes instructions = compiler.getAssembledBytecode();
+	Compiler compiler;
+	compiler.compileContract(*contract);
 	// debug
-	//std::cout << eth::disassemble(instructions) << std::endl;
-	return instructions;
+	//compiler.streamAssembly(cout);
+	return compiler.getAssembledBytecode();
 }
 
-} // end anonymous namespace
-
-BOOST_AUTO_TEST_SUITE(SolidityExpressionCompiler)
-
-BOOST_AUTO_TEST_CASE(literal_true)
+/// Checks that @a _compiledCode is present starting from offset @a _offset in @a _expectation.
+/// This is necessary since the compiler will add boilerplate add the beginning that is not
+/// tested here.
+void checkCodePresentAt(bytes const& _compiledCode, bytes const& _expectation, unsigned _offset)
 {
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = true; }"
-							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH1), 0x1});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
-}
-
-BOOST_AUTO_TEST_CASE(literal_false)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = false; }"
-							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH1), 0x0});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	BOOST_REQUIRE(_compiledCode.size() >= _offset + _expectation.size());
+	auto checkStart = _compiledCode.begin() + _offset;
+	BOOST_CHECK_EQUAL_COLLECTIONS(checkStart, checkStart + _expectation.size(),
+								  _expectation.begin(), _expectation.end());
 }
 
-BOOST_AUTO_TEST_CASE(int_literal)
-{
-	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = 0x12345678901234567890; }"
-							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
+} // end anonymous namespace
 
-	bytes expectation({byte(eth::Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90,
-													   0x12, 0x34, 0x56, 0x78, 0x90});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
-}
+BOOST_AUTO_TEST_SUITE(SolidityCompiler)
 
-BOOST_AUTO_TEST_CASE(comparison)
+BOOST_AUTO_TEST_CASE(smoke_test)
 {
 	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = (0x10aa < 0x11aa) != true; }"
+							 "  function f() { var x = 2; }\n"
 							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH2), 0x10, 0xaa,
-					   byte(eth::Instruction::PUSH2), 0x11, 0xaa,
-					   byte(eth::Instruction::GT),
-					   byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::EQ),
-					   byte(eth::Instruction::NOT)});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	bytes code = compileContract(sourceCode);
+
+	unsigned boilerplateSize = 51;
+	bytes expectation({byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x0, // initialize local variable x
+					   byte(Instruction::PUSH1), 0x2,
+					   byte(Instruction::SWAP1),
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMP)});
+	checkCodePresentAt(code, expectation, boilerplateSize);
 }
 
-BOOST_AUTO_TEST_CASE(short_circuiting)
+BOOST_AUTO_TEST_CASE(different_argument_numbers)
 {
 	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = (10 + 8 >= 4 || 2 != 9) != true; }"
+							 "  function f(uint a, uint b, uint c) returns(uint d) { return b; }\n"
+							 "  function g() returns (uint e, uint h) { h = f(1, 2, 3); }\n"
 							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH1), 0xa,
-					   byte(eth::Instruction::PUSH1), 0x8,
-					   byte(eth::Instruction::ADD),
-					   byte(eth::Instruction::PUSH1), 0x4,
-					   byte(eth::Instruction::GT),
-					   byte(eth::Instruction::NOT), // after this we have 10 + 8 >= 4
-					   byte(eth::Instruction::DUP1),
-					   byte(eth::Instruction::PUSH1), 0x14,
-					   byte(eth::Instruction::JUMPI), // short-circuit if it is true
-					   byte(eth::Instruction::PUSH1), 0x2,
-					   byte(eth::Instruction::PUSH1), 0x9,
-					   byte(eth::Instruction::EQ),
-					   byte(eth::Instruction::NOT), // after this we have 2 != 9
-					   byte(eth::Instruction::JUMPDEST),
-					   byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::EQ),
-					   byte(eth::Instruction::NOT)});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	bytes code = compileContract(sourceCode);
+
+	unsigned shift = 75;
+	unsigned boilerplateSize = 88;
+	bytes expectation({byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x0, // initialize return variable d
+					   byte(Instruction::DUP3),
+					   byte(Instruction::SWAP1), // assign b to d
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0xa + shift), // jump to return
+					   byte(Instruction::JUMP),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::SWAP4), // store d and fetch return address
+					   byte(Instruction::SWAP3), // store return address
+					   byte(Instruction::POP),
+					   byte(Instruction::POP),
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMP), // end of f
+					   byte(Instruction::JUMPDEST), // beginning of g
+					   byte(Instruction::PUSH1), 0x0,
+					   byte(Instruction::DUP1), // initialized e and h
+					   byte(Instruction::PUSH1), byte(0x20 + shift), // ret address
+					   byte(Instruction::PUSH1), 0x1,
+					   byte(Instruction::PUSH1), 0x2,
+					   byte(Instruction::PUSH1), 0x3,
+					   byte(Instruction::PUSH1), byte(0x1 + shift),
+					   // stack here: ret e h 0x20 1 2 3 0x1
+					   byte(Instruction::JUMP),
+					   byte(Instruction::JUMPDEST),
+					   // stack here: ret e h f(1,2,3)
+					   byte(Instruction::DUP2),
+					   byte(Instruction::POP),
+					   byte(Instruction::SWAP1),
+					   // stack here: ret e f(1,2,3) h
+					   byte(Instruction::POP),
+					   byte(Instruction::DUP1), // retrieve it again as "value of expression"
+					   byte(Instruction::POP), // end of assignment
+					   // stack here: ret e f(1,2,3)
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::SWAP1),
+					   // ret e f(1,2,3)
+					   byte(Instruction::SWAP2),
+					   // f(1,2,3) e ret
+					   byte(Instruction::JUMP) // end of g
+					   });
+	checkCodePresentAt(code, expectation, boilerplateSize);
 }
 
-BOOST_AUTO_TEST_CASE(arithmetics)
+BOOST_AUTO_TEST_CASE(ifStatement)
 {
 	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = (1 * (2 / (3 % (4 + (5 - (6 | (7 & (8 ^ 9)))))))); }"
+							 "  function f() { bool x; if (x) 77; else if (!x) 78; else 79; }"
 							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::PUSH1), 0x2,
-					   byte(eth::Instruction::PUSH1), 0x3,
-					   byte(eth::Instruction::PUSH1), 0x4,
-					   byte(eth::Instruction::PUSH1), 0x5,
-					   byte(eth::Instruction::PUSH1), 0x6,
-					   byte(eth::Instruction::PUSH1), 0x7,
-					   byte(eth::Instruction::PUSH1), 0x8,
-					   byte(eth::Instruction::PUSH1), 0x9,
-					   byte(eth::Instruction::XOR),
-					   byte(eth::Instruction::AND),
-					   byte(eth::Instruction::OR),
-					   byte(eth::Instruction::SWAP1),
-					   byte(eth::Instruction::SUB),
-					   byte(eth::Instruction::ADD),
-					   byte(eth::Instruction::SWAP1),
-					   byte(eth::Instruction::MOD),
-					   byte(eth::Instruction::SWAP1),
-					   byte(eth::Instruction::DIV),
-					   byte(eth::Instruction::MUL)});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	bytes code = compileContract(sourceCode);
+
+	unsigned shift = 38;
+	unsigned boilerplateSize = 51;
+	bytes expectation({byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x0,
+					   byte(Instruction::DUP1),
+					   byte(Instruction::PUSH1), byte(0x1b + shift), // "true" target
+					   byte(Instruction::JUMPI),
+					   // new check "else if" condition
+					   byte(Instruction::DUP1),
+					   byte(Instruction::ISZERO),
+					   byte(Instruction::PUSH1), byte(0x13 + shift),
+					   byte(Instruction::JUMPI),
+					   // "else" body
+					   byte(Instruction::PUSH1), 0x4f,
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0x17 + shift), // exit path of second part
+					   byte(Instruction::JUMP),
+					   // "else if" body
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x4e,
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), byte(0x1f + shift),
+					   byte(Instruction::JUMP),
+					   // "if" body
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x4d,
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::POP),
+					   byte(Instruction::JUMP)});
+	checkCodePresentAt(code, expectation, boilerplateSize);
 }
 
-BOOST_AUTO_TEST_CASE(unary_operators)
+BOOST_AUTO_TEST_CASE(loops)
 {
 	char const* sourceCode = "contract test {\n"
-							 "  function f() { var x = !(~+-(--(++1++)--) == 2); }"
+							 "  function f() { while(true){1;break;2;continue;3;return;4;} }"
 							 "}\n";
-	bytes code = compileFirstExpression(sourceCode);
-
-	bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::ADD),
-					   byte(eth::Instruction::PUSH1), 0x1,
-					   byte(eth::Instruction::SWAP1),
-					   byte(eth::Instruction::SUB),
-					   byte(eth::Instruction::PUSH1), 0x0,
-					   byte(eth::Instruction::SUB),
-					   byte(eth::Instruction::NOT),
-					   byte(eth::Instruction::PUSH1), 0x2,
-					   byte(eth::Instruction::EQ),
-					   byte(eth::Instruction::ISZERO)});
-	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	bytes code = compileContract(sourceCode);
+
+	unsigned shift = 38;
+	unsigned boilerplateSize = 51;
+	bytes expectation({byte(Instruction::JUMPDEST),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::PUSH1), 0x1,
+					   byte(Instruction::ISZERO),
+					   byte(Instruction::PUSH1), byte(0x21 + shift),
+					   byte(Instruction::JUMPI),
+					   byte(Instruction::PUSH1), 0x1,
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0x21 + shift),
+					   byte(Instruction::JUMP), // break
+					   byte(Instruction::PUSH1), 0x2,
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0x2 + shift),
+					   byte(Instruction::JUMP), // continue
+					   byte(Instruction::PUSH1), 0x3,
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0x22 + shift),
+					   byte(Instruction::JUMP), // return
+					   byte(Instruction::PUSH1), 0x4,
+					   byte(Instruction::POP),
+					   byte(Instruction::PUSH1), byte(0x2 + shift),
+					   byte(Instruction::JUMP),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::JUMPDEST),
+					   byte(Instruction::JUMP)});
+
+	checkCodePresentAt(code, expectation, boilerplateSize);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/solidityEndToEndTest.cpp b/solidityEndToEndTest.cpp
new file mode 100644
index 00000000..b28b8499
--- /dev/null
+++ b/solidityEndToEndTest.cpp
@@ -0,0 +1,229 @@
+
+/*
+	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 2014
+ * Unit tests for the solidity expression compiler, testing the behaviour of the code.
+ */
+
+#include <string>
+#include <boost/test/unit_test.hpp>
+#include <libethereum/State.h>
+#include <libethereum/Executive.h>
+#include <libsolidity/CompilerStack.h>
+
+using namespace std;
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+class ExecutionFramework
+{
+public:
+	ExecutionFramework() { g_logVerbosity = 0; }
+
+	bytes compileAndRun(std::string const& _sourceCode)
+	{
+		bytes code = dev::solidity::CompilerStack::compile(_sourceCode);
+		sendMessage(code, true);
+		return m_output;
+	}
+
+	bytes callFunction(byte _index, bytes const& _data)
+	{
+		sendMessage(bytes(1, _index) + _data, false);
+		return m_output;
+	}
+
+	bytes callFunction(byte _index, u256 const& _argument1)
+	{
+		callFunction(_index, toBigEndian(_argument1));
+		return m_output;
+	}
+
+private:
+	void sendMessage(bytes const& _data, bool _isCreation)
+	{
+		eth::Executive executive(m_state);
+		eth::Transaction t = _isCreation ? eth::Transaction(0, m_gasPrice, m_gas, _data)
+										 : eth::Transaction(0, m_gasPrice, m_gas, m_contractAddress, _data);
+		bytes transactionRLP = t.rlp();
+		try
+		{
+			// this will throw since the transaction is invalid, but it should nevertheless store the transaction
+			executive.setup(&transactionRLP);
+		}
+		catch (...) {}
+		if (_isCreation)
+		{
+			BOOST_REQUIRE(!executive.create(Address(), 0, m_gasPrice, m_gas, &_data, Address()));
+			m_contractAddress = executive.newAddress();
+			BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
+		}
+		else
+			BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), 0, m_gasPrice, &_data, m_gas, Address()));
+		BOOST_REQUIRE(executive.go());
+		executive.finalize();
+		m_output = executive.out().toBytes();
+	}
+
+	Address m_contractAddress;
+	eth::State m_state;
+	u256 const m_gasPrice = 100 * eth::szabo;
+	u256 const m_gas = 1000000;
+	bytes m_output;
+};
+
+BOOST_AUTO_TEST_SUITE(SolidityCompilerEndToEndTest)
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint a) returns(uint d) { return a * 7; }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	u256 a = 0x200030004;
+	bytes result = framework.callFunction(0, a);
+	BOOST_CHECK(result == toBigEndian(a * 7));
+}
+
+BOOST_AUTO_TEST_CASE(empty_contract)
+{
+	char const* sourceCode = "contract test {\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, bytes()).empty());
+}
+
+BOOST_AUTO_TEST_CASE(recursive_calls)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint n) returns(uint nfac) {\n"
+							 "    if (n <= 1) return 1;\n"
+							 "    else return n * f(n - 1);\n"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(0, u256(2)) == toBigEndian(u256(2)));
+	BOOST_CHECK(framework.callFunction(0, u256(3)) == toBigEndian(u256(6)));
+	BOOST_CHECK(framework.callFunction(0, u256(4)) == toBigEndian(u256(24)));
+}
+
+BOOST_AUTO_TEST_CASE(while_loop)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint n) returns(uint nfac) {\n"
+							 "    nfac = 1;\n"
+							 "    var i = 2;\n"
+							 "    while (i <= n) nfac *= i++;\n"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(0, u256(2)) == toBigEndian(u256(2)));
+	BOOST_CHECK(framework.callFunction(0, u256(3)) == toBigEndian(u256(6)));
+	BOOST_CHECK(framework.callFunction(0, u256(4)) == toBigEndian(u256(24)));
+}
+
+BOOST_AUTO_TEST_CASE(calling_other_functions)
+{
+	// note that the index of a function is its index in the sorted sequence of functions
+	char const* sourceCode = "contract collatz {\n"
+							 "  function run(uint x) returns(uint y) {\n"
+							 "    while ((y = x) > 1) {\n"
+							 "      if (x % 2 == 0) x = evenStep(x);\n"
+							 "      else x = oddStep(x);\n"
+							 "    }\n"
+							 "  }\n"
+							 "  function evenStep(uint x) returns(uint y) {\n"
+							 "    return x / 2;\n"
+							 "  }\n"
+							 "  function oddStep(uint x) returns(uint y) {\n"
+							 "    return 3 * x + 1;\n"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(2, u256(0)) == toBigEndian(u256(0)));
+	BOOST_CHECK(framework.callFunction(2, u256(1)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(2, u256(2)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(2, u256(8)) == toBigEndian(u256(1)));
+	BOOST_CHECK(framework.callFunction(2, u256(127)) == toBigEndian(u256(1)));
+}
+
+BOOST_AUTO_TEST_CASE(many_local_variables)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function run(uint x1, uint x2, uint x3) returns(uint y) {\n"
+							 "    var a = 0x1; var b = 0x10; var c = 0x100;\n"
+							 "    y = a + b + c + x1 + x2 + x3;\n"
+							 "    y += b + x2;\n"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, toBigEndian(u256(0x1000)) + toBigEndian(u256(0x10000)) + toBigEndian(u256(0x100000)))
+				== toBigEndian(u256(0x121121)));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_return_values)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function run(bool x1, uint x2) returns(uint y1, bool y2, uint y3) {\n"
+							 "    y1 = x2; y2 = x1;\n"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, bytes(1, 1) + toBigEndian(u256(0xcd)))
+				== toBigEndian(u256(0xcd)) + bytes(1, 1) + toBigEndian(u256(0)));
+}
+
+BOOST_AUTO_TEST_CASE(short_circuiting)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function run(uint x) returns(uint y) {\n"
+							 "    x == 0 || ((x = 8) > 0);\n"
+							 "    return x;"
+							 "  }\n"
+							 "}\n";
+	ExecutionFramework framework;
+	framework.compileAndRun(sourceCode);
+	BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(0)));
+	BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(8)));
+}
+
+//@todo test smaller types
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
+}
+} // end namespaces
+
diff --git a/solidityExpressionCompiler.cpp b/solidityExpressionCompiler.cpp
new file mode 100644
index 00000000..561cc3bd
--- /dev/null
+++ b/solidityExpressionCompiler.cpp
@@ -0,0 +1,352 @@
+
+/*
+	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 2014
+ * Unit tests for the solidity expression compiler.
+ */
+
+#include <string>
+
+#include <libdevcore/Log.h>
+#include <libsolidity/Scanner.h>
+#include <libsolidity/Parser.h>
+#include <libsolidity/NameAndTypeResolver.h>
+#include <libsolidity/CompilerContext.h>
+#include <libsolidity/ExpressionCompiler.h>
+#include <libsolidity/AST.h>
+#include <boost/test/unit_test.hpp>
+
+using namespace std;
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+namespace
+{
+
+/// Helper class that extracts the first expression in an AST.
+class FirstExpressionExtractor: private ASTVisitor
+{
+public:
+	FirstExpressionExtractor(ASTNode& _node): m_expression(nullptr) { _node.accept(*this); }
+	Expression* getExpression() const { return m_expression; }
+private:
+	virtual bool visit(Expression& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(Assignment& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(UnaryOperation& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(BinaryOperation& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(FunctionCall& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(MemberAccess& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(IndexAccess& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(PrimaryExpression& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(Identifier& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(ElementaryTypeNameExpression& _expression) override { return checkExpression(_expression); }
+	virtual bool visit(Literal& _expression) override { return checkExpression(_expression); }
+	bool checkExpression(Expression& _expression)
+	{
+		if (m_expression == nullptr)
+			m_expression = &_expression;
+		return false;
+	}
+private:
+	Expression* m_expression;
+};
+
+Declaration const& resolveDeclaration(vector<string> const& _namespacedName,
+											  NameAndTypeResolver const& _resolver)
+{
+	Declaration const* declaration = nullptr;
+	for (string const& namePart: _namespacedName)
+		BOOST_REQUIRE(declaration = _resolver.resolveName(namePart, declaration));
+	BOOST_REQUIRE(declaration);
+	return *declaration;
+}
+
+bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _functions = {},
+							 vector<vector<string>> _localVariables = {})
+{
+	Parser parser;
+	ASTPointer<ContractDefinition> contract;
+	BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
+	NameAndTypeResolver resolver;
+	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
+	FirstExpressionExtractor extractor(*contract);
+	BOOST_REQUIRE(extractor.getExpression() != nullptr);
+
+	CompilerContext context;
+	for (vector<string> const& function: _functions)
+		context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
+	for (vector<string> const& variable: _localVariables)
+		context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver)));
+
+	ExpressionCompiler::compileExpression(context, *extractor.getExpression());
+
+	for (vector<string> const& function: _functions)
+		context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
+	bytes instructions = context.getAssembledBytecode();
+	// debug
+	// cout << eth::disassemble(instructions) << endl;
+	return instructions;
+}
+
+} // end anonymous namespace
+
+BOOST_AUTO_TEST_SUITE(SolidityExpressionCompiler)
+
+BOOST_AUTO_TEST_CASE(literal_true)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = true; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH1), 0x1});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(literal_false)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = false; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH1), 0x0});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(int_literal)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = 0x12345678901234567890; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90,
+													   0x12, 0x34, 0x56, 0x78, 0x90});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(comparison)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = (0x10aa < 0x11aa) != true; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH2), 0x10, 0xaa,
+					   byte(eth::Instruction::PUSH2), 0x11, 0xaa,
+					   byte(eth::Instruction::GT),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::EQ),
+					   byte(eth::Instruction::ISZERO)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(short_circuiting)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = (10 + 8 >= 4 || 2 != 9) != true; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH1), 0xa,
+					   byte(eth::Instruction::PUSH1), 0x8,
+					   byte(eth::Instruction::ADD),
+					   byte(eth::Instruction::PUSH1), 0x4,
+					   byte(eth::Instruction::GT),
+					   byte(eth::Instruction::ISZERO), // after this we have 10 + 8 >= 4
+					   byte(eth::Instruction::DUP1),
+					   byte(eth::Instruction::PUSH1), 0x14,
+					   byte(eth::Instruction::JUMPI), // short-circuit if it is true
+					   byte(eth::Instruction::POP),
+					   byte(eth::Instruction::PUSH1), 0x2,
+					   byte(eth::Instruction::PUSH1), 0x9,
+					   byte(eth::Instruction::EQ),
+					   byte(eth::Instruction::ISZERO), // after this we have 2 != 9
+					   byte(eth::Instruction::JUMPDEST),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::EQ),
+					   byte(eth::Instruction::ISZERO)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(arithmetics)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = (1 * (2 / (3 % (4 + (5 - (6 | (7 & (8 ^ 9)))))))); }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::PUSH1), 0x2,
+					   byte(eth::Instruction::PUSH1), 0x3,
+					   byte(eth::Instruction::PUSH1), 0x4,
+					   byte(eth::Instruction::PUSH1), 0x5,
+					   byte(eth::Instruction::PUSH1), 0x6,
+					   byte(eth::Instruction::PUSH1), 0x7,
+					   byte(eth::Instruction::PUSH1), 0x8,
+					   byte(eth::Instruction::PUSH1), 0x9,
+					   byte(eth::Instruction::XOR),
+					   byte(eth::Instruction::AND),
+					   byte(eth::Instruction::OR),
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::SUB),
+					   byte(eth::Instruction::ADD),
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::MOD),
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::DIV),
+					   byte(eth::Instruction::MUL)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(unary_operators)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() { var x = !(~+-1 == 2); }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::PUSH1), 0x0,
+					   byte(eth::Instruction::SUB),
+					   byte(eth::Instruction::NOT),
+					   byte(eth::Instruction::PUSH1), 0x2,
+					   byte(eth::Instruction::EQ),
+					   byte(eth::Instruction::ISZERO)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(unary_inc_dec)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint a) { var x = ((a++ ^ ++a) ^ a--) ^ --a; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "x"}});
+
+	// Stack: a, x
+	bytes expectation({byte(eth::Instruction::DUP2),
+					   byte(eth::Instruction::DUP1),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::ADD),
+					   // Stack here: a x a (a+1)
+					   byte(eth::Instruction::SWAP3),
+					   byte(eth::Instruction::POP), // first ++
+					   // Stack here: (a+1) x a
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::ADD),
+					   // Stack here: (a+1) x a (a+2)
+					   byte(eth::Instruction::SWAP3),
+					   byte(eth::Instruction::POP),
+					   // Stack here: (a+2) x a
+					   byte(eth::Instruction::DUP3), // second ++
+					   byte(eth::Instruction::XOR),
+					   // Stack here: (a+2) x a^(a+2)
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::DUP1),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::SUB),
+					   // Stack here: (a+2) x a^(a+2) (a+2) (a+1)
+					   byte(eth::Instruction::SWAP4),
+					   byte(eth::Instruction::POP), // first --
+					   byte(eth::Instruction::XOR),
+					   // Stack here: (a+1) x a^(a+2)^(a+2)
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::PUSH1), 0x1,
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::SUB),
+					   // Stack here: (a+1) x a^(a+2)^(a+2) a
+					   byte(eth::Instruction::SWAP3),
+					   byte(eth::Instruction::POP), // second ++
+					   // Stack here: a x a^(a+2)^(a+2)
+					   byte(eth::Instruction::DUP3), // will change
+					   byte(eth::Instruction::XOR)});
+					   // Stack here: a x a^(a+2)^(a+2)^a
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(assignment)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint a, uint b) { (a += b) * 2; }"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}});
+
+	// Stack: a, b
+	bytes expectation({byte(eth::Instruction::DUP1),
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::ADD),
+					   // Stack here: a b a+b
+					   byte(eth::Instruction::SWAP2),
+					   byte(eth::Instruction::POP),
+					   byte(eth::Instruction::DUP2),
+					   // Stack here: a+b b a+b
+					   byte(eth::Instruction::PUSH1), 0x2,
+					   byte(eth::Instruction::MUL)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(function_call)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint a, uint b) { a += g(a + 1, b) * 2; }\n"
+							 "  function g(uint a, uint b) returns (uint c) {}\n"
+							 "}\n";
+	bytes code = compileFirstExpression(sourceCode, {{"test", "g"}},
+										{{"test", "f", "a"}, {"test", "f", "b"}});
+
+	// Stack: a, b
+	bytes expectation({byte(eth::Instruction::PUSH1), 0x0a,
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::PUSH1), 0x01,
+					   byte(eth::Instruction::ADD),
+					   // Stack here: a b <ret label> (a+1)
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::PUSH1), 0x14,
+					   byte(eth::Instruction::JUMP),
+					   byte(eth::Instruction::JUMPDEST),
+					   // Stack here: a b g(a+1, b)
+					   byte(eth::Instruction::PUSH1), 0x02,
+					   byte(eth::Instruction::MUL),
+					   // Stack here: a b g(a+1, b)*2
+					   byte(eth::Instruction::DUP3),
+					   byte(eth::Instruction::SWAP1),
+					   byte(eth::Instruction::ADD),
+					   // Stack here: a b a+g(a+1, b)*2
+					   byte(eth::Instruction::SWAP2),
+					   byte(eth::Instruction::POP),
+					   byte(eth::Instruction::DUP2),
+					   byte(eth::Instruction::JUMPDEST)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
+}
+} // end namespaces
+
diff --git a/solidityParser.cpp b/solidityParser.cpp
index 4ca9370d..9319a02c 100644
--- a/solidityParser.cpp
+++ b/solidityParser.cpp
@@ -211,7 +211,15 @@ BOOST_AUTO_TEST_CASE(else_if_statement)
 	BOOST_CHECK_NO_THROW(parseText(text));
 }
 
-
+BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseText(text));
+}
 
 BOOST_AUTO_TEST_SUITE_END()
 
diff --git a/stateOriginal.cpp b/stateOriginal.cpp
index e6b3ab95..8344894f 100644
--- a/stateOriginal.cpp
+++ b/stateOriginal.cpp
@@ -65,12 +65,7 @@ int stateTest()
 	// Inject a transaction to transfer funds from miner to me.
 	bytes tx;
 	{
-		Transaction t;
-		t.nonce = s.transactionsFrom(myMiner.address());
-		t.value = 1000;			// 1e3 wei.
-		t.type = eth::Transaction::MessageCall;
-		t.receiveAddress = me.address();
-		t.sign(myMiner.secret());
+		Transaction t(1000, 0, 0, me.address(), bytes(), s.transactionsFrom(myMiner.address()), myMiner.secret());
 		assert(t.sender() == myMiner.address());
 		tx = t.rlp();
 	}
diff --git a/vm.cpp b/vm.cpp
index 57007507..a093966d 100644
--- a/vm.cpp
+++ b/vm.cpp
@@ -35,25 +35,14 @@ h160 FakeExtVM::create(u256 _endowment, u256* _gas, bytesConstRef _init, OnOpFun
 {
 	Address na = right160(sha3(rlpList(myAddress, get<1>(addresses[myAddress]))));
 
-	Transaction t;
-	t.value = _endowment;
-	t.gasPrice = gasPrice;
-	t.gas = *_gas;
-	t.data = _init.toBytes();
-	t.type = eth::Transaction::ContractCreation;
+	Transaction t(_endowment, gasPrice, *_gas, _init.toBytes());
 	callcreates.push_back(t);
 	return na;
 }
 
 bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256* _gas, bytesRef _out, OnOpFunc const&, Address _myAddressOverride, Address _codeAddressOverride)
 {
-	Transaction t;
-	t.value = _value;
-	t.gasPrice = gasPrice;
-	t.gas = *_gas;
-	t.data = _data.toVector();
-	t.type = eth::Transaction::MessageCall;
-	t.receiveAddress = _receiveAddress;
+	Transaction t(_value, gasPrice, *_gas, _receiveAddress, _data.toVector());
 	callcreates.push_back(t);
 	(void)_out;
 	(void)_myAddressOverride;
@@ -224,10 +213,10 @@ mArray FakeExtVM::exportCallCreates()
 	for (Transaction const& tx: callcreates)
 	{
 		mObject o;
-		o["destination"] = tx.type == Transaction::ContractCreation ? "" : toString(tx.receiveAddress);
-		push(o, "gasLimit", tx.gas);
-		push(o, "value", tx.value);
-		o["data"] = "0x" + toHex(tx.data);
+		o["destination"] = tx.isCreation() ? "" : toString(tx.receiveAddress());
+		push(o, "gasLimit", tx.gas());
+		push(o, "value", tx.value());
+		o["data"] = "0x" + toHex(tx.data());
 		ret.push_back(o);
 	}
 	return ret;
@@ -242,12 +231,9 @@ void FakeExtVM::importCallCreates(mArray& _callcreates)
 		BOOST_REQUIRE(tx.count("value") > 0);
 		BOOST_REQUIRE(tx.count("destination") > 0);
 		BOOST_REQUIRE(tx.count("gasLimit") > 0);
-		Transaction t;
-		t.type = tx["destination"].get_str().empty() ? Transaction::ContractCreation : Transaction::MessageCall;
-		t.receiveAddress = Address(tx["destination"].get_str());
-		t.value = toInt(tx["value"]);
-		t.gas = toInt(tx["gasLimit"]);
-		t.data = importData(tx);
+		Transaction t = tx["destination"].get_str().empty() ?
+			Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), data.toBytes()) :
+			Transaction(toInt(tx["value"]), 0, toInt(tx["gasLimit"]), Address(tx["destination"].get_str()), data.toBytes());
 		callcreates.push_back(t);
 	}
 }
@@ -437,16 +423,6 @@ BOOST_AUTO_TEST_CASE(vmPushDupSwapTest)
 	dev::test::executeTests("vmPushDupSwapTest", "/VMTests", dev::test::doVMTests);
 }
 
-BOOST_AUTO_TEST_CASE(vmNamecoin)
-{
-	dev::test::executeTests("vmNamecoin", "/VMTests", dev::test::doVMTests);
-}
-
-//BOOST_AUTO_TEST_CASE(vmSystemOperationsTest)
-//{
-//	dev::test::executeTests("vmSystemOperationsTest", "/VMTests", dev::test::doVMTests);
-//}
-
 BOOST_AUTO_TEST_CASE(userDefinedFile)
 {
 	if (boost::unit_test::framework::master_test_suite().argc == 2)
diff --git a/vmArithmeticTestFiller.json b/vmArithmeticTestFiller.json
index 29d523a3..b9369457 100644
--- a/vmArithmeticTestFiller.json
+++ b/vmArithmeticTestFiller.json
@@ -1725,7 +1725,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x62122ff4600016600057",
+                "code" : "0x62122ff460000b600055",
                 "storage": {}
             }
         },
@@ -1753,7 +1753,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x62122f6a600016600057",
+                "code" : "0x62122f6a60000b600055",
                 "storage": {}
             }
         },
@@ -1781,7 +1781,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x6212faf4600116600057",
+                "code" : "0x6212faf460010b600055",
                 "storage": {}
             }
         },
@@ -1809,7 +1809,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x62126af4600116600057",
+                "code" : "0x62126af460010b600055",
                 "storage": {}
             }
         },
@@ -1837,7 +1837,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x62126af4605016600057",
+                "code" : "0x62126af460500b600055",
                 "storage": {}
             }
         },
@@ -2005,7 +2005,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x66f000000000000161ffff16600057",
+                "code" : "0x66f000000000000161ffff0b600055",
                 "storage": {}
             }
         },
@@ -2033,7 +2033,7 @@
             "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
                 "balance" : "1000000000000000000",
                 "nonce" : 0,
-                "code" : "0x60ff68f0000000000000000116600057",
+                "code" : "0x60ff68f000000000000000010b600055",
                 "storage": {}
             }
         },
diff --git a/vmIOandFlowOperationsTestFiller.json b/vmIOandFlowOperationsTestFiller.json
index a3aec269..e2ec1def 100644
--- a/vmIOandFlowOperationsTestFiller.json
+++ b/vmIOandFlowOperationsTestFiller.json
@@ -642,6 +642,34 @@
         }
     },
 
+    "jump1": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : 1,
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : 0,
+            "code" : "0x620fffff620fffff0156",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "10000"
+        }
+    },
+
     "jumpi0": {
         "env" : {
         "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",