lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge branch 'develop' of github.com:ethereum/cpp-ethereum into develop 

Conflicts:
	libsolidity/InterfaceHandler.cpp
cl-refactor
Gav Wood 10 years ago
parent
d5c2a6b26a bd45ebb3a3
commit
01332f735d
22 changed files with 1522 additions and 817 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 995
      libjsqrc/ethereumjs/dist/ethereum.js
  2. 20
      libjsqrc/ethereumjs/dist/ethereum.js.map
  3. 2
      libjsqrc/ethereumjs/dist/ethereum.min.js
  4. 55
      libjsqrc/ethereumjs/example/event.html
  5. 317
      libjsqrc/ethereumjs/lib/abi.js
  6. 33
      libjsqrc/ethereumjs/lib/const.js
  7. 55
      libjsqrc/ethereumjs/lib/contract.js
  8. 44
      libjsqrc/ethereumjs/lib/event.js
  9. 11
      libjsqrc/ethereumjs/lib/filter.js
  10. 154
      libjsqrc/ethereumjs/lib/formatters.js
  11. 79
      libjsqrc/ethereumjs/lib/types.js
  12. 113
      libjsqrc/ethereumjs/lib/utils.js
  13. 55
      libjsqrc/ethereumjs/lib/web3.js
  14. 110
      libjsqrc/ethereumjs/test/event.js
  15. 8
      libjsqrc/ethereumjs/test/utils.filters.js
  16. 17
      libsolidity/AST.cpp
  17. 4
      libsolidity/AST.h
  18. 67
      libsolidity/InterfaceHandler.cpp
  19. 7
      libsolidity/NameAndTypeResolver.cpp
  20. 23
      libsolidity/NameAndTypeResolver.h
  21. 157
      test/SolidityABIJSON.cpp
  22. 9
      test/SolidityNameAndTypeResolution.cpp

995
libjsqrc/ethereumjs/dist/ethereum.js
View File

File diff suppressed because it is too large

20
libjsqrc/ethereumjs/dist/ethereum.js.map
View File

File diff suppressed because one or more lines are too long

2
libjsqrc/ethereumjs/dist/ethereum.min.js
View File

File diff suppressed because one or more lines are too long

55
libjsqrc/ethereumjs/example/event.html
View File

@ -27,25 +27,63 @@
var contract = web3.eth.contract(address, desc); var contract = web3.eth.contract(address, desc);
function test1() { function test1() {
// "{"topic":["0x83c9849c","0xc4d76332"],"address":"0x01"}"
web3.eth.watch(contract).changed(function (res) { web3.eth.watch(contract).changed(function (res) {
}); });
}; };
function test2() { function test2() {
// "{"topic":["0x83c9849c"],"address":"0x01"}"
web3.eth.watch(contract.Event).changed(function (res) { web3.eth.watch(contract.Event).changed(function (res) {
}); });
}; };
function test3() { function test3() {
// "{"topic":["0x83c9849c"],"address":"0x01"}"
contract.Event().changed(function (res) { contract.Event().changed(function (res) {
}); });
}; };
function test4() {
// "{"topic":["0x83c9849c","0000000000000000000000000000000000000000000000000000000000000045"],"address":"0x01"}"
contract.Event({a: 69}).changed(function (res) {
});
};
function test5() {
// "{"topic":["0x83c9849c",["0000000000000000000000000000000000000000000000000000000000000045","000000000000000000000000000000000000000000000000000000000000002a"]],"address":"0x01"}"
contract.Event({a: [69, 42]}).changed(function (res) {
});
};
function test6() {
// "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"max":100,"address":"0x01"}"
contract.Event({a: 30}, {max: 100}).changed(function (res) {
});
};
function test7() {
// "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"address":"0x01"}"
web3.eth.watch(contract.Event, {a: 30}).changed(function (res) {
});
};
function test8() {
// "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"max":100,"address":"0x01"}"
web3.eth.watch(contract.Event, {a: 30}, {max: 100}).changed(function (res) {
});
};
// not valid // not valid
// function test4() { // function testX() {
// web3.eth.watch([contract.Event, contract.Event2]).changed(function (res) { // web3.eth.watch([contract.Event, contract.Event2]).changed(function (res) {
// }); // });
// }; // };
@ -63,5 +101,20 @@
<div> <div>
<button type="button" onClick="test3();">test3</button> <button type="button" onClick="test3();">test3</button>
</div> </div>
<div>
<button type="button" onClick="test4();">test4</button>
</div>
<div>
<button type="button" onClick="test5();">test5</button>
</div>
<div>
<button type="button" onClick="test6();">test6</button>
</div>
<div>
<button type="button" onClick="test7();">test7</button>
</div>
<div>
<button type="button" onClick="test8();">test8</button>
</div>
</body> </body>
</html> </html>

317
libjsqrc/ethereumjs/lib/abi.js
View File

@ -21,191 +21,57 @@
* @date 2014 * @date 2014
*/ */
// TODO: is these line is supposed to be here? var web3 = require('./web3');
if (process.env.NODE_ENV !== 'build') { var utils = require('./utils');
var BigNumber = require('bignumber.js'); // jshint ignore:line var types = require('./types');
} var c = require('./const');
var f = require('./formatters');
var web3 = require('./web3'); // jshint ignore:line
BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_DOWN });
var ETH_PADDING = 32;
/// method signature length in bytes
var ETH_METHOD_SIGNATURE_LENGTH = 4;
/// Finds first index of array element matching pattern
/// @param array
/// @param callback pattern
/// @returns index of element
var findIndex = function (array, callback) {
var end = false;
var i = 0;
for (; i < array.length && !end; i++) {
end = callback(array[i]);
}
return end ? i - 1 : -1;
};
/// @returns a function that is used as a pattern for 'findIndex'
var findMethodIndex = function (json, methodName) {
return findIndex(json, function (method) {
return method.name === methodName;
});
};
/// @returns method with given method name
var getMethodWithName = function (json, methodName) {
var index = findMethodIndex(json, methodName);
if (index === -1) {
console.error('method ' + methodName + ' not found in the abi');
return undefined;
}
return json[index];
};
/// Filters all function from input abi
/// @returns abi array with filtered objects of type 'function'
var filterFunctions = function (json) {
return json.filter(function (current) {
return current.type === 'function';
});
};
/// Filters all events form input abi
/// @returns abi array with filtered objects of type 'event'
var filterEvents = function (json) {
return json.filter(function (current) {
return current.type === 'event';
});
};
/// @param string string to be padded
/// @param number of characters that result string should have
/// @param sign, by default 0
/// @returns right aligned string
var padLeft = function (string, chars, sign) {
return new Array(chars - string.length + 1).join(sign ? sign : "0") + string;
};
/// @param expected type prefix (string)
/// @returns function which checks if type has matching prefix. if yes, returns true, otherwise false
var prefixedType = function (prefix) {
return function (type) {
return type.indexOf(prefix) === 0;
};
};
/// @param expected type name (string) var displayTypeError = function (type) {
/// @returns function which checks if type is matching expected one. if yes, returns true, otherwise false console.error('parser does not support type: ' + type);
var namedType = function (name) {
return function (type) {
return name === type;
};
}; };
/// This method should be called if we want to check if givent type is an array type
/// @returns true if it is, otherwise false
var arrayType = function (type) { var arrayType = function (type) {
return type.slice(-2) === '[]'; return type.slice(-2) === '[]';
}; };
/// Formats input value to byte representation of int
/// If value is negative, return it's two's complement
/// If the value is floating point, round it down
/// @returns right-aligned byte representation of int
var formatInputInt = function (value) {
var padding = ETH_PADDING * 2;
if (value instanceof BigNumber || typeof value === 'number') {
if (typeof value === 'number')
value = new BigNumber(value);
value = value.round();
if (value.lessThan(0))
value = new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(value).plus(1);
value = value.toString(16);
}
else if (value.indexOf('0x') === 0)
value = value.substr(2);
else if (typeof value === 'string')
value = formatInputInt(new BigNumber(value));
else
value = (+value).toString(16);
return padLeft(value, padding);
};
/// Formats input value to byte representation of string
/// @returns left-algined byte representation of string
var formatInputString = function (value) {
return web3.fromAscii(value, ETH_PADDING).substr(2);
};
/// Formats input value to byte representation of bool
/// @returns right-aligned byte representation bool
var formatInputBool = function (value) {
return '000000000000000000000000000000000000000000000000000000000000000' + (value ? '1' : '0');
};
/// Formats input value to byte representation of real
/// Values are multiplied by 2^m and encoded as integers
/// @returns byte representation of real
var formatInputReal = function (value) {
return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128)));
};
var dynamicTypeBytes = function (type, value) { var dynamicTypeBytes = function (type, value) {
// TODO: decide what to do with array of strings // TODO: decide what to do with array of strings
if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length. if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length.
return formatInputInt(value.length); return f.formatInputInt(value.length);
return ""; return "";
}; };
/// Setups input formatters for solidity types var inputTypes = types.inputTypes();
/// @returns an array of input formatters
var setupInputTypes = function () {
return [
{ type: prefixedType('uint'), format: formatInputInt },
{ type: prefixedType('int'), format: formatInputInt },
{ type: prefixedType('hash'), format: formatInputInt },
{ type: prefixedType('string'), format: formatInputString },
{ type: prefixedType('real'), format: formatInputReal },
{ type: prefixedType('ureal'), format: formatInputReal },
{ type: namedType('address'), format: formatInputInt },
{ type: namedType('bool'), format: formatInputBool }
];
};
var inputTypes = setupInputTypes();
/// Formats input params to bytes /// Formats input params to bytes
/// @param contract json abi /// @param abi contract method inputs
/// @param name of the method that we want to use
/// @param array of params that will be formatted to bytes /// @param array of params that will be formatted to bytes
/// @returns bytes representation of input params /// @returns bytes representation of input params
var toAbiInput = function (json, methodName, params) { var formatInput = function (inputs, params) {
var bytes = ""; var bytes = "";
var padding = c.ETH_PADDING * 2;
var method = getMethodWithName(json, methodName);
var padding = ETH_PADDING * 2;
/// first we iterate in search for dynamic /// first we iterate in search for dynamic
method.inputs.forEach(function (input, index) { inputs.forEach(function (input, index) {
bytes += dynamicTypeBytes(input.type, params[index]); bytes += dynamicTypeBytes(input.type, params[index]);
}); });
method.inputs.forEach(function (input, i) { inputs.forEach(function (input, i) {
var typeMatch = false; var typeMatch = false;
for (var j = 0; j < inputTypes.length && !typeMatch; j++) { for (var j = 0; j < inputTypes.length && !typeMatch; j++) {
typeMatch = inputTypes[j].type(method.inputs[i].type, params[i]); typeMatch = inputTypes[j].type(inputs[i].type, params[i]);
} }
if (!typeMatch) { if (!typeMatch) {
console.error('input parser does not support type: ' + method.inputs[i].type); displayTypeError(inputs[i].type);
} }
var formatter = inputTypes[j - 1].format; var formatter = inputTypes[j - 1].format;
var toAppend = ""; var toAppend = "";
if (arrayType(method.inputs[i].type)) if (arrayType(inputs[i].type))
toAppend = params[i].reduce(function (acc, curr) { toAppend = params[i].reduce(function (acc, curr) {
return acc + formatter(curr); return acc + formatter(curr);
}, ""); }, "");
@ -217,118 +83,44 @@ var toAbiInput = function (json, methodName, params) {
return bytes; return bytes;
}; };
/// Check if input value is negative
/// @param value is hex format
/// @returns true if it is negative, otherwise false
var signedIsNegative = function (value) {
return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';
};
/// Formats input right-aligned input bytes to int
/// @returns right-aligned input bytes formatted to int
var formatOutputInt = function (value) {
value = value || "0";
// check if it's negative number
// it it is, return two's complement
if (signedIsNegative(value)) {
return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);
}
return new BigNumber(value, 16);
};
/// Formats big right-aligned input bytes to uint
/// @returns right-aligned input bytes formatted to uint
var formatOutputUInt = function (value) {
value = value || "0";
return new BigNumber(value, 16);
};
/// @returns input bytes formatted to real
var formatOutputReal = function (value) {
return formatOutputInt(value).dividedBy(new BigNumber(2).pow(128));
};
/// @returns input bytes formatted to ureal
var formatOutputUReal = function (value) {
return formatOutputUInt(value).dividedBy(new BigNumber(2).pow(128));
};
/// @returns right-aligned input bytes formatted to hex
var formatOutputHash = function (value) {
return "0x" + value;
};
/// @returns right-aligned input bytes formatted to bool
var formatOutputBool = function (value) {
return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
};
/// @returns left-aligned input bytes formatted to ascii string
var formatOutputString = function (value) {
return web3.toAscii(value);
};
/// @returns right-aligned input bytes formatted to address
var formatOutputAddress = function (value) {
return "0x" + value.slice(value.length - 40, value.length);
};
var dynamicBytesLength = function (type) { var dynamicBytesLength = function (type) {
if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length. if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length.
return ETH_PADDING * 2; return c.ETH_PADDING * 2;
return 0; return 0;
}; };
/// Setups output formaters for solidity types var outputTypes = types.outputTypes();
/// @returns an array of output formatters
var setupOutputTypes = function () {
return [
{ type: prefixedType('uint'), format: formatOutputUInt },
{ type: prefixedType('int'), format: formatOutputInt },
{ type: prefixedType('hash'), format: formatOutputHash },
{ type: prefixedType('string'), format: formatOutputString },
{ type: prefixedType('real'), format: formatOutputReal },
{ type: prefixedType('ureal'), format: formatOutputUReal },
{ type: namedType('address'), format: formatOutputAddress },
{ type: namedType('bool'), format: formatOutputBool }
];
};
var outputTypes = setupOutputTypes();
/// Formats output bytes back to param list /// Formats output bytes back to param list
/// @param contract json abi /// @param contract abi method outputs
/// @param name of the method that we want to use
/// @param bytes representtion of output /// @param bytes representtion of output
/// @returns array of output params /// @returns array of output params
var fromAbiOutput = function (json, methodName, output) { var formatOutput = function (outs, output) {
output = output.slice(2); output = output.slice(2);
var result = []; var result = [];
var method = getMethodWithName(json, methodName); var padding = c.ETH_PADDING * 2;
var padding = ETH_PADDING * 2;
var dynamicPartLength = method.outputs.reduce(function (acc, curr) { var dynamicPartLength = outs.reduce(function (acc, curr) {
return acc + dynamicBytesLength(curr.type); return acc + dynamicBytesLength(curr.type);
}, 0); }, 0);
var dynamicPart = output.slice(0, dynamicPartLength); var dynamicPart = output.slice(0, dynamicPartLength);
output = output.slice(dynamicPartLength); output = output.slice(dynamicPartLength);
method.outputs.forEach(function (out, i) { outs.forEach(function (out, i) {
var typeMatch = false; var typeMatch = false;
for (var j = 0; j < outputTypes.length && !typeMatch; j++) { for (var j = 0; j < outputTypes.length && !typeMatch; j++) {
typeMatch = outputTypes[j].type(method.outputs[i].type); typeMatch = outputTypes[j].type(outs[i].type);
} }
if (!typeMatch) { if (!typeMatch) {
console.error('output parser does not support type: ' + method.outputs[i].type); displayTypeError(outs[i].type);
} }
var formatter = outputTypes[j - 1].format; var formatter = outputTypes[j - 1].format;
if (arrayType(method.outputs[i].type)) { if (arrayType(outs[i].type)) {
var size = formatOutputUInt(dynamicPart.slice(0, padding)); var size = f.formatOutputUInt(dynamicPart.slice(0, padding));
dynamicPart = dynamicPart.slice(padding); dynamicPart = dynamicPart.slice(padding);
var array = []; var array = [];
for (var k = 0; k < size; k++) { for (var k = 0; k < size; k++) {
@ -337,7 +129,7 @@ var fromAbiOutput = function (json, methodName, output) {
} }
result.push(array); result.push(array);
} }
else if (prefixedType('string')(method.outputs[i].type)) { else if (types.prefixedType('string')(outs[i].type)) {
dynamicPart = dynamicPart.slice(padding); dynamicPart = dynamicPart.slice(padding);
result.push(formatter(output.slice(0, padding))); result.push(formatter(output.slice(0, padding)));
output = output.slice(padding); output = output.slice(padding);
@ -350,30 +142,18 @@ var fromAbiOutput = function (json, methodName, output) {
return result; return result;
}; };
/// @returns display name for method eg. multiply(uint256) -> multiply
var methodDisplayName = function (method) {
var length = method.indexOf('(');
return length !== -1 ? method.substr(0, length) : method;
};
/// @returns overloaded part of method's name
var methodTypeName = function (method) {
/// TODO: make it not vulnerable
var length = method.indexOf('(');
return length !== -1 ? method.substr(length + 1, method.length - 1 - (length + 1)) : "";
};
/// @param json abi for contract /// @param json abi for contract
/// @returns input parser object for given json abi /// @returns input parser object for given json abi
/// TODO: refactor creating the parser, do not double logic from contract
var inputParser = function (json) { var inputParser = function (json) {
var parser = {}; var parser = {};
filterFunctions(json).forEach(function (method) { json.forEach(function (method) {
var displayName = methodDisplayName(method.name); var displayName = utils.extractDisplayName(method.name);
var typeName = methodTypeName(method.name); var typeName = utils.extractTypeName(method.name);
var impl = function () { var impl = function () {
var params = Array.prototype.slice.call(arguments); var params = Array.prototype.slice.call(arguments);
return toAbiInput(json, method.name, params); return formatInput(method.inputs, params);
}; };
if (parser[displayName] === undefined) { if (parser[displayName] === undefined) {
@ -390,13 +170,13 @@ var inputParser = function (json) {
/// @returns output parser for given json abi /// @returns output parser for given json abi
var outputParser = function (json) { var outputParser = function (json) {
var parser = {}; var parser = {};
filterFunctions(json).forEach(function (method) { json.forEach(function (method) {
var displayName = methodDisplayName(method.name); var displayName = utils.extractDisplayName(method.name);
var typeName = methodTypeName(method.name); var typeName = utils.extractTypeName(method.name);
var impl = function (output) { var impl = function (output) {
return fromAbiOutput(json, method.name, output); return formatOutput(method.outputs, output);
}; };
if (parser[displayName] === undefined) { if (parser[displayName] === undefined) {
@ -409,20 +189,17 @@ var outputParser = function (json) {
return parser; return parser;
}; };
/// @param method name for which we want to get method signature /// @param function/event name for which we want to get signature
/// @returns (promise) contract method signature for method with given name /// @returns signature of function/event with given name
var methodSignature = function (name) { var signatureFromAscii = function (name) {
return web3.sha3(web3.fromAscii(name)).slice(0, 2 + ETH_METHOD_SIGNATURE_LENGTH * 2); return web3.sha3(web3.fromAscii(name)).slice(0, 2 + c.ETH_SIGNATURE_LENGTH * 2);
}; };
module.exports = { module.exports = {
inputParser: inputParser, inputParser: inputParser,
outputParser: outputParser, outputParser: outputParser,
methodSignature: methodSignature, formatInput: formatInput,
methodDisplayName: methodDisplayName, formatOutput: formatOutput,
methodTypeName: methodTypeName, signatureFromAscii: signatureFromAscii
getMethodWithName: getMethodWithName,
filterFunctions: filterFunctions,
filterEvents: filterEvents
}; };

33
libjsqrc/ethereumjs/lib/const.js
View File

@ -0,0 +1,33 @@
/*
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 Lesser 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file const.js
* @authors:
* Marek Kotewicz <marek@ethdev.com>
* @date 2015
*/
/// required to define ETH_BIGNUMBER_ROUNDING_MODE
if (process.env.NODE_ENV !== 'build') {
var BigNumber = require('bignumber.js'); // jshint ignore:line
}
module.exports = {
ETH_PADDING: 32,
ETH_SIGNATURE_LENGTH: 4,
ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN }
};

55
libjsqrc/ethereumjs/lib/contract.js
View File

@ -22,8 +22,18 @@
var web3 = require('./web3'); var web3 = require('./web3');
var abi = require('./abi'); var abi = require('./abi');
var utils = require('./utils');
var eventImpl = require('./event'); var eventImpl = require('./event');
var exportNatspecGlobals = function (vars) {
// it's used byt natspec.js
// TODO: figure out better way to solve this
web3._currentContractAbi = vars.abi;
web3._currentContractAddress = vars.address;
web3._currentContractMethodName = vars.method;
web3._currentContractMethodParams = vars.params;
};
var addFunctionRelatedPropertiesToContract = function (contract) { var addFunctionRelatedPropertiesToContract = function (contract) {
contract.call = function (options) { contract.call = function (options) {
@ -53,14 +63,14 @@ var addFunctionsToContract = function (contract, desc, address) {
var outputParser = abi.outputParser(desc); var outputParser = abi.outputParser(desc);
// create contract functions // create contract functions
abi.filterFunctions(desc).forEach(function (method) { utils.filterFunctions(desc).forEach(function (method) {
var displayName = abi.methodDisplayName(method.name); var displayName = utils.extractDisplayName(method.name);
var typeName = abi.methodTypeName(method.name); var typeName = utils.extractTypeName(method.name);
var impl = function () { var impl = function () {
var params = Array.prototype.slice.call(arguments); var params = Array.prototype.slice.call(arguments);
var signature = abi.methodSignature(method.name); var signature = abi.signatureFromAscii(method.name);
var parsed = inputParser[displayName][typeName].apply(null, params); var parsed = inputParser[displayName][typeName].apply(null, params);
var options = contract._options || {}; var options = contract._options || {};
@ -75,12 +85,13 @@ var addFunctionsToContract = function (contract, desc, address) {
contract._isTransact = null; contract._isTransact = null;
if (isTransact) { if (isTransact) {
// it's used byt natspec.js
// TODO: figure out better way to solve this exportNatspecGlobals({
web3._currentContractAbi = desc; abi: desc,
web3._currentContractAddress = address; address: address,
web3._currentContractMethodName = method.name; method: method.name,
web3._currentContractMethodParams = params; params: params
});
// transactions do not have any output, cause we do not know, when they will be processed // transactions do not have any output, cause we do not know, when they will be processed
web3.eth.transact(options); web3.eth.transact(options);
@ -112,8 +123,8 @@ var addEventRelatedPropertiesToContract = function (contract, desc, address) {
Object.defineProperty(contract, 'topic', { Object.defineProperty(contract, 'topic', {
get: function() { get: function() {
return abi.filterEvents(desc).map(function (e) { return utils.filterEvents(desc).map(function (e) {
return abi.methodSignature(e.name); return abi.signatureFromAscii(e.name);
}); });
} }
}); });
@ -122,27 +133,21 @@ var addEventRelatedPropertiesToContract = function (contract, desc, address) {
var addEventsToContract = function (contract, desc, address) { var addEventsToContract = function (contract, desc, address) {
// create contract events // create contract events
abi.filterEvents(desc).forEach(function (e) { utils.filterEvents(desc).forEach(function (e) {
var impl = function () { var impl = function () {
var params = Array.prototype.slice.call(arguments); var params = Array.prototype.slice.call(arguments);
var signature = abi.methodSignature(e.name); var signature = abi.signatureFromAscii(e.name);
var event = eventImpl(address, signature); var event = eventImpl(address, signature, e);
var o = event.apply(null, params); var o = event.apply(null, params);
return web3.eth.watch(o); return web3.eth.watch(o);
}; };
impl.address = address; // this property should be used by eth.filter to check if object is an event
impl._isEvent = true;
Object.defineProperty(impl, 'topic', {
get: function() {
return [abi.methodSignature(e.name)];
}
});
// TODO: rename these methods, cause they are used not only for methods var displayName = utils.extractDisplayName(e.name);
var displayName = abi.methodDisplayName(e.name); var typeName = utils.extractTypeName(e.name);
var typeName = abi.methodTypeName(e.name);
if (contract[displayName] === undefined) { if (contract[displayName] === undefined) {
contract[displayName] = impl; contract[displayName] = impl;

44
libjsqrc/ethereumjs/lib/event.js
View File

@ -20,13 +20,47 @@
* @date 2014 * @date 2014
*/ */
var implementationOfEvent = function (address, signature) { var abi = require('./abi');
var utils = require('./utils');
return function (options) { var inputWithName = function (inputs, name) {
var index = utils.findIndex(inputs, function (input) {
return input.name === name;
});
if (index === -1) {
console.error('indexed param with name ' + name + ' not found');
return undefined;
}
return inputs[index];
};
var indexedParamsToTopics = function (event, indexed) {
// sort keys?
return Object.keys(indexed).map(function (key) {
var inputs = [inputWithName(event.inputs, key)];
var value = indexed[key];
if (value instanceof Array) {
return value.map(function (v) {
return abi.formatInput(inputs, [v]);
});
}
return abi.formatInput(inputs, [value]);
});
};
var implementationOfEvent = function (address, signature, event) {
// valid options are 'earliest', 'latest', 'offset' and 'max', as defined for 'eth.watch'
return function (indexed, options) {
var o = options || {}; var o = options || {};
o.address = o.address || address; o.address = address;
o.topics = o.topics || []; o.topic = [];
o.topics.push(signature); o.topic.push(signature);
if (indexed) {
o.topic = o.topic.concat(indexedParamsToTopics(event, indexed));
}
return o; return o;
}; };
}; };

11
libjsqrc/ethereumjs/lib/filter.js
View File

@ -27,16 +27,17 @@ var web3 = require('./web3'); // jshint ignore:line
/// should be used when we want to watch something /// should be used when we want to watch something
/// it's using inner polling mechanism and is notified about changes /// it's using inner polling mechanism and is notified about changes
/// TODO: change 'options' name cause it may be not the best matching one, since we have events
var Filter = function(options, impl) { var Filter = function(options, impl) {
this.impl = impl;
this.callbacks = [];
if (typeof options !== "string") { if (typeof options !== "string") {
// evaluate lazy properties
// topics property is deprecated, warn about it!
if (options.topics) { if (options.topics) {
console.warn('"topics" is deprecated, use "topic" instead'); console.warn('"topics" is deprecated, use "topic" instead');
} }
// evaluate lazy properties
options = { options = {
to: options.to, to: options.to,
topic: options.topic, topic: options.topic,
@ -46,8 +47,12 @@ var Filter = function(options, impl) {
skip: options.skip, skip: options.skip,
address: options.address address: options.address
}; };
} }
this.impl = impl;
this.callbacks = [];
this.id = impl.newFilter(options); this.id = impl.newFilter(options);
web3.provider.startPolling({call: impl.changed, args: [this.id]}, this.id, this.trigger.bind(this)); web3.provider.startPolling({call: impl.changed, args: [this.id]}, this.id, this.trigger.bind(this));
}; };

154
libjsqrc/ethereumjs/lib/formatters.js
View File

@ -0,0 +1,154 @@
/*
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 Lesser 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file formatters.js
* @authors:
* Marek Kotewicz <marek@ethdev.com>
* @date 2015
*/
if (process.env.NODE_ENV !== 'build') {
var BigNumber = require('bignumber.js'); // jshint ignore:line
}
var utils = require('./utils');
var c = require('./const');
/// @param string string to be padded
/// @param number of characters that result string should have
/// @param sign, by default 0
/// @returns right aligned string
var padLeft = function (string, chars, sign) {
return new Array(chars - string.length + 1).join(sign ? sign : "0") + string;
};
/// Formats input value to byte representation of int
/// If value is negative, return it's two's complement
/// If the value is floating point, round it down
/// @returns right-aligned byte representation of int
var formatInputInt = function (value) {
var padding = c.ETH_PADDING * 2;
if (value instanceof BigNumber || typeof value === 'number') {
if (typeof value === 'number')
value = new BigNumber(value);
BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);
value = value.round();
if (value.lessThan(0))
value = new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(value).plus(1);
value = value.toString(16);
}
else if (value.indexOf('0x') === 0)
value = value.substr(2);
else if (typeof value === 'string')
value = formatInputInt(new BigNumber(value));
else
value = (+value).toString(16);
return padLeft(value, padding);
};
/// Formats input value to byte representation of string
/// @returns left-algined byte representation of string
var formatInputString = function (value) {
return utils.fromAscii(value, c.ETH_PADDING).substr(2);
};
/// Formats input value to byte representation of bool
/// @returns right-aligned byte representation bool
var formatInputBool = function (value) {
return '000000000000000000000000000000000000000000000000000000000000000' + (value ? '1' : '0');
};
/// Formats input value to byte representation of real
/// Values are multiplied by 2^m and encoded as integers
/// @returns byte representation of real
var formatInputReal = function (value) {
return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128)));
};
/// Check if input value is negative
/// @param value is hex format
/// @returns true if it is negative, otherwise false
var signedIsNegative = function (value) {
return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';
};
/// Formats input right-aligned input bytes to int
/// @returns right-aligned input bytes formatted to int
var formatOutputInt = function (value) {
value = value || "0";
// check if it's negative number
// it it is, return two's complement
if (signedIsNegative(value)) {
return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);
}
return new BigNumber(value, 16);
};
/// Formats big right-aligned input bytes to uint
/// @returns right-aligned input bytes formatted to uint
var formatOutputUInt = function (value) {
value = value || "0";
return new BigNumber(value, 16);
};
/// @returns input bytes formatted to real
var formatOutputReal = function (value) {
return formatOutputInt(value).dividedBy(new BigNumber(2).pow(128));
};
/// @returns input bytes formatted to ureal
var formatOutputUReal = function (value) {
return formatOutputUInt(value).dividedBy(new BigNumber(2).pow(128));
};
/// @returns right-aligned input bytes formatted to hex
var formatOutputHash = function (value) {
return "0x" + value;
};
/// @returns right-aligned input bytes formatted to bool
var formatOutputBool = function (value) {
return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
};
/// @returns left-aligned input bytes formatted to ascii string
var formatOutputString = function (value) {
return utils.toAscii(value);
};
/// @returns right-aligned input bytes formatted to address
var formatOutputAddress = function (value) {
return "0x" + value.slice(value.length - 40, value.length);
};
module.exports = {
formatInputInt: formatInputInt,
formatInputString: formatInputString,
formatInputBool: formatInputBool,
formatInputReal: formatInputReal,
formatOutputInt: formatOutputInt,
formatOutputUInt: formatOutputUInt,
formatOutputReal: formatOutputReal,
formatOutputUReal: formatOutputUReal,
formatOutputHash: formatOutputHash,
formatOutputBool: formatOutputBool,
formatOutputString: formatOutputString,
formatOutputAddress: formatOutputAddress
};

79
libjsqrc/ethereumjs/lib/types.js
View File

@ -0,0 +1,79 @@
/*
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 Lesser 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file types.js
* @authors:
* Marek Kotewicz <marek@ethdev.com>
* @date 2015
*/
var f = require('./formatters');
/// @param expected type prefix (string)
/// @returns function which checks if type has matching prefix. if yes, returns true, otherwise false
var prefixedType = function (prefix) {
return function (type) {
return type.indexOf(prefix) === 0;
};
};
/// @param expected type name (string)
/// @returns function which checks if type is matching expected one. if yes, returns true, otherwise false
var namedType = function (name) {
return function (type) {
return name === type;
};
};
/// Setups input formatters for solidity types
/// @returns an array of input formatters
var inputTypes = function () {
return [
{ type: prefixedType('uint'), format: f.formatInputInt },
{ type: prefixedType('int'), format: f.formatInputInt },
{ type: prefixedType('hash'), format: f.formatInputInt },
{ type: prefixedType('string'), format: f.formatInputString },
{ type: prefixedType('real'), format: f.formatInputReal },
{ type: prefixedType('ureal'), format: f.formatInputReal },
{ type: namedType('address'), format: f.formatInputInt },
{ type: namedType('bool'), format: f.formatInputBool }
];
};
/// Setups output formaters for solidity types
/// @returns an array of output formatters
var outputTypes = function () {
return [
{ type: prefixedType('uint'), format: f.formatOutputUInt },
{ type: prefixedType('int'), format: f.formatOutputInt },
{ type: prefixedType('hash'), format: f.formatOutputHash },
{ type: prefixedType('string'), format: f.formatOutputString },
{ type: prefixedType('real'), format: f.formatOutputReal },
{ type: prefixedType('ureal'), format: f.formatOutputUReal },
{ type: namedType('address'), format: f.formatOutputAddress },
{ type: namedType('bool'), format: f.formatOutputBool }
];
};
module.exports = {
prefixedType: prefixedType,
namedType: namedType,
inputTypes: inputTypes,
outputTypes: outputTypes
};

113
libjsqrc/ethereumjs/lib/utils.js
View File

@ -0,0 +1,113 @@
/*
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 Lesser 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file utils.js
* @authors:
* Marek Kotewicz <marek@ethdev.com>
* @date 2015
*/
/// Finds first index of array element matching pattern
/// @param array
/// @param callback pattern
/// @returns index of element
var findIndex = function (array, callback) {
var end = false;
var i = 0;
for (; i < array.length && !end; i++) {
end = callback(array[i]);
}
return end ? i - 1 : -1;
};
/// @returns ascii string representation of hex value prefixed with 0x
var toAscii = function(hex) {
// Find termination
var str = "";
var i = 0, l = hex.length;
if (hex.substring(0, 2) === '0x') {
i = 2;
}
for (; i < l; i+=2) {
var code = parseInt(hex.substr(i, 2), 16);
if (code === 0) {
break;
}
str += String.fromCharCode(code);
}
return str;
};
var 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;
};
/// @returns hex representation (prefixed by 0x) of ascii string
var fromAscii = function(str, pad) {
pad = pad === undefined ? 0 : pad;
var hex = toHex(str);
while (hex.length < pad*2)
hex += "00";
return "0x" + hex;
};
/// @returns display name for function/event eg. multiply(uint256) -> multiply
var extractDisplayName = function (name) {
var length = name.indexOf('(');
return length !== -1 ? name.substr(0, length) : name;
};
/// @returns overloaded part of function/event name
var extractTypeName = function (name) {
/// TODO: make it invulnerable
var length = name.indexOf('(');
return length !== -1 ? name.substr(length + 1, name.length - 1 - (length + 1)) : "";
};
/// Filters all function from input abi
/// @returns abi array with filtered objects of type 'function'
var filterFunctions = function (json) {
return json.filter(function (current) {
return current.type === 'function';
});
};
/// Filters all events form input abi
/// @returns abi array with filtered objects of type 'event'
var filterEvents = function (json) {
return json.filter(function (current) {
return current.type === 'event';
});
};
module.exports = {
findIndex: findIndex,
toAscii: toAscii,
fromAscii: fromAscii,
extractDisplayName: extractDisplayName,
extractTypeName: extractTypeName,
filterFunctions: filterFunctions,
filterEvents: filterEvents
};

55
libjsqrc/ethereumjs/lib/web3.js
View File

@ -27,6 +27,8 @@ if (process.env.NODE_ENV !== 'build') {
var BigNumber = require('bignumber.js'); var BigNumber = require('bignumber.js');
} }
var utils = require('./utils');
var ETH_UNITS = [ var ETH_UNITS = [
'wei', 'wei',
'Kwei', 'Kwei',
@ -192,43 +194,11 @@ var web3 = {
_events: {}, _events: {},
providers: {}, 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;
},
/// @returns ascii string representation of hex value prefixed with 0x /// @returns ascii string representation of hex value prefixed with 0x
toAscii: function(hex) { toAscii: utils.toAscii,
// Find termination
var str = "";
var i = 0, l = hex.length;
if (hex.substring(0, 2) === '0x')
i = 2;
for(; i < l; i+=2) {
var code = parseInt(hex.substr(i, 2), 16);
if(code === 0) {
break;
}
str += String.fromCharCode(code);
}
return str;
},
/// @returns hex representation (prefixed by 0x) of ascii string /// @returns hex representation (prefixed by 0x) of ascii string
fromAscii: function(str, pad) { fromAscii: utils.fromAscii,
pad = pad === undefined ? 0 : pad;
var hex = this.toHex(str);
while(hex.length < pad*2)
hex += "00";
return "0x" + hex;
},
/// @returns decimal representaton of hex value prefixed by 0x /// @returns decimal representaton of hex value prefixed by 0x
toDecimal: function (val) { toDecimal: function (val) {
@ -278,8 +248,15 @@ var web3 = {
return ret; return ret;
}; };
}, },
watch: function (params) {
return new web3.filter(params, ethWatch); /// @param filter may be a string, object or event
/// @param indexed is optional, this is an object with optional event indexed params
/// @param options is optional, this is an object with optional event options ('max'...)
watch: function (filter, indexed, options) {
if (filter._isEvent) {
return filter(indexed, options);
}
return new web3.filter(filter, ethWatch);
} }
}, },
@ -288,8 +265,10 @@ var web3 = {
/// shh object prototype /// shh object prototype
shh: { shh: {
watch: function (params) {
return new web3.filter(params, shhWatch); /// @param filter may be a string, object or event
watch: function (filter, indexed) {
return new web3.filter(filter, shhWatch);
} }
}, },

110
libjsqrc/ethereumjs/test/event.js
View File

@ -1,22 +1,124 @@
var assert = require('assert'); var assert = require('assert');
var event = require('../lib/event.js'); var event = require('../lib/event.js');
var f = require('../lib/formatters.js');
describe('event', function () { describe('event', function () {
it('should create filter input object from given', function () { it('should create basic filter input object', function () {
// given // given
var address = '0x012345'; var address = '0x012345';
var signature = '0x987654'; var signature = '0x987654';
var e = {
name: 'Event',
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}]
};
// when // when
var impl = event(address, signature); var impl = event(address, signature, e);
var result = impl(); var result = impl();
// then // then
assert.equal(result.address, address); assert.equal(result.address, address);
assert.equal(result.topics.length, 1); assert.equal(result.topic.length, 1);
assert.equal(result.topics[0], signature); assert.equal(result.topic[0], signature);
}); });
it('should create filter input object with options', function () {
// given
var address = '0x012345';
var signature = '0x987654';
var options = {
earliest: 1,
latest: 2,
offset: 3,
max: 4
};
var e = {
name: 'Event',
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}]
};
// when
var impl = event(address, signature, e);
var result = impl({}, options);
// then
assert.equal(result.address, address);
assert.equal(result.topic.length, 1);
assert.equal(result.topic[0], signature);
assert.equal(result.earliest, options.earliest);
assert.equal(result.latest, options.latest);
assert.equal(result.offset, options.offset);
assert.equal(result.max, options.max);
});
it('should create filter input object with indexed params', function () {
// given
var address = '0x012345';
var signature = '0x987654';
var options = {
earliest: 1,
latest: 2,
offset: 3,
max: 4
};
var e = {
name: 'Event',
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}]
};
// when
var impl = event(address, signature, e);
var result = impl({a: 4}, options);
// then
assert.equal(result.address, address);
assert.equal(result.topic.length, 2);
assert.equal(result.topic[0], signature);
assert.equal(result.topic[1], f.formatInputInt(4));
assert.equal(result.earliest, options.earliest);
assert.equal(result.latest, options.latest);
assert.equal(result.offset, options.offset);
assert.equal(result.max, options.max);
});
it('should create filter input object with an array of indexed params', function () {
// given
var address = '0x012345';
var signature = '0x987654';
var options = {
earliest: 1,
latest: 2,
offset: 3,
max: 4
};
var e = {
name: 'Event',
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}]
};
// when
var impl = event(address, signature, e);
var result = impl({a: [4, 69]}, options);
// then
assert.equal(result.address, address);
assert.equal(result.topic.length, 2);
assert.equal(result.topic[0], signature);
assert.equal(result.topic[1][0], f.formatInputInt(4));
assert.equal(result.topic[1][1], f.formatInputInt(69));
assert.equal(result.earliest, options.earliest);
assert.equal(result.latest, options.latest);
assert.equal(result.offset, options.offset);
assert.equal(result.max, options.max);
});
}); });

8
libjsqrc/ethereumjs/test/abi.filters.js → libjsqrc/ethereumjs/test/utils.filters.js
View File

@ -1,7 +1,7 @@
var assert = require('assert'); var assert = require('assert');
var abi = require('../lib/abi.js'); var utils = require('../lib/utils.js');
describe('abi', function() { describe('utils', function() {
it('should filter functions and events from input array properly', function () { it('should filter functions and events from input array properly', function () {
// given // given
@ -36,8 +36,8 @@ describe('abi', function() {
}]; }];
// when // when
var events = abi.filterEvents(description); var events = utils.filterEvents(description);
var functions = abi.filterFunctions(description); var functions = utils.filterFunctions(description);
// then // then
assert.equal(events.length, 1); assert.equal(events.length, 1);

17
libsolidity/AST.cpp
View File

@ -152,6 +152,23 @@ void ContractDefinition::checkIllegalOverrides() const
} }
} }
std::vector<ASTPointer<EventDefinition>> const& ContractDefinition::getInterfaceEvents() const
{
if (!m_interfaceEvents)
{
set<string> eventsSeen;
m_interfaceEvents.reset(new std::vector<ASTPointer<EventDefinition>>());
for (ContractDefinition const* contract: getLinearizedBaseContracts())
for (ASTPointer<EventDefinition> const& e: contract->getEvents())
if (eventsSeen.count(e->getName()) == 0)
{
eventsSeen.insert(e->getName());
m_interfaceEvents->push_back(e);
}
}
return *m_interfaceEvents;
}
vector<pair<FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::getInterfaceFunctionList() const vector<pair<FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::getInterfaceFunctionList() const
{ {
if (!m_interfaceFunctionList) if (!m_interfaceFunctionList)

4
libsolidity/AST.h
View File

@ -222,6 +222,7 @@ public:
std::vector<ASTPointer<ModifierDefinition>> const& getFunctionModifiers() const { return m_functionModifiers; } std::vector<ASTPointer<ModifierDefinition>> const& getFunctionModifiers() const { return m_functionModifiers; }
std::vector<ASTPointer<FunctionDefinition>> const& getDefinedFunctions() const { return m_definedFunctions; } std::vector<ASTPointer<FunctionDefinition>> const& getDefinedFunctions() const { return m_definedFunctions; }
std::vector<ASTPointer<EventDefinition>> const& getEvents() const { return m_events; } std::vector<ASTPointer<EventDefinition>> const& getEvents() const { return m_events; }
std::vector<ASTPointer<EventDefinition>> const& getInterfaceEvents() const;
virtual TypePointer getType(ContractDefinition const* m_currentContract) const override; virtual TypePointer getType(ContractDefinition const* m_currentContract) const override;
@ -257,6 +258,7 @@ private:
std::vector<ContractDefinition const*> m_linearizedBaseContracts; std::vector<ContractDefinition const*> m_linearizedBaseContracts;
mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList; mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList;
mutable std::unique_ptr<std::vector<ASTPointer<EventDefinition>>> m_interfaceEvents;
}; };
class InheritanceSpecifier: public ASTNode class InheritanceSpecifier: public ASTNode
@ -471,7 +473,7 @@ private:
/** /**
* Definition of a (loggable) event. * Definition of a (loggable) event.
*/ */
class EventDefinition: public Declaration, public Documented class EventDefinition: public Declaration, public VariableScope, public Documented
{ {
public: public:
EventDefinition(Location const& _location, EventDefinition(Location const& _location,

67
libsolidity/InterfaceHandler.cpp
View File

@ -37,47 +37,24 @@ std::unique_ptr<std::string> InterfaceHandler::getDocumentation(ContractDefiniti
std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinition const& _contractDef) std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinition const& _contractDef)
{ {
Json::Value members(Json::arrayValue); Json::Value abi(Json::arrayValue);
/*
for (ASTPointer<EventDefinition> const& it: _contractDef.getEvents())
{
Json::Value event;5
Json::Value inputs(Json::arrayValue);
event["type"] = "event";
Json::Value params(Json::arrayValue);
for (ASTPointer<VariableDeclaration> const& p: it->getParameters())
{
Json::Value param;
param["name"] = p->getName();
param["type"] = p->getType()->toString();
param["indexed"] = p->isIndexed();
params.append(param);
}
event["inputs"] = params;
members.append(event);
}*/
for (auto const& it: _contractDef.getInterfaceFunctions()) for (auto const& it: _contractDef.getInterfaceFunctions())
{ {
auto populateParameters = [](vector<string> const& _paramNames, auto populateParameters = [](vector<string> const& _paramNames, vector<string> const& _paramTypes)
vector<string> const& _paramTypes)
{ {
Json::Value params(Json::arrayValue); Json::Value params(Json::arrayValue);
solAssert(_paramNames.size() == _paramTypes.size(), "Names and types vector size does not match"); solAssert(_paramNames.size() == _paramTypes.size(), "Names and types vector size does not match");
for (unsigned i = 0; i < _paramNames.size(); ++i) for (unsigned i = 0; i < _paramNames.size(); ++i)
{ {
Json::Value input; Json::Value param;
input["name"] = _paramNames[i]; param["name"] = _paramNames[i];
input["type"] = _paramTypes[i]; param["type"] = _paramTypes[i];
params.append(input); params.append(param);
} }
return params; return params;
}; };
Json::Value method; Json::Value method;
Json::Value inputs(Json::arrayValue);
Json::Value outputs(Json::arrayValue);
method["type"] = "function"; method["type"] = "function";
method["name"] = it.second->getDeclaration().getName(); method["name"] = it.second->getDeclaration().getName();
method["constant"] = it.second->isConstant(); method["constant"] = it.second->isConstant();
@ -85,9 +62,27 @@ std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinitio
it.second->getParameterTypeNames()); it.second->getParameterTypeNames());
method["outputs"] = populateParameters(it.second->getReturnParameterNames(), method["outputs"] = populateParameters(it.second->getReturnParameterNames(),
it.second->getReturnParameterTypeNames()); it.second->getReturnParameterTypeNames());
members.append(method); abi.append(method);
} }
return std::unique_ptr<std::string>(new std::string(m_writer.write(members)));
for (auto const& it: _contractDef.getInterfaceEvents())
{
Json::Value event;
event["type"] = "event";
event["name"] = it->getName();
Json::Value params(Json::arrayValue);
for (auto const& p: it->getParameters())
{
Json::Value input;
input["name"] = p->getName();
input["type"] = p->getType()->toString();
input["indexed"] = p->isIndexed();
params.append(input);
}
event["inputs"] = params;
abi.append(event);
}
return std::unique_ptr<std::string>(new std::string(m_writer.write(abi)));
} }
unique_ptr<string> InterfaceHandler::getABISolidityInterface(ContractDefinition const& _contractDef) unique_ptr<string> InterfaceHandler::getABISolidityInterface(ContractDefinition const& _contractDef)
@ -113,6 +108,16 @@ unique_ptr<string> InterfaceHandler::getABISolidityInterface(ContractDefinition
ret.pop_back(); ret.pop_back();
ret += "{}"; ret += "{}";
} }
for (auto const& it: _contractDef.getInterfaceEvents())
{
std::string params;
for (auto const& p: it->getParameters())
params += (params.empty() ? "(" : ",") + p->getType()->toString() + (p->isIndexed() ? " indexed " : " ") + p->getName();
if (!params.empty())
params += ")";
ret += "event " + it->getName() + params + ";";
}
return unique_ptr<string>(new string(ret + "}")); return unique_ptr<string>(new string(ret + "}"));
} }

7
libsolidity/NameAndTypeResolver.cpp
View File

@ -263,10 +263,15 @@ bool DeclarationRegistrationHelper::visit(VariableDeclaration& _declaration)
bool DeclarationRegistrationHelper::visit(EventDefinition& _event) bool DeclarationRegistrationHelper::visit(EventDefinition& _event)
{ {
registerDeclaration(_event, false); registerDeclaration(_event, true);
return true; return true;
} }
void DeclarationRegistrationHelper::endVisit(EventDefinition&)
{
closeCurrentScope();
}
void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration) void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration)
{ {
map<ASTNode const*, DeclarationContainer>::iterator iter; map<ASTNode const*, DeclarationContainer>::iterator iter;

23
libsolidity/NameAndTypeResolver.h
View File

@ -94,17 +94,18 @@ public:
DeclarationRegistrationHelper(std::map<ASTNode const*, DeclarationContainer>& _scopes, ASTNode& _astRoot); DeclarationRegistrationHelper(std::map<ASTNode const*, DeclarationContainer>& _scopes, ASTNode& _astRoot);
private: private:
bool visit(ContractDefinition& _contract); bool visit(ContractDefinition& _contract) override;
void endVisit(ContractDefinition& _contract); void endVisit(ContractDefinition& _contract) override;
bool visit(StructDefinition& _struct); bool visit(StructDefinition& _struct) override;
void endVisit(StructDefinition& _struct); void endVisit(StructDefinition& _struct) override;
bool visit(FunctionDefinition& _function); bool visit(FunctionDefinition& _function) override;
void endVisit(FunctionDefinition& _function); void endVisit(FunctionDefinition& _function) override;
bool visit(ModifierDefinition& _modifier); bool visit(ModifierDefinition& _modifier) override;
void endVisit(ModifierDefinition& _modifier); void endVisit(ModifierDefinition& _modifier) override;
void endVisit(VariableDefinition& _variableDefinition); void endVisit(VariableDefinition& _variableDefinition) override;
bool visit(VariableDeclaration& _declaration); bool visit(VariableDeclaration& _declaration) override;
bool visit(EventDefinition& _event); bool visit(EventDefinition& _event) override;
void endVisit(EventDefinition& _event) override;
void enterNewSubScope(Declaration const& _declaration); void enterNewSubScope(Declaration const& _declaration);
void closeCurrentScope(); void closeCurrentScope();

157
test/SolidityABIJSON.cpp
View File

@ -37,7 +37,7 @@ class InterfaceChecker
public: public:
InterfaceChecker(): m_compilerStack(false) {} InterfaceChecker(): m_compilerStack(false) {}
void checkInterface(std::string const& _code, std::string const& _expectedInterfaceString) void checkInterface(std::string const& _code, std::string const& _expectedInterfaceString, std::string const& expectedSolidityInterface)
{ {
try try
{ {
@ -49,13 +49,17 @@ public:
BOOST_FAIL(msg); BOOST_FAIL(msg);
} }
std::string generatedInterfaceString = m_compilerStack.getMetadata("", DocumentationType::ABI_INTERFACE); std::string generatedInterfaceString = m_compilerStack.getMetadata("", DocumentationType::ABI_INTERFACE);
std::string generatedSolidityInterfaceString = m_compilerStack.getMetadata("", DocumentationType::ABI_SOLIDITY_INTERFACE);
Json::Value generatedInterface; Json::Value generatedInterface;
m_reader.parse(generatedInterfaceString, generatedInterface); m_reader.parse(generatedInterfaceString, generatedInterface);
Json::Value expectedInterface; Json::Value expectedInterface;
m_reader.parse(_expectedInterfaceString, expectedInterface); m_reader.parse(_expectedInterfaceString, expectedInterface);
BOOST_CHECK_MESSAGE(expectedInterface == generatedInterface, BOOST_CHECK_MESSAGE(expectedInterface == generatedInterface,
"Expected " << _expectedInterfaceString << "Expected:\n" << expectedInterface.toStyledString() <<
"\n but got:\n" << generatedInterfaceString); "\n but got:\n" << generatedInterface.toStyledString());
BOOST_CHECK_MESSAGE(expectedSolidityInterface == generatedSolidityInterfaceString,
"Expected:\n" << expectedSolidityInterface <<
"\n but got:\n" << generatedSolidityInterfaceString);
} }
private: private:
@ -71,6 +75,8 @@ BOOST_AUTO_TEST_CASE(basic_test)
" function f(uint a) returns(uint d) { return a * 7; }\n" " function f(uint a) returns(uint d) { return a * 7; }\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{function f(uint256 a)returns(uint256 d){}}";
char const* interface = R"([ char const* interface = R"([
{ {
"name": "f", "name": "f",
@ -91,17 +97,18 @@ BOOST_AUTO_TEST_CASE(basic_test)
} }
])"; ])";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(empty_contract) BOOST_AUTO_TEST_CASE(empty_contract)
{ {
char const* sourceCode = "contract test {\n" char const* sourceCode = "contract test {\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{}";
char const* interface = "[]"; char const* interface = "[]";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(multiple_methods) BOOST_AUTO_TEST_CASE(multiple_methods)
@ -110,6 +117,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods)
" function f(uint a) returns(uint d) { return a * 7; }\n" " function f(uint a) returns(uint d) { return a * 7; }\n"
" function g(uint b) returns(uint e) { return b * 8; }\n" " function g(uint b) returns(uint e) { return b * 8; }\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{function f(uint256 a)returns(uint256 d){}function g(uint256 b)returns(uint256 e){}}";
char const* interface = R"([ char const* interface = R"([
{ {
@ -148,7 +156,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods)
} }
])"; ])";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(multiple_params) BOOST_AUTO_TEST_CASE(multiple_params)
@ -156,6 +164,7 @@ BOOST_AUTO_TEST_CASE(multiple_params)
char const* sourceCode = "contract test {\n" char const* sourceCode = "contract test {\n"
" function f(uint a, uint b) returns(uint d) { return a + b; }\n" " function f(uint a, uint b) returns(uint d) { return a + b; }\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{function f(uint256 a,uint256 b)returns(uint256 d){}}";
char const* interface = R"([ char const* interface = R"([
{ {
@ -181,7 +190,7 @@ BOOST_AUTO_TEST_CASE(multiple_params)
} }
])"; ])";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(multiple_methods_order) BOOST_AUTO_TEST_CASE(multiple_methods_order)
@ -191,6 +200,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods_order)
" function f(uint a) returns(uint d) { return a * 7; }\n" " function f(uint a) returns(uint d) { return a * 7; }\n"
" function c(uint b) returns(uint e) { return b * 8; }\n" " function c(uint b) returns(uint e) { return b * 8; }\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{function c(uint256 b)returns(uint256 e){}function f(uint256 a)returns(uint256 d){}}";
char const* interface = R"([ char const* interface = R"([
{ {
@ -229,7 +239,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods_order)
} }
])"; ])";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(const_function) BOOST_AUTO_TEST_CASE(const_function)
@ -238,6 +248,7 @@ BOOST_AUTO_TEST_CASE(const_function)
" function foo(uint a, uint b) returns(uint d) { return a + b; }\n" " function foo(uint a, uint b) returns(uint d) { return a + b; }\n"
" function boo(uint32 a) constant returns(uint b) { return a * 4; }\n" " function boo(uint32 a) constant returns(uint b) { return a * 4; }\n"
"}\n"; "}\n";
char const* sourceInterface = "contract test{function foo(uint256 a,uint256 b)returns(uint256 d){}function boo(uint32 a)constant returns(uint256 b){}}";
char const* interface = R"([ char const* interface = R"([
{ {
@ -278,18 +289,144 @@ BOOST_AUTO_TEST_CASE(const_function)
} }
])"; ])";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_CASE(exclude_fallback_function) BOOST_AUTO_TEST_CASE(exclude_fallback_function)
{ {
char const* sourceCode = "contract test { function() {} }"; char const* sourceCode = "contract test { function() {} }";
char const* sourceInterface = "contract test{}";
char const* interface = "[]"; char const* interface = "[]";
checkInterface(sourceCode, interface); checkInterface(sourceCode, interface, sourceInterface);
}
BOOST_AUTO_TEST_CASE(events)
{
char const* sourceCode = "contract test {\n"
" function f(uint a) returns(uint d) { return a * 7; }\n"
" event e1(uint b, address indexed c); \n"
" event e2(); \n"
"}\n";
char const* sourceInterface = "contract test{function f(uint256 a)returns(uint256 d){}event e1(uint256 b,address indexed c);event e2;}";
char const* interface = R"([
{
"name": "f",
"constant": false,
"type": "function",
"inputs": [
{
"name": "a",
"type": "uint256"
}
],
"outputs": [
{
"name": "d",
"type": "uint256"
}
]
},
{
"name": "e1",
"type": "event",
"inputs": [
{
"indexed": false,
"name": "b",
"type": "uint256"
},
{
"indexed": true,
"name": "c",
"type": "address"
}
]
},
{
"name": "e2",
"type": "event",
"inputs": []
}
])";
checkInterface(sourceCode, interface, sourceInterface);
}
BOOST_AUTO_TEST_CASE(inherited)
{
char const* sourceCode =
" contract Base { \n"
" function baseFunction(uint p) returns (uint i) { return p; } \n"
" event baseEvent(string32 indexed evtArgBase); \n"
" } \n"
" contract Derived is Base { \n"
" function derivedFunction(string32 p) returns (string32 i) { return p; } \n"
" event derivedEvent(uint indexed evtArgDerived); \n"
" }";
char const* sourceInterface = "contract Derived{function baseFunction(uint256 p)returns(uint256 i){}function derivedFunction(string32 p)returns(string32 i){}event derivedEvent(uint256 indexed evtArgDerived);event baseEvent(string32 indexed evtArgBase);}";
char const* interface = R"([
{
"name": "baseFunction",
"constant": false,
"type": "function",
"inputs":
[{
"name": "p",
"type": "uint256"
}],
"outputs":
[{
"name": "i",
"type": "uint256"
}]
},
{
"name": "derivedFunction",
"constant": false,
"type": "function",
"inputs":
[{
"name": "p",
"type": "string32"
}],
"outputs":
[{
"name": "i",
"type": "string32"
}]
},
{
"name": "derivedEvent",
"type": "event",
"inputs":
[{
"indexed": true,
"name": "evtArgDerived",
"type": "uint256"
}]
},
{
"name": "baseEvent",
"type": "event",
"inputs":
[{
"indexed": true,
"name": "evtArgBase",
"type": "string32"
}]
}])";
checkInterface(sourceCode, interface, sourceInterface);
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()
} }

9
test/SolidityNameAndTypeResolution.cpp
View File

@ -770,6 +770,15 @@ BOOST_AUTO_TEST_CASE(event_inheritance)
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text)); BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
} }
BOOST_AUTO_TEST_CASE(multiple_events_argument_clash)
{
char const* text = R"(
contract c {
event e1(uint a, uint e1, uint e2);
event e2(uint a, uint e1, uint e2);
})";
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
}
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

Write Preview
Loading…
Cancel
Save