cpp-ethereum/libweb3jsonrpc/JsonHelper.cpp

/*
	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 JsonHelper.cpp
 * @authors:
 *   Gav Wood <i@gavwood.com>
 * @date 2014
 */

#include "JsonHelper.h"

#include <libevmcore/Instruction.h>
#include <libethcore/SealEngine.h>
#include <libethereum/Client.h>
#include <libwebthree/WebThree.h>
#include <libethcore/CommonJS.h>
#include <libethcore/ICAP.h>
#include <libwhisper/Message.h>
#include <libwhisper/WhisperHost.h>
#include <jsonrpccpp/common/exception.h>
using namespace std;
using namespace dev;
using namespace eth;

namespace dev
{

Json::Value toJson(unordered_map<u256, u256> const& _storage)
{
	Json::Value res(Json::objectValue);
	for (auto i: _storage)
		res[toJS(i.first)] = toJS(i.second);
	return res;
}

Json::Value toJson(map<u256, u256> const& _storage)
{
	Json::Value res(Json::objectValue);
	for (auto i: _storage)
		res[toJS(i.first)] = toJS(i.second);
	return res;
}

Json::Value toJson(Address const& _address)
{
	return toJS(_address);
}

// ////////////////////////////////////////////////////////////////////////////////
// p2p
// ////////////////////////////////////////////////////////////////////////////////
namespace p2p
{

Json::Value toJson(p2p::PeerSessionInfo const& _p)
{
	//@todo localAddress
	//@todo protocols
	Json::Value ret;
	ret["id"] = _p.id.hex();
	ret["name"] = _p.clientVersion;
	ret["network"]["remoteAddress"] = _p.host + ":" + toString(_p.port);
	ret["lastPing"] = (int)chrono::duration_cast<chrono::milliseconds>(_p.lastPing).count();
	for (auto const& i: _p.notes)
		ret["notes"][i.first] = i.second;
	for (auto const& i: _p.caps)
		ret["caps"].append(i.first + "/" + toString((unsigned)i.second));
	return ret;
}

}

// ////////////////////////////////////////////////////////////////////////////////
// eth
// ////////////////////////////////////////////////////////////////////////////////

namespace eth
{

Json::Value toJson(dev::eth::BlockHeader const& _bi, SealEngineFace* _sealer)
{
	Json::Value res;
	if (_bi)
	{
		DEV_IGNORE_EXCEPTIONS(res["hash"] = toJS(_bi.hash()));
		res["parentHash"] = toJS(_bi.parentHash());
		res["sha3Uncles"] = toJS(_bi.sha3Uncles());
		res["author"] = toJS(_bi.author());
		res["stateRoot"] = toJS(_bi.stateRoot());
		res["transactionsRoot"] = toJS(_bi.transactionsRoot());
		res["receiptsRoot"] = toJS(_bi.receiptsRoot());
		res["number"] = toJS(_bi.number());
		res["gasUsed"] = toJS(_bi.gasUsed());
		res["gasLimit"] = toJS(_bi.gasLimit());
		res["extraData"] = toJS(_bi.extraData());
		res["logsBloom"] = toJS(_bi.logBloom());
		res["timestamp"] = toJS(_bi.timestamp());
		// TODO: remove once JSONRPC spec is updated to use "author" over "miner".
		res["miner"] = toJS(_bi.author());
		if (_sealer)
			for (auto const& i: _sealer->jsInfo(_bi))
				res[i.first] = i.second;

	}
	return res;
}

Json::Value toJson(dev::eth::Transaction const& _t, std::pair<h256, unsigned> _location, BlockNumber _blockNumber)
{
	Json::Value res;
	if (_t)
	{
		res["hash"] = toJS(_t.sha3());
		res["input"] = toJS(_t.data());
		res["to"] = _t.isCreation() ? Json::Value() : toJS(_t.receiveAddress());
		res["from"] = toJS(_t.safeSender());
		res["gas"] = toJS(_t.gas());
		res["gasPrice"] = toJS(_t.gasPrice());
		res["nonce"] = toJS(_t.nonce());
		res["value"] = toJS(_t.value());
		res["blockHash"] = toJS(_location.first);
		res["transactionIndex"] = toJS(_location.second);
		res["blockNumber"] = toJS(_blockNumber);
	}
	return res;
}

Json::Value toJson(dev::eth::BlockHeader const& _bi, BlockDetails const& _bd, UncleHashes const& _us, Transactions const& _ts, SealEngineFace* _face)
{
	Json::Value res = toJson(_bi, _face);
	if (_bi)
	{
		res["totalDifficulty"] = toJS(_bd.totalDifficulty);
		res["uncles"] = Json::Value(Json::arrayValue);
		for (h256 h: _us)
			res["uncles"].append(toJS(h));
		res["transactions"] = Json::Value(Json::arrayValue);
		for (unsigned i = 0; i < _ts.size(); i++)
			res["transactions"].append(toJson(_ts[i], std::make_pair(_bi.hash(), i), (BlockNumber)_bi.number()));
	}
	return res;
}

Json::Value toJson(dev::eth::BlockHeader const& _bi, BlockDetails const& _bd, UncleHashes const& _us, TransactionHashes const& _ts, SealEngineFace* _face)
{
	Json::Value res = toJson(_bi, _face);
	if (_bi)
	{
		res["totalDifficulty"] = toJS(_bd.totalDifficulty);
		res["uncles"] = Json::Value(Json::arrayValue);
		for (h256 h: _us)
			res["uncles"].append(toJS(h));
		res["transactions"] = Json::Value(Json::arrayValue);
		for (h256 const& t: _ts)
			res["transactions"].append(toJS(t));
	}
	return res;
}

Json::Value toJson(dev::eth::TransactionSkeleton const& _t)
{
	Json::Value res;
	res["to"] = _t.creation ? Json::Value() : toJS(_t.to);
	res["from"] = toJS(_t.from);
	res["gas"] = toJS(_t.gas);
	res["gasPrice"] = toJS(_t.gasPrice);
	res["value"] = toJS(_t.value);
	res["data"] = toJS(_t.data, 32);
	return res;
}

Json::Value toJson(dev::eth::TransactionReceipt const& _t)
{
	Json::Value res;
	res["stateRoot"] = toJS(_t.stateRoot());
	res["gasUsed"] = toJS(_t.gasUsed());
	res["bloom"] = toJS(_t.bloom());
	res["log"] = dev::toJson(_t.log());
	return res;
}

Json::Value toJson(dev::eth::LocalisedTransactionReceipt const& _t)
{
	Json::Value res;
	res["transactionHash"] = toJS(_t.hash());
	res["transactionIndex"] = _t.transactionIndex();
	res["blockHash"] = toJS(_t.blockHash());
	res["blockNumber"] = _t.blockNumber();
	res["cumulativeGasUsed"] = toJS(_t.gasUsed()); // TODO: check if this is fine
	res["gasUsed"] = toJS(_t.gasUsed());
	res["contractAddress"] = toJS(_t.contractAddress());
	res["logs"] = dev::toJson(_t.localisedLogs());
	return res;
}

Json::Value toJson(dev::eth::Transaction const& _t)
{
	Json::Value res;
	res["to"] = _t.isCreation() ? Json::Value() : toJS(_t.to());
	res["from"] = toJS(_t.from());
	res["gas"] = toJS(_t.gas());
	res["gasPrice"] = toJS(_t.gasPrice());
	res["value"] = toJS(_t.value());
	res["data"] = toJS(_t.data(), 32);
	res["nonce"] = toJS(_t.nonce());
	res["hash"] = toJS(_t.sha3(WithSignature));
	res["sighash"] = toJS(_t.sha3(WithoutSignature));
	res["r"] = toJS(_t.signature().r);
	res["s"] = toJS(_t.signature().s);
	res["v"] = toJS(_t.signature().v);
	return res;
}

Json::Value toJson(dev::eth::LocalisedTransaction const& _t)
{
	Json::Value res;
	if (_t)
	{
		res["hash"] = toJS(_t.sha3());
		res["input"] = toJS(_t.data());
		res["to"] = _t.isCreation() ? Json::Value() : toJS(_t.receiveAddress());
		res["from"] = toJS(_t.safeSender());
		res["gas"] = toJS(_t.gas());
		res["gasPrice"] = toJS(_t.gasPrice());
		res["nonce"] = toJS(_t.nonce());
		res["value"] = toJS(_t.value());
		res["blockHash"] = toJS(_t.blockHash());
		res["transactionIndex"] = toJS(_t.transactionIndex());
		res["blockNumber"] = toJS(_t.blockNumber());
	}
	return res;
}

Json::Value toJson(dev::eth::LocalisedLogEntry const& _e)
{
	Json::Value res;

	if (_e.isSpecial)
		res = toJS(_e.special);
	else
	{
		res = toJson(static_cast<dev::eth::LogEntry const&>(_e));
		res["polarity"] = _e.polarity == BlockPolarity::Live ? true : false;
		if (_e.mined)
		{
			res["type"] = "mined";
			res["blockNumber"] = _e.blockNumber;
			res["blockHash"] = toJS(_e.blockHash);
			res["logIndex"] = _e.logIndex;
			res["transactionHash"] = toJS(_e.transactionHash);
			res["transactionIndex"] = _e.transactionIndex;
		}
		else
		{
			res["type"] = "pending";
			res["blockNumber"] = Json::Value(Json::nullValue);
			res["blockHash"] = Json::Value(Json::nullValue);
			res["logIndex"] = Json::Value(Json::nullValue);
			res["transactionHash"] = Json::Value(Json::nullValue);
			res["transactionIndex"] = Json::Value(Json::nullValue);
		}
	}
	return res;
}

Json::Value toJson(dev::eth::LogEntry const& _e)
{
	Json::Value res;
	res["data"] = toJS(_e.data);
	res["address"] = toJS(_e.address);
	res["topics"] = Json::Value(Json::arrayValue);
	for (auto const& t: _e.topics)
		res["topics"].append(toJS(t));
	return res;
}

Json::Value toJson(std::unordered_map<h256, dev::eth::LocalisedLogEntries> const& _entriesByBlock, vector<h256> const& _order)
{
	Json::Value res(Json::arrayValue);
	for (auto const& i: _order)
	{
		auto entries = _entriesByBlock.at(i);
		Json::Value currentBlock(Json::objectValue);
		LocalisedLogEntry entry = entries[0];
		if (entry.mined)
		{

			currentBlock["blockNumber"] = entry.blockNumber;
			currentBlock["blockHash"] = toJS(entry.blockHash);
			currentBlock["type"] = "mined";
		}
		else
			currentBlock["type"] = "pending";

		currentBlock["polarity"] = entry.polarity == BlockPolarity::Live ? true : false;
		currentBlock["logs"] = Json::Value(Json::arrayValue);

		for (LocalisedLogEntry const& e: entries)
		{
			Json::Value log(Json::objectValue);
			log["logIndex"] = e.logIndex;
			log["transactionIndex"] = e.transactionIndex;
			log["transactionHash"] = toJS(e.transactionHash);
			log["address"] = toJS(e.address);
			log["data"] = toJS(e.data);
			log["topics"] = Json::Value(Json::arrayValue);
			for (auto const& t: e.topics)
				log["topics"].append(toJS(t));

			currentBlock["logs"].append(log);
		}

		res.append(currentBlock);
	}

	return res;
}

Json::Value toJsonByBlock(LocalisedLogEntries const& _entries)
{
	vector<h256> order;
	unordered_map <h256, LocalisedLogEntries> entriesByBlock;

	for (dev::eth::LocalisedLogEntry const& e: _entries)
	{
		if (e.isSpecial) // skip special log
			continue;

		if (entriesByBlock.count(e.blockHash) == 0)
		{
			entriesByBlock[e.blockHash] = LocalisedLogEntries();
			order.push_back(e.blockHash);
		}

		entriesByBlock[e.blockHash].push_back(e);
	}

	return toJson(entriesByBlock, order);
}

TransactionSkeleton toTransactionSkeleton(Json::Value const& _json)
{
	TransactionSkeleton ret;
	if (!_json.isObject() || _json.empty())
		return ret;

	if (!_json["from"].empty())
		ret.from = jsToAddress(_json["from"].asString());
	if (!_json["to"].empty() && _json["to"].asString() != "0x")
		ret.to = jsToAddress(_json["to"].asString());
	else
		ret.creation = true;

	if (!_json["value"].empty())
		ret.value = jsToU256(_json["value"].asString());

	if (!_json["gas"].empty())
		ret.gas = jsToU256(_json["gas"].asString());

	if (!_json["gasPrice"].empty())
		ret.gasPrice = jsToU256(_json["gasPrice"].asString());

	if (!_json["data"].empty())							// ethereum.js has preconstructed the data array
		ret.data = jsToBytes(_json["data"].asString(), OnFailed::Throw);

	if (!_json["code"].empty())
		ret.data = jsToBytes(_json["code"].asString(), OnFailed::Throw);

	if (!_json["nonce"].empty())
		ret.nonce = jsToU256(_json["nonce"].asString());
	return ret;
}

dev::eth::LogFilter toLogFilter(Json::Value const& _json)
{
	dev::eth::LogFilter filter;
	if (!_json.isObject() || _json.empty())
		return filter;

	// check only !empty. it should throw exceptions if input params are incorrect
	if (!_json["fromBlock"].empty())
		filter.withEarliest(jsToFixed<32>(_json["fromBlock"].asString()));
	if (!_json["toBlock"].empty())
		filter.withLatest(jsToFixed<32>(_json["toBlock"].asString()));
	if (!_json["address"].empty())
	{
		if (_json["address"].isArray())
			for (auto i : _json["address"])
				filter.address(jsToAddress(i.asString()));
		else
			filter.address(jsToAddress(_json["address"].asString()));
	}
	if (!_json["topics"].empty())
		for (unsigned i = 0; i < _json["topics"].size(); i++)
		{
			if (_json["topics"][i].isArray())
			{
				for (auto t: _json["topics"][i])
					if (!t.isNull())
						filter.topic(i, jsToFixed<32>(t.asString()));
			}
			else if (!_json["topics"][i].isNull()) // if it is anything else then string, it should and will fail
				filter.topic(i, jsToFixed<32>(_json["topics"][i].asString()));
		}
	return filter;
}

// TODO: this should be removed once we decide to remove backward compatibility with old log filters
dev::eth::LogFilter toLogFilter(Json::Value const& _json, Interface const& _client)	// commented to avoid warning. Uncomment once in use @ PoC-7.
{
	dev::eth::LogFilter filter;
	if (!_json.isObject() || _json.empty())
		return filter;

	// check only !empty. it should throw exceptions if input params are incorrect
	if (!_json["fromBlock"].empty())
		filter.withEarliest(_client.hashFromNumber(jsToBlockNumber(_json["fromBlock"].asString())));
	if (!_json["toBlock"].empty())
		filter.withLatest(_client.hashFromNumber(jsToBlockNumber(_json["toBlock"].asString())));
	if (!_json["address"].empty())
	{
		if (_json["address"].isArray())
			for (auto i : _json["address"])
				filter.address(jsToAddress(i.asString()));
		else
			filter.address(jsToAddress(_json["address"].asString()));
	}
	if (!_json["topics"].empty())
		for (unsigned i = 0; i < _json["topics"].size(); i++)
		{
			if (_json["topics"][i].isArray())
			{
				for (auto t: _json["topics"][i])
					if (!t.isNull())
						filter.topic(i, jsToFixed<32>(t.asString()));
			}
			else if (!_json["topics"][i].isNull()) // if it is anything else then string, it should and will fail
				filter.topic(i, jsToFixed<32>(_json["topics"][i].asString()));
		}
	return filter;
}

}

// ////////////////////////////////////////////////////////////////////////////////////
// shh
// ////////////////////////////////////////////////////////////////////////////////////

namespace shh
{

Json::Value toJson(h256 const& _h, shh::Envelope const& _e, shh::Message const& _m)
{
	Json::Value res;
	res["hash"] = toJS(_h);
	res["expiry"] = toJS(_e.expiry());
	res["sent"] = toJS(_e.sent());
	res["ttl"] = toJS(_e.ttl());
	res["workProved"] = toJS(_e.workProved());
	res["topics"] = Json::Value(Json::arrayValue);
	for (auto const& t: _e.topic())
		res["topics"].append(toJS(t));
	res["payload"] = toJS(_m.payload());
	res["from"] = toJS(_m.from());
	res["to"] = toJS(_m.to());
	return res;
}

shh::Message toMessage(Json::Value const& _json)
{
	shh::Message ret;
	if (!_json["from"].empty())
		ret.setFrom(jsToPublic(_json["from"].asString()));
	if (!_json["to"].empty())
		ret.setTo(jsToPublic(_json["to"].asString()));
	if (!_json["payload"].empty())
		ret.setPayload(jsToBytes(_json["payload"].asString()));
	return ret;
}

shh::Envelope toSealed(Json::Value const& _json, shh::Message const& _m, Secret const& _from)
{
	unsigned ttl = 50;
	unsigned workToProve = 50;
	shh::BuildTopic bt;

	if (!_json["ttl"].empty())
		ttl = jsToInt(_json["ttl"].asString());

	if (!_json["workToProve"].empty())
		workToProve = jsToInt(_json["workToProve"].asString());

	if (!_json["topics"].empty())
		for (auto i: _json["topics"])
		{
			if (i.isArray())
			{
				for (auto j: i)
					if (!j.isNull())
						bt.shift(jsToBytes(j.asString()));
			}
			else if (!i.isNull()) // if it is anything else then string, it should and will fail
				bt.shift(jsToBytes(i.asString()));
		}

	return _m.seal(_from, bt, ttl, workToProve);
}

pair<shh::Topics, Public> toWatch(Json::Value const& _json)
{
	shh::BuildTopic bt;
	Public to;

	if (!_json["to"].empty())
		to = jsToPublic(_json["to"].asString());

	if (!_json["topics"].empty())
		for (auto i: _json["topics"])
			bt.shift(jsToBytes(i.asString()));

	return make_pair(bt, to);
}

}

// ////////////////////////////////////////////////////////////////////////////////////
// rpc
// ////////////////////////////////////////////////////////////////////////////////////

namespace rpc
{
u256 u256fromHex(string const& _s)
{
	try
	{
		return u256(_s);
	}
	catch (runtime_error const&)
	{
		throw jsonrpc::JsonRpcException("Invalid hex-encoded string: " + _s);
	}
}
}

}