Merge branch 'develop' into tcoulter
Conflicts: dist/web3-light.js.map dist/web3-light.min.js dist/web3.js.map dist/web3.min.js
This commit is contained in:
Marek Kotewicz
commit
091c8e5428
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"name": "web3",
|
||||
"namespace": "ethereum",
|
||||
"version": "0.3.4",
|
||||
"version": "0.3.5",
|
||||
"description": "Ethereum Compatible JavaScript API",
|
||||
"main": [
|
||||
"./dist/web3.js",
|
||||
|
|
|
|||
|
|
@ -22,118 +22,29 @@ require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof requ
|
|||
* @date 2014
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
var coder = require('./coder');
|
||||
var solUtils = require('./utils');
|
||||
|
||||
/**
|
||||
* Formats input params to bytes
|
||||
*
|
||||
* @method formatInput
|
||||
* @param {Array} abi inputs of method
|
||||
* @param {Array} params that will be formatted to bytes
|
||||
* @returns bytes representation of input params
|
||||
*/
|
||||
var formatInput = function (inputs, params) {
|
||||
var i = inputs.map(function (input) {
|
||||
return input.type;
|
||||
});
|
||||
return coder.encodeParams(i, params);
|
||||
};
|
||||
|
||||
/**
|
||||
* Formats output bytes back to param list
|
||||
*
|
||||
* @method formatOutput
|
||||
* @param {Array} abi outputs of method
|
||||
* @param {String} bytes represention of output
|
||||
* @returns {Array} output params
|
||||
*/
|
||||
var formatOutput = function (outs, bytes) {
|
||||
var o = outs.map(function (out) {
|
||||
return out.type;
|
||||
});
|
||||
|
||||
return coder.decodeParams(o, bytes);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create input parser for contract with given abi
|
||||
*
|
||||
* @method inputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} input parser object for given json abi
|
||||
* TODO: refactor creating the parser, do not double logic from contract
|
||||
*/
|
||||
var inputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function () {
|
||||
var params = Array.prototype.slice.call(arguments);
|
||||
return formatInput(method.inputs, params);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create output parser for contract with given abi
|
||||
*
|
||||
* @method outputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} output parser for given json abi
|
||||
*/
|
||||
var outputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function (output) {
|
||||
return formatOutput(method.outputs, output);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
var utils = require('./utils');
|
||||
|
||||
var formatConstructorParams = function (abi, params) {
|
||||
var constructor = solUtils.getConstructor(abi, params.length);
|
||||
var constructor = utils.getConstructor(abi, params.length);
|
||||
if (!constructor) {
|
||||
if (params.length > 0) {
|
||||
console.warn("didn't found matching constructor, using default one");
|
||||
}
|
||||
return '';
|
||||
}
|
||||
return formatInput(constructor.inputs, params);
|
||||
|
||||
return coder.encodeParams(constructor.inputs.map(function (input) {
|
||||
return input.type;
|
||||
}), params);
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
inputParser: inputParser,
|
||||
outputParser: outputParser,
|
||||
formatInput: formatInput,
|
||||
formatOutput: formatOutput,
|
||||
formatConstructorParams: formatConstructorParams
|
||||
};
|
||||
|
||||
},{"../utils/utils":8,"./coder":2,"./utils":5}],2:[function(require,module,exports){
|
||||
|
||||
},{"./coder":2,"./utils":5}],2:[function(require,module,exports){
|
||||
/*
|
||||
This file is part of ethereum.js.
|
||||
|
||||
|
|
@ -213,9 +124,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
|
|||
return param.map(function (p) {
|
||||
return self._inputFormatter(p);
|
||||
}).reduce(function (acc, current) {
|
||||
acc.appendArrayElement(current);
|
||||
return acc;
|
||||
}, new SolidityParam('', f.formatInputInt(param.length).value));
|
||||
return acc.combine(current);
|
||||
}, f.formatInputInt(param.length)).withOffset(32);
|
||||
}
|
||||
return this._inputFormatter(param);
|
||||
};
|
||||
|
|
@ -232,9 +142,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
if (arrayType) {
|
||||
// let's assume, that we solidity will never return long arrays :P
|
||||
var result = [];
|
||||
var length = new BigNumber(param.prefix, 16);
|
||||
var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
|
||||
for (var i = 0; i < length * 64; i += 64) {
|
||||
result.push(this._outputFormatter(new SolidityParam(param.suffix.slice(i, i + 64))));
|
||||
result.push(this._outputFormatter(new SolidityParam(param.dynamicPart().substr(i + 64, 64))));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -242,31 +152,21 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
};
|
||||
|
||||
/**
|
||||
* Should be used to check if a type is variadic
|
||||
* Should be used to slice single param from bytes
|
||||
*
|
||||
* @method isVariadicType
|
||||
* @method sliceParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index of param to slice
|
||||
* @param {String} type
|
||||
* @returns {Bool} true if the type is variadic
|
||||
* @returns {SolidityParam} param
|
||||
*/
|
||||
SolidityType.prototype.isVariadicType = function (type) {
|
||||
return isArrayType(type) || this._mode === 'bytes';
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to shift param from params group
|
||||
*
|
||||
* @method shiftParam
|
||||
* @param {String} type
|
||||
* @returns {SolidityParam} shifted param
|
||||
*/
|
||||
SolidityType.prototype.shiftParam = function (type, param) {
|
||||
SolidityType.prototype.sliceParam = function (bytes, index, type) {
|
||||
if (this._mode === 'bytes') {
|
||||
return param.shiftBytes();
|
||||
return SolidityParam.decodeBytes(bytes, index);
|
||||
} else if (isArrayType(type)) {
|
||||
var length = new BigNumber(param.prefix.slice(0, 64), 16);
|
||||
return param.shiftArray(length);
|
||||
return SolidityParam.decodeArray(bytes, index);
|
||||
}
|
||||
return param.shiftValue();
|
||||
return SolidityParam.decodeParam(bytes, index);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -296,28 +196,6 @@ SolidityCoder.prototype._requireType = function (type) {
|
|||
return solidityType;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain bytes to SolidityParam object
|
||||
*
|
||||
* @method _bytesToParam
|
||||
* @param {Array} types of params
|
||||
* @param {String} bytes to be transformed to SolidityParam
|
||||
* @return {SolidityParam} SolidityParam for this group of params
|
||||
*/
|
||||
SolidityCoder.prototype._bytesToParam = function (types, bytes) {
|
||||
var self = this;
|
||||
var prefixTypes = types.reduce(function (acc, type) {
|
||||
return self._requireType(type).isVariadicType(type) ? acc + 1 : acc;
|
||||
}, 0);
|
||||
var valueTypes = types.length - prefixTypes;
|
||||
|
||||
var prefix = bytes.slice(0, prefixTypes * 64);
|
||||
bytes = bytes.slice(prefixTypes * 64);
|
||||
var value = bytes.slice(0, valueTypes * 64);
|
||||
var suffix = bytes.slice(valueTypes * 64);
|
||||
return new SolidityParam(value, prefix, suffix);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain param of given type to SolidityParam
|
||||
*
|
||||
|
|
@ -352,24 +230,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
|
|||
*/
|
||||
SolidityCoder.prototype.encodeParams = function (types, params) {
|
||||
var self = this;
|
||||
return types.map(function (type, index) {
|
||||
var solidityParams = types.map(function (type, index) {
|
||||
return self._formatInput(type, params[index]);
|
||||
}).reduce(function (acc, solidityParam) {
|
||||
acc.append(solidityParam);
|
||||
return acc;
|
||||
}, new SolidityParam()).encode();
|
||||
};
|
||||
});
|
||||
|
||||
/**
|
||||
* Should be used to transform SolidityParam to plain param
|
||||
*
|
||||
* @method _formatOutput
|
||||
* @param {String} type
|
||||
* @param {SolidityParam} param
|
||||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype._formatOutput = function (type, param) {
|
||||
return this._requireType(type).formatOutput(param, isArrayType(type));
|
||||
return SolidityParam.encodeList(solidityParams);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -381,7 +246,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
|
|||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
||||
return this._formatOutput(type, this._bytesToParam([type], bytes));
|
||||
return this.decodeParams([type], bytes)[0];
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -394,10 +259,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
|||
*/
|
||||
SolidityCoder.prototype.decodeParams = function (types, bytes) {
|
||||
var self = this;
|
||||
var param = this._bytesToParam(types, bytes);
|
||||
return types.map(function (type) {
|
||||
return types.map(function (type, index) {
|
||||
var solidityType = self._requireType(type);
|
||||
var p = solidityType.shiftParam(type, param);
|
||||
var p = solidityType.sliceParam(bytes, index, type);
|
||||
return solidityType.formatOutput(p, isArrayType(type));
|
||||
});
|
||||
};
|
||||
|
|
@ -530,7 +394,7 @@ var formatInputBytes = function (value) {
|
|||
*/
|
||||
var formatInputDynamicBytes = function (value) {
|
||||
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2);
|
||||
return new SolidityParam('', formatInputInt(value.length).value, result);
|
||||
return new SolidityParam(formatInputInt(value.length).value + result, 32);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -576,7 +440,7 @@ var signedIsNegative = function (value) {
|
|||
* @returns {BigNumber} right-aligned output bytes formatted to big number
|
||||
*/
|
||||
var formatOutputInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
|
||||
// check if it's negative number
|
||||
// it it is, return two's complement
|
||||
|
|
@ -594,7 +458,7 @@ var formatOutputInt = function (param) {
|
|||
* @returns {BigNumeber} right-aligned output bytes formatted to uint
|
||||
*/
|
||||
var formatOutputUInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
return new BigNumber(value, 16);
|
||||
};
|
||||
|
||||
|
|
@ -628,7 +492,7 @@ var formatOutputUReal = function (param) {
|
|||
* @returns {Boolean} right-aligned input bytes formatted to bool
|
||||
*/
|
||||
var formatOutputBool = function (param) {
|
||||
return param.value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -640,7 +504,7 @@ var formatOutputBool = function (param) {
|
|||
*/
|
||||
var formatOutputBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.value);
|
||||
return utils.toAscii(param.staticPart());
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -652,7 +516,7 @@ var formatOutputBytes = function (param) {
|
|||
*/
|
||||
var formatOutputDynamicBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.suffix);
|
||||
return utils.toAscii(param.dynamicPart().slice(64));
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -663,7 +527,7 @@ var formatOutputDynamicBytes = function (param) {
|
|||
* @returns {String} address
|
||||
*/
|
||||
var formatOutputAddress = function (param) {
|
||||
var value = param.value;
|
||||
var value = param.staticPart();
|
||||
return "0x" + value.slice(value.length - 40, value.length);
|
||||
};
|
||||
|
||||
|
|
@ -707,91 +571,196 @@ module.exports = {
|
|||
* @date 2015
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
|
||||
/**
|
||||
* SolidityParam object prototype.
|
||||
* Should be used when encoding, decoding solidity bytes
|
||||
*/
|
||||
var SolidityParam = function (value, prefix, suffix) {
|
||||
this.prefix = prefix || '';
|
||||
var SolidityParam = function (value, offset) {
|
||||
this.value = value || '';
|
||||
this.suffix = suffix || '';
|
||||
this.offset = offset; // offset in bytes
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode two params one after another
|
||||
*
|
||||
* @method append
|
||||
* @param {SolidityParam} param that it appended after this
|
||||
* This method should be used to get length of params's dynamic part
|
||||
*
|
||||
* @method dynamicPartLength
|
||||
* @returns {Number} length of dynamic part (in bytes)
|
||||
*/
|
||||
SolidityParam.prototype.append = function (param) {
|
||||
this.prefix += param.prefix;
|
||||
this.value += param.value;
|
||||
this.suffix += param.suffix;
|
||||
SolidityParam.prototype.dynamicPartLength = function () {
|
||||
return this.dynamicPart().length / 2;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode next param in an array
|
||||
* This method should be used to create copy of solidity param with different offset
|
||||
*
|
||||
* @method appendArrayElement
|
||||
* @param {SolidityParam} param that is appended to an array
|
||||
* @method withOffset
|
||||
* @param {Number} offset length in bytes
|
||||
* @returns {SolidityParam} new solidity param with applied offset
|
||||
*/
|
||||
SolidityParam.prototype.appendArrayElement = function (param) {
|
||||
this.suffix += param.value;
|
||||
this.prefix += param.prefix;
|
||||
// TODO: suffix not supported = it's required for nested arrays;
|
||||
SolidityParam.prototype.withOffset = function (offset) {
|
||||
return new SolidityParam(this.value, offset);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to create bytearrays from param
|
||||
* This method should be used to combine solidity params together
|
||||
* eg. when appending an array
|
||||
*
|
||||
* @method combine
|
||||
* @param {SolidityParam} param with which we should combine
|
||||
* @param {SolidityParam} result of combination
|
||||
*/
|
||||
SolidityParam.prototype.combine = function (param) {
|
||||
return new SolidityParam(this.value + param.value);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to check if param has dynamic size.
|
||||
* If it has, it returns true, otherwise false
|
||||
*
|
||||
* @method isDynamic
|
||||
* @returns {Boolean}
|
||||
*/
|
||||
SolidityParam.prototype.isDynamic = function () {
|
||||
return this.value.length > 64;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to transform offset to bytes
|
||||
*
|
||||
* @method offsetAsBytes
|
||||
* @returns {String} bytes representation of offset
|
||||
*/
|
||||
SolidityParam.prototype.offsetAsBytes = function () {
|
||||
return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get static part of param
|
||||
*
|
||||
* @method staticPart
|
||||
* @returns {String} offset if it is a dynamic param, otherwise value
|
||||
*/
|
||||
SolidityParam.prototype.staticPart = function () {
|
||||
if (!this.isDynamic()) {
|
||||
return this.value;
|
||||
}
|
||||
return this.offsetAsBytes();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get dynamic part of param
|
||||
*
|
||||
* @method dynamicPart
|
||||
* @returns {String} returns a value if it is a dynamic param, otherwise empty string
|
||||
*/
|
||||
SolidityParam.prototype.dynamicPart = function () {
|
||||
return this.isDynamic() ? this.value : '';
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to encode param
|
||||
*
|
||||
* @method encode
|
||||
* @return {String} encoded param(s)
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.encode = function () {
|
||||
return this.prefix + this.value + this.suffix;
|
||||
return this.staticPart() + this.dynamicPart();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift first param from group of params
|
||||
* This method should be called to encode array of params
|
||||
*
|
||||
* @method shiftValue
|
||||
* @return {SolidityParam} first value param
|
||||
* @method encodeList
|
||||
* @param {Array[SolidityParam]} params
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.shiftValue = function () {
|
||||
var value = this.value.slice(0, 64);
|
||||
this.value = this.value.slice(64);
|
||||
return new SolidityParam(value);
|
||||
SolidityParam.encodeList = function (params) {
|
||||
|
||||
// updating offsets
|
||||
var totalOffset = params.length * 32;
|
||||
var offsetParams = params.map(function (param) {
|
||||
if (!param.isDynamic()) {
|
||||
return param;
|
||||
}
|
||||
var offset = totalOffset;
|
||||
totalOffset += param.dynamicPartLength();
|
||||
return param.withOffset(offset);
|
||||
});
|
||||
|
||||
// encode everything!
|
||||
return offsetParams.reduce(function (result, param) {
|
||||
return result + param.dynamicPart();
|
||||
}, offsetParams.reduce(function (result, param) {
|
||||
return result + param.staticPart();
|
||||
}, ''));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to first bytes param from group of params
|
||||
* This method should be used to decode plain (static) solidity param at given index
|
||||
*
|
||||
* @method shiftBytes
|
||||
* @return {SolidityParam} first bytes param
|
||||
* @method decodeParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.prototype.shiftBytes = function () {
|
||||
return this.shiftArray(1);
|
||||
SolidityParam.decodeParam = function (bytes, index) {
|
||||
index = index || 0;
|
||||
return new SolidityParam(bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift an array from group of params
|
||||
*
|
||||
* @method shiftArray
|
||||
* @param {Number} size of an array to shift
|
||||
* @return {SolidityParam} first array param
|
||||
* This method should be called to get offset value from bytes at given index
|
||||
*
|
||||
* @method getOffset
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {Number} offset as number
|
||||
*/
|
||||
SolidityParam.prototype.shiftArray = function (length) {
|
||||
var prefix = this.prefix.slice(0, 64);
|
||||
this.prefix = this.value.slice(64);
|
||||
var suffix = this.suffix.slice(0, 64 * length);
|
||||
this.suffix = this.suffix.slice(64 * length);
|
||||
return new SolidityParam('', prefix, suffix);
|
||||
var getOffset = function (bytes, index) {
|
||||
// we can do this cause offset is rather small
|
||||
return parseInt('0x' + bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to decode solidity bytes param at given index
|
||||
*
|
||||
* @method decodeBytes
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeBytes = function (bytes, index) {
|
||||
index = index || 0;
|
||||
//TODO add support for strings longer than 32 bytes
|
||||
//var length = parseInt('0x' + bytes.substr(offset * 64, 64));
|
||||
|
||||
var offset = getOffset(bytes, index);
|
||||
|
||||
// 2 * , cause we also parse length
|
||||
return new SolidityParam(bytes.substr(offset * 2, 2 * 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to decode solidity array at given index
|
||||
*
|
||||
* @method decodeArray
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeArray = function (bytes, index) {
|
||||
index = index || 0;
|
||||
var offset = getOffset(bytes, index);
|
||||
var length = parseInt('0x' + bytes.substr(offset * 2, 64));
|
||||
return new SolidityParam(bytes.substr(offset * 2, (length + 1) * 64));
|
||||
};
|
||||
|
||||
module.exports = SolidityParam;
|
||||
|
||||
|
||||
},{}],5:[function(require,module,exports){
|
||||
},{"../utils/utils":8}],5:[function(require,module,exports){
|
||||
/*
|
||||
This file is part of ethereum.js.
|
||||
|
||||
|
|
@ -828,6 +797,11 @@ var getConstructor = function (abi, numberOfArgs) {
|
|||
})[0];
|
||||
};
|
||||
|
||||
//var getSupremeType = function (type) {
|
||||
//return type.substr(0, type.indexOf('[')) + ']';
|
||||
//};
|
||||
|
||||
|
||||
module.exports = {
|
||||
getConstructor: getConstructor
|
||||
};
|
||||
|
|
@ -1394,7 +1368,7 @@ module.exports = {
|
|||
|
||||
},{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){
|
||||
module.exports={
|
||||
"version": "0.3.4"
|
||||
"version": "0.3.5"
|
||||
}
|
||||
|
||||
},{}],10:[function(require,module,exports){
|
||||
|
|
@ -2452,7 +2426,7 @@ var inputTransactionFormatter = function (options){
|
|||
delete options.code;
|
||||
}
|
||||
|
||||
['gasPrice', 'gas', 'value'].filter(function (key) {
|
||||
['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
|
||||
return options[key] !== undefined;
|
||||
}).forEach(function(key){
|
||||
options[key] = utils.fromDecimal(options[key]);
|
||||
|
|
@ -2801,7 +2775,16 @@ HttpProvider.prototype.send = function (payload) {
|
|||
//if (request.status !== 200) {
|
||||
//return;
|
||||
//}
|
||||
return JSON.parse(request.responseText);
|
||||
|
||||
var result = request.responseText;
|
||||
|
||||
try {
|
||||
result = JSON.parse(result);
|
||||
} catch(e) {
|
||||
throw errors.InvalidResponse(result);
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
HttpProvider.prototype.sendAsync = function (payload, callback) {
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -22,118 +22,29 @@ require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof requ
|
|||
* @date 2014
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
var coder = require('./coder');
|
||||
var solUtils = require('./utils');
|
||||
|
||||
/**
|
||||
* Formats input params to bytes
|
||||
*
|
||||
* @method formatInput
|
||||
* @param {Array} abi inputs of method
|
||||
* @param {Array} params that will be formatted to bytes
|
||||
* @returns bytes representation of input params
|
||||
*/
|
||||
var formatInput = function (inputs, params) {
|
||||
var i = inputs.map(function (input) {
|
||||
return input.type;
|
||||
});
|
||||
return coder.encodeParams(i, params);
|
||||
};
|
||||
|
||||
/**
|
||||
* Formats output bytes back to param list
|
||||
*
|
||||
* @method formatOutput
|
||||
* @param {Array} abi outputs of method
|
||||
* @param {String} bytes represention of output
|
||||
* @returns {Array} output params
|
||||
*/
|
||||
var formatOutput = function (outs, bytes) {
|
||||
var o = outs.map(function (out) {
|
||||
return out.type;
|
||||
});
|
||||
|
||||
return coder.decodeParams(o, bytes);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create input parser for contract with given abi
|
||||
*
|
||||
* @method inputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} input parser object for given json abi
|
||||
* TODO: refactor creating the parser, do not double logic from contract
|
||||
*/
|
||||
var inputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function () {
|
||||
var params = Array.prototype.slice.call(arguments);
|
||||
return formatInput(method.inputs, params);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create output parser for contract with given abi
|
||||
*
|
||||
* @method outputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} output parser for given json abi
|
||||
*/
|
||||
var outputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function (output) {
|
||||
return formatOutput(method.outputs, output);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
var utils = require('./utils');
|
||||
|
||||
var formatConstructorParams = function (abi, params) {
|
||||
var constructor = solUtils.getConstructor(abi, params.length);
|
||||
var constructor = utils.getConstructor(abi, params.length);
|
||||
if (!constructor) {
|
||||
if (params.length > 0) {
|
||||
console.warn("didn't found matching constructor, using default one");
|
||||
}
|
||||
return '';
|
||||
}
|
||||
return formatInput(constructor.inputs, params);
|
||||
|
||||
return coder.encodeParams(constructor.inputs.map(function (input) {
|
||||
return input.type;
|
||||
}), params);
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
inputParser: inputParser,
|
||||
outputParser: outputParser,
|
||||
formatInput: formatInput,
|
||||
formatOutput: formatOutput,
|
||||
formatConstructorParams: formatConstructorParams
|
||||
};
|
||||
|
||||
},{"../utils/utils":8,"./coder":2,"./utils":5}],2:[function(require,module,exports){
|
||||
|
||||
},{"./coder":2,"./utils":5}],2:[function(require,module,exports){
|
||||
/*
|
||||
This file is part of ethereum.js.
|
||||
|
||||
|
|
@ -213,9 +124,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
|
|||
return param.map(function (p) {
|
||||
return self._inputFormatter(p);
|
||||
}).reduce(function (acc, current) {
|
||||
acc.appendArrayElement(current);
|
||||
return acc;
|
||||
}, new SolidityParam('', f.formatInputInt(param.length).value));
|
||||
return acc.combine(current);
|
||||
}, f.formatInputInt(param.length)).withOffset(32);
|
||||
}
|
||||
return this._inputFormatter(param);
|
||||
};
|
||||
|
|
@ -232,9 +142,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
if (arrayType) {
|
||||
// let's assume, that we solidity will never return long arrays :P
|
||||
var result = [];
|
||||
var length = new BigNumber(param.prefix, 16);
|
||||
var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
|
||||
for (var i = 0; i < length * 64; i += 64) {
|
||||
result.push(this._outputFormatter(new SolidityParam(param.suffix.slice(i, i + 64))));
|
||||
result.push(this._outputFormatter(new SolidityParam(param.dynamicPart().substr(i + 64, 64))));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -242,31 +152,21 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
};
|
||||
|
||||
/**
|
||||
* Should be used to check if a type is variadic
|
||||
* Should be used to slice single param from bytes
|
||||
*
|
||||
* @method isVariadicType
|
||||
* @method sliceParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index of param to slice
|
||||
* @param {String} type
|
||||
* @returns {Bool} true if the type is variadic
|
||||
* @returns {SolidityParam} param
|
||||
*/
|
||||
SolidityType.prototype.isVariadicType = function (type) {
|
||||
return isArrayType(type) || this._mode === 'bytes';
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to shift param from params group
|
||||
*
|
||||
* @method shiftParam
|
||||
* @param {String} type
|
||||
* @returns {SolidityParam} shifted param
|
||||
*/
|
||||
SolidityType.prototype.shiftParam = function (type, param) {
|
||||
SolidityType.prototype.sliceParam = function (bytes, index, type) {
|
||||
if (this._mode === 'bytes') {
|
||||
return param.shiftBytes();
|
||||
return SolidityParam.decodeBytes(bytes, index);
|
||||
} else if (isArrayType(type)) {
|
||||
var length = new BigNumber(param.prefix.slice(0, 64), 16);
|
||||
return param.shiftArray(length);
|
||||
return SolidityParam.decodeArray(bytes, index);
|
||||
}
|
||||
return param.shiftValue();
|
||||
return SolidityParam.decodeParam(bytes, index);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -296,28 +196,6 @@ SolidityCoder.prototype._requireType = function (type) {
|
|||
return solidityType;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain bytes to SolidityParam object
|
||||
*
|
||||
* @method _bytesToParam
|
||||
* @param {Array} types of params
|
||||
* @param {String} bytes to be transformed to SolidityParam
|
||||
* @return {SolidityParam} SolidityParam for this group of params
|
||||
*/
|
||||
SolidityCoder.prototype._bytesToParam = function (types, bytes) {
|
||||
var self = this;
|
||||
var prefixTypes = types.reduce(function (acc, type) {
|
||||
return self._requireType(type).isVariadicType(type) ? acc + 1 : acc;
|
||||
}, 0);
|
||||
var valueTypes = types.length - prefixTypes;
|
||||
|
||||
var prefix = bytes.slice(0, prefixTypes * 64);
|
||||
bytes = bytes.slice(prefixTypes * 64);
|
||||
var value = bytes.slice(0, valueTypes * 64);
|
||||
var suffix = bytes.slice(valueTypes * 64);
|
||||
return new SolidityParam(value, prefix, suffix);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain param of given type to SolidityParam
|
||||
*
|
||||
|
|
@ -352,24 +230,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
|
|||
*/
|
||||
SolidityCoder.prototype.encodeParams = function (types, params) {
|
||||
var self = this;
|
||||
return types.map(function (type, index) {
|
||||
var solidityParams = types.map(function (type, index) {
|
||||
return self._formatInput(type, params[index]);
|
||||
}).reduce(function (acc, solidityParam) {
|
||||
acc.append(solidityParam);
|
||||
return acc;
|
||||
}, new SolidityParam()).encode();
|
||||
};
|
||||
});
|
||||
|
||||
/**
|
||||
* Should be used to transform SolidityParam to plain param
|
||||
*
|
||||
* @method _formatOutput
|
||||
* @param {String} type
|
||||
* @param {SolidityParam} param
|
||||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype._formatOutput = function (type, param) {
|
||||
return this._requireType(type).formatOutput(param, isArrayType(type));
|
||||
return SolidityParam.encodeList(solidityParams);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -381,7 +246,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
|
|||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
||||
return this._formatOutput(type, this._bytesToParam([type], bytes));
|
||||
return this.decodeParams([type], bytes)[0];
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -394,10 +259,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
|||
*/
|
||||
SolidityCoder.prototype.decodeParams = function (types, bytes) {
|
||||
var self = this;
|
||||
var param = this._bytesToParam(types, bytes);
|
||||
return types.map(function (type) {
|
||||
return types.map(function (type, index) {
|
||||
var solidityType = self._requireType(type);
|
||||
var p = solidityType.shiftParam(type, param);
|
||||
var p = solidityType.sliceParam(bytes, index, type);
|
||||
return solidityType.formatOutput(p, isArrayType(type));
|
||||
});
|
||||
};
|
||||
|
|
@ -530,7 +394,7 @@ var formatInputBytes = function (value) {
|
|||
*/
|
||||
var formatInputDynamicBytes = function (value) {
|
||||
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2);
|
||||
return new SolidityParam('', formatInputInt(value.length).value, result);
|
||||
return new SolidityParam(formatInputInt(value.length).value + result, 32);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -576,7 +440,7 @@ var signedIsNegative = function (value) {
|
|||
* @returns {BigNumber} right-aligned output bytes formatted to big number
|
||||
*/
|
||||
var formatOutputInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
|
||||
// check if it's negative number
|
||||
// it it is, return two's complement
|
||||
|
|
@ -594,7 +458,7 @@ var formatOutputInt = function (param) {
|
|||
* @returns {BigNumeber} right-aligned output bytes formatted to uint
|
||||
*/
|
||||
var formatOutputUInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
return new BigNumber(value, 16);
|
||||
};
|
||||
|
||||
|
|
@ -628,7 +492,7 @@ var formatOutputUReal = function (param) {
|
|||
* @returns {Boolean} right-aligned input bytes formatted to bool
|
||||
*/
|
||||
var formatOutputBool = function (param) {
|
||||
return param.value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -640,7 +504,7 @@ var formatOutputBool = function (param) {
|
|||
*/
|
||||
var formatOutputBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.value);
|
||||
return utils.toAscii(param.staticPart());
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -652,7 +516,7 @@ var formatOutputBytes = function (param) {
|
|||
*/
|
||||
var formatOutputDynamicBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.suffix);
|
||||
return utils.toAscii(param.dynamicPart().slice(64));
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -663,7 +527,7 @@ var formatOutputDynamicBytes = function (param) {
|
|||
* @returns {String} address
|
||||
*/
|
||||
var formatOutputAddress = function (param) {
|
||||
var value = param.value;
|
||||
var value = param.staticPart();
|
||||
return "0x" + value.slice(value.length - 40, value.length);
|
||||
};
|
||||
|
||||
|
|
@ -707,91 +571,196 @@ module.exports = {
|
|||
* @date 2015
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
|
||||
/**
|
||||
* SolidityParam object prototype.
|
||||
* Should be used when encoding, decoding solidity bytes
|
||||
*/
|
||||
var SolidityParam = function (value, prefix, suffix) {
|
||||
this.prefix = prefix || '';
|
||||
var SolidityParam = function (value, offset) {
|
||||
this.value = value || '';
|
||||
this.suffix = suffix || '';
|
||||
this.offset = offset; // offset in bytes
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode two params one after another
|
||||
*
|
||||
* @method append
|
||||
* @param {SolidityParam} param that it appended after this
|
||||
* This method should be used to get length of params's dynamic part
|
||||
*
|
||||
* @method dynamicPartLength
|
||||
* @returns {Number} length of dynamic part (in bytes)
|
||||
*/
|
||||
SolidityParam.prototype.append = function (param) {
|
||||
this.prefix += param.prefix;
|
||||
this.value += param.value;
|
||||
this.suffix += param.suffix;
|
||||
SolidityParam.prototype.dynamicPartLength = function () {
|
||||
return this.dynamicPart().length / 2;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode next param in an array
|
||||
* This method should be used to create copy of solidity param with different offset
|
||||
*
|
||||
* @method appendArrayElement
|
||||
* @param {SolidityParam} param that is appended to an array
|
||||
* @method withOffset
|
||||
* @param {Number} offset length in bytes
|
||||
* @returns {SolidityParam} new solidity param with applied offset
|
||||
*/
|
||||
SolidityParam.prototype.appendArrayElement = function (param) {
|
||||
this.suffix += param.value;
|
||||
this.prefix += param.prefix;
|
||||
// TODO: suffix not supported = it's required for nested arrays;
|
||||
SolidityParam.prototype.withOffset = function (offset) {
|
||||
return new SolidityParam(this.value, offset);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to create bytearrays from param
|
||||
* This method should be used to combine solidity params together
|
||||
* eg. when appending an array
|
||||
*
|
||||
* @method combine
|
||||
* @param {SolidityParam} param with which we should combine
|
||||
* @param {SolidityParam} result of combination
|
||||
*/
|
||||
SolidityParam.prototype.combine = function (param) {
|
||||
return new SolidityParam(this.value + param.value);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to check if param has dynamic size.
|
||||
* If it has, it returns true, otherwise false
|
||||
*
|
||||
* @method isDynamic
|
||||
* @returns {Boolean}
|
||||
*/
|
||||
SolidityParam.prototype.isDynamic = function () {
|
||||
return this.value.length > 64;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to transform offset to bytes
|
||||
*
|
||||
* @method offsetAsBytes
|
||||
* @returns {String} bytes representation of offset
|
||||
*/
|
||||
SolidityParam.prototype.offsetAsBytes = function () {
|
||||
return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get static part of param
|
||||
*
|
||||
* @method staticPart
|
||||
* @returns {String} offset if it is a dynamic param, otherwise value
|
||||
*/
|
||||
SolidityParam.prototype.staticPart = function () {
|
||||
if (!this.isDynamic()) {
|
||||
return this.value;
|
||||
}
|
||||
return this.offsetAsBytes();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get dynamic part of param
|
||||
*
|
||||
* @method dynamicPart
|
||||
* @returns {String} returns a value if it is a dynamic param, otherwise empty string
|
||||
*/
|
||||
SolidityParam.prototype.dynamicPart = function () {
|
||||
return this.isDynamic() ? this.value : '';
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to encode param
|
||||
*
|
||||
* @method encode
|
||||
* @return {String} encoded param(s)
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.encode = function () {
|
||||
return this.prefix + this.value + this.suffix;
|
||||
return this.staticPart() + this.dynamicPart();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift first param from group of params
|
||||
* This method should be called to encode array of params
|
||||
*
|
||||
* @method shiftValue
|
||||
* @return {SolidityParam} first value param
|
||||
* @method encodeList
|
||||
* @param {Array[SolidityParam]} params
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.shiftValue = function () {
|
||||
var value = this.value.slice(0, 64);
|
||||
this.value = this.value.slice(64);
|
||||
return new SolidityParam(value);
|
||||
SolidityParam.encodeList = function (params) {
|
||||
|
||||
// updating offsets
|
||||
var totalOffset = params.length * 32;
|
||||
var offsetParams = params.map(function (param) {
|
||||
if (!param.isDynamic()) {
|
||||
return param;
|
||||
}
|
||||
var offset = totalOffset;
|
||||
totalOffset += param.dynamicPartLength();
|
||||
return param.withOffset(offset);
|
||||
});
|
||||
|
||||
// encode everything!
|
||||
return offsetParams.reduce(function (result, param) {
|
||||
return result + param.dynamicPart();
|
||||
}, offsetParams.reduce(function (result, param) {
|
||||
return result + param.staticPart();
|
||||
}, ''));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to first bytes param from group of params
|
||||
* This method should be used to decode plain (static) solidity param at given index
|
||||
*
|
||||
* @method shiftBytes
|
||||
* @return {SolidityParam} first bytes param
|
||||
* @method decodeParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.prototype.shiftBytes = function () {
|
||||
return this.shiftArray(1);
|
||||
SolidityParam.decodeParam = function (bytes, index) {
|
||||
index = index || 0;
|
||||
return new SolidityParam(bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift an array from group of params
|
||||
*
|
||||
* @method shiftArray
|
||||
* @param {Number} size of an array to shift
|
||||
* @return {SolidityParam} first array param
|
||||
* This method should be called to get offset value from bytes at given index
|
||||
*
|
||||
* @method getOffset
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {Number} offset as number
|
||||
*/
|
||||
SolidityParam.prototype.shiftArray = function (length) {
|
||||
var prefix = this.prefix.slice(0, 64);
|
||||
this.prefix = this.value.slice(64);
|
||||
var suffix = this.suffix.slice(0, 64 * length);
|
||||
this.suffix = this.suffix.slice(64 * length);
|
||||
return new SolidityParam('', prefix, suffix);
|
||||
var getOffset = function (bytes, index) {
|
||||
// we can do this cause offset is rather small
|
||||
return parseInt('0x' + bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to decode solidity bytes param at given index
|
||||
*
|
||||
* @method decodeBytes
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeBytes = function (bytes, index) {
|
||||
index = index || 0;
|
||||
//TODO add support for strings longer than 32 bytes
|
||||
//var length = parseInt('0x' + bytes.substr(offset * 64, 64));
|
||||
|
||||
var offset = getOffset(bytes, index);
|
||||
|
||||
// 2 * , cause we also parse length
|
||||
return new SolidityParam(bytes.substr(offset * 2, 2 * 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to decode solidity array at given index
|
||||
*
|
||||
* @method decodeArray
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeArray = function (bytes, index) {
|
||||
index = index || 0;
|
||||
var offset = getOffset(bytes, index);
|
||||
var length = parseInt('0x' + bytes.substr(offset * 2, 64));
|
||||
return new SolidityParam(bytes.substr(offset * 2, (length + 1) * 64));
|
||||
};
|
||||
|
||||
module.exports = SolidityParam;
|
||||
|
||||
|
||||
},{}],5:[function(require,module,exports){
|
||||
},{"../utils/utils":8}],5:[function(require,module,exports){
|
||||
/*
|
||||
This file is part of ethereum.js.
|
||||
|
||||
|
|
@ -828,6 +797,11 @@ var getConstructor = function (abi, numberOfArgs) {
|
|||
})[0];
|
||||
};
|
||||
|
||||
//var getSupremeType = function (type) {
|
||||
//return type.substr(0, type.indexOf('[')) + ']';
|
||||
//};
|
||||
|
||||
|
||||
module.exports = {
|
||||
getConstructor: getConstructor
|
||||
};
|
||||
|
|
@ -1394,7 +1368,7 @@ module.exports = {
|
|||
|
||||
},{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){
|
||||
module.exports={
|
||||
"version": "0.3.4"
|
||||
"version": "0.3.5"
|
||||
}
|
||||
|
||||
},{}],10:[function(require,module,exports){
|
||||
|
|
@ -2452,7 +2426,7 @@ var inputTransactionFormatter = function (options){
|
|||
delete options.code;
|
||||
}
|
||||
|
||||
['gasPrice', 'gas', 'value'].filter(function (key) {
|
||||
['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
|
||||
return options[key] !== undefined;
|
||||
}).forEach(function(key){
|
||||
options[key] = utils.fromDecimal(options[key]);
|
||||
|
|
@ -2801,7 +2775,16 @@ HttpProvider.prototype.send = function (payload) {
|
|||
//if (request.status !== 200) {
|
||||
//return;
|
||||
//}
|
||||
return JSON.parse(request.responseText);
|
||||
|
||||
var result = request.responseText;
|
||||
|
||||
try {
|
||||
result = JSON.parse(result);
|
||||
} catch(e) {
|
||||
throw errors.InvalidResponse(result);
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
HttpProvider.prototype.sendAsync = function (payload, callback) {
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -21,113 +21,24 @@
|
|||
* @date 2014
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
var coder = require('./coder');
|
||||
var solUtils = require('./utils');
|
||||
|
||||
/**
|
||||
* Formats input params to bytes
|
||||
*
|
||||
* @method formatInput
|
||||
* @param {Array} abi inputs of method
|
||||
* @param {Array} params that will be formatted to bytes
|
||||
* @returns bytes representation of input params
|
||||
*/
|
||||
var formatInput = function (inputs, params) {
|
||||
var i = inputs.map(function (input) {
|
||||
return input.type;
|
||||
});
|
||||
return coder.encodeParams(i, params);
|
||||
};
|
||||
|
||||
/**
|
||||
* Formats output bytes back to param list
|
||||
*
|
||||
* @method formatOutput
|
||||
* @param {Array} abi outputs of method
|
||||
* @param {String} bytes represention of output
|
||||
* @returns {Array} output params
|
||||
*/
|
||||
var formatOutput = function (outs, bytes) {
|
||||
var o = outs.map(function (out) {
|
||||
return out.type;
|
||||
});
|
||||
|
||||
return coder.decodeParams(o, bytes);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create input parser for contract with given abi
|
||||
*
|
||||
* @method inputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} input parser object for given json abi
|
||||
* TODO: refactor creating the parser, do not double logic from contract
|
||||
*/
|
||||
var inputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function () {
|
||||
var params = Array.prototype.slice.call(arguments);
|
||||
return formatInput(method.inputs, params);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be called to create output parser for contract with given abi
|
||||
*
|
||||
* @method outputParser
|
||||
* @param {Array} contract abi
|
||||
* @returns {Object} output parser for given json abi
|
||||
*/
|
||||
var outputParser = function (json) {
|
||||
var parser = {};
|
||||
json.forEach(function (method) {
|
||||
|
||||
var displayName = utils.extractDisplayName(method.name);
|
||||
var typeName = utils.extractTypeName(method.name);
|
||||
|
||||
var impl = function (output) {
|
||||
return formatOutput(method.outputs, output);
|
||||
};
|
||||
|
||||
if (parser[displayName] === undefined) {
|
||||
parser[displayName] = impl;
|
||||
}
|
||||
|
||||
parser[displayName][typeName] = impl;
|
||||
});
|
||||
|
||||
return parser;
|
||||
};
|
||||
var utils = require('./utils');
|
||||
|
||||
var formatConstructorParams = function (abi, params) {
|
||||
var constructor = solUtils.getConstructor(abi, params.length);
|
||||
var constructor = utils.getConstructor(abi, params.length);
|
||||
if (!constructor) {
|
||||
if (params.length > 0) {
|
||||
console.warn("didn't found matching constructor, using default one");
|
||||
}
|
||||
return '';
|
||||
}
|
||||
return formatInput(constructor.inputs, params);
|
||||
|
||||
return coder.encodeParams(constructor.inputs.map(function (input) {
|
||||
return input.type;
|
||||
}), params);
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
inputParser: inputParser,
|
||||
outputParser: outputParser,
|
||||
formatInput: formatInput,
|
||||
formatOutput: formatOutput,
|
||||
formatConstructorParams: formatConstructorParams
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -77,9 +77,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
|
|||
return param.map(function (p) {
|
||||
return self._inputFormatter(p);
|
||||
}).reduce(function (acc, current) {
|
||||
acc.appendArrayElement(current);
|
||||
return acc;
|
||||
}, new SolidityParam('', f.formatInputInt(param.length).value));
|
||||
return acc.combine(current);
|
||||
}, f.formatInputInt(param.length)).withOffset(32);
|
||||
}
|
||||
return this._inputFormatter(param);
|
||||
};
|
||||
|
|
@ -96,9 +95,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
if (arrayType) {
|
||||
// let's assume, that we solidity will never return long arrays :P
|
||||
var result = [];
|
||||
var length = new BigNumber(param.prefix, 16);
|
||||
var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
|
||||
for (var i = 0; i < length * 64; i += 64) {
|
||||
result.push(this._outputFormatter(new SolidityParam(param.suffix.slice(i, i + 64))));
|
||||
result.push(this._outputFormatter(new SolidityParam(param.dynamicPart().substr(i + 64, 64))));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -106,31 +105,21 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
|
|||
};
|
||||
|
||||
/**
|
||||
* Should be used to check if a type is variadic
|
||||
* Should be used to slice single param from bytes
|
||||
*
|
||||
* @method isVariadicType
|
||||
* @method sliceParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index of param to slice
|
||||
* @param {String} type
|
||||
* @returns {Bool} true if the type is variadic
|
||||
* @returns {SolidityParam} param
|
||||
*/
|
||||
SolidityType.prototype.isVariadicType = function (type) {
|
||||
return isArrayType(type) || this._mode === 'bytes';
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to shift param from params group
|
||||
*
|
||||
* @method shiftParam
|
||||
* @param {String} type
|
||||
* @returns {SolidityParam} shifted param
|
||||
*/
|
||||
SolidityType.prototype.shiftParam = function (type, param) {
|
||||
SolidityType.prototype.sliceParam = function (bytes, index, type) {
|
||||
if (this._mode === 'bytes') {
|
||||
return param.shiftBytes();
|
||||
return SolidityParam.decodeBytes(bytes, index);
|
||||
} else if (isArrayType(type)) {
|
||||
var length = new BigNumber(param.prefix.slice(0, 64), 16);
|
||||
return param.shiftArray(length);
|
||||
return SolidityParam.decodeArray(bytes, index);
|
||||
}
|
||||
return param.shiftValue();
|
||||
return SolidityParam.decodeParam(bytes, index);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -160,28 +149,6 @@ SolidityCoder.prototype._requireType = function (type) {
|
|||
return solidityType;
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain bytes to SolidityParam object
|
||||
*
|
||||
* @method _bytesToParam
|
||||
* @param {Array} types of params
|
||||
* @param {String} bytes to be transformed to SolidityParam
|
||||
* @return {SolidityParam} SolidityParam for this group of params
|
||||
*/
|
||||
SolidityCoder.prototype._bytesToParam = function (types, bytes) {
|
||||
var self = this;
|
||||
var prefixTypes = types.reduce(function (acc, type) {
|
||||
return self._requireType(type).isVariadicType(type) ? acc + 1 : acc;
|
||||
}, 0);
|
||||
var valueTypes = types.length - prefixTypes;
|
||||
|
||||
var prefix = bytes.slice(0, prefixTypes * 64);
|
||||
bytes = bytes.slice(prefixTypes * 64);
|
||||
var value = bytes.slice(0, valueTypes * 64);
|
||||
var suffix = bytes.slice(valueTypes * 64);
|
||||
return new SolidityParam(value, prefix, suffix);
|
||||
};
|
||||
|
||||
/**
|
||||
* Should be used to transform plain param of given type to SolidityParam
|
||||
*
|
||||
|
|
@ -216,24 +183,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
|
|||
*/
|
||||
SolidityCoder.prototype.encodeParams = function (types, params) {
|
||||
var self = this;
|
||||
return types.map(function (type, index) {
|
||||
var solidityParams = types.map(function (type, index) {
|
||||
return self._formatInput(type, params[index]);
|
||||
}).reduce(function (acc, solidityParam) {
|
||||
acc.append(solidityParam);
|
||||
return acc;
|
||||
}, new SolidityParam()).encode();
|
||||
};
|
||||
});
|
||||
|
||||
/**
|
||||
* Should be used to transform SolidityParam to plain param
|
||||
*
|
||||
* @method _formatOutput
|
||||
* @param {String} type
|
||||
* @param {SolidityParam} param
|
||||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype._formatOutput = function (type, param) {
|
||||
return this._requireType(type).formatOutput(param, isArrayType(type));
|
||||
return SolidityParam.encodeList(solidityParams);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -245,7 +199,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
|
|||
* @return {Object} plain param
|
||||
*/
|
||||
SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
||||
return this._formatOutput(type, this._bytesToParam([type], bytes));
|
||||
return this.decodeParams([type], bytes)[0];
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -258,10 +212,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
|
|||
*/
|
||||
SolidityCoder.prototype.decodeParams = function (types, bytes) {
|
||||
var self = this;
|
||||
var param = this._bytesToParam(types, bytes);
|
||||
return types.map(function (type) {
|
||||
return types.map(function (type, index) {
|
||||
var solidityType = self._requireType(type);
|
||||
var p = solidityType.shiftParam(type, param);
|
||||
var p = solidityType.sliceParam(bytes, index, type);
|
||||
return solidityType.formatOutput(p, isArrayType(type));
|
||||
});
|
||||
};
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ var formatInputBytes = function (value) {
|
|||
*/
|
||||
var formatInputDynamicBytes = function (value) {
|
||||
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2);
|
||||
return new SolidityParam('', formatInputInt(value.length).value, result);
|
||||
return new SolidityParam(formatInputInt(value.length).value + result, 32);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -109,7 +109,7 @@ var signedIsNegative = function (value) {
|
|||
* @returns {BigNumber} right-aligned output bytes formatted to big number
|
||||
*/
|
||||
var formatOutputInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
|
||||
// check if it's negative number
|
||||
// it it is, return two's complement
|
||||
|
|
@ -127,7 +127,7 @@ var formatOutputInt = function (param) {
|
|||
* @returns {BigNumeber} right-aligned output bytes formatted to uint
|
||||
*/
|
||||
var formatOutputUInt = function (param) {
|
||||
var value = param.value || "0";
|
||||
var value = param.staticPart() || "0";
|
||||
return new BigNumber(value, 16);
|
||||
};
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ var formatOutputUReal = function (param) {
|
|||
* @returns {Boolean} right-aligned input bytes formatted to bool
|
||||
*/
|
||||
var formatOutputBool = function (param) {
|
||||
return param.value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -173,7 +173,7 @@ var formatOutputBool = function (param) {
|
|||
*/
|
||||
var formatOutputBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.value);
|
||||
return utils.toAscii(param.staticPart());
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -185,7 +185,7 @@ var formatOutputBytes = function (param) {
|
|||
*/
|
||||
var formatOutputDynamicBytes = function (param) {
|
||||
// length might also be important!
|
||||
return utils.toAscii(param.suffix);
|
||||
return utils.toAscii(param.dynamicPart().slice(64));
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -196,7 +196,7 @@ var formatOutputDynamicBytes = function (param) {
|
|||
* @returns {String} address
|
||||
*/
|
||||
var formatOutputAddress = function (param) {
|
||||
var value = param.value;
|
||||
var value = param.staticPart();
|
||||
return "0x" + value.slice(value.length - 40, value.length);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -20,85 +20,190 @@
|
|||
* @date 2015
|
||||
*/
|
||||
|
||||
var utils = require('../utils/utils');
|
||||
|
||||
/**
|
||||
* SolidityParam object prototype.
|
||||
* Should be used when encoding, decoding solidity bytes
|
||||
*/
|
||||
var SolidityParam = function (value, prefix, suffix) {
|
||||
this.prefix = prefix || '';
|
||||
var SolidityParam = function (value, offset) {
|
||||
this.value = value || '';
|
||||
this.suffix = suffix || '';
|
||||
this.offset = offset; // offset in bytes
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode two params one after another
|
||||
*
|
||||
* @method append
|
||||
* @param {SolidityParam} param that it appended after this
|
||||
* This method should be used to get length of params's dynamic part
|
||||
*
|
||||
* @method dynamicPartLength
|
||||
* @returns {Number} length of dynamic part (in bytes)
|
||||
*/
|
||||
SolidityParam.prototype.append = function (param) {
|
||||
this.prefix += param.prefix;
|
||||
this.value += param.value;
|
||||
this.suffix += param.suffix;
|
||||
SolidityParam.prototype.dynamicPartLength = function () {
|
||||
return this.dynamicPart().length / 2;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to encode next param in an array
|
||||
* This method should be used to create copy of solidity param with different offset
|
||||
*
|
||||
* @method appendArrayElement
|
||||
* @param {SolidityParam} param that is appended to an array
|
||||
* @method withOffset
|
||||
* @param {Number} offset length in bytes
|
||||
* @returns {SolidityParam} new solidity param with applied offset
|
||||
*/
|
||||
SolidityParam.prototype.appendArrayElement = function (param) {
|
||||
this.suffix += param.value;
|
||||
this.prefix += param.prefix;
|
||||
// TODO: suffix not supported = it's required for nested arrays;
|
||||
SolidityParam.prototype.withOffset = function (offset) {
|
||||
return new SolidityParam(this.value, offset);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to create bytearrays from param
|
||||
* This method should be used to combine solidity params together
|
||||
* eg. when appending an array
|
||||
*
|
||||
* @method combine
|
||||
* @param {SolidityParam} param with which we should combine
|
||||
* @param {SolidityParam} result of combination
|
||||
*/
|
||||
SolidityParam.prototype.combine = function (param) {
|
||||
return new SolidityParam(this.value + param.value);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to check if param has dynamic size.
|
||||
* If it has, it returns true, otherwise false
|
||||
*
|
||||
* @method isDynamic
|
||||
* @returns {Boolean}
|
||||
*/
|
||||
SolidityParam.prototype.isDynamic = function () {
|
||||
return this.value.length > 64;
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to transform offset to bytes
|
||||
*
|
||||
* @method offsetAsBytes
|
||||
* @returns {String} bytes representation of offset
|
||||
*/
|
||||
SolidityParam.prototype.offsetAsBytes = function () {
|
||||
return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64);
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get static part of param
|
||||
*
|
||||
* @method staticPart
|
||||
* @returns {String} offset if it is a dynamic param, otherwise value
|
||||
*/
|
||||
SolidityParam.prototype.staticPart = function () {
|
||||
if (!this.isDynamic()) {
|
||||
return this.value;
|
||||
}
|
||||
return this.offsetAsBytes();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to get dynamic part of param
|
||||
*
|
||||
* @method dynamicPart
|
||||
* @returns {String} returns a value if it is a dynamic param, otherwise empty string
|
||||
*/
|
||||
SolidityParam.prototype.dynamicPart = function () {
|
||||
return this.isDynamic() ? this.value : '';
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to encode param
|
||||
*
|
||||
* @method encode
|
||||
* @return {String} encoded param(s)
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.encode = function () {
|
||||
return this.prefix + this.value + this.suffix;
|
||||
return this.staticPart() + this.dynamicPart();
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift first param from group of params
|
||||
* This method should be called to encode array of params
|
||||
*
|
||||
* @method shiftValue
|
||||
* @return {SolidityParam} first value param
|
||||
* @method encodeList
|
||||
* @param {Array[SolidityParam]} params
|
||||
* @returns {String}
|
||||
*/
|
||||
SolidityParam.prototype.shiftValue = function () {
|
||||
var value = this.value.slice(0, 64);
|
||||
this.value = this.value.slice(64);
|
||||
return new SolidityParam(value);
|
||||
SolidityParam.encodeList = function (params) {
|
||||
|
||||
// updating offsets
|
||||
var totalOffset = params.length * 32;
|
||||
var offsetParams = params.map(function (param) {
|
||||
if (!param.isDynamic()) {
|
||||
return param;
|
||||
}
|
||||
var offset = totalOffset;
|
||||
totalOffset += param.dynamicPartLength();
|
||||
return param.withOffset(offset);
|
||||
});
|
||||
|
||||
// encode everything!
|
||||
return offsetParams.reduce(function (result, param) {
|
||||
return result + param.dynamicPart();
|
||||
}, offsetParams.reduce(function (result, param) {
|
||||
return result + param.staticPart();
|
||||
}, ''));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to first bytes param from group of params
|
||||
* This method should be used to decode plain (static) solidity param at given index
|
||||
*
|
||||
* @method shiftBytes
|
||||
* @return {SolidityParam} first bytes param
|
||||
* @method decodeParam
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.prototype.shiftBytes = function () {
|
||||
return this.shiftArray(1);
|
||||
SolidityParam.decodeParam = function (bytes, index) {
|
||||
index = index || 0;
|
||||
return new SolidityParam(bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to shift an array from group of params
|
||||
*
|
||||
* @method shiftArray
|
||||
* @param {Number} size of an array to shift
|
||||
* @return {SolidityParam} first array param
|
||||
* This method should be called to get offset value from bytes at given index
|
||||
*
|
||||
* @method getOffset
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {Number} offset as number
|
||||
*/
|
||||
SolidityParam.prototype.shiftArray = function (length) {
|
||||
var prefix = this.prefix.slice(0, 64);
|
||||
this.prefix = this.value.slice(64);
|
||||
var suffix = this.suffix.slice(0, 64 * length);
|
||||
this.suffix = this.suffix.slice(64 * length);
|
||||
return new SolidityParam('', prefix, suffix);
|
||||
var getOffset = function (bytes, index) {
|
||||
// we can do this cause offset is rather small
|
||||
return parseInt('0x' + bytes.substr(index * 64, 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be called to decode solidity bytes param at given index
|
||||
*
|
||||
* @method decodeBytes
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeBytes = function (bytes, index) {
|
||||
index = index || 0;
|
||||
//TODO add support for strings longer than 32 bytes
|
||||
//var length = parseInt('0x' + bytes.substr(offset * 64, 64));
|
||||
|
||||
var offset = getOffset(bytes, index);
|
||||
|
||||
// 2 * , cause we also parse length
|
||||
return new SolidityParam(bytes.substr(offset * 2, 2 * 64));
|
||||
};
|
||||
|
||||
/**
|
||||
* This method should be used to decode solidity array at given index
|
||||
*
|
||||
* @method decodeArray
|
||||
* @param {String} bytes
|
||||
* @param {Number} index
|
||||
* @returns {SolidityParam}
|
||||
*/
|
||||
SolidityParam.decodeArray = function (bytes, index) {
|
||||
index = index || 0;
|
||||
var offset = getOffset(bytes, index);
|
||||
var length = parseInt('0x' + bytes.substr(offset * 2, 64));
|
||||
return new SolidityParam(bytes.substr(offset * 2, (length + 1) * 64));
|
||||
};
|
||||
|
||||
module.exports = SolidityParam;
|
||||
|
|
|
|||
|
|
@ -34,6 +34,11 @@ var getConstructor = function (abi, numberOfArgs) {
|
|||
})[0];
|
||||
};
|
||||
|
||||
//var getSupremeType = function (type) {
|
||||
//return type.substr(0, type.indexOf('[')) + ']';
|
||||
//};
|
||||
|
||||
|
||||
module.exports = {
|
||||
getConstructor: getConstructor
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
{
|
||||
"version": "0.3.4"
|
||||
"version": "0.3.5"
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ var inputTransactionFormatter = function (options){
|
|||
delete options.code;
|
||||
}
|
||||
|
||||
['gasPrice', 'gas', 'value'].filter(function (key) {
|
||||
['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
|
||||
return options[key] !== undefined;
|
||||
}).forEach(function(key){
|
||||
options[key] = utils.fromDecimal(options[key]);
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/* jshint ignore:start */
|
||||
Package.describe({
|
||||
name: 'ethereum:web3',
|
||||
version: '0.3.4',
|
||||
version: '0.3.5',
|
||||
summary: 'Ethereum JavaScript API, middleware to talk to a ethreum node over RPC',
|
||||
git: 'https://github.com/ethereum/ethereum.js',
|
||||
// By default, Meteor will default to using README.md for documentation.
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"name": "web3",
|
||||
"namespace": "ethereum",
|
||||
"version": "0.3.4",
|
||||
"version": "0.3.5",
|
||||
"description": "Ethereum JavaScript API, middleware to talk to a ethereum node over RPC",
|
||||
"main": "./index.js",
|
||||
"directories": {
|
||||
|
|
|
|||
|
|
@ -1,515 +0,0 @@
|
|||
var chai = require('chai');
|
||||
var assert = chai.assert;
|
||||
var BigNumber = require('bignumber.js');
|
||||
var abi = require('../lib/solidity/abi');
|
||||
var clone = function (object) { return JSON.parse(JSON.stringify(object)); };
|
||||
|
||||
var description = [{
|
||||
"name": "test",
|
||||
"type": "function",
|
||||
"inputs": [{
|
||||
"name": "a",
|
||||
"type": "uint256"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "d",
|
||||
"type": "uint256"
|
||||
}
|
||||
]
|
||||
}];
|
||||
|
||||
describe('lib/solidity/abi', function () {
|
||||
describe('inputParser', function () {
|
||||
it('should parse input uint', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "uint" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input uint128', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "uint128" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input uint256', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "uint256" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input int', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
|
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
|
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
});
|
||||
|
||||
it('should parse input int128', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int128" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
|
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
|
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input int256', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int256" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
|
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
|
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
|
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
|
||||
assert.equal(
|
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
);
|
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input bool', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: 'bool' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(true), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.test(false), "0000000000000000000000000000000000000000000000000000000000000000");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input address', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "address" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d)
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input fixed bytes type', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "bytes" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test('hello'),
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000"
|
||||
);
|
||||
assert.equal(
|
||||
parser.test('world'),
|
||||
"0000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse input int followed by a fixed bytes type', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int" },
|
||||
{ type: "bytes" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test(9, 'hello'),
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000009" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse input fixed bytes type followed by an int', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "bytes" },
|
||||
{ type: "int" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test('hello', 9),
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000009" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000"
|
||||
);
|
||||
});
|
||||
|
||||
it('should use proper method name', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].name = 'helloworld(int)';
|
||||
d[0].inputs = [
|
||||
{ type: "int" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.helloworld(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(parser.helloworld['int'](1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
|
||||
});
|
||||
|
||||
it('should parse multiple methods', function () {
|
||||
|
||||
// given
|
||||
var d = [{
|
||||
name: "test",
|
||||
type: "function",
|
||||
inputs: [{ type: "int" }],
|
||||
outputs: [{ type: "int" }]
|
||||
},{
|
||||
name: "test2",
|
||||
type: "function",
|
||||
inputs: [{ type: "bytes" }],
|
||||
outputs: [{ type: "bytes" }]
|
||||
}];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
//then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
|
||||
assert.equal(
|
||||
parser.test2('hello'),
|
||||
"000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000"
|
||||
);
|
||||
|
||||
});
|
||||
|
||||
it('should parse input array of ints', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int[]" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test([5, 6]),
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse an array followed by an int', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int[]" },
|
||||
{ type: "int" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test([5, 6], 3),
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000003" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse an int followed by an array', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int" },
|
||||
{ type: "int[]" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test(3, [5, 6]),
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000003" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse mixture of arrays and ints', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: "int" },
|
||||
{ type: "int[]" },
|
||||
{ type: "int" },
|
||||
{ type: "int[]" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test(3, [5, 6, 1, 2], 7, [8, 9]),
|
||||
"0000000000000000000000000000000000000000000000000000000000000004" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000003" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000007" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000001" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000008" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000009"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse input real', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: 'real' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000100000000000000000000000000000000");
|
||||
assert.equal(parser.test(2.125), "0000000000000000000000000000000220000000000000000000000000000000");
|
||||
assert.equal(parser.test(8.5), "0000000000000000000000000000000880000000000000000000000000000000");
|
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffff00000000000000000000000000000000");
|
||||
|
||||
});
|
||||
|
||||
it('should parse input ureal', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].inputs = [
|
||||
{ type: 'ureal' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000100000000000000000000000000000000");
|
||||
assert.equal(parser.test(2.125), "0000000000000000000000000000000220000000000000000000000000000000");
|
||||
assert.equal(parser.test(8.5), "0000000000000000000000000000000880000000000000000000000000000000");
|
||||
|
||||
});
|
||||
|
||||
it('should throw an incorrect type error', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].inputs = [
|
||||
{ type: 'uin' }
|
||||
]
|
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d);
|
||||
|
||||
// then
|
||||
assert.throws(function () {parser.test('0x')}, Error);
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
|
@ -1,419 +0,0 @@
|
|||
var assert = require('assert');
|
||||
var BigNumber = require('bignumber.js');
|
||||
var abi = require('../lib/solidity/abi.js');
|
||||
var clone = function (object) { return JSON.parse(JSON.stringify(object)); };
|
||||
|
||||
var description = [{
|
||||
"name": "test",
|
||||
"type": "function",
|
||||
"inputs": [{
|
||||
"name": "a",
|
||||
"type": "uint256"
|
||||
}
|
||||
],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "d",
|
||||
"type": "uint256"
|
||||
}
|
||||
]
|
||||
}];
|
||||
|
||||
describe('lib/solidity/abi', function() {
|
||||
describe('outputParser', function() {
|
||||
it('should parse output fixed bytes type', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: "bytes" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
|
||||
'hello'
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[0],
|
||||
'world'
|
||||
);
|
||||
|
||||
});
|
||||
|
||||
it('should parse output uint', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'uint' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(
|
||||
parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
|
||||
);
|
||||
assert.equal(
|
||||
parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse output uint256', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'uint256' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(
|
||||
parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
|
||||
);
|
||||
assert.equal(
|
||||
parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse output uint128', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'uint128' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(
|
||||
parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
|
||||
);
|
||||
assert.equal(
|
||||
parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse output int', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'int' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
|
||||
assert.equal(parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
|
||||
});
|
||||
|
||||
it('should parse output int256', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'int256' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
|
||||
assert.equal(parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
|
||||
});
|
||||
|
||||
it('should parse output int128', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'int128' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
|
||||
assert.equal(parser.test("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
|
||||
assert.equal(parser.test("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
|
||||
});
|
||||
|
||||
it('should parse output address', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'address' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test("000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
|
||||
"0x407d73d8a49eeb85d32cf465507dd71d507100c1"
|
||||
);
|
||||
});
|
||||
|
||||
it('should parse output bool', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'bool' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], true);
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000000")[0], false);
|
||||
|
||||
|
||||
});
|
||||
|
||||
it('should parse output real', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'real' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
|
||||
assert.equal(parser.test("0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125);
|
||||
assert.equal(parser.test("0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5);
|
||||
assert.equal(parser.test("ffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1);
|
||||
|
||||
});
|
||||
|
||||
it('should parse output ureal', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: 'ureal' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
|
||||
assert.equal(parser.test("0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125);
|
||||
assert.equal(parser.test("0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5);
|
||||
|
||||
});
|
||||
|
||||
|
||||
it('should parse multiple output fixed bytes type', function() {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [
|
||||
{ type: "bytes" },
|
||||
{ type: "bytes" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(
|
||||
parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000" +
|
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[0],
|
||||
'hello'
|
||||
);
|
||||
assert.equal(
|
||||
parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000" +
|
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[1],
|
||||
'world'
|
||||
);
|
||||
|
||||
});
|
||||
|
||||
it('should use proper method name', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].name = 'helloworld(int)';
|
||||
d[0].outputs = [
|
||||
{ type: "int" }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.helloworld("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.helloworld['int']("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
|
||||
});
|
||||
|
||||
|
||||
it('should parse multiple methods', function () {
|
||||
|
||||
// given
|
||||
var d = [{
|
||||
name: "test",
|
||||
type: "function",
|
||||
inputs: [{ type: "int" }],
|
||||
outputs: [{ type: "int" }]
|
||||
},{
|
||||
name: "test2",
|
||||
type: "function",
|
||||
inputs: [{ type: "bytes" }],
|
||||
outputs: [{ type: "bytes" }]
|
||||
}];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
//then
|
||||
assert.equal(parser.test("00000000000000000000000000000000000000000000000000000000000001")[0], 1);
|
||||
assert.equal(parser.test2(
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
|
||||
"hello"
|
||||
);
|
||||
|
||||
});
|
||||
|
||||
it('should parse output array', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].outputs = [
|
||||
{ type: 'int[]' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006")[0][0],
|
||||
5
|
||||
);
|
||||
assert.equal(parser.test(
|
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006")[0][1],
|
||||
6
|
||||
);
|
||||
|
||||
});
|
||||
|
||||
it('should parse 0x0 value', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].outputs = [
|
||||
{ type: 'int' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0")[0], 0);
|
||||
|
||||
});
|
||||
|
||||
it('should parse 0x0 value', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].outputs = [
|
||||
{ type: 'uint' }
|
||||
];
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0")[0], 0);
|
||||
|
||||
});
|
||||
|
||||
it('should throw an incorrect type error', function () {
|
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
d[0].outputs = [
|
||||
{ type: 'uin' }
|
||||
]
|
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d);
|
||||
|
||||
// then
|
||||
assert.throws(function () {parser.test('0x')}, Error);
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -21,17 +21,32 @@ describe('lib/solidity/coder', function () {
|
|||
test({ type: 'int256', expected: new bn(16), value: '0000000000000000000000000000000000000000000000000000000000000010'});
|
||||
test({ type: 'int256', expected: new bn(-1), value: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
|
||||
test({ type: 'bytes32', expected: 'gavofyork', value: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'bytes', expected: 'gavofyork', value: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
test({ type: 'bytes', expected: 'gavofyork', value: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'int[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ type: 'int[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'int256[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ type: 'int256[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'int[]', expected: [new bn(1), new bn(2), new bn(3)],
|
||||
value: '0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
value: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'bool', expected: true, value: '0000000000000000000000000000000000000000000000000000000000000001'});
|
||||
test({ type: 'bool', expected: false, value: '0000000000000000000000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'real', expected: new bn(1), value: '0000000000000000000000000000000100000000000000000000000000000000'});
|
||||
test({ type: 'real', expected: new bn(2.125), value: '0000000000000000000000000000000220000000000000000000000000000000'});
|
||||
test({ type: 'real', expected: new bn(8.5), value: '0000000000000000000000000000000880000000000000000000000000000000'});
|
||||
test({ type: 'real', expected: new bn(-1), value: 'ffffffffffffffffffffffffffffffff00000000000000000000000000000000'});
|
||||
test({ type: 'ureal', expected: new bn(1), value: '0000000000000000000000000000000100000000000000000000000000000000'});
|
||||
test({ type: 'ureal', expected: new bn(2.125), value: '0000000000000000000000000000000220000000000000000000000000000000'});
|
||||
test({ type: 'ureal', expected: new bn(8.5), value: '0000000000000000000000000000000880000000000000000000000000000000'});
|
||||
test({ type: 'address', expected: '0x407d73d8a49eeb85d32cf465507dd71d507100c1',
|
||||
value: '000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1'});
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -53,16 +68,18 @@ describe('lib/solidity/coder', function () {
|
|||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['int', 'bytes', 'int', 'int', 'int', 'int[]'], expected: [new bn(1), 'gavofyork', new bn(2), new bn(3), new bn(4),
|
||||
[new bn(5), new bn(6), new bn(7)]],
|
||||
values: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000004' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000006' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000007'});
|
||||
values: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'00000000000000000000000000000000000000000000000000000000000000c0' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000004' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000100' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000006' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000007'});
|
||||
});
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -15,20 +15,37 @@ describe('lib/solidity/coder', function () {
|
|||
test({ type: 'int', value: 1, expected: '0000000000000000000000000000000000000000000000000000000000000001'});
|
||||
test({ type: 'int', value: 16, expected: '0000000000000000000000000000000000000000000000000000000000000010'});
|
||||
test({ type: 'int', value: -1, expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
|
||||
test({ type: 'int', value: 0.1, expected: '0000000000000000000000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'int', value: 3.9, expected: '0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'int256', value: 1, expected: '0000000000000000000000000000000000000000000000000000000000000001'});
|
||||
test({ type: 'int256', value: 16, expected: '0000000000000000000000000000000000000000000000000000000000000010'});
|
||||
test({ type: 'int256', value: -1, expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
|
||||
test({ type: 'bytes32', value: 'gavofyork', expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'bytes', value: 'gavofyork', expected: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
test({ type: 'bytes', value: 'gavofyork', expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'int[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ type: 'int[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'int256[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ type: 'int256[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'int[]', value: [1,2,3], expected: '0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
test({ type: 'int[]', value: [1,2,3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ type: 'bool', value: true, expected: '0000000000000000000000000000000000000000000000000000000000000001'});
|
||||
test({ type: 'bool', value: false, expected: '0000000000000000000000000000000000000000000000000000000000000000'});
|
||||
test({ type: 'address', value: '0x407d73d8a49eeb85d32cf465507dd71d507100c1',
|
||||
expected: '000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1'});
|
||||
test({ type: 'real', value: 1, expected: '0000000000000000000000000000000100000000000000000000000000000000'});
|
||||
test({ type: 'real', value: 2.125, expected: '0000000000000000000000000000000220000000000000000000000000000000'});
|
||||
test({ type: 'real', value: 8.5, expected: '0000000000000000000000000000000880000000000000000000000000000000'});
|
||||
test({ type: 'real', value: -1, expected: 'ffffffffffffffffffffffffffffffff00000000000000000000000000000000'});
|
||||
test({ type: 'ureal', value: 1, expected: '0000000000000000000000000000000100000000000000000000000000000000'});
|
||||
test({ type: 'ureal', value: 2.125, expected: '0000000000000000000000000000000220000000000000000000000000000000'});
|
||||
test({ type: 'ureal', value: 8.5, expected: '0000000000000000000000000000000880000000000000000000000000000000'});
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -49,16 +66,29 @@ describe('lib/solidity/coder', function () {
|
|||
test({ types: ['int256'], values: [16], expected: '0000000000000000000000000000000000000000000000000000000000000010'});
|
||||
test({ types: ['int256'], values: [-1], expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
|
||||
test({ types: ['bytes32'], values: ['gavofyork'], expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['bytes'], values: ['gavofyork'], expected: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
test({ types: ['bytes'], values: ['gavofyork'], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['int[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ types: ['int[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ types: ['int256[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
test({ types: ['int256[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ types: ['int256[]'], values: [[1,2,3]], expected: '0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
test({ types: ['int256[]'], values: [[1,2,3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ types: ['int[]', 'int[]'], values: [[1,2], [3,4]],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000040' +
|
||||
'00000000000000000000000000000000000000000000000000000000000000a0' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000004'});
|
||||
test({ types: ['bytes32', 'int'], values: ['gavofyork', 5],
|
||||
expected: '6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005'});
|
||||
|
|
@ -66,25 +96,47 @@ describe('lib/solidity/coder', function () {
|
|||
expected: '0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['bytes', 'int'], values: ['gavofyork', 5],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000040' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['bytes', 'bool', 'int[]'], values: ['gavofyork', true, [1, 2, 3]],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000060' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'00000000000000000000000000000000000000000000000000000000000000a0' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ types: ['bytes', 'int[]'], values: ['gavofyork', [1, 2, 3]],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000040' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000080' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003'});
|
||||
test({ types: ['int', 'bytes'], values: [5, 'gavofyork'],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000040' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000'});
|
||||
test({ types: ['int', 'bytes', 'int', 'int', 'int', 'int[]'], values: [1, 'gavofyork', 2, 3, 4, [5, 6, 7]],
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
expected: '0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'00000000000000000000000000000000000000000000000000000000000000c0' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000002' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000004' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000100' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000009' +
|
||||
'6761766f66796f726b0000000000000000000000000000000000000000000000' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000005' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000006' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000007'});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -345,6 +345,7 @@ describe('web3.eth.contract', function () {
|
|||
assert.equal(payload.method, 'eth_call');
|
||||
assert.deepEqual(payload.params, [{
|
||||
data: sha3.slice(0, 10) +
|
||||
'0000000000000000000000000000000000000000000000000000000000000020' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000001' +
|
||||
'0000000000000000000000000000000000000000000000000000000000000003',
|
||||
to: address
|
||||
|
|
|
|||
|
|
@ -3,24 +3,62 @@ var assert = chai.assert;
|
|||
var formatters = require('../lib/web3/formatters.js');
|
||||
var BigNumber = require('bignumber.js');
|
||||
|
||||
var tests = [{
|
||||
input: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: new BigNumber(100),
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
nonce: 1000,
|
||||
gas: 1000,
|
||||
gasPrice: new BigNumber(1000)
|
||||
},
|
||||
result: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: '0x64',
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
nonce: '0x3e8',
|
||||
gas: '0x3e8',
|
||||
gasPrice: '0x3e8'
|
||||
}
|
||||
},{
|
||||
input: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: new BigNumber(100),
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
},
|
||||
result: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: '0x64',
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
}
|
||||
},{
|
||||
input: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: new BigNumber(100),
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
gas: '1000',
|
||||
gasPrice: new BigNumber(1000)
|
||||
},
|
||||
result: {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: '0x64',
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
gas: '0x3e8',
|
||||
gasPrice: '0x3e8'
|
||||
}
|
||||
}];
|
||||
|
||||
describe('formatters', function () {
|
||||
describe('inputTransactionFormatter', function () {
|
||||
it('should return the correct value', function () {
|
||||
|
||||
assert.deepEqual(formatters.inputTransactionFormatter({
|
||||
data: '0x34234bf23bf4234',
|
||||
value: new BigNumber(100),
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
gas: 1000,
|
||||
gasPrice: new BigNumber(1000)
|
||||
}), {
|
||||
data: '0x34234bf23bf4234',
|
||||
value: '0x64',
|
||||
from: '0x00000',
|
||||
to: '0x00000',
|
||||
gas: '0x3e8',
|
||||
gasPrice: '0x3e8'
|
||||
tests.forEach(function(test){
|
||||
it('should return the correct value', function () {
|
||||
assert.deepEqual(formatters.inputTransactionFormatter(test.input), test.result);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
Loading…
Reference in New Issue