Merge branch 'develop-evmcc' into pr-jit

4 files changed, 843 insertions, 3 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 17dda74d..e6c10cd1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,8 +4,6 @@ aux_source_directory(. SRC_LIST)
 list(REMOVE_ITEM SRC_LIST "./createRandomTest.cpp")
 
 include_directories(..)
-link_directories(../libethcore)
-link_directories(../libethereum)
 link_directories(../libevm)
 
 file(GLOB HEADERS "*.h")
@@ -18,7 +16,10 @@ target_link_libraries(testeth secp256k1)
 target_link_libraries(testeth gmp)
 target_link_libraries(testeth solidity)
 target_link_libraries(testeth ${CRYPTOPP_LS})
-target_link_libraries(testeth evm)
+target_link_libraries(testeth webthree)
+if(JSONRPC_LS)
+target_link_libraries(testeth web3jsonrpc)
+endif()
 if (EVMJIT)
 	target_link_libraries(testeth evmjit)
 endif()
diff --git a/jsonrpc.cpp b/jsonrpc.cpp
new file mode 100644
index 00000000..033339ec
--- /dev/null
+++ b/jsonrpc.cpp
@@ -0,0 +1,250 @@
+/*
+	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 jsonrpc.cpp
+ * @author Marek Kotewicz <marek@ethdev.com>
+ * @date 2014
+ */
+
+#if ETH_JSONRPC
+
+#include <boost/test/unit_test.hpp>
+#include <boost/lexical_cast.hpp>
+#include <libdevcore/Log.h>
+#include <libdevcore/CommonIO.h>
+#include <libdevcore/CommonJS.h>
+#include <libwebthree/WebThree.h>
+#include <libweb3jsonrpc/WebThreeStubServer.h>
+#include <libweb3jsonrpc/CorsHttpServer.h>
+#include <jsonrpc/connectors/httpserver.h>
+#include <jsonrpc/connectors/httpclient.h>
+#include <set>
+#include "JsonSpiritHeaders.h"
+#include "TestHelper.h"
+#include "webthreestubclient.h"
+
+BOOST_AUTO_TEST_SUITE(jsonrpc)
+
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+namespace js = json_spirit;
+
+namespace jsonrpc_tests
+{
+
+string name = "Ethereum(++) tests";
+string dbPath;
+auto s = set<string>{"eth", "shh"};
+dev::p2p::NetworkPreferences np(30303, std::string(), false);
+dev::WebThreeDirect web3(name, dbPath, true, s, np);
+
+unique_ptr<WebThreeStubServer> jsonrpcServer;
+unique_ptr<WebThreeStubClient> jsonrpcClient;
+
+struct JsonrpcFixture  {
+	JsonrpcFixture()
+	{
+		cnote << "setup jsonrpc";
+
+		web3.setIdealPeerCount(5);
+		web3.ethereum()->setForceMining(true);
+		jsonrpcServer = unique_ptr<WebThreeStubServer>(new WebThreeStubServer(new jsonrpc::CorsHttpServer(8080), web3, {}));
+		jsonrpcServer->setIdentities({});
+		jsonrpcServer->StartListening();
+		
+		jsonrpcClient = unique_ptr<WebThreeStubClient>(new WebThreeStubClient(new jsonrpc::HttpClient("http://localhost:8080")));
+	}
+	~JsonrpcFixture()
+	{
+		cnote << "teardown jsonrpc";
+	}
+};
+
+BOOST_GLOBAL_FIXTURE(JsonrpcFixture)
+
+BOOST_AUTO_TEST_CASE(jsonrpc_defaultBlock)
+{
+	cnote << "Testing jsonrpc defaultBlock...";
+	int defaultBlock = jsonrpcClient->defaultBlock();
+	BOOST_CHECK_EQUAL(defaultBlock, web3.ethereum()->getDefault());
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_gasPrice)
+{
+	cnote << "Testing jsonrpc gasPrice...";
+	string gasPrice = jsonrpcClient->gasPrice();
+	BOOST_CHECK_EQUAL(gasPrice, toJS(10 * dev::eth::szabo));
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_isListening)
+{
+	cnote << "Testing jsonrpc isListening...";
+
+	web3.startNetwork();
+	bool listeningOn = jsonrpcClient->listening();
+	BOOST_CHECK_EQUAL(listeningOn, web3.isNetworkStarted());
+	
+	web3.stopNetwork();
+	bool listeningOff = jsonrpcClient->listening();
+	BOOST_CHECK_EQUAL(listeningOff, web3.isNetworkStarted());
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_isMining)
+{
+	cnote << "Testing jsonrpc isMining...";
+
+	web3.ethereum()->startMining();
+	bool miningOn = jsonrpcClient->mining();
+	BOOST_CHECK_EQUAL(miningOn, web3.ethereum()->isMining());
+
+	web3.ethereum()->stopMining();
+	bool miningOff = jsonrpcClient->mining();
+	BOOST_CHECK_EQUAL(miningOff, web3.ethereum()->isMining());
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_accounts)
+{
+	cnote << "Testing jsonrpc accounts...";
+	std::vector <dev::KeyPair> keys = {KeyPair::create(), KeyPair::create()};
+	jsonrpcServer->setAccounts(keys);
+	Json::Value k = jsonrpcClient->accounts();
+	jsonrpcServer->setAccounts({});
+	BOOST_CHECK_EQUAL(k.isArray(), true);
+	BOOST_CHECK_EQUAL(k.size(),  keys.size());
+	for (auto &i:k)
+	{
+		auto it = std::find_if(keys.begin(), keys.end(), [i](dev::KeyPair const& keyPair)
+		{
+			return jsToAddress(i.asString()) == keyPair.address();
+		});
+		BOOST_CHECK_EQUAL(it != keys.end(), true);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_number)
+{
+	cnote << "Testing jsonrpc number2...";
+	int number = jsonrpcClient->number();
+	BOOST_CHECK_EQUAL(number, web3.ethereum()->number() + 1);
+	dev::eth::mine(*(web3.ethereum()), 1);
+	int numberAfter = jsonrpcClient->number();
+	BOOST_CHECK_EQUAL(number + 1, numberAfter);
+	BOOST_CHECK_EQUAL(numberAfter, web3.ethereum()->number() + 1);
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_peerCount)
+{
+	cnote << "Testing jsonrpc peerCount...";
+	int peerCount = jsonrpcClient->peerCount();
+	BOOST_CHECK_EQUAL(web3.peerCount(), peerCount);
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_setListening)
+{
+	cnote << "Testing jsonrpc setListening...";
+
+	jsonrpcClient->setListening(true);
+	BOOST_CHECK_EQUAL(web3.isNetworkStarted(), true);
+	
+	jsonrpcClient->setListening(false);
+	BOOST_CHECK_EQUAL(web3.isNetworkStarted(), false);
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_setMining)
+{
+	cnote << "Testing jsonrpc setMining...";
+
+	jsonrpcClient->setMining(true);
+	BOOST_CHECK_EQUAL(web3.ethereum()->isMining(), true);
+
+	jsonrpcClient->setMining(false);
+	BOOST_CHECK_EQUAL(web3.ethereum()->isMining(), false);
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_stateAt)
+{
+	cnote << "Testing jsonrpc stateAt...";
+	dev::KeyPair key = KeyPair::create();
+	auto address = key.address();
+	string stateAt = jsonrpcClient->stateAt(toJS(address), "0");
+	BOOST_CHECK_EQUAL(toJS(web3.ethereum()->stateAt(address, jsToU256("0"), 0)), stateAt);
+}
+
+BOOST_AUTO_TEST_CASE(jsonrpc_transact)
+{
+	cnote << "Testing jsonrpc transact...";
+	string coinbase = jsonrpcClient->coinbase();
+	BOOST_CHECK_EQUAL(jsToAddress(coinbase), web3.ethereum()->address());
+	
+	dev::KeyPair key = KeyPair::create();
+	auto address = key.address();
+	auto receiver = KeyPair::create();
+	web3.ethereum()->setAddress(address);
+
+	coinbase = jsonrpcClient->coinbase();
+	BOOST_CHECK_EQUAL(jsToAddress(coinbase), web3.ethereum()->address());
+	BOOST_CHECK_EQUAL(jsToAddress(coinbase), address);
+	
+	jsonrpcServer->setAccounts({key});
+	auto balance = web3.ethereum()->balanceAt(address, 0);
+	string balanceString = jsonrpcClient->balanceAt(toJS(address));
+	double countAt = jsonrpcClient->countAt(toJS(address));
+	
+	BOOST_CHECK_EQUAL(countAt, (double)(uint64_t)web3.ethereum()->countAt(address));
+	BOOST_CHECK_EQUAL(countAt, 0);
+	BOOST_CHECK_EQUAL(toJS(balance), balanceString);
+	BOOST_CHECK_EQUAL(jsToDecimal(balanceString), "0");
+	
+	dev::eth::mine(*(web3.ethereum()), 1);
+	balance = web3.ethereum()->balanceAt(address, 0);
+	balanceString = jsonrpcClient->balanceAt(toJS(address));
+	
+	BOOST_CHECK_EQUAL(toJS(balance), balanceString);
+	BOOST_CHECK_EQUAL(jsToDecimal(balanceString), "1500000000000000000");
+	
+	auto txAmount = balance / 2u;
+	auto gasPrice = 10 * dev::eth::szabo;
+	auto gas = dev::eth::c_txGas;
+	
+	Json::Value t;
+	t["from"] = toJS(address);
+	t["value"] = jsToDecimal(toJS(txAmount));
+	t["to"] = toJS(receiver.address());
+	t["data"] = toJS(bytes());
+	t["gas"] = toJS(gas);
+	t["gasPrice"] = toJS(gasPrice);
+	
+	jsonrpcClient->transact(t);
+	jsonrpcServer->setAccounts({});
+	dev::eth::mine(*(web3.ethereum()), 1);
+	
+	countAt = jsonrpcClient->countAt(toJS(address));
+	auto balance2 = web3.ethereum()->balanceAt(receiver.address());
+	string balanceString2 = jsonrpcClient->balanceAt(toJS(receiver.address()));
+	
+	BOOST_CHECK_EQUAL(countAt, (double)(uint64_t)web3.ethereum()->countAt(address));
+	BOOST_CHECK_EQUAL(countAt, 1);
+	BOOST_CHECK_EQUAL(toJS(balance2), balanceString2);
+	BOOST_CHECK_EQUAL(jsToDecimal(balanceString2), "750000000000000000");
+	BOOST_CHECK_EQUAL(txAmount, balance2);
+}
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+#endif
diff --git a/solidityCompiler.cpp b/solidityCompiler.cpp
index e0860511..e024043e 100644
--- a/solidityCompiler.cpp
+++ b/solidityCompiler.cpp
@@ -193,7 +193,9 @@ BOOST_AUTO_TEST_CASE(arithmetics)
 					   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());
diff --git a/webthreestubclient.h b/webthreestubclient.h
new file mode 100644
index 00000000..6beee5bb
--- /dev/null
+++ b/webthreestubclient.h
@@ -0,0 +1,587 @@
+/**
+ * THIS FILE IS GENERATED BY jsonrpcstub, DO NOT CHANGE IT!!!!!
+ */
+
+#ifndef _WEBTHREESTUBCLIENT_H_
+#define _WEBTHREESTUBCLIENT_H_
+
+#include <jsonrpc/rpc.h>
+
+class WebThreeStubClient
+{
+    public:
+        WebThreeStubClient(jsonrpc::AbstractClientConnector* conn)
+        {
+            this->client = new jsonrpc::Client(conn);
+        }
+        ~WebThreeStubClient()
+        {
+            delete this->client;
+        }
+
+        std::string account() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("account",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value accounts() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("accounts",p);
+    if (result.isArray())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string addToGroup(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("addToGroup",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string balanceAt(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("balanceAt",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value blockByHash(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("blockByHash",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value blockByNumber(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("blockByNumber",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string call(const Json::Value& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("call",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool changed(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("changed",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string codeAt(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("codeAt",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string coinbase() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("coinbase",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string compile(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("compile",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        double countAt(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("countAt",p);
+    if (result.isDouble())
+        return result.asDouble();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int defaultBlock() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("defaultBlock",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string gasPrice() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("gasPrice",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string get(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("get",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value getMessages(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("getMessages",p);
+    if (result.isArray())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string getString(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("getString",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool haveIdentity(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("haveIdentity",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool listening() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("listening",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool mining() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("mining",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int newFilter(const Json::Value& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("newFilter",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int newFilterString(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("newFilterString",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string newGroup(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("newGroup",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string newIdentity() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("newIdentity",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int number() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("number",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int peerCount() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->client->CallMethod("peerCount",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool post(const Json::Value& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("post",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool put(const std::string& param1, const std::string& param2, const std::string& param3) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+p.append(param3);
+
+            Json::Value result = this->client->CallMethod("put",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool putString(const std::string& param1, const std::string& param2, const std::string& param3) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+p.append(param3);
+
+            Json::Value result = this->client->CallMethod("putString",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool setCoinbase(const std::string& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("setCoinbase",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool setDefaultBlock(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("setDefaultBlock",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool setListening(const bool& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("setListening",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool setMining(const bool& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("setMining",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value shhChanged(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("shhChanged",p);
+    if (result.isArray())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        int shhNewFilter(const Json::Value& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("shhNewFilter",p);
+    if (result.isInt())
+        return result.asInt();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool shhUninstallFilter(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("shhUninstallFilter",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string stateAt(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("stateAt",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        std::string transact(const Json::Value& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("transact",p);
+    if (result.isString())
+        return result.asString();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value transactionByHash(const std::string& param1, const int& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("transactionByHash",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value transactionByNumber(const int& param1, const int& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("transactionByNumber",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value uncleByHash(const std::string& param1, const int& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("uncleByHash",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        Json::Value uncleByNumber(const int& param1, const int& param2) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+p.append(param2);
+
+            Json::Value result = this->client->CallMethod("uncleByNumber",p);
+    if (result.isObject())
+        return result;
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+        bool uninstallFilter(const int& param1) throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p.append(param1);
+
+            Json::Value result = this->client->CallMethod("uninstallFilter",p);
+    if (result.isBool())
+        return result.asBool();
+     else 
+         throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+
+        }
+
+    private:
+        jsonrpc::Client* client;
+};
+#endif //_WEBTHREESTUBCLIENT_H_