subtly
10 years ago
90 changed files with 6063 additions and 2690 deletions
@ -1,379 +0,0 @@ |
|||
var bigInt = (function () { |
|||
var base = 10000000, logBase = 7; |
|||
var sign = { |
|||
positive: false, |
|||
negative: true |
|||
}; |
|||
|
|||
var normalize = function (first, second) { |
|||
var a = first.value, b = second.value; |
|||
var length = a.length > b.length ? a.length : b.length; |
|||
for (var i = 0; i < length; i++) { |
|||
a[i] = a[i] || 0; |
|||
b[i] = b[i] || 0; |
|||
} |
|||
for (var i = length - 1; i >= 0; i--) { |
|||
if (a[i] === 0 && b[i] === 0) { |
|||
a.pop(); |
|||
b.pop(); |
|||
} else break; |
|||
} |
|||
if (!a.length) a = [0], b = [0]; |
|||
first.value = a; |
|||
second.value = b; |
|||
}; |
|||
|
|||
var parse = function (text, first) { |
|||
if (typeof text === "object") return text; |
|||
text += ""; |
|||
var s = sign.positive, value = []; |
|||
if (text[0] === "-") { |
|||
s = sign.negative; |
|||
text = text.slice(1); |
|||
} |
|||
var base = 10; |
|||
if (text.slice(0, 2) == "0x") { |
|||
base = 16; |
|||
text = text.slice(2); |
|||
} |
|||
else { |
|||
var texts = text.split("e"); |
|||
if (texts.length > 2) throw new Error("Invalid integer"); |
|||
if (texts[1]) { |
|||
var exp = texts[1]; |
|||
if (exp[0] === "+") exp = exp.slice(1); |
|||
exp = parse(exp); |
|||
if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers"); |
|||
while (exp.notEquals(0)) { |
|||
texts[0] += "0"; |
|||
exp = exp.prev(); |
|||
} |
|||
} |
|||
text = texts[0]; |
|||
} |
|||
if (text === "-0") text = "0"; |
|||
text = text.toUpperCase(); |
|||
var isValid = (base == 16 ? /^[0-9A-F]*$/ : /^[0-9]+$/).test(text); |
|||
if (!isValid) throw new Error("Invalid integer"); |
|||
if (base == 16) { |
|||
var val = bigInt(0); |
|||
while (text.length) { |
|||
v = text.charCodeAt(0) - 48; |
|||
if (v > 9) |
|||
v -= 7; |
|||
text = text.slice(1); |
|||
val = val.times(16).plus(v); |
|||
} |
|||
return val; |
|||
} |
|||
else { |
|||
while (text.length) { |
|||
var divider = text.length > logBase ? text.length - logBase : 0; |
|||
value.push(+text.slice(divider)); |
|||
text = text.slice(0, divider); |
|||
} |
|||
var val = bigInt(value, s); |
|||
if (first) normalize(first, val); |
|||
return val; |
|||
} |
|||
}; |
|||
|
|||
var goesInto = function (a, b) { |
|||
var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive); |
|||
if (a.equals(0)) throw new Error("Cannot divide by 0"); |
|||
var n = 0; |
|||
do { |
|||
var inc = 1; |
|||
var c = bigInt(a.value, sign.positive), t = c.times(10); |
|||
while (t.lesser(b)) { |
|||
c = t; |
|||
inc *= 10; |
|||
t = t.times(10); |
|||
} |
|||
while (c.lesserOrEquals(b)) { |
|||
b = b.minus(c); |
|||
n += inc; |
|||
} |
|||
} while (a.lesserOrEquals(b)); |
|||
|
|||
return { |
|||
remainder: b.value, |
|||
result: n |
|||
}; |
|||
}; |
|||
|
|||
var bigInt = function (value, s) { |
|||
var self = { |
|||
value: value, |
|||
sign: s |
|||
}; |
|||
var o = { |
|||
value: value, |
|||
sign: s, |
|||
negate: function (m) { |
|||
var first = m || self; |
|||
return bigInt(first.value, !first.sign); |
|||
}, |
|||
abs: function (m) { |
|||
var first = m || self; |
|||
return bigInt(first.value, sign.positive); |
|||
}, |
|||
add: function (n, m) { |
|||
var s, first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m)); |
|||
else second = parse(n, first); |
|||
s = first.sign; |
|||
if (first.sign !== second.sign) { |
|||
first = bigInt(first.value, sign.positive); |
|||
second = bigInt(second.value, sign.positive); |
|||
return s === sign.positive ? |
|||
o.subtract(first, second) : |
|||
o.subtract(second, first); |
|||
} |
|||
normalize(first, second); |
|||
var a = first.value, b = second.value; |
|||
var result = [], |
|||
carry = 0; |
|||
for (var i = 0; i < a.length || carry > 0; i++) { |
|||
var sum = (a[i] || 0) + (b[i] || 0) + carry; |
|||
carry = sum >= base ? 1 : 0; |
|||
sum -= carry * base; |
|||
result.push(sum); |
|||
} |
|||
return bigInt(result, s); |
|||
}, |
|||
plus: function (n, m) { |
|||
return o.add(n, m); |
|||
}, |
|||
subtract: function (n, m) { |
|||
var first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m)); |
|||
else second = parse(n, first); |
|||
if (first.sign !== second.sign) return o.add(first, o.negate(second)); |
|||
if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first)); |
|||
if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first)); |
|||
var a = first.value, b = second.value; |
|||
var result = [], |
|||
borrow = 0; |
|||
for (var i = 0; i < a.length; i++) { |
|||
var tmp = a[i] - borrow; |
|||
borrow = tmp < b[i] ? 1 : 0; |
|||
var minuend = (borrow * base) + tmp - b[i]; |
|||
result.push(minuend); |
|||
} |
|||
return bigInt(result, sign.positive); |
|||
}, |
|||
minus: function (n, m) { |
|||
return o.subtract(n, m); |
|||
}, |
|||
multiply: function (n, m) { |
|||
var s, first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m)); |
|||
else second = parse(n, first); |
|||
s = first.sign !== second.sign; |
|||
var a = first.value, b = second.value; |
|||
var resultSum = []; |
|||
for (var i = 0; i < a.length; i++) { |
|||
resultSum[i] = []; |
|||
var j = i; |
|||
while (j--) { |
|||
resultSum[i].push(0); |
|||
} |
|||
} |
|||
var carry = 0; |
|||
for (var i = 0; i < a.length; i++) { |
|||
var x = a[i]; |
|||
for (var j = 0; j < b.length || carry > 0; j++) { |
|||
var y = b[j]; |
|||
var product = y ? (x * y) + carry : carry; |
|||
carry = product > base ? Math.floor(product / base) : 0; |
|||
product -= carry * base; |
|||
resultSum[i].push(product); |
|||
} |
|||
} |
|||
var max = -1; |
|||
for (var i = 0; i < resultSum.length; i++) { |
|||
var len = resultSum[i].length; |
|||
if (len > max) max = len; |
|||
} |
|||
var result = [], carry = 0; |
|||
for (var i = 0; i < max || carry > 0; i++) { |
|||
var sum = carry; |
|||
for (var j = 0; j < resultSum.length; j++) { |
|||
sum += resultSum[j][i] || 0; |
|||
} |
|||
carry = sum > base ? Math.floor(sum / base) : 0; |
|||
sum -= carry * base; |
|||
result.push(sum); |
|||
} |
|||
return bigInt(result, s); |
|||
}, |
|||
times: function (n, m) { |
|||
return o.multiply(n, m); |
|||
}, |
|||
divmod: function (n, m) { |
|||
var s, first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m)); |
|||
else second = parse(n, first); |
|||
s = first.sign !== second.sign; |
|||
if (bigInt(first.value, first.sign).equals(0)) return { |
|||
quotient: bigInt([0], sign.positive), |
|||
remainder: bigInt([0], sign.positive) |
|||
}; |
|||
if (second.equals(0)) throw new Error("Cannot divide by zero"); |
|||
var a = first.value, b = second.value; |
|||
var result = [], remainder = []; |
|||
for (var i = a.length - 1; i >= 0; i--) { |
|||
var n = [a[i]].concat(remainder); |
|||
var quotient = goesInto(b, n); |
|||
result.push(quotient.result); |
|||
remainder = quotient.remainder; |
|||
} |
|||
result.reverse(); |
|||
return { |
|||
quotient: bigInt(result, s), |
|||
remainder: bigInt(remainder, first.sign) |
|||
}; |
|||
}, |
|||
divide: function (n, m) { |
|||
return o.divmod(n, m).quotient; |
|||
}, |
|||
over: function (n, m) { |
|||
return o.divide(n, m); |
|||
}, |
|||
mod: function (n, m) { |
|||
return o.divmod(n, m).remainder; |
|||
}, |
|||
pow: function (n, m) { |
|||
var first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m)); |
|||
else second = parse(n, first); |
|||
var a = first, b = second; |
|||
if (b.lesser(0)) return ZERO; |
|||
if (b.equals(0)) return ONE; |
|||
var result = bigInt(a.value, a.sign); |
|||
|
|||
if (b.mod(2).equals(0)) { |
|||
var c = result.pow(b.over(2)); |
|||
return c.times(c); |
|||
} else { |
|||
return result.times(result.pow(b.minus(1))); |
|||
} |
|||
}, |
|||
next: function (m) { |
|||
var first = m || self; |
|||
return o.add(first, 1); |
|||
}, |
|||
prev: function (m) { |
|||
var first = m || self; |
|||
return o.subtract(first, 1); |
|||
}, |
|||
compare: function (n, m) { |
|||
var first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m, first)); |
|||
else second = parse(n, first); |
|||
normalize(first, second); |
|||
if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0; |
|||
if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1; |
|||
var multiplier = first.sign === sign.positive ? 1 : -1; |
|||
var a = first.value, b = second.value; |
|||
for (var i = a.length - 1; i >= 0; i--) { |
|||
if (a[i] > b[i]) return 1 * multiplier; |
|||
if (b[i] > a[i]) return -1 * multiplier; |
|||
} |
|||
return 0; |
|||
}, |
|||
compareAbs: function (n, m) { |
|||
var first = self, second; |
|||
if (m) (first = parse(n)) && (second = parse(m, first)); |
|||
else second = parse(n, first); |
|||
first.sign = second.sign = sign.positive; |
|||
return o.compare(first, second); |
|||
}, |
|||
equals: function (n, m) { |
|||
return o.compare(n, m) === 0; |
|||
}, |
|||
notEquals: function (n, m) { |
|||
return !o.equals(n, m); |
|||
}, |
|||
lesser: function (n, m) { |
|||
return o.compare(n, m) < 0; |
|||
}, |
|||
greater: function (n, m) { |
|||
return o.compare(n, m) > 0; |
|||
}, |
|||
greaterOrEquals: function (n, m) { |
|||
return o.compare(n, m) >= 0; |
|||
}, |
|||
lesserOrEquals: function (n, m) { |
|||
return o.compare(n, m) <= 0; |
|||
}, |
|||
isPositive: function (m) { |
|||
var first = m || self; |
|||
return first.sign === sign.positive; |
|||
}, |
|||
isNegative: function (m) { |
|||
var first = m || self; |
|||
return first.sign === sign.negative; |
|||
}, |
|||
isEven: function (m) { |
|||
var first = m || self; |
|||
return first.value[0] % 2 === 0; |
|||
}, |
|||
isOdd: function (m) { |
|||
var first = m || self; |
|||
return first.value[0] % 2 === 1; |
|||
}, |
|||
toString: function (m) { |
|||
var first = m || self; |
|||
var str = "", len = first.value.length; |
|||
while (len--) { |
|||
if (first.value[len].toString().length === 8) str += first.value[len]; |
|||
else str += (base.toString() + first.value[len]).slice(-logBase); |
|||
} |
|||
while (str[0] === "0") { |
|||
str = str.slice(1); |
|||
} |
|||
if (!str.length) str = "0"; |
|||
var s = (first.sign === sign.positive || str == "0") ? "" : "-"; |
|||
return s + str; |
|||
}, |
|||
toHex: function (m) { |
|||
var first = m || self; |
|||
var str = ""; |
|||
var l = this.abs(); |
|||
while (l > 0) { |
|||
var qr = l.divmod(256); |
|||
var b = qr.remainder.toJSNumber(); |
|||
str = (b >> 4).toString(16) + (b & 15).toString(16) + str; |
|||
l = qr.quotient; |
|||
} |
|||
return (this.isNegative() ? "-" : "") + "0x" + str; |
|||
}, |
|||
toJSNumber: function (m) { |
|||
return +o.toString(m); |
|||
}, |
|||
valueOf: function (m) { |
|||
return o.toJSNumber(m); |
|||
} |
|||
}; |
|||
return o; |
|||
}; |
|||
|
|||
var ZERO = bigInt([0], sign.positive); |
|||
var ONE = bigInt([1], sign.positive); |
|||
var MINUS_ONE = bigInt([1], sign.negative); |
|||
|
|||
var fnReturn = function (a) { |
|||
if (typeof a === "undefined") return ZERO; |
|||
return parse(a); |
|||
}; |
|||
fnReturn.zero = ZERO; |
|||
fnReturn.one = ONE; |
|||
fnReturn.minusOne = MINUS_ONE; |
|||
return fnReturn; |
|||
})(); |
|||
|
|||
if (typeof module !== "undefined") { |
|||
module.exports = bigInt; |
|||
} |
|||
@ -1,217 +0,0 @@ |
|||
/*
|
|||
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 EthStubServer.cpp
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#if ETH_JSONRPC |
|||
#include "EthStubServer.h" |
|||
#include <libevmface/Instruction.h> |
|||
#include <liblll/Compiler.h> |
|||
#include <libethereum/Client.h> |
|||
#include <libwebthree/WebThree.h> |
|||
#include "CommonJS.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
EthStubServer::EthStubServer(jsonrpc::AbstractServerConnector* _conn, WebThreeDirect& _web3): |
|||
AbstractEthStubServer(_conn), |
|||
m_web3(_web3) |
|||
{ |
|||
} |
|||
|
|||
//only works with a json spec that doesn't have notifications for now
|
|||
Json::Value EthStubServer::procedures() |
|||
{ |
|||
Json::Value ret; |
|||
|
|||
for (auto proc: this->GetProtocolHanlder()->GetProcedures()) |
|||
{ |
|||
Json::Value proc_j; |
|||
|
|||
proc_j[proc.second->GetProcedureType() == 0 ? "method" : "notification"] = proc.first; |
|||
|
|||
Json::Value params_j; |
|||
for (auto params: proc.second->GetParameters()) |
|||
params_j[params.first] = jsontypeToValue(params.second); |
|||
proc_j["params"] = params_j; |
|||
|
|||
proc_j["returns"] = jsontypeToValue(proc.second->GetReturnType()); |
|||
|
|||
ret.append(proc_j); |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
dev::eth::Client& EthStubServer::ethereum() const |
|||
{ |
|||
return *m_web3.ethereum(); |
|||
} |
|||
|
|||
std::string EthStubServer::coinbase() |
|||
{ |
|||
return toJS(ethereum().address()); |
|||
} |
|||
|
|||
std::string EthStubServer::balanceAt(std::string const& _a) |
|||
{ |
|||
return toJS(ethereum().balanceAt(jsToAddress(_a), 0)); |
|||
} |
|||
|
|||
Json::Value EthStubServer::check(Json::Value const& _as) |
|||
{ |
|||
// TODO
|
|||
// if (ethereum().changed())
|
|||
return _as; |
|||
/* else
|
|||
{ |
|||
Json::Value ret; |
|||
ret.resize(0); |
|||
return ret; |
|||
}*/ |
|||
} |
|||
|
|||
std::string EthStubServer::create(const std::string& _bCode, const std::string& _sec, const std::string& _xEndowment, const std::string& _xGas, const std::string& _xGasPrice) |
|||
{ |
|||
Address ret = ethereum().transact(jsToSecret(_sec), jsToU256(_xEndowment), jsToBytes(_bCode), jsToU256(_xGas), jsToU256(_xGasPrice)); |
|||
return toJS(ret); |
|||
} |
|||
|
|||
std::string EthStubServer::lll(const std::string& _s) |
|||
{ |
|||
return "0x" + toHex(dev::eth::compileLLL(_s)); |
|||
} |
|||
|
|||
std::string EthStubServer::gasPrice() |
|||
{ |
|||
return "100000000000000"; |
|||
} |
|||
|
|||
bool EthStubServer::isContractAt(const std::string& _a) |
|||
{ |
|||
return ethereum().codeAt(jsToAddress(_a), 0).size(); |
|||
} |
|||
|
|||
bool EthStubServer::isListening() |
|||
{ |
|||
return m_web3.haveNetwork(); |
|||
} |
|||
|
|||
bool EthStubServer::isMining() |
|||
{ |
|||
return ethereum().isMining(); |
|||
} |
|||
|
|||
std::string EthStubServer::key() |
|||
{ |
|||
if (!m_keys.size()) |
|||
return std::string(); |
|||
return toJS(m_keys[0].sec()); |
|||
} |
|||
|
|||
Json::Value EthStubServer::keys() |
|||
{ |
|||
Json::Value ret; |
|||
for (auto i: m_keys) |
|||
ret.append(toJS(i.secret())); |
|||
return ret; |
|||
} |
|||
|
|||
int EthStubServer::peerCount() |
|||
{ |
|||
return m_web3.peerCount(); |
|||
} |
|||
|
|||
std::string EthStubServer::storageAt(const std::string& _a, const std::string& x) |
|||
{ |
|||
return toJS(ethereum().stateAt(jsToAddress(_a), jsToU256(x), 0)); |
|||
} |
|||
|
|||
std::string EthStubServer::stateAt(const std::string& _a, const std::string& x, const std::string& s) |
|||
{ |
|||
return toJS(ethereum().stateAt(jsToAddress(_a), jsToU256(x), std::atol(s.c_str()))); |
|||
} |
|||
|
|||
Json::Value EthStubServer::transact(const std::string& _aDest, const std::string& _bData, const std::string& _sec, const std::string& _xGas, const std::string& _xGasPrice, const std::string& _xValue) |
|||
{ |
|||
ethereum().transact(jsToSecret(_sec), jsToU256(_xValue), jsToAddress(_aDest), jsToBytes(_bData), jsToU256(_xGas), jsToU256(_xGasPrice)); |
|||
return Json::Value(); |
|||
} |
|||
|
|||
std::string EthStubServer::txCountAt(const std::string& _a) |
|||
{ |
|||
return toJS(ethereum().countAt(jsToAddress(_a), 0)); |
|||
} |
|||
|
|||
std::string EthStubServer::secretToAddress(const std::string& _a) |
|||
{ |
|||
return toJS(KeyPair(jsToSecret(_a)).address()); |
|||
} |
|||
|
|||
Json::Value EthStubServer::lastBlock() |
|||
{ |
|||
return blockJson(""); |
|||
} |
|||
|
|||
Json::Value EthStubServer::block(const std::string& _hash) |
|||
{ |
|||
return blockJson(_hash); |
|||
} |
|||
|
|||
Json::Value EthStubServer::blockJson(const std::string& _hash) |
|||
{ |
|||
Json::Value res; |
|||
auto const& bc = ethereum().blockChain(); |
|||
|
|||
auto b = _hash.length() ? bc.block(h256(_hash)) : bc.block(); |
|||
|
|||
auto bi = BlockInfo(b); |
|||
res["number"] = boost::lexical_cast<string>(bi.number); |
|||
res["hash"] = boost::lexical_cast<string>(bi.hash); |
|||
res["parentHash"] = boost::lexical_cast<string>(bi.parentHash); |
|||
res["sha3Uncles"] = boost::lexical_cast<string>(bi.sha3Uncles); |
|||
res["coinbaseAddress"] = boost::lexical_cast<string>(bi.coinbaseAddress); |
|||
res["stateRoot"] = boost::lexical_cast<string>(bi.stateRoot); |
|||
res["transactionsRoot"] = boost::lexical_cast<string>(bi.transactionsRoot); |
|||
res["minGasPrice"] = boost::lexical_cast<string>(bi.minGasPrice); |
|||
res["gasLimit"] = boost::lexical_cast<string>(bi.gasLimit); |
|||
res["gasUsed"] = boost::lexical_cast<string>(bi.gasUsed); |
|||
res["difficulty"] = boost::lexical_cast<string>(bi.difficulty); |
|||
res["timestamp"] = boost::lexical_cast<string>(bi.timestamp); |
|||
res["nonce"] = boost::lexical_cast<string>(bi.nonce); |
|||
|
|||
return res; |
|||
} |
|||
|
|||
Json::Value EthStubServer::jsontypeToValue(int _jsontype) |
|||
{ |
|||
switch (_jsontype) |
|||
{ |
|||
case jsonrpc::JSON_STRING: return ""; //Json::stringValue segfault, fuck knows why
|
|||
case jsonrpc::JSON_BOOLEAN: return Json::booleanValue; |
|||
case jsonrpc::JSON_INTEGER: return Json::intValue; |
|||
case jsonrpc::JSON_REAL: return Json::realValue; |
|||
case jsonrpc::JSON_OBJECT: return Json::objectValue; |
|||
case jsonrpc::JSON_ARRAY: return Json::arrayValue; |
|||
default: return Json::nullValue; |
|||
} |
|||
} |
|||
|
|||
#endif |
|||
@ -1,66 +0,0 @@ |
|||
/*
|
|||
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 EthStubServer.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <iostream> |
|||
#include <jsonrpc/rpc.h> |
|||
#include <libdevcrypto/Common.h> |
|||
#pragma GCC diagnostic push |
|||
#pragma GCC diagnostic ignored "-Wunused-parameter" |
|||
#include "abstractethstubserver.h" |
|||
#pragma GCC diagnostic pop |
|||
|
|||
namespace dev { class WebThreeDirect; namespace eth { class Client; } class KeyPair; } |
|||
|
|||
class EthStubServer: public AbstractEthStubServer |
|||
{ |
|||
public: |
|||
EthStubServer(jsonrpc::AbstractServerConnector* _conn, dev::WebThreeDirect& _web3); |
|||
|
|||
virtual Json::Value procedures(); |
|||
virtual std::string balanceAt(std::string const& _a); |
|||
virtual Json::Value check(Json::Value const& _as); |
|||
virtual std::string coinbase(); |
|||
virtual std::string create(const std::string& bCode, const std::string& sec, const std::string& xEndowment, const std::string& xGas, const std::string& xGasPrice); |
|||
virtual std::string gasPrice(); |
|||
virtual bool isContractAt(const std::string& a); |
|||
virtual bool isListening(); |
|||
virtual bool isMining(); |
|||
virtual std::string key(); |
|||
virtual Json::Value keys(); |
|||
virtual int peerCount(); |
|||
virtual std::string storageAt(const std::string& a, const std::string& x); |
|||
virtual std::string stateAt(const std::string& a, const std::string& x, const std::string& s); |
|||
virtual Json::Value transact(const std::string& aDest, const std::string& bData, const std::string& sec, const std::string& xGas, const std::string& xGasPrice, const std::string& xValue); |
|||
virtual std::string txCountAt(const std::string& a); |
|||
virtual std::string secretToAddress(const std::string& a); |
|||
virtual Json::Value lastBlock(); |
|||
virtual std::string lll(const std::string& s); |
|||
virtual Json::Value block(const std::string&); |
|||
void setKeys(std::vector<dev::KeyPair> _keys) { m_keys = _keys; } |
|||
private: |
|||
dev::eth::Client& ethereum() const; |
|||
dev::WebThreeDirect& m_web3; |
|||
std::vector<dev::KeyPair> m_keys; |
|||
Json::Value jsontypeToValue(int); |
|||
Json::Value blockJson(const std::string&); |
|||
}; |
|||
@ -1,162 +0,0 @@ |
|||
/**
|
|||
* THIS FILE IS GENERATED BY jsonrpcstub, DO NOT CHANGE IT!!!!! |
|||
*/ |
|||
|
|||
#ifndef _ABSTRACTETHSTUBSERVER_H_ |
|||
#define _ABSTRACTETHSTUBSERVER_H_ |
|||
|
|||
#include <jsonrpc/rpc.h> |
|||
|
|||
class AbstractEthStubServer : public jsonrpc::AbstractServer<AbstractEthStubServer> |
|||
{ |
|||
public: |
|||
AbstractEthStubServer(jsonrpc::AbstractServerConnector* conn) : |
|||
jsonrpc::AbstractServer<AbstractEthStubServer>(conn) |
|||
{ |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("balanceAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::balanceAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("block", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::blockI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("check", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_ARRAY, "a",jsonrpc::JSON_ARRAY, NULL), &AbstractEthStubServer::checkI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("coinbase", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::coinbaseI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("create", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "bCode",jsonrpc::JSON_STRING,"sec",jsonrpc::JSON_STRING,"xEndowment",jsonrpc::JSON_STRING,"xGas",jsonrpc::JSON_STRING,"xGasPrice",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::createI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("gasPrice", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::gasPriceI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("isContractAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_BOOLEAN, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::isContractAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("isListening", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_BOOLEAN, NULL), &AbstractEthStubServer::isListeningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("isMining", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_BOOLEAN, NULL), &AbstractEthStubServer::isMiningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("key", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::keyI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("keys", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_ARRAY, NULL), &AbstractEthStubServer::keysI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("lastBlock", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, NULL), &AbstractEthStubServer::lastBlockI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("lll", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "s",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::lllI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("peerCount", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_INTEGER, NULL), &AbstractEthStubServer::peerCountI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("procedures", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_ARRAY, NULL), &AbstractEthStubServer::proceduresI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("secretToAddress", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::secretToAddressI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("storageAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING,"x",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::storageAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("stateAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING,"x",jsonrpc::JSON_STRING,"s",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::stateAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("transact", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, "aDest",jsonrpc::JSON_STRING,"bData",jsonrpc::JSON_STRING,"sec",jsonrpc::JSON_STRING,"xGas",jsonrpc::JSON_STRING,"xGasPrice",jsonrpc::JSON_STRING,"xValue",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::transactI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("txCountAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::txCountAtI); |
|||
|
|||
} |
|||
|
|||
inline virtual void balanceAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->balanceAt(request["a"].asString()); |
|||
} |
|||
|
|||
inline virtual void blockI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->block(request["a"].asString()); |
|||
} |
|||
|
|||
inline virtual void checkI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->check(request["a"]); |
|||
} |
|||
|
|||
inline virtual void coinbaseI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->coinbase(); |
|||
} |
|||
|
|||
inline virtual void createI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->create(request["bCode"].asString(), request["sec"].asString(), request["xEndowment"].asString(), request["xGas"].asString(), request["xGasPrice"].asString()); |
|||
} |
|||
|
|||
inline virtual void gasPriceI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->gasPrice(); |
|||
} |
|||
|
|||
inline virtual void isContractAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->isContractAt(request["a"].asString()); |
|||
} |
|||
|
|||
inline virtual void isListeningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->isListening(); |
|||
} |
|||
|
|||
inline virtual void isMiningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->isMining(); |
|||
} |
|||
|
|||
inline virtual void keyI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->key(); |
|||
} |
|||
|
|||
inline virtual void keysI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->keys(); |
|||
} |
|||
|
|||
inline virtual void lastBlockI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->lastBlock(); |
|||
} |
|||
|
|||
inline virtual void lllI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->lll(request["s"].asString()); |
|||
} |
|||
|
|||
inline virtual void peerCountI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->peerCount(); |
|||
} |
|||
|
|||
inline virtual void proceduresI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->procedures(); |
|||
} |
|||
|
|||
inline virtual void secretToAddressI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->secretToAddress(request["a"].asString()); |
|||
} |
|||
|
|||
inline virtual void storageAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->storageAt(request["a"].asString(), request["x"].asString()); |
|||
} |
|||
|
|||
inline virtual void stateAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->stateAt(request["a"].asString(), request["x"].asString(), request["s"].asString()); |
|||
} |
|||
|
|||
inline virtual void transactI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->transact(request["aDest"].asString(), request["bData"].asString(), request["sec"].asString(), request["xGas"].asString(), request["xGasPrice"].asString(), request["xValue"].asString()); |
|||
} |
|||
|
|||
inline virtual void txCountAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->txCountAt(request["a"].asString()); |
|||
} |
|||
|
|||
|
|||
virtual std::string balanceAt(const std::string& a) = 0; |
|||
virtual Json::Value block(const std::string& a) = 0; |
|||
virtual Json::Value check(const Json::Value& a) = 0; |
|||
virtual std::string coinbase() = 0; |
|||
virtual std::string create(const std::string& bCode, const std::string& sec, const std::string& xEndowment, const std::string& xGas, const std::string& xGasPrice) = 0; |
|||
virtual std::string gasPrice() = 0; |
|||
virtual bool isContractAt(const std::string& a) = 0; |
|||
virtual bool isListening() = 0; |
|||
virtual bool isMining() = 0; |
|||
virtual std::string key() = 0; |
|||
virtual Json::Value keys() = 0; |
|||
virtual Json::Value lastBlock() = 0; |
|||
virtual std::string lll(const std::string& s) = 0; |
|||
virtual int peerCount() = 0; |
|||
virtual Json::Value procedures() = 0; |
|||
virtual std::string secretToAddress(const std::string& a) = 0; |
|||
virtual std::string storageAt(const std::string& a, const std::string& x) = 0; |
|||
virtual std::string stateAt(const std::string& a, const std::string& x, const std::string& b) = 0; |
|||
virtual Json::Value transact(const std::string& aDest, const std::string& bData, const std::string& sec, const std::string& xGas, const std::string& xGasPrice, const std::string& xValue) = 0; |
|||
virtual std::string txCountAt(const std::string& a) = 0; |
|||
|
|||
}; |
|||
#endif //_ABSTRACTETHSTUBSERVER_H_
|
|||
@ -1,137 +0,0 @@ |
|||
if (typeof(window.eth) === "undefined") |
|||
{ |
|||
if (typeof(require) !== "undefined") |
|||
require( ['ethString'], function() {} ) |
|||
else if (typeof(String.prototype.pad) === "undefined") |
|||
{ |
|||
var scriptTag = document.getElementsByTagName('script'); |
|||
scriptTag = scriptTag[scriptTag.length - 1]; |
|||
var scriptPath = scriptTag.src; |
|||
var path = scriptPath.substr(0, scriptPath.lastIndexOf( '/' )); |
|||
var start = '<script src="' + path + '/'; |
|||
var slash = '"><'+'/script>'; |
|||
document.write(start + 'BigInteger.js' + slash); |
|||
document.write(start + 'ethString.js' + slash); |
|||
} |
|||
|
|||
var spec = [ |
|||
{ "method": "procedures", "params": null, "order": [], "returns": [] }, |
|||
{ "method": "coinbase", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "isListening", "params": null, "order": [], "returns" : false }, |
|||
{ "method": "isMining", "params": null, "order": [], "returns" : false }, |
|||
{ "method": "gasPrice", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "key", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "keys", "params": null, "order": [], "returns" : [] }, |
|||
{ "method": "peerCount", "params": null, "order": [], "returns" : 0 }, |
|||
{ "method": "balanceAt", "params": { "a": "" }, "order": ["a"], "returns" : "" }, |
|||
{ "method": "storageAt", "params": { "a": "", "x": "" }, "order": ["a", "x"], "returns" : "" }, |
|||
{ "method": "stateAt", "params": { "a": "", "x": "", "s": "" }, "order": ["a", "x", "s"], "returns" : "" }, |
|||
{ "method": "txCountAt", "params": { "a": "" },"order": ["a"], "returns" : "" }, |
|||
{ "method": "isContractAt", "params": { "a": "" }, "order": ["a"], "returns" : false }, |
|||
{ "method": "create", "params": { "sec": "", "xEndowment": "", "bCode": "", "xGas": "", "xGasPrice": "" }, "order": ["sec", "xEndowment", "bCode", "xGas", "xGasPrice"] , "returns": "" }, |
|||
{ "method": "transact", "params": { "sec": "", "xValue": "", "aDest": "", "bData": "", "xGas": "", "xGasPrice": "" }, "order": ["sec", "xValue", "aDest", "bData", "xGas", "xGasPrice"], "returns": {} }, |
|||
{ "method": "secretToAddress", "params": { "a": "" }, "order": ["a"], "returns" : "" }, |
|||
{ "method": "lll", "params": { "s": "" }, "order": ["s"], "returns" : "" } |
|||
]; |
|||
|
|||
window.eth = (function ethScope() { |
|||
var m_reqId = 0 |
|||
var ret = {} |
|||
function reformat(m, d) { return m == "lll" ? d.bin() : d; } |
|||
function reqSync(m, p) { |
|||
var req = { "jsonrpc": "2.0", "method": m, "params": p, "id": m_reqId } |
|||
m_reqId++ |
|||
var request = new XMLHttpRequest(); |
|||
request.open("POST", "http://localhost:8080", false) |
|||
// console.log("Sending " + JSON.stringify(req))
|
|||
request.send(JSON.stringify(req)) |
|||
return reformat(m, JSON.parse(request.responseText).result) |
|||
} |
|||
function reqAsync(m, p, f) { |
|||
var req = { "jsonrpc": "2.0", "method": m, "params": p, "id": m_reqId } |
|||
m_reqId++ |
|||
var request = new XMLHttpRequest(); |
|||
request.open("POST", "http://localhost:8080", true) |
|||
request.send(JSON.stringify(req)) |
|||
request.onreadystatechange = function() { |
|||
if (request.readyState === 4) |
|||
f(reformat(m, JSON.parse(request.responseText).result)) |
|||
}; |
|||
} |
|||
function isEmpty(obj) { |
|||
for (var prop in obj) |
|||
if (obj.hasOwnProperty(prop)) |
|||
return false |
|||
return true |
|||
} |
|||
|
|||
var m_watching = {}; |
|||
|
|||
for (si in spec) (function(s) { |
|||
var m = s.method; |
|||
var am = "get" + m.slice(0, 1).toUpperCase() + m.slice(1); |
|||
var getParams = function(a) { |
|||
var p = s.params ? {} : null; |
|||
if (m == "stateAt") |
|||
if (a.length == 2) |
|||
a[2] = "0"; |
|||
else |
|||
a[2] = String(a[2]); |
|||
for (j in s.order) |
|||
p[s.order[j]] = (s.order[j][0] === "b") ? a[j].unbin() : a[j]; |
|||
return p |
|||
}; |
|||
if (m == "create" || m == "transact") |
|||
ret[m] = function() { return reqAsync(m, getParams(arguments), arguments[s.order.length]) } |
|||
else |
|||
{ |
|||
ret[am] = function() { return reqAsync(m, getParams(arguments), arguments[s.order.length]) } |
|||
if (s.params) |
|||
ret[m] = function() { return reqSync(m, getParams(arguments)) } |
|||
else |
|||
Object.defineProperty(ret, m, { |
|||
get: function() { return reqSync(m, {}); }, |
|||
set: function(v) {} |
|||
}) |
|||
} |
|||
})(spec[si]); |
|||
|
|||
ret.check = function(force) { |
|||
if (!force && isEmpty(m_watching)) |
|||
return |
|||
var watching = []; |
|||
for (var w in m_watching) |
|||
watching.push(w) |
|||
var changed = reqSync("check", { "a": watching } ); |
|||
// console.log("Got " + JSON.stringify(changed));
|
|||
for (var c in changed) |
|||
m_watching[changed[c]]() |
|||
var that = this; |
|||
setTimeout(function() { that.check() }, 12000) |
|||
} |
|||
|
|||
ret.watch = function(a, fx, f) { |
|||
var old = isEmpty(m_watching) |
|||
if (f) |
|||
m_watching[a + fx] = f |
|||
else |
|||
m_watching[a] = fx |
|||
(f ? f : fx)() |
|||
if (isEmpty(m_watching) != old) |
|||
this.check() |
|||
} |
|||
ret.unwatch = function(f, fx) { |
|||
delete m_watching[fx ? f + fx : f]; |
|||
} |
|||
ret.newBlock = function(f) { |
|||
var old = isEmpty(m_watching) |
|||
m_watching[""] = f |
|||
f() |
|||
if (isEmpty(m_watching) != old) |
|||
this.check() |
|||
} |
|||
return ret; |
|||
}()); |
|||
|
|||
} |
|||
|
|||
@ -1,62 +0,0 @@ |
|||
if (typeof(require) !== "undefined") |
|||
require( ['BigInteger'], function() {} ) |
|||
else if (typeof(bigInt) === "undefined") |
|||
alert("You need to have included BigInteger.js for eth to work.") |
|||
|
|||
String.prototype.pad = function(l, r) { |
|||
if (r === null) { |
|||
r = l |
|||
if (!(this.substr(0, 2) == "0x" || /^\d+$/.test(this))) |
|||
l = 0 |
|||
} |
|||
var ret = this.bin(); |
|||
while (ret.length < l) |
|||
ret = "\0" + ret |
|||
while (ret.length < r) |
|||
ret = ret + "\0" |
|||
return ret; |
|||
} |
|||
|
|||
String.prototype.unpad = function() { |
|||
var i = this.length; |
|||
while (i && this[i - 1] == "\0") |
|||
--i |
|||
return this.substr(0, i) |
|||
} |
|||
|
|||
String.prototype.bin = function() { |
|||
if (this.substr(0, 2) == "0x") { |
|||
bytes = [] |
|||
var i = 2; |
|||
// Check if it's odd - pad with a zero if so.
|
|||
if (this.length % 2) |
|||
bytes.push(parseInt(this.substr(i++, 1), 16)) |
|||
for (; i < this.length - 1; i += 2) |
|||
bytes.push(parseInt(this.substr(i, 2), 16)); |
|||
return String.fromCharCode.apply(String, bytes); |
|||
} else if (/^\d+$/.test(this)) |
|||
return bigInt(this.substr(0)).toHex().bin() |
|||
|
|||
// Otherwise we'll return the "String" object instead of an actual string
|
|||
return this.substr(0, this.length) |
|||
} |
|||
|
|||
String.prototype.unbin = function() { |
|||
var i, l, o = ''; |
|||
for(i = 0, l = this.length; i < l; i++) { |
|||
var n = this.charCodeAt(i).toString(16); |
|||
o += n.length < 2 ? '0' + n : n; |
|||
} |
|||
|
|||
return "0x" + o; |
|||
} |
|||
|
|||
String.prototype.dec = function() { |
|||
return bigInt(this.substr(0)).toString() |
|||
} |
|||
|
|||
String.prototype.hex = function() { |
|||
return bigInt(this.substr(0)).toHex() |
|||
} |
|||
|
|||
|
|||
@ -1,24 +0,0 @@ |
|||
[ |
|||
{ "method": "procedures", "params": null, "order": [], "returns": [] }, |
|||
{ "method": "coinbase", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "isListening", "params": null, "order": [], "returns" : false }, |
|||
{ "method": "isMining", "params": null, "order": [], "returns" : false }, |
|||
{ "method": "gasPrice", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "key", "params": null, "order": [], "returns" : "" }, |
|||
{ "method": "keys", "params": null, "order": [], "returns" : [] }, |
|||
{ "method": "peerCount", "params": null, "order": [], "returns" : 0 }, |
|||
{ "method": "balanceAt", "params": { "a": "" }, "order": ["a"], "returns" : "" }, |
|||
{ "method": "storageAt", "params": { "a": "", "x": "" }, "order": ["a", "x"], "returns" : "" }, |
|||
{ "method": "txCountAt", "params": { "a": "" },"order": ["a"], "returns" : "" }, |
|||
{ "method": "isContractAt", "params": { "a": "" }, "order": ["a"], "returns" : false }, |
|||
{ "method": "create", "params": { "sec": "", "xEndowment": "", "bCode": "", "xGas": "", "xGasPrice": "" }, "order": ["sec", "xEndowment", "bCode", "xGas", "xGasPrice"] , "returns": "" }, |
|||
{ "method": "transact", "params": { "sec": "", "xValue": "", "aDest": "", "bData": "", "xGas": "", "xGasPrice": "" }, "order": ["sec", "xValue", "aDest", "bData", "xGas", "xGasPrice"], "returns": {} }, |
|||
{ "method": "secretToAddress", "params": { "a": "" }, "order": ["a"], "returns" : "" }, |
|||
{ "method": "lll", "params": { "s": "" }, "order": ["s"], "returns" : "" } |
|||
, |
|||
{ "method": "check", "params": { "a": [] }, "order": ["a"], "returns" : [] }, |
|||
{ "method": "lastBlock", "params": null, "order": [], "returns": {}}, |
|||
{ "method": "block", "params": {"a":""}, "order": ["a"], "returns": {}} |
|||
] |
|||
|
|||
|
|||
@ -0,0 +1,190 @@ |
|||
/*
|
|||
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 Account.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcore/RLP.h> |
|||
#include <libdevcrypto/TrieDB.h> |
|||
#include <libdevcrypto/SHA3.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
/**
|
|||
* Models the state of a single Ethereum account. |
|||
* Used to cache a portion of the full Ethereum state. State keeps a mapping of Address's to Accounts. |
|||
* |
|||
* Aside from storing the nonce and balance, the account may also be "dead" (where isAlive() returns false). |
|||
* This allows State to explicitly store the notion of a deleted account in it's cache. kill() can be used |
|||
* for this. |
|||
* |
|||
* For the account's storage, the class operates a cache. baseRoot() specifies the base state of the storage |
|||
* given as the Trie root to be looked up in the state database. Alterations beyond this base are specified |
|||
* in the overlay, stored in this class and retrieved with storageOverlay(). setStorage allows the overlay |
|||
* to be altered. |
|||
* |
|||
* The code handling explicitly supports a two-stage commit model needed for contract-creation. When creating |
|||
* a contract (running the initialisation code), the code of the account is considered empty. The attribute |
|||
* of emptiness can be retrieved with codeBearing(). After initialisation one must set the code accordingly; |
|||
* the code of the Account can be set with setCode(). To validate a setCode() call, this class records the |
|||
* state of being in contract-creation (and thus in a state where setCode may validly be called). It can be |
|||
* determined through isFreshCode(). |
|||
* |
|||
* The code can be retrieved through code(), and its hash through codeHash(). codeHash() is only valid when |
|||
* the account is not in the contract-creation phase (i.e. when isFreshCode() returns false). This class |
|||
* supports populating code on-demand from the state database. To determine if the code has been prepopulated |
|||
* call codeCacheValid(). To populate the code, look it up with codeHash() and populate with noteCode(). |
|||
* |
|||
* @todo: need to make a noteCodeCommitted(). |
|||
* |
|||
* The constructor allows you to create an one of a number of "types" of accounts. The default constructor |
|||
* makes a dead account (this is ignored by State when writing out the Trie). Another three allow a basic |
|||
* or contract account to be specified along with an initial balance. The fina two allow either a basic or |
|||
* a contract account to be created with arbitrary values. |
|||
*/ |
|||
class Account |
|||
{ |
|||
public: |
|||
/// Type of account to create.
|
|||
enum NewAccountType |
|||
{ |
|||
/// Normal account.
|
|||
NormalCreation, |
|||
/// Contract account - we place this object into the contract-creation state (and as such we
|
|||
/// expect setCode(), but codeHash() won't work).
|
|||
ContractConception |
|||
}; |
|||
|
|||
/// Construct a dead Account.
|
|||
Account() {} |
|||
|
|||
/// Construct an alive Account, with given endowment, for either a normal (non-contract) account or for a
|
|||
/// contract account in the
|
|||
/// conception phase, where the code is not yet known.
|
|||
Account(u256 _balance, NewAccountType _t): m_isAlive(true), m_balance(_balance), m_codeHash(_t == NormalCreation ? EmptySHA3 : c_contractConceptionCodeHash) {} |
|||
/// Explicit constructor for wierd cases of construction of a normal account.
|
|||
Account(u256 _nonce, u256 _balance): m_isAlive(true), m_nonce(_nonce), m_balance(_balance) {} |
|||
|
|||
/// Explicit constructor for wierd cases of construction or a contract account.
|
|||
Account(u256 _nonce, u256 _balance, h256 _contractRoot, h256 _codeHash): m_isAlive(true), m_nonce(_nonce), m_balance(_balance), m_storageRoot(_contractRoot), m_codeHash(_codeHash) { assert(_contractRoot); } |
|||
|
|||
|
|||
/// Kill this account. Useful for the suicide opcode. Following this call, isAlive() returns false.
|
|||
void kill() { m_isAlive = false; m_storageOverlay.clear(); m_codeHash = EmptySHA3; m_storageRoot = EmptyTrie; m_balance = 0; m_nonce = 0; } |
|||
|
|||
/// @returns true iff this object represents an account in the state. Returns false if this object
|
|||
/// represents an account that should no longer exist in the trie (an account that never existed or was
|
|||
/// suicided).
|
|||
bool isAlive() const { return m_isAlive; } |
|||
|
|||
|
|||
/// @returns the balance of this account. Can be altered in place.
|
|||
u256& balance() { return m_balance; } |
|||
|
|||
/// @returns the balance of this account.
|
|||
u256 const& balance() const { return m_balance; } |
|||
|
|||
/// Increments the balance of this account by the given amount. It's a bigint, so can be negative.
|
|||
void addBalance(bigint _i) { m_balance = (u256)((bigint)m_balance + _i); } |
|||
|
|||
/// @returns the nonce of the account. Can be altered in place.
|
|||
u256& nonce() { return m_nonce; } |
|||
|
|||
/// @returns the nonce of the account.
|
|||
u256 const& nonce() const { return m_nonce; } |
|||
|
|||
/// Increment the nonce of the account by one.
|
|||
void incNonce() { m_nonce++; } |
|||
|
|||
|
|||
/// @returns the root of the trie (whose nodes are stored in the state db externally to this class)
|
|||
/// which encodes the base-state of the account's storage (upon which the storage is overlaid).
|
|||
h256 baseRoot() const { assert(m_storageRoot); return m_storageRoot; } |
|||
|
|||
/// @returns the storage overlay as a simple map.
|
|||
std::map<u256, u256> const& storageOverlay() const { return m_storageOverlay; } |
|||
|
|||
/// Set a key/value pair in the account's storage. This actually goes into the overlay, for committing
|
|||
/// to the trie later.
|
|||
void setStorage(u256 _p, u256 _v) { m_storageOverlay[_p] = _v; } |
|||
|
|||
/// @returns true if we are in the contract-conception state and setCode is valid to call.
|
|||
bool isFreshCode() const { return m_codeHash == c_contractConceptionCodeHash; } |
|||
|
|||
/// @returns true if we are either in the contract-conception state or if the account's code is not
|
|||
/// empty.
|
|||
bool codeBearing() const { return m_codeHash != EmptySHA3; } |
|||
|
|||
/// @returns the hash of the account's code. Must only be called when isFreshCode() returns false.
|
|||
h256 codeHash() const { assert(!isFreshCode()); return m_codeHash; } |
|||
|
|||
/// Sets the code of the account. Must only be called when isFreshCode() returns true.
|
|||
void setCode(bytesConstRef _code) { assert(isFreshCode()); m_codeCache = _code.toBytes(); } |
|||
|
|||
/// @returns true if the account's code is available through code().
|
|||
bool codeCacheValid() const { return m_codeHash == EmptySHA3 || m_codeHash == c_contractConceptionCodeHash || m_codeCache.size(); } |
|||
|
|||
/// Specify to the object what the actual code is for the account. @a _code must have a SHA3 equal to
|
|||
/// codeHash() and must only be called when isFreshCode() returns false.
|
|||
void noteCode(bytesConstRef _code) { assert(sha3(_code) == m_codeHash); m_codeCache = _code.toBytes(); } |
|||
|
|||
/// @returns the account's code. Must only be called when codeCacheValid returns true.
|
|||
bytes const& code() const { assert(codeCacheValid()); return m_codeCache; } |
|||
|
|||
private: |
|||
/// Is this account existant? If not, it represents a deleted account.
|
|||
bool m_isAlive = false; |
|||
|
|||
/// Account's nonce.
|
|||
u256 m_nonce = 0; |
|||
|
|||
/// Account's balance.
|
|||
u256 m_balance = 0; |
|||
|
|||
/// The base storage root. Used with the state DB to give a base to the storage. m_storageOverlay is
|
|||
/// overlaid on this and takes precedence for all values set.
|
|||
h256 m_storageRoot = EmptyTrie; |
|||
|
|||
/** If c_contractConceptionCodeHash then we're in the limbo where we're running the initialisation code.
|
|||
* We expect a setCode() at some point later. |
|||
* If EmptySHA3, then m_code, which should be empty, is valid. |
|||
* If anything else, then m_code is valid iff it's not empty, otherwise, State::ensureCached() needs to |
|||
* be called with the correct args. |
|||
*/ |
|||
h256 m_codeHash = EmptySHA3; |
|||
|
|||
/// The map with is overlaid onto whatever storage is implied by the m_storageRoot in the trie.
|
|||
std::map<u256, u256> m_storageOverlay; |
|||
|
|||
/// The associated code for this account. The SHA3 of this should be equal to m_codeHash unless m_codeHash
|
|||
/// equals c_contractConceptionCodeHash.
|
|||
bytes m_codeCache; |
|||
|
|||
/// Value for m_codeHash when this account is having its code determined.
|
|||
static const h256 c_contractConceptionCodeHash; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
|
|||
@ -1,94 +0,0 @@ |
|||
/*
|
|||
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 AddressState.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcore/RLP.h> |
|||
#include <libdevcrypto/TrieDB.h> |
|||
#include <libdevcrypto/SHA3.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
// TODO: Document fully.
|
|||
|
|||
class AddressState |
|||
{ |
|||
public: |
|||
enum NewAccountType { NormalCreation, ContractConception }; |
|||
|
|||
/// Construct a dead AddressState.
|
|||
AddressState() {} |
|||
/// Construct an alive AddressState, with given endowment, for either a normal (non-contract) account or for a contract account in the
|
|||
/// conception phase, where the code is not yet known.
|
|||
AddressState(u256 _balance, NewAccountType _t): m_isAlive(true), m_balance(_balance), m_codeHash(_t == NormalCreation ? h256() : EmptySHA3) {} |
|||
/// Explicit constructor for wierd cases of construction of a normal account.
|
|||
AddressState(u256 _nonce, u256 _balance): m_isAlive(true), m_nonce(_nonce), m_balance(_balance) {} |
|||
/// Explicit constructor for wierd cases of construction or a contract account.
|
|||
AddressState(u256 _nonce, u256 _balance, h256 _contractRoot, h256 _codeHash): m_isAlive(true), m_nonce(_nonce), m_balance(_balance), m_storageRoot(_contractRoot), m_codeHash(_codeHash) {} |
|||
|
|||
void kill() { m_isAlive = false; m_storageOverlay.clear(); m_codeHash = EmptySHA3; m_storageRoot = EmptyTrie; m_balance = 0; m_nonce = 0; } |
|||
bool isAlive() const { return m_isAlive; } |
|||
|
|||
u256& balance() { return m_balance; } |
|||
u256 const& balance() const { return m_balance; } |
|||
void addBalance(bigint _i) { m_balance = (u256)((bigint)m_balance + _i); } |
|||
|
|||
u256& nonce() { return m_nonce; } |
|||
u256 const& nonce() const { return m_nonce; } |
|||
void incNonce() { m_nonce++; } |
|||
|
|||
h256 baseRoot() const { return m_storageRoot; } |
|||
std::map<u256, u256> const& storage() const { return m_storageOverlay; } |
|||
void setStorage(u256 _p, u256 _v) { m_storageOverlay[_p] = _v; } |
|||
|
|||
bool isFreshCode() const { return !m_codeHash; } |
|||
bool codeBearing() const { return m_codeHash != EmptySHA3; } |
|||
bool codeCacheValid() const { return m_codeHash == EmptySHA3 || !m_codeHash || m_codeCache.size(); } |
|||
h256 codeHash() const { assert(m_codeHash); return m_codeHash; } |
|||
bytes const& code() const { assert(m_codeHash == EmptySHA3 || !m_codeHash || m_codeCache.size()); return m_codeCache; } |
|||
void setCode(bytesConstRef _code) { assert(!m_codeHash); m_codeCache = _code.toBytes(); } |
|||
void noteCode(bytesConstRef _code) { assert(sha3(_code) == m_codeHash); m_codeCache = _code.toBytes(); } |
|||
|
|||
private: |
|||
bool m_isAlive = false; |
|||
u256 m_nonce = 0; |
|||
u256 m_balance = 0; |
|||
|
|||
/// The base storage root. Used with the state DB to give a base to the storage. m_storageOverlay is overlaid on this and takes precedence for all values set.
|
|||
h256 m_storageRoot = EmptyTrie; |
|||
|
|||
/// If 0 then we're in the limbo where we're running the initialisation code. We expect a setCode() at some point later.
|
|||
/// If EmptySHA3, then m_code, which should be empty, is valid.
|
|||
/// If anything else, then m_code is valid iff it's not empty, otherwise, State::ensureCached() needs to be called with the correct args.
|
|||
h256 m_codeHash = EmptySHA3; |
|||
|
|||
// TODO: change to unordered_map.
|
|||
std::map<u256, u256> m_storageOverlay; |
|||
bytes m_codeCache; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,24 @@ |
|||
cmake_policy(SET CMP0015 NEW) |
|||
|
|||
# Find Qt5 for Apple and update src_list for windows |
|||
if (APPLE) |
|||
# homebrew defaults to qt4 and installs qt5 as 'keg-only' |
|||
# which places it into /usr/local/opt insteadof /usr/local. |
|||
|
|||
set(CMAKE_PREFIX_PATH /usr/local/opt/qt5) |
|||
include_directories(/usr/local/opt/qt5/include /usr/local/include) |
|||
elseif ("${TARGET_PLATFORM}" STREQUAL "w64") |
|||
set(SRC_LIST ${SRC_LIST} ../windows/qt_plugin_import.cpp) |
|||
elseif (UNIX) |
|||
set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ";$ENV{QTDIR}/lib/cmake") |
|||
endif () |
|||
|
|||
find_package(Qt5Core) |
|||
|
|||
set(CMAKE_AUTOMOC OFF) |
|||
|
|||
qt5_add_resources(JSQRC js.qrc) |
|||
add_library(jsqrc STATIC ${JSQRC}) |
|||
qt5_use_modules(jsqrc Core) |
|||
|
|||
install( TARGETS jsqrc ARCHIVE DESTINATION lib LIBRARY DESTINATION lib ) |
|||
@ -0,0 +1,966 @@ |
|||
/*! |
|||
* @overview es6-promise - a tiny implementation of Promises/A+. |
|||
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald) |
|||
* @license Licensed under MIT license |
|||
* See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
|
|||
* @version 2.0.0 |
|||
*/ |
|||
|
|||
(function() { |
|||
"use strict"; |
|||
|
|||
function $$utils$$objectOrFunction(x) { |
|||
return typeof x === 'function' || (typeof x === 'object' && x !== null); |
|||
} |
|||
|
|||
function $$utils$$isFunction(x) { |
|||
return typeof x === 'function'; |
|||
} |
|||
|
|||
function $$utils$$isMaybeThenable(x) { |
|||
return typeof x === 'object' && x !== null; |
|||
} |
|||
|
|||
var $$utils$$_isArray; |
|||
|
|||
if (!Array.isArray) { |
|||
$$utils$$_isArray = function (x) { |
|||
return Object.prototype.toString.call(x) === '[object Array]'; |
|||
}; |
|||
} else { |
|||
$$utils$$_isArray = Array.isArray; |
|||
} |
|||
|
|||
var $$utils$$isArray = $$utils$$_isArray; |
|||
var $$utils$$now = Date.now || function() { return new Date().getTime(); }; |
|||
function $$utils$$F() { } |
|||
|
|||
var $$utils$$o_create = (Object.create || function (o) { |
|||
if (arguments.length > 1) { |
|||
throw new Error('Second argument not supported'); |
|||
} |
|||
if (typeof o !== 'object') { |
|||
throw new TypeError('Argument must be an object'); |
|||
} |
|||
$$utils$$F.prototype = o; |
|||
return new $$utils$$F(); |
|||
}); |
|||
|
|||
var $$asap$$len = 0; |
|||
|
|||
var $$asap$$default = function asap(callback, arg) { |
|||
$$asap$$queue[$$asap$$len] = callback; |
|||
$$asap$$queue[$$asap$$len + 1] = arg; |
|||
$$asap$$len += 2; |
|||
if ($$asap$$len === 2) { |
|||
// If len is 1, that means that we need to schedule an async flush.
|
|||
// If additional callbacks are queued before the queue is flushed, they
|
|||
// will be processed by this flush that we are scheduling.
|
|||
$$asap$$scheduleFlush(); |
|||
} |
|||
}; |
|||
|
|||
var $$asap$$browserGlobal = (typeof window !== 'undefined') ? window : {}; |
|||
var $$asap$$BrowserMutationObserver = $$asap$$browserGlobal.MutationObserver || $$asap$$browserGlobal.WebKitMutationObserver; |
|||
|
|||
// test for web worker but not in IE10
|
|||
var $$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' && |
|||
typeof importScripts !== 'undefined' && |
|||
typeof MessageChannel !== 'undefined'; |
|||
|
|||
// node
|
|||
function $$asap$$useNextTick() { |
|||
return function() { |
|||
process.nextTick($$asap$$flush); |
|||
}; |
|||
} |
|||
|
|||
function $$asap$$useMutationObserver() { |
|||
var iterations = 0; |
|||
var observer = new $$asap$$BrowserMutationObserver($$asap$$flush); |
|||
var node = document.createTextNode(''); |
|||
observer.observe(node, { characterData: true }); |
|||
|
|||
return function() { |
|||
node.data = (iterations = ++iterations % 2); |
|||
}; |
|||
} |
|||
|
|||
// web worker
|
|||
function $$asap$$useMessageChannel() { |
|||
var channel = new MessageChannel(); |
|||
channel.port1.onmessage = $$asap$$flush; |
|||
return function () { |
|||
channel.port2.postMessage(0); |
|||
}; |
|||
} |
|||
|
|||
function $$asap$$useSetTimeout() { |
|||
return function() { |
|||
setTimeout($$asap$$flush, 1); |
|||
}; |
|||
} |
|||
|
|||
var $$asap$$queue = new Array(1000); |
|||
|
|||
function $$asap$$flush() { |
|||
for (var i = 0; i < $$asap$$len; i+=2) { |
|||
var callback = $$asap$$queue[i]; |
|||
var arg = $$asap$$queue[i+1]; |
|||
|
|||
callback(arg); |
|||
|
|||
$$asap$$queue[i] = undefined; |
|||
$$asap$$queue[i+1] = undefined; |
|||
} |
|||
|
|||
$$asap$$len = 0; |
|||
} |
|||
|
|||
var $$asap$$scheduleFlush; |
|||
|
|||
// Decide what async method to use to triggering processing of queued callbacks:
|
|||
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') { |
|||
$$asap$$scheduleFlush = $$asap$$useNextTick(); |
|||
} else if ($$asap$$BrowserMutationObserver) { |
|||
$$asap$$scheduleFlush = $$asap$$useMutationObserver(); |
|||
} else if ($$asap$$isWorker) { |
|||
$$asap$$scheduleFlush = $$asap$$useMessageChannel(); |
|||
} else { |
|||
$$asap$$scheduleFlush = $$asap$$useSetTimeout(); |
|||
} |
|||
|
|||
function $$$internal$$noop() {} |
|||
var $$$internal$$PENDING = void 0; |
|||
var $$$internal$$FULFILLED = 1; |
|||
var $$$internal$$REJECTED = 2; |
|||
var $$$internal$$GET_THEN_ERROR = new $$$internal$$ErrorObject(); |
|||
|
|||
function $$$internal$$selfFullfillment() { |
|||
return new TypeError("You cannot resolve a promise with itself"); |
|||
} |
|||
|
|||
function $$$internal$$cannotReturnOwn() { |
|||
return new TypeError('A promises callback cannot return that same promise.') |
|||
} |
|||
|
|||
function $$$internal$$getThen(promise) { |
|||
try { |
|||
return promise.then; |
|||
} catch(error) { |
|||
$$$internal$$GET_THEN_ERROR.error = error; |
|||
return $$$internal$$GET_THEN_ERROR; |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) { |
|||
try { |
|||
then.call(value, fulfillmentHandler, rejectionHandler); |
|||
} catch(e) { |
|||
return e; |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$handleForeignThenable(promise, thenable, then) { |
|||
$$asap$$default(function(promise) { |
|||
var sealed = false; |
|||
var error = $$$internal$$tryThen(then, thenable, function(value) { |
|||
if (sealed) { return; } |
|||
sealed = true; |
|||
if (thenable !== value) { |
|||
$$$internal$$resolve(promise, value); |
|||
} else { |
|||
$$$internal$$fulfill(promise, value); |
|||
} |
|||
}, function(reason) { |
|||
if (sealed) { return; } |
|||
sealed = true; |
|||
|
|||
$$$internal$$reject(promise, reason); |
|||
}, 'Settle: ' + (promise._label || ' unknown promise')); |
|||
|
|||
if (!sealed && error) { |
|||
sealed = true; |
|||
$$$internal$$reject(promise, error); |
|||
} |
|||
}, promise); |
|||
} |
|||
|
|||
function $$$internal$$handleOwnThenable(promise, thenable) { |
|||
if (thenable._state === $$$internal$$FULFILLED) { |
|||
$$$internal$$fulfill(promise, thenable._result); |
|||
} else if (promise._state === $$$internal$$REJECTED) { |
|||
$$$internal$$reject(promise, thenable._result); |
|||
} else { |
|||
$$$internal$$subscribe(thenable, undefined, function(value) { |
|||
$$$internal$$resolve(promise, value); |
|||
}, function(reason) { |
|||
$$$internal$$reject(promise, reason); |
|||
}); |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$handleMaybeThenable(promise, maybeThenable) { |
|||
if (maybeThenable.constructor === promise.constructor) { |
|||
$$$internal$$handleOwnThenable(promise, maybeThenable); |
|||
} else { |
|||
var then = $$$internal$$getThen(maybeThenable); |
|||
|
|||
if (then === $$$internal$$GET_THEN_ERROR) { |
|||
$$$internal$$reject(promise, $$$internal$$GET_THEN_ERROR.error); |
|||
} else if (then === undefined) { |
|||
$$$internal$$fulfill(promise, maybeThenable); |
|||
} else if ($$utils$$isFunction(then)) { |
|||
$$$internal$$handleForeignThenable(promise, maybeThenable, then); |
|||
} else { |
|||
$$$internal$$fulfill(promise, maybeThenable); |
|||
} |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$resolve(promise, value) { |
|||
if (promise === value) { |
|||
$$$internal$$reject(promise, $$$internal$$selfFullfillment()); |
|||
} else if ($$utils$$objectOrFunction(value)) { |
|||
$$$internal$$handleMaybeThenable(promise, value); |
|||
} else { |
|||
$$$internal$$fulfill(promise, value); |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$publishRejection(promise) { |
|||
if (promise._onerror) { |
|||
promise._onerror(promise._result); |
|||
} |
|||
|
|||
$$$internal$$publish(promise); |
|||
} |
|||
|
|||
function $$$internal$$fulfill(promise, value) { |
|||
if (promise._state !== $$$internal$$PENDING) { return; } |
|||
|
|||
promise._result = value; |
|||
promise._state = $$$internal$$FULFILLED; |
|||
|
|||
if (promise._subscribers.length === 0) { |
|||
} else { |
|||
$$asap$$default($$$internal$$publish, promise); |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$reject(promise, reason) { |
|||
if (promise._state !== $$$internal$$PENDING) { return; } |
|||
promise._state = $$$internal$$REJECTED; |
|||
promise._result = reason; |
|||
|
|||
$$asap$$default($$$internal$$publishRejection, promise); |
|||
} |
|||
|
|||
function $$$internal$$subscribe(parent, child, onFulfillment, onRejection) { |
|||
var subscribers = parent._subscribers; |
|||
var length = subscribers.length; |
|||
|
|||
parent._onerror = null; |
|||
|
|||
subscribers[length] = child; |
|||
subscribers[length + $$$internal$$FULFILLED] = onFulfillment; |
|||
subscribers[length + $$$internal$$REJECTED] = onRejection; |
|||
|
|||
if (length === 0 && parent._state) { |
|||
$$asap$$default($$$internal$$publish, parent); |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$publish(promise) { |
|||
var subscribers = promise._subscribers; |
|||
var settled = promise._state; |
|||
|
|||
if (subscribers.length === 0) { return; } |
|||
|
|||
var child, callback, detail = promise._result; |
|||
|
|||
for (var i = 0; i < subscribers.length; i += 3) { |
|||
child = subscribers[i]; |
|||
callback = subscribers[i + settled]; |
|||
|
|||
if (child) { |
|||
$$$internal$$invokeCallback(settled, child, callback, detail); |
|||
} else { |
|||
callback(detail); |
|||
} |
|||
} |
|||
|
|||
promise._subscribers.length = 0; |
|||
} |
|||
|
|||
function $$$internal$$ErrorObject() { |
|||
this.error = null; |
|||
} |
|||
|
|||
var $$$internal$$TRY_CATCH_ERROR = new $$$internal$$ErrorObject(); |
|||
|
|||
function $$$internal$$tryCatch(callback, detail) { |
|||
try { |
|||
return callback(detail); |
|||
} catch(e) { |
|||
$$$internal$$TRY_CATCH_ERROR.error = e; |
|||
return $$$internal$$TRY_CATCH_ERROR; |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$invokeCallback(settled, promise, callback, detail) { |
|||
var hasCallback = $$utils$$isFunction(callback), |
|||
value, error, succeeded, failed; |
|||
|
|||
if (hasCallback) { |
|||
value = $$$internal$$tryCatch(callback, detail); |
|||
|
|||
if (value === $$$internal$$TRY_CATCH_ERROR) { |
|||
failed = true; |
|||
error = value.error; |
|||
value = null; |
|||
} else { |
|||
succeeded = true; |
|||
} |
|||
|
|||
if (promise === value) { |
|||
$$$internal$$reject(promise, $$$internal$$cannotReturnOwn()); |
|||
return; |
|||
} |
|||
|
|||
} else { |
|||
value = detail; |
|||
succeeded = true; |
|||
} |
|||
|
|||
if (promise._state !== $$$internal$$PENDING) { |
|||
// noop
|
|||
} else if (hasCallback && succeeded) { |
|||
$$$internal$$resolve(promise, value); |
|||
} else if (failed) { |
|||
$$$internal$$reject(promise, error); |
|||
} else if (settled === $$$internal$$FULFILLED) { |
|||
$$$internal$$fulfill(promise, value); |
|||
} else if (settled === $$$internal$$REJECTED) { |
|||
$$$internal$$reject(promise, value); |
|||
} |
|||
} |
|||
|
|||
function $$$internal$$initializePromise(promise, resolver) { |
|||
try { |
|||
resolver(function resolvePromise(value){ |
|||
$$$internal$$resolve(promise, value); |
|||
}, function rejectPromise(reason) { |
|||
$$$internal$$reject(promise, reason); |
|||
}); |
|||
} catch(e) { |
|||
$$$internal$$reject(promise, e); |
|||
} |
|||
} |
|||
|
|||
function $$$enumerator$$makeSettledResult(state, position, value) { |
|||
if (state === $$$internal$$FULFILLED) { |
|||
return { |
|||
state: 'fulfilled', |
|||
value: value |
|||
}; |
|||
} else { |
|||
return { |
|||
state: 'rejected', |
|||
reason: value |
|||
}; |
|||
} |
|||
} |
|||
|
|||
function $$$enumerator$$Enumerator(Constructor, input, abortOnReject, label) { |
|||
this._instanceConstructor = Constructor; |
|||
this.promise = new Constructor($$$internal$$noop, label); |
|||
this._abortOnReject = abortOnReject; |
|||
|
|||
if (this._validateInput(input)) { |
|||
this._input = input; |
|||
this.length = input.length; |
|||
this._remaining = input.length; |
|||
|
|||
this._init(); |
|||
|
|||
if (this.length === 0) { |
|||
$$$internal$$fulfill(this.promise, this._result); |
|||
} else { |
|||
this.length = this.length || 0; |
|||
this._enumerate(); |
|||
if (this._remaining === 0) { |
|||
$$$internal$$fulfill(this.promise, this._result); |
|||
} |
|||
} |
|||
} else { |
|||
$$$internal$$reject(this.promise, this._validationError()); |
|||
} |
|||
} |
|||
|
|||
$$$enumerator$$Enumerator.prototype._validateInput = function(input) { |
|||
return $$utils$$isArray(input); |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._validationError = function() { |
|||
return new Error('Array Methods must be provided an Array'); |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._init = function() { |
|||
this._result = new Array(this.length); |
|||
}; |
|||
|
|||
var $$$enumerator$$default = $$$enumerator$$Enumerator; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._enumerate = function() { |
|||
var length = this.length; |
|||
var promise = this.promise; |
|||
var input = this._input; |
|||
|
|||
for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) { |
|||
this._eachEntry(input[i], i); |
|||
} |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) { |
|||
var c = this._instanceConstructor; |
|||
if ($$utils$$isMaybeThenable(entry)) { |
|||
if (entry.constructor === c && entry._state !== $$$internal$$PENDING) { |
|||
entry._onerror = null; |
|||
this._settledAt(entry._state, i, entry._result); |
|||
} else { |
|||
this._willSettleAt(c.resolve(entry), i); |
|||
} |
|||
} else { |
|||
this._remaining--; |
|||
this._result[i] = this._makeResult($$$internal$$FULFILLED, i, entry); |
|||
} |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) { |
|||
var promise = this.promise; |
|||
|
|||
if (promise._state === $$$internal$$PENDING) { |
|||
this._remaining--; |
|||
|
|||
if (this._abortOnReject && state === $$$internal$$REJECTED) { |
|||
$$$internal$$reject(promise, value); |
|||
} else { |
|||
this._result[i] = this._makeResult(state, i, value); |
|||
} |
|||
} |
|||
|
|||
if (this._remaining === 0) { |
|||
$$$internal$$fulfill(promise, this._result); |
|||
} |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._makeResult = function(state, i, value) { |
|||
return value; |
|||
}; |
|||
|
|||
$$$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) { |
|||
var enumerator = this; |
|||
|
|||
$$$internal$$subscribe(promise, undefined, function(value) { |
|||
enumerator._settledAt($$$internal$$FULFILLED, i, value); |
|||
}, function(reason) { |
|||
enumerator._settledAt($$$internal$$REJECTED, i, reason); |
|||
}); |
|||
}; |
|||
|
|||
var $$promise$all$$default = function all(entries, label) { |
|||
return new $$$enumerator$$default(this, entries, true /* abort on reject */, label).promise; |
|||
}; |
|||
|
|||
var $$promise$race$$default = function race(entries, label) { |
|||
/*jshint validthis:true */ |
|||
var Constructor = this; |
|||
|
|||
var promise = new Constructor($$$internal$$noop, label); |
|||
|
|||
if (!$$utils$$isArray(entries)) { |
|||
$$$internal$$reject(promise, new TypeError('You must pass an array to race.')); |
|||
return promise; |
|||
} |
|||
|
|||
var length = entries.length; |
|||
|
|||
function onFulfillment(value) { |
|||
$$$internal$$resolve(promise, value); |
|||
} |
|||
|
|||
function onRejection(reason) { |
|||
$$$internal$$reject(promise, reason); |
|||
} |
|||
|
|||
for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) { |
|||
$$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection); |
|||
} |
|||
|
|||
return promise; |
|||
}; |
|||
|
|||
var $$promise$resolve$$default = function resolve(object, label) { |
|||
/*jshint validthis:true */ |
|||
var Constructor = this; |
|||
|
|||
if (object && typeof object === 'object' && object.constructor === Constructor) { |
|||
return object; |
|||
} |
|||
|
|||
var promise = new Constructor($$$internal$$noop, label); |
|||
$$$internal$$resolve(promise, object); |
|||
return promise; |
|||
}; |
|||
|
|||
var $$promise$reject$$default = function reject(reason, label) { |
|||
/*jshint validthis:true */ |
|||
var Constructor = this; |
|||
var promise = new Constructor($$$internal$$noop, label); |
|||
$$$internal$$reject(promise, reason); |
|||
return promise; |
|||
}; |
|||
|
|||
var $$es6$promise$promise$$counter = 0; |
|||
|
|||
function $$es6$promise$promise$$needsResolver() { |
|||
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); |
|||
} |
|||
|
|||
function $$es6$promise$promise$$needsNew() { |
|||
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); |
|||
} |
|||
|
|||
var $$es6$promise$promise$$default = $$es6$promise$promise$$Promise; |
|||
|
|||
/** |
|||
Promise objects represent the eventual result of an asynchronous operation. The |
|||
primary way of interacting with a promise is through its `then` method, which |
|||
registers callbacks to receive either a promise’s eventual value or the reason |
|||
why the promise cannot be fulfilled. |
|||
|
|||
Terminology |
|||
----------- |
|||
|
|||
- `promise` is an object or function with a `then` method whose behavior conforms to this specification. |
|||
- `thenable` is an object or function that defines a `then` method. |
|||
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise). |
|||
- `exception` is a value that is thrown using the throw statement. |
|||
- `reason` is a value that indicates why a promise was rejected. |
|||
- `settled` the final resting state of a promise, fulfilled or rejected. |
|||
|
|||
A promise can be in one of three states: pending, fulfilled, or rejected. |
|||
|
|||
Promises that are fulfilled have a fulfillment value and are in the fulfilled |
|||
state. Promises that are rejected have a rejection reason and are in the |
|||
rejected state. A fulfillment value is never a thenable. |
|||
|
|||
Promises can also be said to *resolve* a value. If this value is also a |
|||
promise, then the original promise's settled state will match the value's |
|||
settled state. So a promise that *resolves* a promise that rejects will |
|||
itself reject, and a promise that *resolves* a promise that fulfills will |
|||
itself fulfill. |
|||
|
|||
|
|||
Basic Usage: |
|||
------------ |
|||
|
|||
```js
|
|||
var promise = new Promise(function(resolve, reject) { |
|||
// on success
|
|||
resolve(value); |
|||
|
|||
// on failure
|
|||
reject(reason); |
|||
}); |
|||
|
|||
promise.then(function(value) { |
|||
// on fulfillment
|
|||
}, function(reason) { |
|||
// on rejection
|
|||
}); |
|||
``` |
|||
|
|||
Advanced Usage: |
|||
--------------- |
|||
|
|||
Promises shine when abstracting away asynchronous interactions such as |
|||
`XMLHttpRequest`s. |
|||
|
|||
```js
|
|||
function getJSON(url) { |
|||
return new Promise(function(resolve, reject){ |
|||
var xhr = new XMLHttpRequest(); |
|||
|
|||
xhr.open('GET', url); |
|||
xhr.onreadystatechange = handler; |
|||
xhr.responseType = 'json'; |
|||
xhr.setRequestHeader('Accept', 'application/json'); |
|||
xhr.send(); |
|||
|
|||
function handler() { |
|||
if (this.readyState === this.DONE) { |
|||
if (this.status === 200) { |
|||
resolve(this.response); |
|||
} else { |
|||
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); |
|||
} |
|||
} |
|||
}; |
|||
}); |
|||
} |
|||
|
|||
getJSON('/posts.json').then(function(json) { |
|||
// on fulfillment
|
|||
}, function(reason) { |
|||
// on rejection
|
|||
}); |
|||
``` |
|||
|
|||
Unlike callbacks, promises are great composable primitives. |
|||
|
|||
```js
|
|||
Promise.all([ |
|||
getJSON('/posts'), |
|||
getJSON('/comments') |
|||
]).then(function(values){ |
|||
values[0] // => postsJSON
|
|||
values[1] // => commentsJSON
|
|||
|
|||
return values; |
|||
}); |
|||
``` |
|||
|
|||
@class Promise |
|||
@param {function} resolver |
|||
@param {String} label optional string for labeling the promise. |
|||
Useful for tooling. |
|||
@constructor |
|||
*/ |
|||
function $$es6$promise$promise$$Promise(resolver, label) { |
|||
this._id = $$es6$promise$promise$$counter++; |
|||
this._label = label; |
|||
this._state = undefined; |
|||
this._result = undefined; |
|||
this._subscribers = []; |
|||
|
|||
if ($$$internal$$noop !== resolver) { |
|||
if (!$$utils$$isFunction(resolver)) { |
|||
$$es6$promise$promise$$needsResolver(); |
|||
} |
|||
|
|||
if (!(this instanceof $$es6$promise$promise$$Promise)) { |
|||
$$es6$promise$promise$$needsNew(); |
|||
} |
|||
|
|||
$$$internal$$initializePromise(this, resolver); |
|||
} |
|||
} |
|||
|
|||
$$es6$promise$promise$$Promise.all = $$promise$all$$default; |
|||
$$es6$promise$promise$$Promise.race = $$promise$race$$default; |
|||
$$es6$promise$promise$$Promise.resolve = $$promise$resolve$$default; |
|||
$$es6$promise$promise$$Promise.reject = $$promise$reject$$default; |
|||
|
|||
$$es6$promise$promise$$Promise.prototype = { |
|||
constructor: $$es6$promise$promise$$Promise, |
|||
|
|||
/** |
|||
The primary way of interacting with a promise is through its `then` method, |
|||
which registers callbacks to receive either a promise's eventual value or the |
|||
reason why the promise cannot be fulfilled. |
|||
|
|||
```js
|
|||
findUser().then(function(user){ |
|||
// user is available
|
|||
}, function(reason){ |
|||
// user is unavailable, and you are given the reason why
|
|||
}); |
|||
``` |
|||
|
|||
Chaining |
|||
-------- |
|||
|
|||
The return value of `then` is itself a promise. This second, 'downstream' |
|||
promise is resolved with the return value of the first promise's fulfillment |
|||
or rejection handler, or rejected if the handler throws an exception. |
|||
|
|||
```js
|
|||
findUser().then(function (user) { |
|||
return user.name; |
|||
}, function (reason) { |
|||
return 'default name'; |
|||
}).then(function (userName) { |
|||
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
|||
// will be `'default name'`
|
|||
}); |
|||
|
|||
findUser().then(function (user) { |
|||
throw new Error('Found user, but still unhappy'); |
|||
}, function (reason) { |
|||
throw new Error('`findUser` rejected and we're unhappy'); |
|||
}).then(function (value) { |
|||
// never reached
|
|||
}, function (reason) { |
|||
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
|||
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
|||
}); |
|||
``` |
|||
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. |
|||
|
|||
```js
|
|||
findUser().then(function (user) { |
|||
throw new PedagogicalException('Upstream error'); |
|||
}).then(function (value) { |
|||
// never reached
|
|||
}).then(function (value) { |
|||
// never reached
|
|||
}, function (reason) { |
|||
// The `PedgagocialException` is propagated all the way down to here
|
|||
}); |
|||
``` |
|||
|
|||
Assimilation |
|||
------------ |
|||
|
|||
Sometimes the value you want to propagate to a downstream promise can only be |
|||
retrieved asynchronously. This can be achieved by returning a promise in the |
|||
fulfillment or rejection handler. The downstream promise will then be pending |
|||
until the returned promise is settled. This is called *assimilation*. |
|||
|
|||
```js
|
|||
findUser().then(function (user) { |
|||
return findCommentsByAuthor(user); |
|||
}).then(function (comments) { |
|||
// The user's comments are now available
|
|||
}); |
|||
``` |
|||
|
|||
If the assimliated promise rejects, then the downstream promise will also reject. |
|||
|
|||
```js
|
|||
findUser().then(function (user) { |
|||
return findCommentsByAuthor(user); |
|||
}).then(function (comments) { |
|||
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
|||
}, function (reason) { |
|||
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
|||
}); |
|||
``` |
|||
|
|||
Simple Example |
|||
-------------- |
|||
|
|||
Synchronous Example |
|||
|
|||
```javascript
|
|||
var result; |
|||
|
|||
try { |
|||
result = findResult(); |
|||
// success
|
|||
} catch(reason) { |
|||
// failure
|
|||
} |
|||
``` |
|||
|
|||
Errback Example |
|||
|
|||
```js
|
|||
findResult(function(result, err){ |
|||
if (err) { |
|||
// failure
|
|||
} else { |
|||
// success
|
|||
} |
|||
}); |
|||
``` |
|||
|
|||
Promise Example; |
|||
|
|||
```javascript
|
|||
findResult().then(function(result){ |
|||
// success
|
|||
}, function(reason){ |
|||
// failure
|
|||
}); |
|||
``` |
|||
|
|||
Advanced Example |
|||
-------------- |
|||
|
|||
Synchronous Example |
|||
|
|||
```javascript
|
|||
var author, books; |
|||
|
|||
try { |
|||
author = findAuthor(); |
|||
books = findBooksByAuthor(author); |
|||
// success
|
|||
} catch(reason) { |
|||
// failure
|
|||
} |
|||
``` |
|||
|
|||
Errback Example |
|||
|
|||
```js
|
|||
|
|||
function foundBooks(books) { |
|||
|
|||
} |
|||
|
|||
function failure(reason) { |
|||
|
|||
} |
|||
|
|||
findAuthor(function(author, err){ |
|||
if (err) { |
|||
failure(err); |
|||
// failure
|
|||
} else { |
|||
try { |
|||
findBoooksByAuthor(author, function(books, err) { |
|||
if (err) { |
|||
failure(err); |
|||
} else { |
|||
try { |
|||
foundBooks(books); |
|||
} catch(reason) { |
|||
failure(reason); |
|||
} |
|||
} |
|||
}); |
|||
} catch(error) { |
|||
failure(err); |
|||
} |
|||
// success
|
|||
} |
|||
}); |
|||
``` |
|||
|
|||
Promise Example; |
|||
|
|||
```javascript
|
|||
findAuthor(). |
|||
then(findBooksByAuthor). |
|||
then(function(books){ |
|||
// found books
|
|||
}).catch(function(reason){ |
|||
// something went wrong
|
|||
}); |
|||
``` |
|||
|
|||
@method then |
|||
@param {Function} onFulfilled |
|||
@param {Function} onRejected |
|||
@param {String} label optional string for labeling the promise. |
|||
Useful for tooling. |
|||
@return {Promise} |
|||
*/ |
|||
then: function(onFulfillment, onRejection, label) { |
|||
var parent = this; |
|||
var state = parent._state; |
|||
|
|||
if (state === $$$internal$$FULFILLED && !onFulfillment || state === $$$internal$$REJECTED && !onRejection) { |
|||
return this; |
|||
} |
|||
|
|||
parent._onerror = null; |
|||
|
|||
var child = new this.constructor($$$internal$$noop, label); |
|||
var result = parent._result; |
|||
|
|||
if (state) { |
|||
var callback = arguments[state - 1]; |
|||
$$asap$$default(function(){ |
|||
$$$internal$$invokeCallback(state, child, callback, result); |
|||
}); |
|||
} else { |
|||
$$$internal$$subscribe(parent, child, onFulfillment, onRejection); |
|||
} |
|||
|
|||
return child; |
|||
}, |
|||
|
|||
/** |
|||
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same |
|||
as the catch block of a try/catch statement. |
|||
|
|||
```js
|
|||
function findAuthor(){ |
|||
throw new Error('couldn't find that author'); |
|||
} |
|||
|
|||
// synchronous
|
|||
try { |
|||
findAuthor(); |
|||
} catch(reason) { |
|||
// something went wrong
|
|||
} |
|||
|
|||
// async with promises
|
|||
findAuthor().catch(function(reason){ |
|||
// something went wrong
|
|||
}); |
|||
``` |
|||
|
|||
@method catch |
|||
@param {Function} onRejection |
|||
@param {String} label optional string for labeling the promise. |
|||
Useful for tooling. |
|||
@return {Promise} |
|||
*/ |
|||
'catch': function(onRejection, label) { |
|||
return this.then(null, onRejection, label); |
|||
} |
|||
}; |
|||
|
|||
var $$es6$promise$polyfill$$default = function polyfill() { |
|||
var local; |
|||
|
|||
if (typeof global !== 'undefined') { |
|||
local = global; |
|||
} else if (typeof window !== 'undefined' && window.document) { |
|||
local = window; |
|||
} else { |
|||
local = self; |
|||
} |
|||
|
|||
var es6PromiseSupport = |
|||
"Promise" in local && |
|||
// Some of these methods are missing from
|
|||
// Firefox/Chrome experimental implementations
|
|||
"resolve" in local.Promise && |
|||
"reject" in local.Promise && |
|||
"all" in local.Promise && |
|||
"race" in local.Promise && |
|||
// Older version of the spec had a resolver object
|
|||
// as the arg rather than a function
|
|||
(function() { |
|||
var resolve; |
|||
new local.Promise(function(r) { resolve = r; }); |
|||
return $$utils$$isFunction(resolve); |
|||
}()); |
|||
|
|||
if (!es6PromiseSupport) { |
|||
local.Promise = $$es6$promise$promise$$default; |
|||
} |
|||
}; |
|||
|
|||
var es6$promise$umd$$ES6Promise = { |
|||
Promise: $$es6$promise$promise$$default, |
|||
polyfill: $$es6$promise$polyfill$$default |
|||
}; |
|||
|
|||
/* global define:true module:true window: true */ |
|||
if (typeof define === 'function' && define['amd']) { |
|||
define(function() { return es6$promise$umd$$ES6Promise; }); |
|||
} else if (typeof module !== 'undefined' && module['exports']) { |
|||
module['exports'] = es6$promise$umd$$ES6Promise; |
|||
} else if (typeof this !== 'undefined') { |
|||
this['ES6Promise'] = es6$promise$umd$$ES6Promise; |
|||
} |
|||
}).call(this); |
|||
@ -0,0 +1,8 @@ |
|||
<RCC version="1.0"> |
|||
<qresource prefix="/js"> |
|||
<file>es6-promise-2.0.0.js</file> |
|||
<file>setup.js</file> |
|||
<file>main.js</file> |
|||
<file>qt.js</file> |
|||
</qresource> |
|||
</RCC> |
|||
@ -0,0 +1,458 @@ |
|||
/* |
|||
This file is part of ethereum.js. |
|||
|
|||
ethereum.js 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. |
|||
|
|||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file ethereum.js |
|||
* @authors: |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
(function(window) { |
|||
function isPromise(o) { |
|||
return o instanceof Promise |
|||
} |
|||
|
|||
function flattenPromise (obj) { |
|||
if (obj instanceof Promise) { |
|||
return Promise.resolve(obj); |
|||
} |
|||
|
|||
if (obj instanceof Array) { |
|||
return new Promise(function (resolve) { |
|||
var promises = obj.map(function (o) { |
|||
return flattenPromise(o); |
|||
}); |
|||
|
|||
return Promise.all(promises).then(function (res) { |
|||
for (var i = 0; i < obj.length; i++) { |
|||
obj[i] = res[i]; |
|||
} |
|||
resolve(obj); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
if (obj instanceof Object) { |
|||
return new Promise(function (resolve) { |
|||
var keys = Object.keys(obj); |
|||
var promises = keys.map(function (key) { |
|||
return flattenPromise(obj[key]); |
|||
}); |
|||
|
|||
return Promise.all(promises).then(function (res) { |
|||
for (var i = 0; i < keys.length; i++) { |
|||
obj[keys[i]] = res[i]; |
|||
} |
|||
resolve(obj); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
return Promise.resolve(obj); |
|||
}; |
|||
|
|||
var ethMethods = function () { |
|||
var blockCall = function (args) { |
|||
return typeof args[0] === "string" ? "blockByHash" : "blockByNumber"; |
|||
}; |
|||
|
|||
var transactionCall = function (args) { |
|||
return typeof args[0] === "string" ? 'transactionByHash' : 'transactionByNumber'; |
|||
}; |
|||
|
|||
var uncleCall = function (args) { |
|||
return typeof args[0] === "string" ? 'uncleByHash' : 'uncleByNumber'; |
|||
}; |
|||
|
|||
var methods = [ |
|||
{ name: 'balanceAt', call: 'balanceAt' }, |
|||
{ name: 'stateAt', call: 'stateAt' }, |
|||
{ name: 'countAt', call: 'countAt'}, |
|||
{ name: 'codeAt', call: 'codeAt' }, |
|||
{ name: 'transact', call: 'transact' }, |
|||
{ name: 'call', call: 'call' }, |
|||
{ name: 'block', call: blockCall }, |
|||
{ name: 'transaction', call: transactionCall }, |
|||
{ name: 'uncle', call: uncleCall }, |
|||
{ name: 'compile', call: 'compile' } |
|||
]; |
|||
return methods; |
|||
}; |
|||
|
|||
var ethProperties = function () { |
|||
return [ |
|||
{ name: 'coinbase', getter: 'coinbase', setter: 'setCoinbase' }, |
|||
{ name: 'listening', getter: 'listening', setter: 'setListening' }, |
|||
{ name: 'mining', getter: 'mining', setter: 'setMining' }, |
|||
{ name: 'gasPrice', getter: 'gasPrice' }, |
|||
{ name: 'account', getter: 'account' }, |
|||
{ name: 'accounts', getter: 'accounts' }, |
|||
{ name: 'peerCount', getter: 'peerCount' }, |
|||
{ name: 'defaultBlock', getter: 'defaultBlock', setter: 'setDefaultBlock' }, |
|||
{ name: 'number', getter: 'number'} |
|||
]; |
|||
}; |
|||
|
|||
var dbMethods = function () { |
|||
return [ |
|||
{ name: 'put', call: 'put' }, |
|||
{ name: 'get', call: 'get' }, |
|||
{ name: 'putString', call: 'putString' }, |
|||
{ name: 'getString', call: 'getString' } |
|||
]; |
|||
}; |
|||
|
|||
var shhMethods = function () { |
|||
return [ |
|||
{ name: 'post', call: 'post' }, |
|||
{ name: 'newIdentity', call: 'newIdentity' }, |
|||
{ name: 'haveIdentity', call: 'haveIdentity' }, |
|||
{ name: 'newGroup', call: 'newGroup' }, |
|||
{ name: 'addToGroup', call: 'addToGroup' } |
|||
]; |
|||
}; |
|||
|
|||
var ethWatchMethods = function () { |
|||
var newFilter = function (args) { |
|||
return typeof args[0] === 'string' ? 'newFilterString' : 'newFilter'; |
|||
}; |
|||
|
|||
return [ |
|||
{ name: 'newFilter', call: newFilter }, |
|||
{ name: 'uninstallFilter', call: 'uninstallFilter' }, |
|||
{ name: 'getMessages', call: 'getMessages' } |
|||
]; |
|||
}; |
|||
|
|||
var shhWatchMethods = function () { |
|||
return [ |
|||
{ name: 'newFilter', call: 'shhNewFilter' }, |
|||
{ name: 'uninstallFilter', call: 'shhUninstallFilter' }, |
|||
{ name: 'getMessage', call: 'shhGetMessages' } |
|||
]; |
|||
}; |
|||
|
|||
var setupMethods = function (obj, methods) { |
|||
methods.forEach(function (method) { |
|||
obj[method.name] = function () { |
|||
return flattenPromise(Array.prototype.slice.call(arguments)).then(function (args) { |
|||
var call = typeof method.call === "function" ? method.call(args) : method.call; |
|||
return {call: call, args: args}; |
|||
}).then(function (request) { |
|||
return new Promise(function (resolve, reject) { |
|||
web3.provider.send(request, function (result) { |
|||
if (result || typeof result === "boolean") { |
|||
resolve(result); |
|||
return; |
|||
} |
|||
reject(result); |
|||
}); |
|||
}); |
|||
}).catch(function( err) { |
|||
console.error(err); |
|||
}); |
|||
}; |
|||
}); |
|||
}; |
|||
|
|||
var setupProperties = function (obj, properties) { |
|||
properties.forEach(function (property) { |
|||
var proto = {}; |
|||
proto.get = function () { |
|||
return new Promise(function(resolve, reject) { |
|||
web3.provider.send({call: property.getter}, function(result) { |
|||
resolve(result); |
|||
}); |
|||
}); |
|||
}; |
|||
if (property.setter) { |
|||
proto.set = function (val) { |
|||
return flattenPromise([val]).then(function (args) { |
|||
return new Promise(function (resolve) { |
|||
web3.provider.send({call: property.setter, args: args}, function (result) { |
|||
if (result) { |
|||
resolve(result); |
|||
} else { |
|||
reject(result); |
|||
} |
|||
}); |
|||
}); |
|||
}).catch(function (err) { |
|||
console.error(err); |
|||
}); |
|||
} |
|||
} |
|||
Object.defineProperty(obj, property.name, proto); |
|||
}); |
|||
}; |
|||
|
|||
var web3 = { |
|||
_callbacks: {}, |
|||
_events: {}, |
|||
providers: {}, |
|||
toHex: function(str) { |
|||
var hex = ""; |
|||
for(var i = 0; i < str.length; i++) { |
|||
var n = str.charCodeAt(i).toString(16); |
|||
hex += n.length < 2 ? '0' + n : n; |
|||
} |
|||
|
|||
return hex; |
|||
}, |
|||
|
|||
toAscii: function(hex) { |
|||
// Find termination
|
|||
var str = ""; |
|||
var i = 0, l = hex.length; |
|||
for(; i < l; i+=2) { |
|||
var code = hex.charCodeAt(i) |
|||
if(code == 0) { |
|||
break; |
|||
} |
|||
|
|||
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16)); |
|||
} |
|||
|
|||
return str; |
|||
}, |
|||
|
|||
toDecimal: function (val) { |
|||
return parseInt(val, 16); |
|||
}, |
|||
|
|||
fromAscii: function(str, pad) { |
|||
pad = pad === undefined ? 32 : pad; |
|||
var hex = this.toHex(str); |
|||
while(hex.length < pad*2) |
|||
hex += "00"; |
|||
return hex |
|||
}, |
|||
|
|||
eth: { |
|||
prototype: Object(), |
|||
watch: function (params) { |
|||
return new Filter(params, ethWatch); |
|||
}, |
|||
}, |
|||
|
|||
db: { |
|||
prototype: Object() |
|||
}, |
|||
|
|||
shh: { |
|||
prototype: Object(), |
|||
watch: function (params) { |
|||
return new Filter(params, shhWatch); |
|||
} |
|||
}, |
|||
|
|||
on: function(event, id, cb) { |
|||
if(web3._events[event] === undefined) { |
|||
web3._events[event] = {}; |
|||
} |
|||
|
|||
web3._events[event][id] = cb; |
|||
return this |
|||
}, |
|||
|
|||
off: function(event, id) { |
|||
if(web3._events[event] !== undefined) { |
|||
delete web3._events[event][id]; |
|||
} |
|||
|
|||
return this |
|||
}, |
|||
|
|||
trigger: function(event, id, data) { |
|||
var callbacks = web3._events[event]; |
|||
if (!callbacks || !callbacks[id]) { |
|||
return; |
|||
} |
|||
var cb = callbacks[id]; |
|||
cb(data); |
|||
}, |
|||
}; |
|||
|
|||
var eth = web3.eth; |
|||
setupMethods(eth, ethMethods()); |
|||
setupProperties(eth, ethProperties()); |
|||
setupMethods(web3.db, dbMethods()); |
|||
setupMethods(web3.shh, shhMethods()); |
|||
|
|||
var ethWatch = { |
|||
changed: 'changed' |
|||
}; |
|||
setupMethods(ethWatch, ethWatchMethods()); |
|||
var shhWatch = { |
|||
changed: 'shhChanged' |
|||
}; |
|||
setupMethods(shhWatch, shhWatchMethods()); |
|||
|
|||
var ProviderManager = function() { |
|||
this.queued = []; |
|||
this.polls = []; |
|||
this.ready = false; |
|||
this.provider = undefined; |
|||
this.id = 1; |
|||
|
|||
var self = this; |
|||
var poll = function () { |
|||
if (self.provider && self.provider.poll) { |
|||
self.polls.forEach(function (data) { |
|||
data.data._id = self.id; |
|||
self.id++; |
|||
self.provider.poll(data.data, data.id); |
|||
}); |
|||
} |
|||
setTimeout(poll, 12000); |
|||
}; |
|||
poll(); |
|||
}; |
|||
|
|||
ProviderManager.prototype.send = function(data, cb) { |
|||
data._id = this.id; |
|||
if (cb) { |
|||
web3._callbacks[data._id] = cb; |
|||
} |
|||
|
|||
data.args = data.args || []; |
|||
this.id++; |
|||
|
|||
if(this.provider !== undefined) { |
|||
this.provider.send(data); |
|||
} else { |
|||
console.warn("provider is not set"); |
|||
this.queued.push(data); |
|||
} |
|||
}; |
|||
|
|||
ProviderManager.prototype.set = function(provider) { |
|||
if(this.provider !== undefined && this.provider.unload !== undefined) { |
|||
this.provider.unload(); |
|||
} |
|||
|
|||
this.provider = provider; |
|||
this.ready = true; |
|||
}; |
|||
|
|||
ProviderManager.prototype.sendQueued = function() { |
|||
for(var i = 0; this.queued.length; i++) { |
|||
// Resend
|
|||
this.send(this.queued[i]); |
|||
} |
|||
}; |
|||
|
|||
ProviderManager.prototype.installed = function() { |
|||
return this.provider !== undefined; |
|||
}; |
|||
|
|||
ProviderManager.prototype.startPolling = function (data, pollId) { |
|||
if (!this.provider || !this.provider.poll) { |
|||
return; |
|||
} |
|||
this.polls.push({data: data, id: pollId}); |
|||
}; |
|||
|
|||
ProviderManager.prototype.stopPolling = function (pollId) { |
|||
for (var i = this.polls.length; i--;) { |
|||
var poll = this.polls[i]; |
|||
if (poll.id === pollId) { |
|||
this.polls.splice(i, 1); |
|||
} |
|||
} |
|||
}; |
|||
|
|||
web3.provider = new ProviderManager(); |
|||
|
|||
web3.setProvider = function(provider) { |
|||
provider.onmessage = messageHandler; |
|||
web3.provider.set(provider); |
|||
web3.provider.sendQueued(); |
|||
}; |
|||
|
|||
var Filter = function(options, impl) { |
|||
this.impl = impl; |
|||
this.callbacks = []; |
|||
|
|||
var self = this; |
|||
this.promise = impl.newFilter(options); |
|||
this.promise.then(function (id) { |
|||
self.id = id; |
|||
web3.on(impl.changed, id, self.trigger.bind(self)); |
|||
web3.provider.startPolling({call: impl.changed, args: [id]}, id); |
|||
}); |
|||
}; |
|||
|
|||
Filter.prototype.arrived = function(callback) { |
|||
this.changed(callback); |
|||
} |
|||
|
|||
Filter.prototype.changed = function(callback) { |
|||
var self = this; |
|||
this.promise.then(function(id) { |
|||
self.callbacks.push(callback); |
|||
}); |
|||
}; |
|||
|
|||
Filter.prototype.trigger = function(messages) { |
|||
for(var i = 0; i < this.callbacks.length; i++) { |
|||
this.callbacks[i].call(this, messages); |
|||
} |
|||
}; |
|||
|
|||
Filter.prototype.uninstall = function() { |
|||
var self = this; |
|||
this.promise.then(function (id) { |
|||
self.impl.uninstallFilter(id); |
|||
web3.provider.stopPolling(id); |
|||
web3.off(impl.changed, id); |
|||
}); |
|||
}; |
|||
|
|||
Filter.prototype.messages = function() { |
|||
var self = this; |
|||
return this.promise.then(function (id) { |
|||
return self.impl.getMessages(id); |
|||
}); |
|||
}; |
|||
|
|||
function messageHandler(data) { |
|||
if(data._event !== undefined) { |
|||
web3.trigger(data._event, data._id, data.data); |
|||
return; |
|||
} |
|||
|
|||
if(data._id) { |
|||
var cb = web3._callbacks[data._id]; |
|||
if (cb) { |
|||
cb.call(this, data.data) |
|||
delete web3._callbacks[data._id]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/* |
|||
// Install default provider
|
|||
if(!web3.provider.installed()) { |
|||
var sock = new web3.WebSocket("ws://localhost:40404/eth"); |
|||
|
|||
web3.setProvider(sock); |
|||
} |
|||
*/ |
|||
|
|||
window.web3 = web3; |
|||
|
|||
})(this); |
|||
@ -0,0 +1,49 @@ |
|||
/* |
|||
This file is part of ethereum.js. |
|||
|
|||
ethereum.js 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. |
|||
|
|||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file ethereum.js |
|||
* @authors: |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
(function() { |
|||
var QtProvider = function() { |
|||
this.handlers = []; |
|||
|
|||
var self = this; |
|||
navigator.qt.onmessage = function (message) { |
|||
self.handlers.forEach(function (handler) { |
|||
handler.call(self, JSON.parse(message.data)); |
|||
}); |
|||
} |
|||
}; |
|||
|
|||
QtProvider.prototype.send = function(payload) { |
|||
navigator.qt.postMessage(JSON.stringify(payload)); |
|||
}; |
|||
|
|||
Object.defineProperty(QtProvider.prototype, "onmessage", { |
|||
set: function(handler) { |
|||
this.handlers.push(handler); |
|||
}, |
|||
}); |
|||
|
|||
if(typeof(web3) !== "undefined" && web3.providers !== undefined) { |
|||
web3.providers.QtProvider = QtProvider; |
|||
} |
|||
})(); |
|||
|
|||
@ -0,0 +1,44 @@ |
|||
/* |
|||
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 QEthereum.cpp |
|||
* @authors: |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
navigator.qt = _web3; |
|||
|
|||
(function () { |
|||
navigator.qt.handlers = []; |
|||
Object.defineProperty(navigator.qt, 'onmessage', { |
|||
set: function (handler) { |
|||
navigator.qt.handlers.push(handler); |
|||
} |
|||
}); |
|||
})(); |
|||
|
|||
navigator.qt.response.connect(function (res) { |
|||
navigator.qt.handlers.forEach(function (handler) { |
|||
handler({data: res}); |
|||
}); |
|||
}); |
|||
|
|||
if (window.Promise === undefined) { |
|||
window.Promise = ES6Promise.Promise; |
|||
} |
|||
|
|||
web3.setProvider(new web3.providers.QtProvider()); |
|||
@ -0,0 +1,401 @@ |
|||
/*
|
|||
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 |
|||
* Solidity AST to EVM bytecode compiler. |
|||
*/ |
|||
|
|||
#include <cassert> |
|||
#include <utility> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/Compiler.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
void CompilerContext::setLabelPosition(uint32_t _label, uint32_t _position) |
|||
{ |
|||
assert(m_labelPositions.find(_label) == m_labelPositions.end()); |
|||
m_labelPositions[_label] = _position; |
|||
} |
|||
|
|||
uint32_t CompilerContext::getLabelPosition(uint32_t _label) const |
|||
{ |
|||
auto iter = m_labelPositions.find(_label); |
|||
assert(iter != m_labelPositions.end()); |
|||
return iter->second; |
|||
} |
|||
|
|||
void ExpressionCompiler::compile(Expression& _expression) |
|||
{ |
|||
m_assemblyItems.clear(); |
|||
_expression.accept(*this); |
|||
} |
|||
|
|||
bytes ExpressionCompiler::getAssembledBytecode() const |
|||
{ |
|||
bytes assembled; |
|||
assembled.reserve(m_assemblyItems.size()); |
|||
|
|||
// resolve label references
|
|||
for (uint32_t pos = 0; pos < m_assemblyItems.size(); ++pos) |
|||
{ |
|||
AssemblyItem const& item = m_assemblyItems[pos]; |
|||
if (item.getType() == AssemblyItem::Type::LABEL) |
|||
m_context.setLabelPosition(item.getLabel(), pos + 1); |
|||
} |
|||
|
|||
for (AssemblyItem const& item: m_assemblyItems) |
|||
if (item.getType() == AssemblyItem::Type::LABELREF) |
|||
assembled.push_back(m_context.getLabelPosition(item.getLabel())); |
|||
else |
|||
assembled.push_back(item.getData()); |
|||
|
|||
return assembled; |
|||
} |
|||
|
|||
AssemblyItems ExpressionCompiler::compileExpression(CompilerContext& _context, |
|||
Expression& _expression) |
|||
{ |
|||
ExpressionCompiler compiler(_context); |
|||
compiler.compile(_expression); |
|||
return compiler.getAssemblyItems(); |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Assignment& _assignment) |
|||
{ |
|||
Expression& rightHandSide = _assignment.getRightHandSide(); |
|||
Token::Value op = _assignment.getAssignmentOperator(); |
|||
if (op != Token::ASSIGN) |
|||
{ |
|||
// compound assignment
|
|||
// @todo retrieve lvalue value
|
|||
rightHandSide.accept(*this); |
|||
Type const& resultType = *_assignment.getType(); |
|||
cleanHigherOrderBitsIfNeeded(*rightHandSide.getType(), resultType); |
|||
appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), resultType); |
|||
} |
|||
else |
|||
rightHandSide.accept(*this); |
|||
// @todo store value
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation) |
|||
{ |
|||
//@todo type checking and creating code for an operator should be in the same place:
|
|||
// the operator should know how to convert itself and to which types it applies, so
|
|||
// put this code together with "Type::acceptsBinary/UnaryOperator" into a class that
|
|||
// represents the operator
|
|||
switch (_unaryOperation.getOperator()) |
|||
{ |
|||
case Token::NOT: // !
|
|||
append(eth::Instruction::ISZERO); |
|||
break; |
|||
case Token::BIT_NOT: // ~
|
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::DELETE: // delete
|
|||
// a -> a xor a (= 0).
|
|||
// @todo this should also be an assignment
|
|||
// @todo semantics change for complex types
|
|||
append(eth::Instruction::DUP1); |
|||
append(eth::Instruction::XOR); |
|||
break; |
|||
case Token::INC: // ++ (pre- or postfix)
|
|||
// @todo this should also be an assignment
|
|||
if (_unaryOperation.isPrefixOperation()) |
|||
{ |
|||
append(eth::Instruction::PUSH1); |
|||
append(1); |
|||
append(eth::Instruction::ADD); |
|||
} |
|||
break; |
|||
case Token::DEC: // -- (pre- or postfix)
|
|||
// @todo this should also be an assignment
|
|||
if (_unaryOperation.isPrefixOperation()) |
|||
{ |
|||
append(eth::Instruction::PUSH1); |
|||
append(1); |
|||
append(eth::Instruction::SWAP1); //@todo avoid this
|
|||
append(eth::Instruction::SUB); |
|||
} |
|||
break; |
|||
case Token::ADD: // +
|
|||
// unary add, so basically no-op
|
|||
break; |
|||
case Token::SUB: // -
|
|||
// unary -x translates into "0-x"
|
|||
append(eth::Instruction::PUSH1); |
|||
append(0); |
|||
append(eth::Instruction::SUB); |
|||
break; |
|||
default: |
|||
assert(false); // invalid operation
|
|||
} |
|||
} |
|||
|
|||
bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation) |
|||
{ |
|||
Expression& leftExpression = _binaryOperation.getLeftExpression(); |
|||
Expression& rightExpression = _binaryOperation.getRightExpression(); |
|||
Type const& resultType = *_binaryOperation.getType(); |
|||
Token::Value const op = _binaryOperation.getOperator(); |
|||
|
|||
if (op == Token::AND || op == Token::OR) |
|||
{ |
|||
// special case: short-circuiting
|
|||
appendAndOrOperatorCode(_binaryOperation); |
|||
} |
|||
else if (Token::isCompareOp(op)) |
|||
{ |
|||
leftExpression.accept(*this); |
|||
rightExpression.accept(*this); |
|||
|
|||
// the types to compare have to be the same, but the resulting type is always bool
|
|||
assert(*leftExpression.getType() == *rightExpression.getType()); |
|||
appendCompareOperatorCode(op, *leftExpression.getType()); |
|||
} |
|||
else |
|||
{ |
|||
leftExpression.accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*leftExpression.getType(), resultType); |
|||
rightExpression.accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*rightExpression.getType(), resultType); |
|||
appendOrdinaryBinaryOperatorCode(op, resultType); |
|||
} |
|||
|
|||
// do not visit the child nodes, we already did that explicitly
|
|||
return false; |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(FunctionCall& _functionCall) |
|||
{ |
|||
if (_functionCall.isTypeConversion()) |
|||
{ |
|||
//@todo binary representation for all supported types (bool and int) is the same, so no-op
|
|||
// here for now.
|
|||
} |
|||
else |
|||
{ |
|||
//@todo
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(MemberAccess&) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(IndexAccess&) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Identifier&) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Literal& _literal) |
|||
{ |
|||
switch (_literal.getType()->getCategory()) |
|||
{ |
|||
case Type::Category::INTEGER: |
|||
case Type::Category::BOOL: |
|||
{ |
|||
bytes value = _literal.getType()->literalToBigEndian(_literal); |
|||
assert(value.size() <= 32); |
|||
assert(!value.empty()); |
|||
append(static_cast<byte>(eth::Instruction::PUSH1) + static_cast<byte>(value.size() - 1)); |
|||
append(value); |
|||
break; |
|||
} |
|||
default: |
|||
assert(false); // @todo
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::cleanHigherOrderBitsIfNeeded(Type const& _typeOnStack, Type const& _targetType) |
|||
{ |
|||
// If the type of one of the operands is extended, we need to remove all
|
|||
// higher-order bits that we might have ignored in previous operations.
|
|||
// @todo: store in the AST whether the operand might have "dirty" higher
|
|||
// order bits
|
|||
|
|||
if (_typeOnStack == _targetType) |
|||
return; |
|||
if (_typeOnStack.getCategory() == Type::Category::INTEGER && |
|||
_targetType.getCategory() == Type::Category::INTEGER) |
|||
{ |
|||
//@todo
|
|||
} |
|||
else |
|||
{ |
|||
// If we get here, there is either an implementation missing to clean higher oder bits
|
|||
// for non-integer types that are explicitly convertible or we got here in error.
|
|||
assert(!_typeOnStack.isExplicitlyConvertibleTo(_targetType)); |
|||
assert(false); // these types should not be convertible.
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation& _binaryOperation) |
|||
{ |
|||
Token::Value const op = _binaryOperation.getOperator(); |
|||
assert(op == Token::OR || op == Token::AND); |
|||
|
|||
_binaryOperation.getLeftExpression().accept(*this); |
|||
append(eth::Instruction::DUP1); |
|||
if (op == Token::AND) |
|||
append(eth::Instruction::NOT); |
|||
uint32_t endLabel = appendConditionalJump(); |
|||
_binaryOperation.getRightExpression().accept(*this); |
|||
appendLabel(endLabel); |
|||
} |
|||
|
|||
void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
if (_operator == Token::EQ || _operator == Token::NE) |
|||
{ |
|||
append(eth::Instruction::EQ); |
|||
if (_operator == Token::NE) |
|||
append(eth::Instruction::NOT); |
|||
} |
|||
else |
|||
{ |
|||
IntegerType const* type = dynamic_cast<IntegerType const*>(&_type); |
|||
assert(type); |
|||
bool const isSigned = type->isSigned(); |
|||
|
|||
// note that EVM opcodes compare like "stack[0] < stack[1]",
|
|||
// but our left value is at stack[1], so everyhing is reversed.
|
|||
switch (_operator) |
|||
{ |
|||
case Token::GTE: |
|||
append(isSigned ? eth::Instruction::SGT : eth::Instruction::GT); |
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::LTE: |
|||
append(isSigned ? eth::Instruction::SLT : eth::Instruction::LT); |
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::GT: |
|||
append(isSigned ? eth::Instruction::SLT : eth::Instruction::LT); |
|||
break; |
|||
case Token::LT: |
|||
append(isSigned ? eth::Instruction::SGT : eth::Instruction::GT); |
|||
break; |
|||
default: |
|||
assert(false); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendOrdinaryBinaryOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
if (Token::isArithmeticOp(_operator)) |
|||
appendArithmeticOperatorCode(_operator, _type); |
|||
else if (Token::isBitOp(_operator)) |
|||
appendBitOperatorCode(_operator); |
|||
else if (Token::isShiftOp(_operator)) |
|||
appendShiftOperatorCode(_operator); |
|||
else |
|||
assert(false); // unknown binary operator
|
|||
} |
|||
|
|||
void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
IntegerType const* type = dynamic_cast<IntegerType const*>(&_type); |
|||
assert(type); |
|||
bool const isSigned = type->isSigned(); |
|||
|
|||
switch (_operator) |
|||
{ |
|||
case Token::ADD: |
|||
append(eth::Instruction::ADD); |
|||
break; |
|||
case Token::SUB: |
|||
append(eth::Instruction::SWAP1); |
|||
append(eth::Instruction::SUB); |
|||
break; |
|||
case Token::MUL: |
|||
append(eth::Instruction::MUL); |
|||
break; |
|||
case Token::DIV: |
|||
append(isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV); |
|||
break; |
|||
case Token::MOD: |
|||
append(isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD); |
|||
break; |
|||
default: |
|||
assert(false); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator) |
|||
{ |
|||
switch (_operator) |
|||
{ |
|||
case Token::BIT_OR: |
|||
append(eth::Instruction::OR); |
|||
break; |
|||
case Token::BIT_AND: |
|||
append(eth::Instruction::AND); |
|||
break; |
|||
case Token::BIT_XOR: |
|||
append(eth::Instruction::XOR); |
|||
break; |
|||
default: |
|||
assert(false); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendShiftOperatorCode(Token::Value _operator) |
|||
{ |
|||
switch (_operator) |
|||
{ |
|||
case Token::SHL: |
|||
assert(false); //@todo
|
|||
break; |
|||
case Token::SAR: |
|||
assert(false); //@todo
|
|||
break; |
|||
default: |
|||
assert(false); |
|||
} |
|||
} |
|||
|
|||
uint32_t ExpressionCompiler::appendConditionalJump() |
|||
{ |
|||
uint32_t label = m_context.dispenseNewLabel(); |
|||
append(eth::Instruction::PUSH1); |
|||
appendLabelref(label); |
|||
append(eth::Instruction::JUMPI); |
|||
return label; |
|||
} |
|||
|
|||
void ExpressionCompiler::append(bytes const& _data) |
|||
{ |
|||
m_assemblyItems.reserve(m_assemblyItems.size() + _data.size()); |
|||
for (byte b: _data) |
|||
append(b); |
|||
} |
|||
|
|||
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,146 @@ |
|||
/*
|
|||
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 |
|||
* Solidity AST to EVM bytecode compiler. |
|||
*/ |
|||
|
|||
#include <libevmface/Instruction.h> |
|||
#include <libsolidity/ASTVisitor.h> |
|||
#include <libsolidity/Types.h> |
|||
#include <libsolidity/Token.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
/**
|
|||
* A single item of compiled code that can be assembled to a single byte value in the final |
|||
* bytecode. Its main purpose is to inject jump labels and label references into the opcode stream, |
|||
* which can be resolved in the final step. |
|||
*/ |
|||
class AssemblyItem |
|||
{ |
|||
public: |
|||
enum class Type |
|||
{ |
|||
CODE, ///< m_data is opcode, m_label is empty.
|
|||
DATA, ///< m_data is actual data, m_label is empty
|
|||
LABEL, ///< m_data is JUMPDEST opcode, m_label is id of label
|
|||
LABELREF ///< m_data is empty, m_label is id of label
|
|||
}; |
|||
|
|||
explicit AssemblyItem(eth::Instruction _instruction) : m_type(Type::CODE), m_data(byte(_instruction)) {} |
|||
explicit AssemblyItem(byte _data): m_type(Type::DATA), m_data(_data) {} |
|||
|
|||
/// Factory functions
|
|||
static AssemblyItem labelRef(uint32_t _label) { return AssemblyItem(Type::LABELREF, 0, _label); } |
|||
static AssemblyItem label(uint32_t _label) { return AssemblyItem(Type::LABEL, byte(eth::Instruction::JUMPDEST), _label); } |
|||
|
|||
Type getType() const { return m_type; } |
|||
byte getData() const { return m_data; } |
|||
uint32_t getLabel() const { return m_label; } |
|||
|
|||
private: |
|||
AssemblyItem(Type _type, byte _data, uint32_t _label): m_type(_type), m_data(_data), m_label(_label) {} |
|||
|
|||
Type m_type; |
|||
byte m_data; ///< data to be written to the bytecode stream (or filled by a label if this is a LABELREF)
|
|||
uint32_t m_label; ///< the id of a label either referenced or defined by this item
|
|||
}; |
|||
|
|||
using AssemblyItems = std::vector<AssemblyItem>; |
|||
|
|||
|
|||
/**
|
|||
* Context to be shared by all units that compile the same contract. Its current usage only |
|||
* concerns dispensing unique jump label IDs and storing their actual positions in the bytecode |
|||
* stream. |
|||
*/ |
|||
class CompilerContext |
|||
{ |
|||
public: |
|||
CompilerContext(): m_nextLabel(0) {} |
|||
uint32_t dispenseNewLabel() { return m_nextLabel++; } |
|||
void setLabelPosition(uint32_t _label, uint32_t _position); |
|||
uint32_t getLabelPosition(uint32_t _label) const; |
|||
|
|||
private: |
|||
uint32_t m_nextLabel; |
|||
|
|||
std::map<uint32_t, uint32_t> m_labelPositions; |
|||
}; |
|||
|
|||
/**
|
|||
* Compiler for expressions, i.e. converts an AST tree whose root is an Expression into a stream |
|||
* of EVM instructions. It needs a compiler context that is the same for the whole compilation |
|||
* unit. |
|||
*/ |
|||
class ExpressionCompiler: public ASTVisitor |
|||
{ |
|||
public: |
|||
ExpressionCompiler(CompilerContext& _compilerContext): m_context(_compilerContext) {} |
|||
|
|||
/// Compile the given expression and (re-)populate the assembly item list.
|
|||
void compile(Expression& _expression); |
|||
AssemblyItems const& getAssemblyItems() const { return m_assemblyItems; } |
|||
bytes getAssembledBytecode() const; |
|||
|
|||
/// Compile the given expression and return the assembly items right away.
|
|||
static AssemblyItems compileExpression(CompilerContext& _context, Expression& _expression); |
|||
|
|||
private: |
|||
virtual void endVisit(Assignment& _assignment) override; |
|||
virtual void endVisit(UnaryOperation& _unaryOperation) override; |
|||
virtual bool visit(BinaryOperation& _binaryOperation) override; |
|||
virtual void endVisit(FunctionCall& _functionCall) override; |
|||
virtual void endVisit(MemberAccess& _memberAccess) override; |
|||
virtual void endVisit(IndexAccess& _indexAccess) override; |
|||
virtual void endVisit(Identifier& _identifier) override; |
|||
virtual void endVisit(Literal& _literal) override; |
|||
|
|||
/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
|
|||
void cleanHigherOrderBitsIfNeeded(Type const& _typeOnStack, Type const& _targetType); |
|||
|
|||
///@{
|
|||
///@name Append code for various operator types
|
|||
void appendAndOrOperatorCode(BinaryOperation& _binaryOperation); |
|||
void appendCompareOperatorCode(Token::Value _operator, Type const& _type); |
|||
void appendOrdinaryBinaryOperatorCode(Token::Value _operator, Type const& _type); |
|||
|
|||
void appendArithmeticOperatorCode(Token::Value _operator, Type const& _type); |
|||
void appendBitOperatorCode(Token::Value _operator); |
|||
void appendShiftOperatorCode(Token::Value _operator); |
|||
/// @}
|
|||
|
|||
/// Appends a JUMPI instruction to a new label and returns the label
|
|||
uint32_t appendConditionalJump(); |
|||
|
|||
/// Append elements to the current instruction list.
|
|||
void append(eth::Instruction const& _instruction) { m_assemblyItems.push_back(AssemblyItem(_instruction)); } |
|||
void append(byte _value) { m_assemblyItems.push_back(AssemblyItem(_value)); } |
|||
void append(bytes const& _data); |
|||
void appendLabelref(byte _label) { m_assemblyItems.push_back(AssemblyItem::labelRef(_label)); } |
|||
void appendLabel(byte _label) { m_assemblyItems.push_back(AssemblyItem::label(_label)); } |
|||
|
|||
AssemblyItems m_assemblyItems; |
|||
CompilerContext& m_context; |
|||
}; |
|||
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
cmake_policy(SET CMP0015 NEW) |
|||
|
|||
aux_source_directory(. SRC_LIST) |
|||
|
|||
include_directories(..) |
|||
link_directories(../libethcore) |
|||
link_directories(../libwebthree) |
|||
|
|||
set(EXECUTABLE web3jsonrpc) |
|||
file(GLOB HEADERS "*.h") |
|||
|
|||
if(ETH_STATIC) |
|||
add_library(${EXECUTABLE} STATIC ${SRC_LIST} ${HEADERS}) |
|||
else() |
|||
add_library(${EXECUTABLE} SHARED ${SRC_LIST} ${HEADERS}) |
|||
endif() |
|||
|
|||
target_link_libraries(${EXECUTABLE} webthree) |
|||
target_link_libraries(${EXECUTABLE} secp256k1) |
|||
target_link_libraries(${EXECUTABLE} gmp) |
|||
if(MINIUPNPC_LS) |
|||
target_link_libraries(${EXECUTABLE} ${MINIUPNPC_LS}) |
|||
endif() |
|||
target_link_libraries(${EXECUTABLE} ${LEVELDB_LS}) |
|||
target_link_libraries(${EXECUTABLE} ${CRYPTOPP_LS}) |
|||
target_link_libraries(${EXECUTABLE} ${JSONRPC_LS}) |
|||
target_link_libraries(${EXECUTABLE} ${LEVELDB_LS}) |
|||
if(READLINE_LS) |
|||
target_link_libraries(${EXECUTABLE} ${READLINE_LS}) |
|||
endif() |
|||
|
|||
if ("${TARGET_PLATFORM}" STREQUAL "w64") |
|||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++") |
|||
target_link_libraries(${EXECUTABLE} boost_system-mt-s) |
|||
target_link_libraries(${EXECUTABLE} boost_filesystem-mt-s) |
|||
target_link_libraries(${EXECUTABLE} boost_thread_win32-mt-s) |
|||
target_link_libraries(${EXECUTABLE} gcc) |
|||
target_link_libraries(${EXECUTABLE} gdi32) |
|||
target_link_libraries(${EXECUTABLE} ws2_32) |
|||
target_link_libraries(${EXECUTABLE} mswsock) |
|||
target_link_libraries(${EXECUTABLE} shlwapi) |
|||
target_link_libraries(${EXECUTABLE} iphlpapi) |
|||
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS) |
|||
elseif (UNIX) |
|||
else () |
|||
target_link_libraries(${EXECUTABLE} boost_system) |
|||
target_link_libraries(${EXECUTABLE} boost_filesystem) |
|||
find_package(Threads REQUIRED) |
|||
target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT}) |
|||
endif () |
|||
|
|||
install( TARGETS ${EXECUTABLE} ARCHIVE DESTINATION lib LIBRARY DESTINATION lib ) |
|||
install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} ) |
|||
|
|||
|
|||
@ -0,0 +1,42 @@ |
|||
/*
|
|||
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 CorsHttpServer.cpp
|
|||
* @author Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "CorsHttpServer.h" |
|||
|
|||
namespace jsonrpc |
|||
{ |
|||
|
|||
bool CorsHttpServer::SendResponse(std::string const& _response, void* _addInfo) |
|||
{ |
|||
struct mg_connection* conn = (struct mg_connection*) _addInfo; |
|||
if (mg_printf(conn, "HTTP/1.1 200 OK\r\n" |
|||
"Content-Type: application/json\r\n" |
|||
"Content-Length: %d\r\n" |
|||
"Access-Control-Allow-Origin: *\r\n" |
|||
"Access-Control-Allow-Headers: Content-Type\r\n" |
|||
"\r\n" |
|||
"%s",(int)_response.length(), _response.c_str()) > 0) |
|||
return true; |
|||
return false; |
|||
|
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,35 @@ |
|||
/*
|
|||
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 CorsHttpServer.h
|
|||
* @author Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include <jsonrpc/connectors/httpserver.h> |
|||
|
|||
namespace jsonrpc |
|||
{ |
|||
|
|||
class CorsHttpServer : public HttpServer |
|||
{ |
|||
public: |
|||
using HttpServer::HttpServer; |
|||
bool virtual SendResponse(std::string const& _response, void* _addInfo = NULL); |
|||
}; |
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,657 @@ |
|||
/*
|
|||
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 WebThreeStubServer.cpp
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "WebThreeStubServer.h" |
|||
#include <libevmface/Instruction.h> |
|||
#include <liblll/Compiler.h> |
|||
#include <libethereum/Client.h> |
|||
#include <libwebthree/WebThree.h> |
|||
#include <libdevcore/CommonJS.h> |
|||
#include <boost/filesystem.hpp> |
|||
#include <libdevcrypto/FileSystem.h> |
|||
#include <libwhisper/Message.h> |
|||
#include <libwhisper/WhisperHost.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
static Json::Value toJson(dev::eth::BlockInfo const& _bi) |
|||
{ |
|||
Json::Value res; |
|||
res["hash"] = boost::lexical_cast<string>(_bi.hash); |
|||
res["parentHash"] = toJS(_bi.parentHash); |
|||
res["sha3Uncles"] = toJS(_bi.sha3Uncles); |
|||
res["miner"] = toJS(_bi.coinbaseAddress); |
|||
res["stateRoot"] = toJS(_bi.stateRoot); |
|||
res["transactionsRoot"] = toJS(_bi.transactionsRoot); |
|||
res["difficulty"] = toJS(_bi.difficulty); |
|||
res["number"] = (int)_bi.number; |
|||
res["minGasPrice"] = toJS(_bi.minGasPrice); |
|||
res["gasLimit"] = (int)_bi.gasLimit; |
|||
res["timestamp"] = (int)_bi.timestamp; |
|||
res["extraData"] = jsFromBinary(_bi.extraData); |
|||
res["nonce"] = toJS(_bi.nonce); |
|||
return res; |
|||
} |
|||
|
|||
static Json::Value toJson(dev::eth::PastMessage const& _t) |
|||
{ |
|||
Json::Value res; |
|||
res["input"] = jsFromBinary(_t.input); |
|||
res["output"] = jsFromBinary(_t.output); |
|||
res["to"] = toJS(_t.to); |
|||
res["from"] = toJS(_t.from); |
|||
res["value"] = jsToDecimal(toJS(_t.value)); |
|||
res["origin"] = toJS(_t.origin); |
|||
res["timestamp"] = toJS(_t.timestamp); |
|||
res["coinbase"] = toJS(_t.coinbase); |
|||
res["block"] = toJS(_t.block); |
|||
Json::Value path; |
|||
for (int i: _t.path) |
|||
path.append(i); |
|||
res["path"] = path; |
|||
res["number"] = (int)_t.number; |
|||
return res; |
|||
} |
|||
|
|||
static Json::Value toJson(dev::eth::PastMessages const& _pms) |
|||
{ |
|||
Json::Value res; |
|||
for (dev::eth::PastMessage const& t: _pms) |
|||
res.append(toJson(t)); |
|||
return res; |
|||
} |
|||
|
|||
static Json::Value toJson(dev::eth::Transaction const& _t) |
|||
{ |
|||
Json::Value res; |
|||
res["hash"] = toJS(_t.sha3()); |
|||
res["input"] = jsFromBinary(_t.data); |
|||
res["to"] = toJS(_t.receiveAddress); |
|||
res["from"] = toJS(_t.sender()); |
|||
res["gas"] = (int)_t.gas; |
|||
res["gasPrice"] = toJS(_t.gasPrice); |
|||
res["nonce"] = toJS(_t.nonce); |
|||
res["value"] = toJS(_t.value); |
|||
return res; |
|||
} |
|||
|
|||
static dev::eth::MessageFilter toMessageFilter(Json::Value const& _json) |
|||
{ |
|||
dev::eth::MessageFilter filter; |
|||
if (!_json.isObject() || _json.empty()) |
|||
return filter; |
|||
|
|||
if (!_json["earliest"].empty()) |
|||
filter.withEarliest(_json["earliest"].asInt()); |
|||
if (!_json["latest"].empty()) |
|||
filter.withLatest(_json["lastest"].asInt()); |
|||
if (!_json["max"].empty()) |
|||
filter.withMax(_json["max"].asInt()); |
|||
if (!_json["skip"].empty()) |
|||
filter.withSkip(_json["skip"].asInt()); |
|||
if (!_json["from"].empty()) |
|||
{ |
|||
if (_json["from"].isArray()) |
|||
for (auto i : _json["from"]) |
|||
filter.from(jsToAddress(i.asString())); |
|||
else |
|||
filter.from(jsToAddress(_json["from"].asString())); |
|||
} |
|||
if (!_json["to"].empty()) |
|||
{ |
|||
if (_json["to"].isArray()) |
|||
for (auto i : _json["to"]) |
|||
filter.from(jsToAddress(i.asString())); |
|||
else |
|||
filter.from(jsToAddress(_json["to"].asString())); |
|||
} |
|||
if (!_json["altered"].empty()) |
|||
{ |
|||
if (_json["altered"].isArray()) |
|||
for (auto i: _json["altered"]) |
|||
if (i.isObject()) |
|||
filter.altered(jsToAddress(i["id"].asString()), jsToU256(i["at"].asString())); |
|||
else |
|||
filter.altered((jsToAddress(i.asString()))); |
|||
else if (_json["altered"].isObject()) |
|||
filter.altered(jsToAddress(_json["altered"]["id"].asString()), jsToU256(_json["altered"]["at"].asString())); |
|||
else |
|||
filter.altered(jsToAddress(_json["altered"].asString())); |
|||
} |
|||
return filter; |
|||
} |
|||
|
|||
static 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(asBytes(_json["payload"].asString())); |
|||
return ret; |
|||
} |
|||
|
|||
static shh::Envelope toSealed(Json::Value const& _json, shh::Message const& _m, Secret _from) |
|||
{ |
|||
unsigned ttl = 50; |
|||
unsigned workToProve = 50; |
|||
shh::BuildTopic bt; |
|||
|
|||
if (!_json["ttl"].empty()) |
|||
ttl = _json["ttl"].asInt(); |
|||
if (!_json["workToProve"].empty()) |
|||
workToProve = _json["workToProve"].asInt(); |
|||
if (!_json["topic"].empty()) |
|||
{ |
|||
if (_json["topic"].isString()) |
|||
bt.shift(asBytes(jsPadded(_json["topic"].asString(), 32))); |
|||
else if (_json["topic"].isArray()) |
|||
for (auto i: _json["topic"]) |
|||
bt.shift(asBytes(jsPadded(i.asString(), 32))); |
|||
} |
|||
return _m.seal(_from, bt, ttl, workToProve); |
|||
} |
|||
|
|||
static pair<shh::TopicMask, Public> toWatch(Json::Value const& _json) |
|||
{ |
|||
shh::BuildTopicMask bt(shh::BuildTopicMask::Empty); |
|||
Public to; |
|||
|
|||
if (!_json["to"].empty()) |
|||
to = jsToPublic(_json["to"].asString()); |
|||
|
|||
if (!_json["topic"].empty()) |
|||
{ |
|||
if (_json["topic"].isString()) |
|||
bt.shift(asBytes(jsPadded(_json["topic"].asString(), 32))); |
|||
else if (_json["topic"].isArray()) |
|||
for (auto i: _json["topic"]) |
|||
{ |
|||
if (i.isString()) |
|||
bt.shift(asBytes(jsPadded(i.asString(), 32))); |
|||
else |
|||
bt.shift(); |
|||
} |
|||
} |
|||
return make_pair(bt.toTopicMask(), to); |
|||
} |
|||
|
|||
static Json::Value toJson(h256 const& _h, shh::Envelope const& _e, shh::Message const& _m) |
|||
{ |
|||
Json::Value res; |
|||
res["hash"] = toJS(_h); |
|||
res["expiry"] = (int)_e.expiry(); |
|||
res["sent"] = (int)_e.sent(); |
|||
res["ttl"] = (int)_e.ttl(); |
|||
res["workProved"] = (int)_e.workProved(); |
|||
res["topic"] = toJS(_e.topic()); |
|||
res["payload"] = asString(_m.payload()); |
|||
res["from"] = toJS(_m.from()); |
|||
res["to"] = toJS(_m.to()); |
|||
return res; |
|||
} |
|||
|
|||
|
|||
WebThreeStubServer::WebThreeStubServer(jsonrpc::AbstractServerConnector* _conn, WebThreeDirect& _web3, std::vector<dev::KeyPair> const& _accounts): |
|||
AbstractWebThreeStubServer(_conn), |
|||
m_web3(_web3) |
|||
{ |
|||
setAccounts(_accounts); |
|||
auto path = getDataDir() + "/.web3"; |
|||
boost::filesystem::create_directories(path); |
|||
ldb::Options o; |
|||
o.create_if_missing = true; |
|||
ldb::DB::Open(o, path, &m_db); |
|||
} |
|||
|
|||
void WebThreeStubServer::setAccounts(std::vector<dev::KeyPair> const& _accounts) |
|||
{ |
|||
m_accounts.clear(); |
|||
for (auto i: _accounts) |
|||
m_accounts[i.address()] = i.secret(); |
|||
} |
|||
|
|||
void WebThreeStubServer::setIdentities(std::vector<dev::KeyPair> const& _ids) |
|||
{ |
|||
m_ids.clear(); |
|||
for (auto i: _ids) |
|||
m_ids[i.pub()] = i.secret(); |
|||
} |
|||
|
|||
dev::eth::Interface* WebThreeStubServer::client() const |
|||
{ |
|||
return m_web3.ethereum(); |
|||
} |
|||
|
|||
std::shared_ptr<dev::shh::Interface> WebThreeStubServer::face() const |
|||
{ |
|||
return m_web3.whisper(); |
|||
} |
|||
|
|||
std::string WebThreeStubServer::account() |
|||
{ |
|||
if (!m_accounts.empty()) |
|||
return toJS(m_accounts.begin()->first); |
|||
return ""; |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::accounts() |
|||
{ |
|||
Json::Value ret(Json::arrayValue); |
|||
for (auto i: m_accounts) |
|||
ret.append(toJS(i.first)); |
|||
return ret; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::addToGroup(std::string const& _group, std::string const& _who) |
|||
{ |
|||
(void)_group; |
|||
(void)_who; |
|||
return ""; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::balanceAt(string const& _address) |
|||
{ |
|||
int block = 0; |
|||
return toJS(client()->balanceAt(jsToAddress(_address), block)); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::blockByHash(std::string const& _hash) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->blockInfo(jsToFixed<32>(_hash))); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::blockByNumber(int const& _number) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->blockInfo(client()->hashFromNumber(_number))); |
|||
} |
|||
|
|||
static TransactionSkeleton toTransaction(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()) |
|||
ret.to = jsToAddress(_json["to"].asString()); |
|||
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() || _json["code"].empty() || _json["dataclose"].empty()) |
|||
{ |
|||
if (_json["data"].isString()) |
|||
ret.data = jsToBytes(_json["data"].asString()); |
|||
else if (_json["code"].isString()) |
|||
ret.data = jsToBytes(_json["code"].asString()); |
|||
else if (_json["data"].isArray()) |
|||
for (auto i: _json["data"]) |
|||
dev::operator +=(ret.data, asBytes(jsPadded(i.asString(), 32))); |
|||
else if (_json["code"].isArray()) |
|||
for (auto i: _json["code"]) |
|||
dev::operator +=(ret.data, asBytes(jsPadded(i.asString(), 32))); |
|||
else if (_json["dataclose"].isArray()) |
|||
for (auto i: _json["dataclose"]) |
|||
dev::operator +=(ret.data, jsToBytes(i.asString())); |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::call(Json::Value const& _json) |
|||
{ |
|||
std::string ret; |
|||
if (!client()) |
|||
return ret; |
|||
TransactionSkeleton t = toTransaction(_json); |
|||
if (!t.from && m_accounts.size()) |
|||
{ |
|||
auto b = m_accounts.begin()->first; |
|||
for (auto a: m_accounts) |
|||
if (client()->balanceAt(a.first) > client()->balanceAt(b)) |
|||
b = a.first; |
|||
t.from = b; |
|||
} |
|||
if (!m_accounts.count(t.from)) |
|||
return ret; |
|||
if (!t.gasPrice) |
|||
t.gasPrice = 10 * dev::eth::szabo; |
|||
if (!t.gas) |
|||
t.gas = min<u256>(client()->gasLimitRemaining(), client()->balanceAt(t.from) / t.gasPrice); |
|||
ret = toJS(client()->call(m_accounts[t.from].secret(), t.value, t.to, t.data, t.gas, t.gasPrice)); |
|||
return ret; |
|||
} |
|||
|
|||
bool WebThreeStubServer::changed(int const& _id) |
|||
{ |
|||
if (!client()) |
|||
return false; |
|||
return client()->checkWatch(_id); |
|||
} |
|||
|
|||
std::string WebThreeStubServer::codeAt(string const& _address) |
|||
{ |
|||
int block = 0; |
|||
return client() ? jsFromBinary(client()->codeAt(jsToAddress(_address), block)) : ""; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::coinbase() |
|||
{ |
|||
return client() ? toJS(client()->address()) : ""; |
|||
} |
|||
|
|||
double WebThreeStubServer::countAt(string const& _address) |
|||
{ |
|||
int block = 0; |
|||
return client() ? (double)(uint64_t)client()->countAt(jsToAddress(_address), block) : 0; |
|||
} |
|||
|
|||
int WebThreeStubServer::defaultBlock() |
|||
{ |
|||
return client() ? client()->getDefault() : 0; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::gasPrice() |
|||
{ |
|||
return toJS(10 * dev::eth::szabo); |
|||
} |
|||
|
|||
std::string WebThreeStubServer::get(std::string const& _name, std::string const& _key) |
|||
{ |
|||
bytes k = sha3(_name).asBytes() + sha3(_key).asBytes(); |
|||
string ret; |
|||
m_db->Get(m_readOptions, ldb::Slice((char const*)k.data(), k.size()), &ret); |
|||
return toJS(dev::asBytes(ret)); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::getMessages(int const& _id) |
|||
{ |
|||
if (!client()) |
|||
return Json::Value(); |
|||
return toJson(client()->messages(_id)); |
|||
} |
|||
|
|||
std::string WebThreeStubServer::getString(std::string const& _name, std::string const& _key) |
|||
{ |
|||
bytes k = sha3(_name).asBytes() + sha3(_key).asBytes(); |
|||
string ret; |
|||
m_db->Get(m_readOptions, ldb::Slice((char const*)k.data(), k.size()), &ret); |
|||
return ret; |
|||
} |
|||
|
|||
bool WebThreeStubServer::haveIdentity(std::string const& _id) |
|||
{ |
|||
return m_ids.count(jsToPublic(_id)) > 0; |
|||
} |
|||
|
|||
bool WebThreeStubServer::listening() |
|||
{ |
|||
return m_web3.isNetworkStarted(); |
|||
} |
|||
|
|||
bool WebThreeStubServer::mining() |
|||
{ |
|||
return client() ? client()->isMining() : false; |
|||
} |
|||
|
|||
int WebThreeStubServer::newFilter(Json::Value const& _json) |
|||
{ |
|||
unsigned ret = -1; |
|||
if (!client()) |
|||
return ret; |
|||
ret = client()->installWatch(toMessageFilter(_json)); |
|||
return ret; |
|||
} |
|||
|
|||
int WebThreeStubServer::newFilterString(std::string const& _filter) |
|||
{ |
|||
unsigned ret = -1; |
|||
if (!client()) |
|||
return ret; |
|||
if (_filter.compare("chain") == 0) |
|||
ret = client()->installWatch(dev::eth::ChainChangedFilter); |
|||
else if (_filter.compare("pending") == 0) |
|||
ret = client()->installWatch(dev::eth::PendingChangedFilter); |
|||
return ret; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::newGroup(std::string const& _id, std::string const& _who) |
|||
{ |
|||
(void)_id; |
|||
(void)_who; |
|||
return ""; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::newIdentity() |
|||
{ |
|||
KeyPair kp = KeyPair::create(); |
|||
m_ids[kp.pub()] = kp.secret(); |
|||
return toJS(kp.pub()); |
|||
} |
|||
|
|||
std::string WebThreeStubServer::compile(string const& _s) |
|||
{ |
|||
return toJS(dev::eth::compileLLL(_s)); |
|||
} |
|||
|
|||
int WebThreeStubServer::number() |
|||
{ |
|||
return client() ? client()->number() + 1 : 0; |
|||
} |
|||
|
|||
int WebThreeStubServer::peerCount() |
|||
{ |
|||
return m_web3.peerCount(); |
|||
} |
|||
|
|||
bool WebThreeStubServer::post(Json::Value const& _json) |
|||
{ |
|||
shh::Message m = toMessage(_json); |
|||
Secret from; |
|||
|
|||
if (m.from() && m_ids.count(m.from())) |
|||
{ |
|||
cwarn << "Silently signing message from identity" << m.from().abridged() << ": User validation hook goes here."; |
|||
// TODO: insert validification hook here.
|
|||
from = m_ids[m.from()]; |
|||
} |
|||
|
|||
face()->inject(toSealed(_json, m, from)); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::put(std::string const& _name, std::string const& _key, std::string const& _value) |
|||
{ |
|||
bytes k = sha3(_name).asBytes() + sha3(_key).asBytes(); |
|||
bytes v = jsToBytes(_value); |
|||
m_db->Put(m_writeOptions, ldb::Slice((char const*)k.data(), k.size()), ldb::Slice((char const*)v.data(), v.size())); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::putString(std::string const& _name, std::string const& _key, std::string const& _value) |
|||
{ |
|||
bytes k = sha3(_name).asBytes() + sha3(_key).asBytes(); |
|||
string v = _value; |
|||
m_db->Put(m_writeOptions, ldb::Slice((char const*)k.data(), k.size()), ldb::Slice((char const*)v.data(), v.size())); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::setCoinbase(std::string const& _address) |
|||
{ |
|||
if (!client()) |
|||
return false; |
|||
client()->setAddress(jsToAddress(_address)); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::setDefaultBlock(int const& _block) |
|||
{ |
|||
if (!client()) |
|||
return false; |
|||
client()->setDefault(_block); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::setListening(bool const& _listening) |
|||
{ |
|||
if (_listening) |
|||
m_web3.startNetwork(); |
|||
else |
|||
m_web3.stopNetwork(); |
|||
return true; |
|||
} |
|||
|
|||
bool WebThreeStubServer::setMining(bool const& _mining) |
|||
{ |
|||
if (!client()) |
|||
return false; |
|||
|
|||
if (_mining) |
|||
client()->startMining(); |
|||
else |
|||
client()->stopMining(); |
|||
return true; |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::shhChanged(int const& _id) |
|||
{ |
|||
Json::Value ret(Json::arrayValue); |
|||
auto pub = m_shhWatches[_id]; |
|||
if (!pub || m_ids.count(pub)) |
|||
for (h256 const& h: face()->checkWatch(_id)) |
|||
{ |
|||
auto e = face()->envelope(h); |
|||
shh::Message m; |
|||
if (pub) |
|||
{ |
|||
cwarn << "Silently decrypting message from identity" << pub.abridged() << ": User validation hook goes here."; |
|||
m = e.open(m_ids[pub]); |
|||
if (!m) |
|||
continue; |
|||
} |
|||
else |
|||
m = e.open(); |
|||
ret.append(toJson(h,e,m)); |
|||
} |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
int WebThreeStubServer::shhNewFilter(Json::Value const& _json) |
|||
{ |
|||
auto w = toWatch(_json); |
|||
auto ret = face()->installWatch(w.first); |
|||
m_shhWatches.insert(make_pair(ret, w.second)); |
|||
return ret; |
|||
} |
|||
|
|||
bool WebThreeStubServer::shhUninstallFilter(int const& _id) |
|||
{ |
|||
face()->uninstallWatch(_id); |
|||
return true; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::stateAt(string const& _address, string const& _storage) |
|||
{ |
|||
int block = 0; |
|||
return client() ? toJS(client()->stateAt(jsToAddress(_address), jsToU256(_storage), block)) : ""; |
|||
} |
|||
|
|||
std::string WebThreeStubServer::transact(Json::Value const& _json) |
|||
{ |
|||
std::string ret; |
|||
if (!client()) |
|||
return ret; |
|||
TransactionSkeleton t = toTransaction(_json); |
|||
if (!t.from && m_accounts.size()) |
|||
{ |
|||
auto b = m_accounts.begin()->first; |
|||
for (auto a: m_accounts) |
|||
if (client()->balanceAt(a.first) > client()->balanceAt(b)) |
|||
b = a.first; |
|||
t.from = b; |
|||
} |
|||
if (!m_accounts.count(t.from)) |
|||
return ret; |
|||
if (!t.gasPrice) |
|||
t.gasPrice = 10 * dev::eth::szabo; |
|||
if (!t.gas) |
|||
t.gas = min<u256>(client()->gasLimitRemaining(), client()->balanceAt(t.from) / t.gasPrice); |
|||
cwarn << "Silently signing transaction from address" << t.from.abridged() << ": User validation hook goes here."; |
|||
if (t.to) |
|||
// TODO: from qethereum, insert validification hook here.
|
|||
client()->transact(m_accounts[t.from].secret(), t.value, t.to, t.data, t.gas, t.gasPrice); |
|||
else |
|||
ret = toJS(client()->transact(m_accounts[t.from].secret(), t.value, t.data, t.gas, t.gasPrice)); |
|||
client()->flushTransactions(); |
|||
return ret; |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::transactionByHash(std::string const& _hash, int const& _i) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->transaction(jsToFixed<32>(_hash), _i)); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::transactionByNumber(int const& _number, int const& _i) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->transaction(client()->hashFromNumber(_number), _i)); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::uncleByHash(std::string const& _hash, int const& _i) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->uncle(jsToFixed<32>(_hash), _i)); |
|||
} |
|||
|
|||
Json::Value WebThreeStubServer::uncleByNumber(int const& _number, int const& _i) |
|||
{ |
|||
if (!client()) |
|||
return ""; |
|||
return toJson(client()->uncle(client()->hashFromNumber(_number), _i)); |
|||
} |
|||
|
|||
bool WebThreeStubServer::uninstallFilter(int const& _id) |
|||
{ |
|||
if (!client()) |
|||
return false; |
|||
client()->uninstallWatch(_id); |
|||
return true; |
|||
} |
|||
|
|||
@ -0,0 +1,124 @@ |
|||
/*
|
|||
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 WebThreeStubServer.h
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#pragma warning(push) |
|||
#pragma warning(disable: 4100 4267) |
|||
#include <leveldb/db.h> |
|||
#pragma warning(pop) |
|||
|
|||
#include <iostream> |
|||
#include <jsonrpc/rpc.h> |
|||
#include <libdevcrypto/Common.h> |
|||
#pragma GCC diagnostic push |
|||
#pragma GCC diagnostic ignored "-Wunused-parameter" |
|||
#include "abstractwebthreestubserver.h" |
|||
#pragma GCC diagnostic pop |
|||
|
|||
namespace ldb = leveldb; |
|||
|
|||
namespace dev |
|||
{ |
|||
class WebThreeDirect; |
|||
class KeyPair; |
|||
namespace eth |
|||
{ |
|||
class Interface; |
|||
} |
|||
namespace shh |
|||
{ |
|||
class Interface; |
|||
} |
|||
} |
|||
|
|||
/**
|
|||
* @brief JSON-RPC api implementation |
|||
* @todo filters should work on unsigned instead of int |
|||
* unsigned are not supported in json-rpc-cpp and there are bugs with double in json-rpc-cpp version 0.2.1 |
|||
*/ |
|||
class WebThreeStubServer: public AbstractWebThreeStubServer |
|||
{ |
|||
public: |
|||
WebThreeStubServer(jsonrpc::AbstractServerConnector* _conn, dev::WebThreeDirect& _web3, std::vector<dev::KeyPair> const& _accounts); |
|||
|
|||
virtual std::string account(); |
|||
virtual Json::Value accounts(); |
|||
virtual std::string addToGroup(std::string const& _group, std::string const& _who); |
|||
virtual std::string balanceAt(std::string const& _address); |
|||
virtual Json::Value blockByHash(std::string const& _hash); |
|||
virtual Json::Value blockByNumber(int const& _number); |
|||
virtual std::string call(Json::Value const& _json); |
|||
virtual bool changed(int const& _id); |
|||
virtual std::string codeAt(std::string const& _address); |
|||
virtual std::string coinbase(); |
|||
virtual std::string compile(std::string const& _s); |
|||
virtual double countAt(std::string const& _address); |
|||
virtual int defaultBlock(); |
|||
virtual std::string gasPrice(); |
|||
virtual std::string get(std::string const& _name, std::string const& _key); |
|||
virtual Json::Value getMessages(int const& _id); |
|||
virtual std::string getString(std::string const& _name, std::string const& _key); |
|||
virtual bool haveIdentity(std::string const& _id); |
|||
virtual bool listening(); |
|||
virtual bool mining(); |
|||
virtual int newFilter(Json::Value const& _json); |
|||
virtual int newFilterString(std::string const& _filter); |
|||
virtual std::string newGroup(std::string const& _id, std::string const& _who); |
|||
virtual std::string newIdentity(); |
|||
virtual int number(); |
|||
virtual int peerCount(); |
|||
virtual bool post(Json::Value const& _json); |
|||
virtual bool put(std::string const& _name, std::string const& _key, std::string const& _value); |
|||
virtual bool putString(std::string const& _name, std::string const& _key, std::string const& _value); |
|||
virtual bool setCoinbase(std::string const& _address); |
|||
virtual bool setDefaultBlock(int const& _block); |
|||
virtual bool setListening(bool const& _listening); |
|||
virtual bool setMining(bool const& _mining); |
|||
virtual Json::Value shhChanged(int const& _id); |
|||
virtual int shhNewFilter(Json::Value const& _json); |
|||
virtual bool shhUninstallFilter(int const& _id); |
|||
virtual std::string stateAt(std::string const& _address, std::string const& _storage); |
|||
virtual std::string transact(Json::Value const& _json); |
|||
virtual Json::Value transactionByHash(std::string const& _hash, int const& _i); |
|||
virtual Json::Value transactionByNumber(int const& _number, int const& _i); |
|||
virtual Json::Value uncleByHash(std::string const& _hash, int const& _i); |
|||
virtual Json::Value uncleByNumber(int const& _number, int const& _i); |
|||
virtual bool uninstallFilter(int const& _id); |
|||
|
|||
void setAccounts(std::vector<dev::KeyPair> const& _accounts); |
|||
void setIdentities(std::vector<dev::KeyPair> const& _ids); |
|||
std::map<dev::Public, dev::Secret> const& ids() const { return m_ids; } |
|||
private: |
|||
dev::eth::Interface* client() const; |
|||
std::shared_ptr<dev::shh::Interface> face() const; |
|||
dev::WebThreeDirect& m_web3; |
|||
std::map<dev::Address, dev::KeyPair> m_accounts; |
|||
|
|||
ldb::ReadOptions m_readOptions; |
|||
ldb::WriteOptions m_writeOptions; |
|||
ldb::DB* m_db; |
|||
|
|||
std::map<dev::Public, dev::Secret> m_ids; |
|||
std::map<unsigned, dev::Public> m_shhWatches; |
|||
}; |
|||
@ -0,0 +1,323 @@ |
|||
/**
|
|||
* THIS FILE IS GENERATED BY jsonrpcstub, DO NOT CHANGE IT!!!!! |
|||
*/ |
|||
|
|||
#ifndef _ABSTRACTWEBTHREESTUBSERVER_H_ |
|||
#define _ABSTRACTWEBTHREESTUBSERVER_H_ |
|||
|
|||
#include <jsonrpc/rpc.h> |
|||
|
|||
class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThreeStubServer> |
|||
{ |
|||
public: |
|||
AbstractWebThreeStubServer(jsonrpc::AbstractServerConnector* conn) : |
|||
jsonrpc::AbstractServer<AbstractWebThreeStubServer>(conn) |
|||
{ |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("account", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::accountI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("accounts", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_ARRAY, NULL), &AbstractWebThreeStubServer::accountsI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("addToGroup", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::addToGroupI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("balanceAt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::balanceAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("blockByHash", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::blockByHashI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("blockByNumber", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::blockByNumberI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("call", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_OBJECT, NULL), &AbstractWebThreeStubServer::callI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("changed", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::changedI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("codeAt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::codeAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("coinbase", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::coinbaseI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("compile", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::compileI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("countAt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_REAL, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::countAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("defaultBlock", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::defaultBlockI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("gasPrice", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::gasPriceI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("get", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::getI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("getMessages", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_ARRAY, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::getMessagesI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("getString", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::getStringI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("haveIdentity", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::haveIdentityI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("listening", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, NULL), &AbstractWebThreeStubServer::listeningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("mining", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, NULL), &AbstractWebThreeStubServer::miningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("newFilter", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, "param1",jsonrpc::JSON_OBJECT, NULL), &AbstractWebThreeStubServer::newFilterI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("newFilterString", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::newFilterStringI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("newGroup", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::newGroupI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("newIdentity", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::newIdentityI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("number", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::numberI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("peerCount", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::peerCountI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("post", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_OBJECT, NULL), &AbstractWebThreeStubServer::postI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("put", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING,"param3",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::putI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("putString", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING,"param3",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::putStringI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("setCoinbase", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::setCoinbaseI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("setDefaultBlock", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::setDefaultBlockI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("setListening", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_BOOLEAN, NULL), &AbstractWebThreeStubServer::setListeningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("setMining", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_BOOLEAN, NULL), &AbstractWebThreeStubServer::setMiningI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("shhChanged", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_ARRAY, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::shhChangedI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("shhNewFilter", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_INTEGER, "param1",jsonrpc::JSON_OBJECT, NULL), &AbstractWebThreeStubServer::shhNewFilterI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("shhUninstallFilter", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::shhUninstallFilterI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("stateAt", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_STRING, NULL), &AbstractWebThreeStubServer::stateAtI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("transact", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING, "param1",jsonrpc::JSON_OBJECT, NULL), &AbstractWebThreeStubServer::transactI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("transactionByHash", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::transactionByHashI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("transactionByNumber", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_INTEGER,"param2",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::transactionByNumberI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("uncleByHash", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_STRING,"param2",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::uncleByHashI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("uncleByNumber", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_OBJECT, "param1",jsonrpc::JSON_INTEGER,"param2",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::uncleByNumberI); |
|||
this->bindAndAddMethod(new jsonrpc::Procedure("uninstallFilter", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN, "param1",jsonrpc::JSON_INTEGER, NULL), &AbstractWebThreeStubServer::uninstallFilterI); |
|||
|
|||
} |
|||
|
|||
inline virtual void accountI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->account(); |
|||
} |
|||
|
|||
inline virtual void accountsI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->accounts(); |
|||
} |
|||
|
|||
inline virtual void addToGroupI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->addToGroup(request[0u].asString(), request[1u].asString()); |
|||
} |
|||
|
|||
inline virtual void balanceAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->balanceAt(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void blockByHashI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->blockByHash(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void blockByNumberI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->blockByNumber(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void callI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->call(request[0u]); |
|||
} |
|||
|
|||
inline virtual void changedI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->changed(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void codeAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->codeAt(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void coinbaseI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->coinbase(); |
|||
} |
|||
|
|||
inline virtual void compileI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->compile(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void countAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->countAt(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void defaultBlockI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->defaultBlock(); |
|||
} |
|||
|
|||
inline virtual void gasPriceI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->gasPrice(); |
|||
} |
|||
|
|||
inline virtual void getI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->get(request[0u].asString(), request[1u].asString()); |
|||
} |
|||
|
|||
inline virtual void getMessagesI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->getMessages(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void getStringI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->getString(request[0u].asString(), request[1u].asString()); |
|||
} |
|||
|
|||
inline virtual void haveIdentityI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->haveIdentity(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void listeningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->listening(); |
|||
} |
|||
|
|||
inline virtual void miningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->mining(); |
|||
} |
|||
|
|||
inline virtual void newFilterI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->newFilter(request[0u]); |
|||
} |
|||
|
|||
inline virtual void newFilterStringI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->newFilterString(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void newGroupI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->newGroup(request[0u].asString(), request[1u].asString()); |
|||
} |
|||
|
|||
inline virtual void newIdentityI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->newIdentity(); |
|||
} |
|||
|
|||
inline virtual void numberI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->number(); |
|||
} |
|||
|
|||
inline virtual void peerCountI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->peerCount(); |
|||
} |
|||
|
|||
inline virtual void postI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->post(request[0u]); |
|||
} |
|||
|
|||
inline virtual void putI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->put(request[0u].asString(), request[1u].asString(), request[2u].asString()); |
|||
} |
|||
|
|||
inline virtual void putStringI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->putString(request[0u].asString(), request[1u].asString(), request[2u].asString()); |
|||
} |
|||
|
|||
inline virtual void setCoinbaseI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->setCoinbase(request[0u].asString()); |
|||
} |
|||
|
|||
inline virtual void setDefaultBlockI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->setDefaultBlock(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void setListeningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->setListening(request[0u].asBool()); |
|||
} |
|||
|
|||
inline virtual void setMiningI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->setMining(request[0u].asBool()); |
|||
} |
|||
|
|||
inline virtual void shhChangedI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->shhChanged(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void shhNewFilterI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->shhNewFilter(request[0u]); |
|||
} |
|||
|
|||
inline virtual void shhUninstallFilterI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->shhUninstallFilter(request[0u].asInt()); |
|||
} |
|||
|
|||
inline virtual void stateAtI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->stateAt(request[0u].asString(), request[1u].asString()); |
|||
} |
|||
|
|||
inline virtual void transactI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->transact(request[0u]); |
|||
} |
|||
|
|||
inline virtual void transactionByHashI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->transactionByHash(request[0u].asString(), request[1u].asInt()); |
|||
} |
|||
|
|||
inline virtual void transactionByNumberI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->transactionByNumber(request[0u].asInt(), request[1u].asInt()); |
|||
} |
|||
|
|||
inline virtual void uncleByHashI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->uncleByHash(request[0u].asString(), request[1u].asInt()); |
|||
} |
|||
|
|||
inline virtual void uncleByNumberI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->uncleByNumber(request[0u].asInt(), request[1u].asInt()); |
|||
} |
|||
|
|||
inline virtual void uninstallFilterI(const Json::Value& request, Json::Value& response) |
|||
{ |
|||
response = this->uninstallFilter(request[0u].asInt()); |
|||
} |
|||
|
|||
|
|||
virtual std::string account() = 0; |
|||
virtual Json::Value accounts() = 0; |
|||
virtual std::string addToGroup(const std::string& param1, const std::string& param2) = 0; |
|||
virtual std::string balanceAt(const std::string& param1) = 0; |
|||
virtual Json::Value blockByHash(const std::string& param1) = 0; |
|||
virtual Json::Value blockByNumber(const int& param1) = 0; |
|||
virtual std::string call(const Json::Value& param1) = 0; |
|||
virtual bool changed(const int& param1) = 0; |
|||
virtual std::string codeAt(const std::string& param1) = 0; |
|||
virtual std::string coinbase() = 0; |
|||
virtual std::string compile(const std::string& param1) = 0; |
|||
virtual double countAt(const std::string& param1) = 0; |
|||
virtual int defaultBlock() = 0; |
|||
virtual std::string gasPrice() = 0; |
|||
virtual std::string get(const std::string& param1, const std::string& param2) = 0; |
|||
virtual Json::Value getMessages(const int& param1) = 0; |
|||
virtual std::string getString(const std::string& param1, const std::string& param2) = 0; |
|||
virtual bool haveIdentity(const std::string& param1) = 0; |
|||
virtual bool listening() = 0; |
|||
virtual bool mining() = 0; |
|||
virtual int newFilter(const Json::Value& param1) = 0; |
|||
virtual int newFilterString(const std::string& param1) = 0; |
|||
virtual std::string newGroup(const std::string& param1, const std::string& param2) = 0; |
|||
virtual std::string newIdentity() = 0; |
|||
virtual int number() = 0; |
|||
virtual int peerCount() = 0; |
|||
virtual bool post(const Json::Value& param1) = 0; |
|||
virtual bool put(const std::string& param1, const std::string& param2, const std::string& param3) = 0; |
|||
virtual bool putString(const std::string& param1, const std::string& param2, const std::string& param3) = 0; |
|||
virtual bool setCoinbase(const std::string& param1) = 0; |
|||
virtual bool setDefaultBlock(const int& param1) = 0; |
|||
virtual bool setListening(const bool& param1) = 0; |
|||
virtual bool setMining(const bool& param1) = 0; |
|||
virtual Json::Value shhChanged(const int& param1) = 0; |
|||
virtual int shhNewFilter(const Json::Value& param1) = 0; |
|||
virtual bool shhUninstallFilter(const int& param1) = 0; |
|||
virtual std::string stateAt(const std::string& param1, const std::string& param2) = 0; |
|||
virtual std::string transact(const Json::Value& param1) = 0; |
|||
virtual Json::Value transactionByHash(const std::string& param1, const int& param2) = 0; |
|||
virtual Json::Value transactionByNumber(const int& param1, const int& param2) = 0; |
|||
virtual Json::Value uncleByHash(const std::string& param1, const int& param2) = 0; |
|||
virtual Json::Value uncleByNumber(const int& param1, const int& param2) = 0; |
|||
virtual bool uninstallFilter(const int& param1) = 0; |
|||
|
|||
}; |
|||
#endif //_ABSTRACTWEBTHREESTUBSERVER_H_
|
|||
@ -0,0 +1,55 @@ |
|||
[ |
|||
{ "method": "coinbase", "params": [], "order": [], "returns" : "" }, |
|||
{ "method": "setCoinbase", "params": [""], "order": [], "returns" : true }, |
|||
{ "method": "listening", "params": [], "order": [], "returns" : false }, |
|||
{ "method": "setListening", "params": [false], "order" : [], "returns" : true }, |
|||
{ "method": "mining", "params": [], "order": [], "returns" : false }, |
|||
{ "method": "setMining", "params": [false], "order" : [], "returns" : true }, |
|||
{ "method": "gasPrice", "params": [], "order": [], "returns" : "" }, |
|||
{ "method": "account", "params": [], "order": [], "returns" : "" }, |
|||
{ "method": "accounts", "params": [], "order": [], "returns" : [] }, |
|||
{ "method": "peerCount", "params": [], "order": [], "returns" : 0 }, |
|||
{ "method": "defaultBlock", "params": [], "order": [], "returns" : 0}, |
|||
{ "method": "setDefaultBlock", "params": [0], "order": [], "returns" : true}, |
|||
{ "method": "number", "params": [], "order": [], "returns" : 0}, |
|||
|
|||
{ "method": "balanceAt", "params": [""], "order": [], "returns" : ""}, |
|||
{ "method": "stateAt", "params": ["", ""], "order": [], "returns": ""}, |
|||
{ "method": "countAt", "params": [""], "order": [], "returns" : 0.0}, |
|||
{ "method": "codeAt", "params": [""], "order": [], "returns": ""}, |
|||
|
|||
{ "method": "transact", "params": [{}], "order": [], "returns": ""}, |
|||
{ "method": "call", "params": [{}], "order": [], "returns": ""}, |
|||
|
|||
{ "method": "blockByHash", "params": [""],"order": [], "returns": {}}, |
|||
{ "method": "blockByNumber", "params": [0],"order": [], "returns": {}}, |
|||
{ "method": "transactionByHash", "params": ["", 0], "order": [], "returns": {}}, |
|||
{ "method": "transactionByNumber", "params": [0, 0], "order": [], "returns": {}}, |
|||
{ "method": "uncleByHash", "params": ["", 0], "order": [], "returns": {}}, |
|||
{ "method": "uncleByNumber", "params": [0, 0], "order": [], "returns": {}}, |
|||
|
|||
{ "method": "compile", "params": [""], "order": [], "returns": ""}, |
|||
|
|||
{ "method": "newFilter", "params": [{}], "order": [], "returns": 0}, |
|||
{ "method": "newFilterString", "params": [""], "order": [], "returns": 0}, |
|||
{ "method": "uninstallFilter", "params": [0], "order": [], "returns": true}, |
|||
{ "method": "changed", "params": [0], "order": [], "returns": false}, |
|||
{ "method": "getMessages", "params": [0], "order": [], "returns": []}, |
|||
|
|||
{ "method": "put", "params": ["", "", ""], "order": [], "returns": true}, |
|||
{ "method": "get", "params": ["", ""], "order": [], "returns": ""}, |
|||
{ "method": "putString", "params": ["", "", ""], "order": [], "returns": true}, |
|||
{ "method": "getString", "params": ["", ""], "order": [], "returns": ""}, |
|||
|
|||
{ "method": "post", "params": [{}], "order": [], "returns": true}, |
|||
{ "method": "newIdentity", "params": [], "order": [], "returns": ""}, |
|||
{ "method": "haveIdentity", "params": [""], "order": [], "returns": false}, |
|||
{ "method": "newGroup", "params": ["", ""], "order": [], "returns": ""}, |
|||
{ "method": "addToGroup", "params": ["", ""], "order": [], "returns": ""}, |
|||
|
|||
{ "method": "shhNewFilter", "params": [{}], "order": [], "returns": 0}, |
|||
{ "method": "shhUninstallFilter", "params": [0], "order": [], "returns": true}, |
|||
{ "method": "shhChanged", "params": [0], "order": [], "returns": []} |
|||
|
|||
] |
|||
|
|||
@ -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 |
|||
@ -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 name and type resolution of the solidity parser. |
|||
*/ |
|||
|
|||
#include <string> |
|||
|
|||
#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> |
|||
|
|||
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; |
|||
}; |
|||
|
|||
bytes compileFirstExpression(std::string const& _sourceCode) |
|||
{ |
|||
Parser parser; |
|||
ASTPointer<ContractDefinition> contract; |
|||
BOOST_REQUIRE_NO_THROW(contract = parser.parse(std::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(); |
|||
// debug
|
|||
//std::cout << eth::disassemble(instructions) << std::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::NOT)}); |
|||
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::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()); |
|||
} |
|||
|
|||
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::MOD), |
|||
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), 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()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
|
|||
@ -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_
|
|||
Loading…
Reference in new issue