status-im/web3.js
2
0
Fork 0
mirror of https://github.com/status-im/web3.js.git synced 2025-02-24 03:58:13 +00:00
Code Issues Projects Releases Wiki Activity

add miner functions

Browse Source
This commit is contained in:
Fabian Vogelsteller 2015-05-11 12:45:04 +02:00
commit 6f466f64bb
20 changed files with 766 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bower.json
View File

@ -1,7 +1,7 @@
{ {
"name": "web3", "name": "web3",
"namespace": "ethereum", "namespace": "ethereum",
"version": "0.3.5", "version": "0.3.6",
"description": "Ethereum Compatible JavaScript API", "description": "Ethereum Compatible JavaScript API",
"main": [ "main": [
"./dist/web3.js", "./dist/web3.js",

432
dist/web3-light.js vendored
View File

@ -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 * @date 2014
*/ */
var utils = require('../utils/utils');
var coder = require('./coder'); var coder = require('./coder');
var solUtils = require('./utils'); var utils = 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 formatConstructorParams = function (abi, params) { var formatConstructorParams = function (abi, params) {
var constructor = solUtils.getConstructor(abi, params.length); var constructor = utils.getConstructor(abi, params.length);
if (!constructor) { if (!constructor) {
if (params.length > 0) { if (params.length > 0) {
console.warn("didn't found matching constructor, using default one"); console.warn("didn't found matching constructor, using default one");
} }
return ''; return '';
} }
return formatInput(constructor.inputs, params);
return coder.encodeParams(constructor.inputs.map(function (input) {
return input.type;
}), params);
}; };
module.exports = { module.exports = {
inputParser: inputParser,
outputParser: outputParser,
formatInput: formatInput,
formatOutput: formatOutput,
formatConstructorParams: formatConstructorParams 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. This file is part of ethereum.js.
@ -213,9 +124,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
return param.map(function (p) { return param.map(function (p) {
return self._inputFormatter(p); return self._inputFormatter(p);
}).reduce(function (acc, current) { }).reduce(function (acc, current) {
acc.appendArrayElement(current); return acc.combine(current);
return acc; }, f.formatInputInt(param.length)).withOffset(32);
}, new SolidityParam(f.formatInputInt(param.length).value));
} }
return this._inputFormatter(param); return this._inputFormatter(param);
}; };
@ -232,9 +142,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
if (arrayType) { if (arrayType) {
// let's assume, that we solidity will never return long arrays :P // let's assume, that we solidity will never return long arrays :P
var result = []; var result = [];
var length = new BigNumber(param.value, 16); var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
for (var i = 0; i < length * 64; i += 64) { 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; 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 * @param {String} type
* @returns {Bool} true if the type is variadic * @returns {SolidityParam} param
*/ */
SolidityType.prototype.isVariadicType = function (type) { SolidityType.prototype.sliceParam = function (bytes, index, 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) {
if (this._mode === 'bytes') { if (this._mode === 'bytes') {
return param.shiftBytes(); return SolidityParam.decodeBytes(bytes, index);
} else if (isArrayType(type)) { } else if (isArrayType(type)) {
var length = new BigNumber(param.value.slice(0, 64), 16); return SolidityParam.decodeArray(bytes, index);
return param.shiftArray(length);
} }
return param.shiftValue(); return SolidityParam.decodeParam(bytes, index);
}; };
/** /**
@ -296,20 +196,6 @@ SolidityCoder.prototype._requireType = function (type) {
return solidityType; 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 value = bytes.slice(0, types.length * 64);
var suffix = bytes.slice(types.length * 64);
return new SolidityParam(value, suffix);
};
/** /**
* Should be used to transform plain param of given type to SolidityParam * Should be used to transform plain param of given type to SolidityParam
* *
@ -344,24 +230,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
*/ */
SolidityCoder.prototype.encodeParams = function (types, params) { SolidityCoder.prototype.encodeParams = function (types, params) {
var self = this; var self = this;
return types.map(function (type, index) { var solidityParams = types.map(function (type, index) {
return self._formatInput(type, params[index]); return self._formatInput(type, params[index]);
}).reduce(function (acc, solidityParam) { });
acc.append(solidityParam);
return acc;
}, new SolidityParam()).encode();
};
/** return SolidityParam.encodeList(solidityParams);
* 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));
}; };
/** /**
@ -373,7 +246,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
* @return {Object} plain param * @return {Object} plain param
*/ */
SolidityCoder.prototype.decodeParam = function (type, bytes) { SolidityCoder.prototype.decodeParam = function (type, bytes) {
return this._formatOutput(type, this._bytesToParam([type], bytes)); return this.decodeParams([type], bytes)[0];
}; };
/** /**
@ -386,10 +259,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
*/ */
SolidityCoder.prototype.decodeParams = function (types, bytes) { SolidityCoder.prototype.decodeParams = function (types, bytes) {
var self = this; var self = this;
var param = this._bytesToParam(types, bytes); return types.map(function (type, index) {
return types.map(function (type) {
var solidityType = self._requireType(type); var solidityType = self._requireType(type);
var p = solidityType.shiftParam(type, param); var p = solidityType.sliceParam(bytes, index, type);
return solidityType.formatOutput(p, isArrayType(type)); return solidityType.formatOutput(p, isArrayType(type));
}); });
}; };
@ -522,7 +394,7 @@ var formatInputBytes = function (value) {
*/ */
var formatInputDynamicBytes = function (value) { var formatInputDynamicBytes = function (value) {
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2); 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);
}; };
/** /**
@ -568,7 +440,7 @@ var signedIsNegative = function (value) {
* @returns {BigNumber} right-aligned output bytes formatted to big number * @returns {BigNumber} right-aligned output bytes formatted to big number
*/ */
var formatOutputInt = function (param) { var formatOutputInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
// check if it's negative number // check if it's negative number
// it it is, return two's complement // it it is, return two's complement
@ -586,7 +458,7 @@ var formatOutputInt = function (param) {
* @returns {BigNumeber} right-aligned output bytes formatted to uint * @returns {BigNumeber} right-aligned output bytes formatted to uint
*/ */
var formatOutputUInt = function (param) { var formatOutputUInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
return new BigNumber(value, 16); return new BigNumber(value, 16);
}; };
@ -620,7 +492,7 @@ var formatOutputUReal = function (param) {
* @returns {Boolean} right-aligned input bytes formatted to bool * @returns {Boolean} right-aligned input bytes formatted to bool
*/ */
var formatOutputBool = function (param) { var formatOutputBool = function (param) {
return param.value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false; return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
}; };
/** /**
@ -632,7 +504,7 @@ var formatOutputBool = function (param) {
*/ */
var formatOutputBytes = function (param) { var formatOutputBytes = function (param) {
// length might also be important! // length might also be important!
return utils.toAscii(param.value); return utils.toAscii(param.staticPart());
}; };
/** /**
@ -644,7 +516,7 @@ var formatOutputBytes = function (param) {
*/ */
var formatOutputDynamicBytes = function (param) { var formatOutputDynamicBytes = function (param) {
// length might also be important! // length might also be important!
return utils.toAscii(param.suffix); return utils.toAscii(param.dynamicPart().slice(64));
}; };
/** /**
@ -655,7 +527,7 @@ var formatOutputDynamicBytes = function (param) {
* @returns {String} address * @returns {String} address
*/ */
var formatOutputAddress = function (param) { var formatOutputAddress = function (param) {
var value = param.value; var value = param.staticPart();
return "0x" + value.slice(value.length - 40, value.length); return "0x" + value.slice(value.length - 40, value.length);
}; };
@ -699,88 +571,196 @@ module.exports = {
* @date 2015 * @date 2015
*/ */
var utils = require('../utils/utils');
/** /**
* SolidityParam object prototype. * SolidityParam object prototype.
* Should be used when encoding, decoding solidity bytes * Should be used when encoding, decoding solidity bytes
*/ */
var SolidityParam = function (value, suffix) { var SolidityParam = function (value, offset) {
this.value = value || ''; this.value = value || '';
this.suffix = suffix || ''; this.offset = offset; // offset in bytes
}; };
/** /**
* This method should be used to encode two params one after another * This method should be used to get length of params's dynamic part
* *
* @method append * @method dynamicPartLength
* @param {SolidityParam} param that it appended after this * @returns {Number} length of dynamic part (in bytes)
*/ */
SolidityParam.prototype.append = function (param) { SolidityParam.prototype.dynamicPartLength = function () {
this.value += param.value; return this.dynamicPart().length / 2;
this.suffix += param.suffix;
}; };
/** /**
* 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 * @method withOffset
* @param {SolidityParam} param that is appended to an array * @param {Number} offset length in bytes
* @returns {SolidityParam} new solidity param with applied offset
*/ */
SolidityParam.prototype.appendArrayElement = function (param) { SolidityParam.prototype.withOffset = function (offset) {
this.suffix += param.value; return new SolidityParam(this.value, offset);
//this.suffix += param.suffix; // we do not support nested dynamic types
}; };
/** /**
* 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 * @method encode
* @return {String} encoded param(s) * @returns {String}
*/ */
SolidityParam.prototype.encode = function () { SolidityParam.prototype.encode = function () {
return 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 * @method encodeList
* @return {SolidityParam} first value param * @param {Array[SolidityParam]} params
* @returns {String}
*/ */
SolidityParam.prototype.shiftValue = function () { SolidityParam.encodeList = function (params) {
var value = this.value.slice(0, 64);
this.value = this.value.slice(64); // updating offsets
return new SolidityParam(value); 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 * @method decodeParam
* @return {SolidityParam} first bytes param * @param {String} bytes
* @param {Number} index
* @returns {SolidityParam}
*/ */
SolidityParam.prototype.shiftBytes = function () { SolidityParam.decodeParam = function (bytes, index) {
return this.shiftArray(1); index = index || 0;
return new SolidityParam(bytes.substr(index * 64, 64));
}; };
/** /**
* This method should be used to shift an array from group of params * This method should be called to get offset value from bytes at given index
* *
* @method shiftArray * @method getOffset
* @param {Number} size of an array to shift * @param {String} bytes
* @return {SolidityParam} first array param * @param {Number} index
* @returns {Number} offset as number
*/ */
SolidityParam.prototype.shiftArray = function (length) { var getOffset = function (bytes, index) {
var value = this.value.slice(0, 64); // we can do this cause offset is rather small
this.value = this.value.slice(64); return parseInt('0x' + bytes.substr(index * 64, 64));
var suffix = this.suffix.slice(0, 64 * length); };
this.suffix = this.suffix.slice(64 * length);
return new SolidityParam(value, suffix); /**
* 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; module.exports = SolidityParam;
},{}],5:[function(require,module,exports){ },{"../utils/utils":8}],5:[function(require,module,exports){
/* /*
This file is part of ethereum.js. This file is part of ethereum.js.
@ -817,6 +797,11 @@ var getConstructor = function (abi, numberOfArgs) {
})[0]; })[0];
}; };
//var getSupremeType = function (type) {
//return type.substr(0, type.indexOf('[')) + ']';
//};
module.exports = { module.exports = {
getConstructor: getConstructor getConstructor: getConstructor
}; };
@ -1383,7 +1368,7 @@ module.exports = {
},{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){ },{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){
module.exports={ module.exports={
"version": "0.3.5" "version": "0.3.6"
} }
},{}],10:[function(require,module,exports){ },{}],10:[function(require,module,exports){
@ -1954,6 +1939,18 @@ var compileSerpent = new Method({
params: 1 params: 1
}); });
var submitWork = new Method({
name: 'submitWork',
call: 'eth_submitWork',
params: 3
});
var getWork = new Method({
name: 'getWork',
call: 'eth_getWork',
params: 0
});
var methods = [ var methods = [
getBalance, getBalance,
getStorageAt, getStorageAt,
@ -1971,6 +1968,8 @@ var methods = [
compileSolidity, compileSolidity,
compileLLL, compileLLL,
compileSerpent, compileSerpent,
submitWork,
getWork
]; ];
/// @returns an array of objects describing web3.eth api properties /// @returns an array of objects describing web3.eth api properties
@ -2790,15 +2789,32 @@ HttpProvider.prototype.send = function (payload) {
//if (request.status !== 200) { //if (request.status !== 200) {
//return; //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) { HttpProvider.prototype.sendAsync = function (payload, callback) {
var request = new XMLHttpRequest(); var request = new XMLHttpRequest();
request.onreadystatechange = function() { request.onreadystatechange = function() {
if (request.readyState === 4) { if (request.readyState === 4) {
// TODO: handle the error properly here!!! var result = request.responseText;
callback(null, JSON.parse(request.responseText)); var error = null;
try {
result = JSON.parse(result);
} catch(e) {
error = errors.InvalidResponse(result);
}
callback(error, result);
} }
}; };

18
dist/web3-light.js.map vendored
View File

File diff suppressed because one or more lines are too long

4
dist/web3-light.min.js vendored
View File

File diff suppressed because one or more lines are too long

432
dist/web3.js vendored
View File

@ -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 * @date 2014
*/ */
var utils = require('../utils/utils');
var coder = require('./coder'); var coder = require('./coder');
var solUtils = require('./utils'); var utils = 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 formatConstructorParams = function (abi, params) { var formatConstructorParams = function (abi, params) {
var constructor = solUtils.getConstructor(abi, params.length); var constructor = utils.getConstructor(abi, params.length);
if (!constructor) { if (!constructor) {
if (params.length > 0) { if (params.length > 0) {
console.warn("didn't found matching constructor, using default one"); console.warn("didn't found matching constructor, using default one");
} }
return ''; return '';
} }
return formatInput(constructor.inputs, params);
return coder.encodeParams(constructor.inputs.map(function (input) {
return input.type;
}), params);
}; };
module.exports = { module.exports = {
inputParser: inputParser,
outputParser: outputParser,
formatInput: formatInput,
formatOutput: formatOutput,
formatConstructorParams: formatConstructorParams 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. This file is part of ethereum.js.
@ -213,9 +124,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
return param.map(function (p) { return param.map(function (p) {
return self._inputFormatter(p); return self._inputFormatter(p);
}).reduce(function (acc, current) { }).reduce(function (acc, current) {
acc.appendArrayElement(current); return acc.combine(current);
return acc; }, f.formatInputInt(param.length)).withOffset(32);
}, new SolidityParam(f.formatInputInt(param.length).value));
} }
return this._inputFormatter(param); return this._inputFormatter(param);
}; };
@ -232,9 +142,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
if (arrayType) { if (arrayType) {
// let's assume, that we solidity will never return long arrays :P // let's assume, that we solidity will never return long arrays :P
var result = []; var result = [];
var length = new BigNumber(param.value, 16); var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
for (var i = 0; i < length * 64; i += 64) { 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; 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 * @param {String} type
* @returns {Bool} true if the type is variadic * @returns {SolidityParam} param
*/ */
SolidityType.prototype.isVariadicType = function (type) { SolidityType.prototype.sliceParam = function (bytes, index, 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) {
if (this._mode === 'bytes') { if (this._mode === 'bytes') {
return param.shiftBytes(); return SolidityParam.decodeBytes(bytes, index);
} else if (isArrayType(type)) { } else if (isArrayType(type)) {
var length = new BigNumber(param.value.slice(0, 64), 16); return SolidityParam.decodeArray(bytes, index);
return param.shiftArray(length);
} }
return param.shiftValue(); return SolidityParam.decodeParam(bytes, index);
}; };
/** /**
@ -296,20 +196,6 @@ SolidityCoder.prototype._requireType = function (type) {
return solidityType; 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 value = bytes.slice(0, types.length * 64);
var suffix = bytes.slice(types.length * 64);
return new SolidityParam(value, suffix);
};
/** /**
* Should be used to transform plain param of given type to SolidityParam * Should be used to transform plain param of given type to SolidityParam
* *
@ -344,24 +230,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
*/ */
SolidityCoder.prototype.encodeParams = function (types, params) { SolidityCoder.prototype.encodeParams = function (types, params) {
var self = this; var self = this;
return types.map(function (type, index) { var solidityParams = types.map(function (type, index) {
return self._formatInput(type, params[index]); return self._formatInput(type, params[index]);
}).reduce(function (acc, solidityParam) { });
acc.append(solidityParam);
return acc;
}, new SolidityParam()).encode();
};
/** return SolidityParam.encodeList(solidityParams);
* 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));
}; };
/** /**
@ -373,7 +246,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
* @return {Object} plain param * @return {Object} plain param
*/ */
SolidityCoder.prototype.decodeParam = function (type, bytes) { SolidityCoder.prototype.decodeParam = function (type, bytes) {
return this._formatOutput(type, this._bytesToParam([type], bytes)); return this.decodeParams([type], bytes)[0];
}; };
/** /**
@ -386,10 +259,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
*/ */
SolidityCoder.prototype.decodeParams = function (types, bytes) { SolidityCoder.prototype.decodeParams = function (types, bytes) {
var self = this; var self = this;
var param = this._bytesToParam(types, bytes); return types.map(function (type, index) {
return types.map(function (type) {
var solidityType = self._requireType(type); var solidityType = self._requireType(type);
var p = solidityType.shiftParam(type, param); var p = solidityType.sliceParam(bytes, index, type);
return solidityType.formatOutput(p, isArrayType(type)); return solidityType.formatOutput(p, isArrayType(type));
}); });
}; };
@ -522,7 +394,7 @@ var formatInputBytes = function (value) {
*/ */
var formatInputDynamicBytes = function (value) { var formatInputDynamicBytes = function (value) {
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2); 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);
}; };
/** /**
@ -568,7 +440,7 @@ var signedIsNegative = function (value) {
* @returns {BigNumber} right-aligned output bytes formatted to big number * @returns {BigNumber} right-aligned output bytes formatted to big number
*/ */
var formatOutputInt = function (param) { var formatOutputInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
// check if it's negative number // check if it's negative number
// it it is, return two's complement // it it is, return two's complement
@ -586,7 +458,7 @@ var formatOutputInt = function (param) {
* @returns {BigNumeber} right-aligned output bytes formatted to uint * @returns {BigNumeber} right-aligned output bytes formatted to uint
*/ */
var formatOutputUInt = function (param) { var formatOutputUInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
return new BigNumber(value, 16); return new BigNumber(value, 16);
}; };
@ -620,7 +492,7 @@ var formatOutputUReal = function (param) {
* @returns {Boolean} right-aligned input bytes formatted to bool * @returns {Boolean} right-aligned input bytes formatted to bool
*/ */
var formatOutputBool = function (param) { var formatOutputBool = function (param) {
return param.value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false; return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
}; };
/** /**
@ -632,7 +504,7 @@ var formatOutputBool = function (param) {
*/ */
var formatOutputBytes = function (param) { var formatOutputBytes = function (param) {
// length might also be important! // length might also be important!
return utils.toAscii(param.value); return utils.toAscii(param.staticPart());
}; };
/** /**
@ -644,7 +516,7 @@ var formatOutputBytes = function (param) {
*/ */
var formatOutputDynamicBytes = function (param) { var formatOutputDynamicBytes = function (param) {
// length might also be important! // length might also be important!
return utils.toAscii(param.suffix); return utils.toAscii(param.dynamicPart().slice(64));
}; };
/** /**
@ -655,7 +527,7 @@ var formatOutputDynamicBytes = function (param) {
* @returns {String} address * @returns {String} address
*/ */
var formatOutputAddress = function (param) { var formatOutputAddress = function (param) {
var value = param.value; var value = param.staticPart();
return "0x" + value.slice(value.length - 40, value.length); return "0x" + value.slice(value.length - 40, value.length);
}; };
@ -699,88 +571,196 @@ module.exports = {
* @date 2015 * @date 2015
*/ */
var utils = require('../utils/utils');
/** /**
* SolidityParam object prototype. * SolidityParam object prototype.
* Should be used when encoding, decoding solidity bytes * Should be used when encoding, decoding solidity bytes
*/ */
var SolidityParam = function (value, suffix) { var SolidityParam = function (value, offset) {
this.value = value || ''; this.value = value || '';
this.suffix = suffix || ''; this.offset = offset; // offset in bytes
}; };
/** /**
* This method should be used to encode two params one after another * This method should be used to get length of params's dynamic part
* *
* @method append * @method dynamicPartLength
* @param {SolidityParam} param that it appended after this * @returns {Number} length of dynamic part (in bytes)
*/ */
SolidityParam.prototype.append = function (param) { SolidityParam.prototype.dynamicPartLength = function () {
this.value += param.value; return this.dynamicPart().length / 2;
this.suffix += param.suffix;
}; };
/** /**
* 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 * @method withOffset
* @param {SolidityParam} param that is appended to an array * @param {Number} offset length in bytes
* @returns {SolidityParam} new solidity param with applied offset
*/ */
SolidityParam.prototype.appendArrayElement = function (param) { SolidityParam.prototype.withOffset = function (offset) {
this.suffix += param.value; return new SolidityParam(this.value, offset);
//this.suffix += param.suffix; // we do not support nested dynamic types
}; };
/** /**
* 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 * @method encode
* @return {String} encoded param(s) * @returns {String}
*/ */
SolidityParam.prototype.encode = function () { SolidityParam.prototype.encode = function () {
return 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 * @method encodeList
* @return {SolidityParam} first value param * @param {Array[SolidityParam]} params
* @returns {String}
*/ */
SolidityParam.prototype.shiftValue = function () { SolidityParam.encodeList = function (params) {
var value = this.value.slice(0, 64);
this.value = this.value.slice(64); // updating offsets
return new SolidityParam(value); 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 * @method decodeParam
* @return {SolidityParam} first bytes param * @param {String} bytes
* @param {Number} index
* @returns {SolidityParam}
*/ */
SolidityParam.prototype.shiftBytes = function () { SolidityParam.decodeParam = function (bytes, index) {
return this.shiftArray(1); index = index || 0;
return new SolidityParam(bytes.substr(index * 64, 64));
}; };
/** /**
* This method should be used to shift an array from group of params * This method should be called to get offset value from bytes at given index
* *
* @method shiftArray * @method getOffset
* @param {Number} size of an array to shift * @param {String} bytes
* @return {SolidityParam} first array param * @param {Number} index
* @returns {Number} offset as number
*/ */
SolidityParam.prototype.shiftArray = function (length) { var getOffset = function (bytes, index) {
var value = this.value.slice(0, 64); // we can do this cause offset is rather small
this.value = this.value.slice(64); return parseInt('0x' + bytes.substr(index * 64, 64));
var suffix = this.suffix.slice(0, 64 * length); };
this.suffix = this.suffix.slice(64 * length);
return new SolidityParam(value, suffix); /**
* 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; module.exports = SolidityParam;
},{}],5:[function(require,module,exports){ },{"../utils/utils":8}],5:[function(require,module,exports){
/* /*
This file is part of ethereum.js. This file is part of ethereum.js.
@ -817,6 +797,11 @@ var getConstructor = function (abi, numberOfArgs) {
})[0]; })[0];
}; };
//var getSupremeType = function (type) {
//return type.substr(0, type.indexOf('[')) + ']';
//};
module.exports = { module.exports = {
getConstructor: getConstructor getConstructor: getConstructor
}; };
@ -1383,7 +1368,7 @@ module.exports = {
},{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){ },{"bignumber.js":"bignumber.js"}],9:[function(require,module,exports){
module.exports={ module.exports={
"version": "0.3.5" "version": "0.3.6"
} }
},{}],10:[function(require,module,exports){ },{}],10:[function(require,module,exports){
@ -1954,6 +1939,18 @@ var compileSerpent = new Method({
params: 1 params: 1
}); });
var submitWork = new Method({
name: 'submitWork',
call: 'eth_submitWork',
params: 3
});
var getWork = new Method({
name: 'getWork',
call: 'eth_getWork',
params: 0
});
var methods = [ var methods = [
getBalance, getBalance,
getStorageAt, getStorageAt,
@ -1971,6 +1968,8 @@ var methods = [
compileSolidity, compileSolidity,
compileLLL, compileLLL,
compileSerpent, compileSerpent,
submitWork,
getWork
]; ];
/// @returns an array of objects describing web3.eth api properties /// @returns an array of objects describing web3.eth api properties
@ -2790,15 +2789,32 @@ HttpProvider.prototype.send = function (payload) {
//if (request.status !== 200) { //if (request.status !== 200) {
//return; //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) { HttpProvider.prototype.sendAsync = function (payload, callback) {
var request = new XMLHttpRequest(); var request = new XMLHttpRequest();
request.onreadystatechange = function() { request.onreadystatechange = function() {
if (request.readyState === 4) { if (request.readyState === 4) {
// TODO: handle the error properly here!!! var result = request.responseText;
callback(null, JSON.parse(request.responseText)); var error = null;
try {
result = JSON.parse(result);
} catch(e) {
error = errors.InvalidResponse(result);
}
callback(error, result);
} }
}; };

18
dist/web3.js.map vendored
View File

File diff suppressed because one or more lines are too long

4
dist/web3.min.js vendored
View File

File diff suppressed because one or more lines are too long

103
lib/solidity/abi.js
View File

@ -21,113 +21,24 @@
* @date 2014 * @date 2014
*/ */
var utils = require('../utils/utils');
var coder = require('./coder'); var coder = require('./coder');
var solUtils = require('./utils'); var utils = 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 formatConstructorParams = function (abi, params) { var formatConstructorParams = function (abi, params) {
var constructor = solUtils.getConstructor(abi, params.length); var constructor = utils.getConstructor(abi, params.length);
if (!constructor) { if (!constructor) {
if (params.length > 0) { if (params.length > 0) {
console.warn("didn't found matching constructor, using default one"); console.warn("didn't found matching constructor, using default one");
} }
return ''; return '';
} }
return formatInput(constructor.inputs, params);
return coder.encodeParams(constructor.inputs.map(function (input) {
return input.type;
}), params);
}; };
module.exports = { module.exports = {
inputParser: inputParser,
outputParser: outputParser,
formatInput: formatInput,
formatOutput: formatOutput,
formatConstructorParams: formatConstructorParams formatConstructorParams: formatConstructorParams
}; };

77
lib/solidity/coder.js
View File

@ -77,9 +77,8 @@ SolidityType.prototype.formatInput = function (param, arrayType) {
return param.map(function (p) { return param.map(function (p) {
return self._inputFormatter(p); return self._inputFormatter(p);
}).reduce(function (acc, current) { }).reduce(function (acc, current) {
acc.appendArrayElement(current); return acc.combine(current);
return acc; }, f.formatInputInt(param.length)).withOffset(32);
}, new SolidityParam(f.formatInputInt(param.length).value));
} }
return this._inputFormatter(param); return this._inputFormatter(param);
}; };
@ -96,9 +95,9 @@ SolidityType.prototype.formatOutput = function (param, arrayType) {
if (arrayType) { if (arrayType) {
// let's assume, that we solidity will never return long arrays :P // let's assume, that we solidity will never return long arrays :P
var result = []; var result = [];
var length = new BigNumber(param.value, 16); var length = new BigNumber(param.dynamicPart().slice(0, 64), 16);
for (var i = 0; i < length * 64; i += 64) { 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; 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 * @param {String} type
* @returns {Bool} true if the type is variadic * @returns {SolidityParam} param
*/ */
SolidityType.prototype.isVariadicType = function (type) { SolidityType.prototype.sliceParam = function (bytes, index, 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) {
if (this._mode === 'bytes') { if (this._mode === 'bytes') {
return param.shiftBytes(); return SolidityParam.decodeBytes(bytes, index);
} else if (isArrayType(type)) { } else if (isArrayType(type)) {
var length = new BigNumber(param.value.slice(0, 64), 16); return SolidityParam.decodeArray(bytes, index);
return param.shiftArray(length);
} }
return param.shiftValue(); return SolidityParam.decodeParam(bytes, index);
}; };
/** /**
@ -160,20 +149,6 @@ SolidityCoder.prototype._requireType = function (type) {
return solidityType; 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 value = bytes.slice(0, types.length * 64);
var suffix = bytes.slice(types.length * 64);
return new SolidityParam(value, suffix);
};
/** /**
* Should be used to transform plain param of given type to SolidityParam * Should be used to transform plain param of given type to SolidityParam
* *
@ -208,24 +183,11 @@ SolidityCoder.prototype.encodeParam = function (type, param) {
*/ */
SolidityCoder.prototype.encodeParams = function (types, params) { SolidityCoder.prototype.encodeParams = function (types, params) {
var self = this; var self = this;
return types.map(function (type, index) { var solidityParams = types.map(function (type, index) {
return self._formatInput(type, params[index]); return self._formatInput(type, params[index]);
}).reduce(function (acc, solidityParam) { });
acc.append(solidityParam);
return acc;
}, new SolidityParam()).encode();
};
/** return SolidityParam.encodeList(solidityParams);
* 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));
}; };
/** /**
@ -237,7 +199,7 @@ SolidityCoder.prototype._formatOutput = function (type, param) {
* @return {Object} plain param * @return {Object} plain param
*/ */
SolidityCoder.prototype.decodeParam = function (type, bytes) { SolidityCoder.prototype.decodeParam = function (type, bytes) {
return this._formatOutput(type, this._bytesToParam([type], bytes)); return this.decodeParams([type], bytes)[0];
}; };
/** /**
@ -250,10 +212,9 @@ SolidityCoder.prototype.decodeParam = function (type, bytes) {
*/ */
SolidityCoder.prototype.decodeParams = function (types, bytes) { SolidityCoder.prototype.decodeParams = function (types, bytes) {
var self = this; var self = this;
var param = this._bytesToParam(types, bytes); return types.map(function (type, index) {
return types.map(function (type) {
var solidityType = self._requireType(type); var solidityType = self._requireType(type);
var p = solidityType.shiftParam(type, param); var p = solidityType.sliceParam(bytes, index, type);
return solidityType.formatOutput(p, isArrayType(type)); return solidityType.formatOutput(p, isArrayType(type));
}); });
}; };

14
lib/solidity/formatters.js
View File

@ -63,7 +63,7 @@ var formatInputBytes = function (value) {
*/ */
var formatInputDynamicBytes = function (value) { var formatInputDynamicBytes = function (value) {
var result = utils.fromAscii(value, c.ETH_PADDING).substr(2); 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 * @returns {BigNumber} right-aligned output bytes formatted to big number
*/ */
var formatOutputInt = function (param) { var formatOutputInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
// check if it's negative number // check if it's negative number
// it it is, return two's complement // it it is, return two's complement
@ -127,7 +127,7 @@ var formatOutputInt = function (param) {
* @returns {BigNumeber} right-aligned output bytes formatted to uint * @returns {BigNumeber} right-aligned output bytes formatted to uint
*/ */
var formatOutputUInt = function (param) { var formatOutputUInt = function (param) {
var value = param.value || "0"; var value = param.staticPart() || "0";
return new BigNumber(value, 16); return new BigNumber(value, 16);
}; };
@ -161,7 +161,7 @@ var formatOutputUReal = function (param) {
* @returns {Boolean} right-aligned input bytes formatted to bool * @returns {Boolean} right-aligned input bytes formatted to bool
*/ */
var formatOutputBool = function (param) { 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) { var formatOutputBytes = function (param) {
// length might also be important! // 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) { var formatOutputDynamicBytes = function (param) {
// length might also be important! // 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 * @returns {String} address
*/ */
var formatOutputAddress = function (param) { var formatOutputAddress = function (param) {
var value = param.value; var value = param.staticPart();
return "0x" + value.slice(value.length - 40, value.length); return "0x" + value.slice(value.length - 40, value.length);
}; };

190
lib/solidity/param.js
View File

@ -20,82 +20,190 @@
* @date 2015 * @date 2015
*/ */
var utils = require('../utils/utils');
/** /**
* SolidityParam object prototype. * SolidityParam object prototype.
* Should be used when encoding, decoding solidity bytes * Should be used when encoding, decoding solidity bytes
*/ */
var SolidityParam = function (value, suffix) { var SolidityParam = function (value, offset) {
this.value = value || ''; this.value = value || '';
this.suffix = suffix || ''; this.offset = offset; // offset in bytes
}; };
/** /**
* This method should be used to encode two params one after another * This method should be used to get length of params's dynamic part
* *
* @method append * @method dynamicPartLength
* @param {SolidityParam} param that it appended after this * @returns {Number} length of dynamic part (in bytes)
*/ */
SolidityParam.prototype.append = function (param) { SolidityParam.prototype.dynamicPartLength = function () {
this.value += param.value; return this.dynamicPart().length / 2;
this.suffix += param.suffix;
}; };
/** /**
* 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 * @method withOffset
* @param {SolidityParam} param that is appended to an array * @param {Number} offset length in bytes
* @returns {SolidityParam} new solidity param with applied offset
*/ */
SolidityParam.prototype.appendArrayElement = function (param) { SolidityParam.prototype.withOffset = function (offset) {
this.suffix += param.value; return new SolidityParam(this.value, offset);
//this.suffix += param.suffix; // we do not support nested dynamic types
}; };
/** /**
* 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 * @method encode
* @return {String} encoded param(s) * @returns {String}
*/ */
SolidityParam.prototype.encode = function () { SolidityParam.prototype.encode = function () {
return 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 * @method encodeList
* @return {SolidityParam} first value param * @param {Array[SolidityParam]} params
* @returns {String}
*/ */
SolidityParam.prototype.shiftValue = function () { SolidityParam.encodeList = function (params) {
var value = this.value.slice(0, 64);
this.value = this.value.slice(64); // updating offsets
return new SolidityParam(value); 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 * @method decodeParam
* @return {SolidityParam} first bytes param * @param {String} bytes
* @param {Number} index
* @returns {SolidityParam}
*/ */
SolidityParam.prototype.shiftBytes = function () { SolidityParam.decodeParam = function (bytes, index) {
return this.shiftArray(1); index = index || 0;
return new SolidityParam(bytes.substr(index * 64, 64));
}; };
/** /**
* This method should be used to shift an array from group of params * This method should be called to get offset value from bytes at given index
* *
* @method shiftArray * @method getOffset
* @param {Number} size of an array to shift * @param {String} bytes
* @return {SolidityParam} first array param * @param {Number} index
* @returns {Number} offset as number
*/ */
SolidityParam.prototype.shiftArray = function (length) { var getOffset = function (bytes, index) {
var value = this.value.slice(0, 64); // we can do this cause offset is rather small
this.value = this.value.slice(64); return parseInt('0x' + bytes.substr(index * 64, 64));
var suffix = this.suffix.slice(0, 64 * length); };
this.suffix = this.suffix.slice(64 * length);
return new SolidityParam(value, suffix); /**
* 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; module.exports = SolidityParam;

5
lib/solidity/utils.js
View File

@ -34,6 +34,11 @@ var getConstructor = function (abi, numberOfArgs) {
})[0]; })[0];
}; };
//var getSupremeType = function (type) {
//return type.substr(0, type.indexOf('[')) + ']';
//};
module.exports = { module.exports = {
getConstructor: getConstructor getConstructor: getConstructor
}; };

2
lib/version.json
View File

@ -1,3 +1,3 @@
{ {
"version": "0.3.5" "version": "0.3.6"
} }

14
lib/web3/eth.js
View File

@ -192,6 +192,18 @@ var compileSerpent = new Method({
params: 1 params: 1
}); });
var submitWork = new Method({
name: 'submitWork',
call: 'eth_submitWork',
params: 3
});
var getWork = new Method({
name: 'getWork',
call: 'eth_getWork',
params: 0
});
var methods = [ var methods = [
getBalance, getBalance,
getStorageAt, getStorageAt,
@ -209,6 +221,8 @@ var methods = [
compileSolidity, compileSolidity,
compileLLL, compileLLL,
compileSerpent, compileSerpent,
submitWork,
getWork
]; ];
/// @returns an array of objects describing web3.eth api properties /// @returns an array of objects describing web3.eth api properties

23
lib/web3/httpprovider.js
View File

@ -48,15 +48,32 @@ HttpProvider.prototype.send = function (payload) {
//if (request.status !== 200) { //if (request.status !== 200) {
//return; //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) { HttpProvider.prototype.sendAsync = function (payload, callback) {
var request = new XMLHttpRequest(); var request = new XMLHttpRequest();
request.onreadystatechange = function() { request.onreadystatechange = function() {
if (request.readyState === 4) { if (request.readyState === 4) {
// TODO: handle the error properly here!!! var result = request.responseText;
callback(null, JSON.parse(request.responseText)); var error = null;
try {
result = JSON.parse(result);
} catch(e) {
error = errors.InvalidResponse(result);
}
callback(error, result);
} }
}; };

2
package.js
View File

@ -1,7 +1,7 @@
/* jshint ignore:start */ /* jshint ignore:start */
Package.describe({ Package.describe({
name: 'ethereum:web3', name: 'ethereum:web3',
version: '0.3.5', version: '0.3.6',
summary: 'Ethereum JavaScript API, middleware to talk to a ethreum node over RPC', summary: 'Ethereum JavaScript API, middleware to talk to a ethreum node over RPC',
git: 'https://github.com/ethereum/ethereum.js', git: 'https://github.com/ethereum/ethereum.js',
// By default, Meteor will default to using README.md for documentation. // By default, Meteor will default to using README.md for documentation.

2
package.json
View File

@ -1,7 +1,7 @@
{ {
"name": "web3", "name": "web3",
"namespace": "ethereum", "namespace": "ethereum",
"version": "0.3.5", "version": "0.3.6",
"description": "Ethereum JavaScript API, middleware to talk to a ethereum node over RPC", "description": "Ethereum JavaScript API, middleware to talk to a ethereum node over RPC",
"main": "./index.js", "main": "./index.js",
"directories": { "directories": {

32
test/coder.decodeParam.js
View File

@ -21,14 +21,18 @@ describe('lib/solidity/coder', function () {
test({ type: 'int256', expected: new bn(16), value: '0000000000000000000000000000000000000000000000000000000000000010'}); test({ type: 'int256', expected: new bn(16), value: '0000000000000000000000000000000000000000000000000000000000000010'});
test({ type: 'int256', expected: new bn(-1), value: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'}); test({ type: 'int256', expected: new bn(-1), value: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
test({ type: 'bytes32', expected: 'gavofyork', value: '6761766f66796f726b0000000000000000000000000000000000000000000000'}); test({ type: 'bytes32', expected: 'gavofyork', value: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ type: 'bytes', expected: 'gavofyork', value: '0000000000000000000000000000000000000000000000000000000000000009' + test({ type: 'bytes', expected: 'gavofyork', value: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ type: 'int[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000001' + test({ type: 'int[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ type: 'int256[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000001' + test({ type: 'int256[]', expected: [new bn(3)], value: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ type: 'int[]', expected: [new bn(1), new bn(2), new bn(3)], test({ type: 'int[]', expected: [new bn(1), new bn(2), new bn(3)],
value: '0000000000000000000000000000000000000000000000000000000000000003' + value: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000001' + '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000002' + '0000000000000000000000000000000000000000000000000000000000000002' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
@ -65,15 +69,17 @@ describe('lib/solidity/coder', function () {
test({ types: ['int', 'bytes', 'int', 'int', 'int', 'int[]'], expected: [new bn(1), 'gavofyork', new bn(2), new bn(3), new bn(4), 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)]], [new bn(5), new bn(6), new bn(7)]],
values: '0000000000000000000000000000000000000000000000000000000000000001' + values: '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000009' + '00000000000000000000000000000000000000000000000000000000000000c0' +
'0000000000000000000000000000000000000000000000000000000000000002' + '0000000000000000000000000000000000000000000000000000000000000002' +
'0000000000000000000000000000000000000000000000000000000000000003' + '0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000004' + '0000000000000000000000000000000000000000000000000000000000000004' +
'0000000000000000000000000000000000000000000000000000000000000003' + '0000000000000000000000000000000000000000000000000000000000000100' +
'6761766f66796f726b0000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000009' +
'0000000000000000000000000000000000000000000000000000000000000005' + '6761766f66796f726b0000000000000000000000000000000000000000000000' +
'0000000000000000000000000000000000000000000000000000000000000006' + '0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000007'}); '0000000000000000000000000000000000000000000000000000000000000005' +
'0000000000000000000000000000000000000000000000000000000000000006' +
'0000000000000000000000000000000000000000000000000000000000000007'});
}); });
}); });

63
test/coder.encodeParam.js
View File

@ -21,13 +21,17 @@ describe('lib/solidity/coder', function () {
test({ type: 'int256', value: 16, expected: '0000000000000000000000000000000000000000000000000000000000000010'}); test({ type: 'int256', value: 16, expected: '0000000000000000000000000000000000000000000000000000000000000010'});
test({ type: 'int256', value: -1, expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'}); test({ type: 'int256', value: -1, expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
test({ type: 'bytes32', value: 'gavofyork', expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'}); test({ type: 'bytes32', value: 'gavofyork', expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ type: 'bytes', value: 'gavofyork', expected: '0000000000000000000000000000000000000000000000000000000000000009' + test({ type: 'bytes', value: 'gavofyork', expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ type: 'int[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000001' + test({ type: 'int[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ type: 'int256[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000001' + test({ type: 'int256[]', value: [3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ type: 'int[]', value: [1,2,3], expected: '0000000000000000000000000000000000000000000000000000000000000003' + test({ type: 'int[]', value: [1,2,3], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000001' + '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000002' + '0000000000000000000000000000000000000000000000000000000000000002' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
@ -62,16 +66,29 @@ describe('lib/solidity/coder', function () {
test({ types: ['int256'], values: [16], expected: '0000000000000000000000000000000000000000000000000000000000000010'}); test({ types: ['int256'], values: [16], expected: '0000000000000000000000000000000000000000000000000000000000000010'});
test({ types: ['int256'], values: [-1], expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'}); test({ types: ['int256'], values: [-1], expected: 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'});
test({ types: ['bytes32'], values: ['gavofyork'], expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'}); test({ types: ['bytes32'], values: ['gavofyork'], expected: '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ types: ['bytes'], values: ['gavofyork'], expected: '0000000000000000000000000000000000000000000000000000000000000009' + test({ types: ['bytes'], values: ['gavofyork'], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ types: ['int[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000001' + test({ types: ['int[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ types: ['int256[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000001' + test({ types: ['int256[]'], values: [[3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '0000000000000000000000000000000000000000000000000000000000000003'});
test({ types: ['int256[]'], values: [[1,2,3]], expected: '0000000000000000000000000000000000000000000000000000000000000003' + test({ types: ['int256[]'], values: [[1,2,3]], expected: '0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000001' + '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000002' + '0000000000000000000000000000000000000000000000000000000000000002' +
'0000000000000000000000000000000000000000000000000000000000000003'}); '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], test({ types: ['bytes32', 'int'], values: ['gavofyork', 5],
expected: '6761766f66796f726b0000000000000000000000000000000000000000000000' + expected: '6761766f66796f726b0000000000000000000000000000000000000000000000' +
'0000000000000000000000000000000000000000000000000000000000000005'}); '0000000000000000000000000000000000000000000000000000000000000005'});
@ -79,25 +96,47 @@ describe('lib/solidity/coder', function () {
expected: '0000000000000000000000000000000000000000000000000000000000000005' + expected: '0000000000000000000000000000000000000000000000000000000000000005' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ types: ['bytes', 'int'], values: ['gavofyork', 5], test({ types: ['bytes', 'int'], values: ['gavofyork', 5],
expected: '0000000000000000000000000000000000000000000000000000000000000009' + expected: '0000000000000000000000000000000000000000000000000000000000000040' +
'0000000000000000000000000000000000000000000000000000000000000005' + '0000000000000000000000000000000000000000000000000000000000000005' +
'0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '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'], test({ types: ['int', 'bytes'], values: [5, 'gavofyork'],
expected: '0000000000000000000000000000000000000000000000000000000000000005' + expected: '0000000000000000000000000000000000000000000000000000000000000005' +
'0000000000000000000000000000000000000000000000000000000000000040' +
'0000000000000000000000000000000000000000000000000000000000000009' + '0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000'}); '6761766f66796f726b0000000000000000000000000000000000000000000000'});
test({ types: ['int', 'bytes', 'int', 'int', 'int', 'int[]'], values: [1, 'gavofyork', 2, 3, 4, [5, 6, 7]], test({ types: ['int', 'bytes', 'int', 'int', 'int', 'int[]'], values: [1, 'gavofyork', 2, 3, 4, [5, 6, 7]],
expected: '0000000000000000000000000000000000000000000000000000000000000001' + expected: '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000009' + '00000000000000000000000000000000000000000000000000000000000000c0' +
'0000000000000000000000000000000000000000000000000000000000000002' + '0000000000000000000000000000000000000000000000000000000000000002' +
'0000000000000000000000000000000000000000000000000000000000000003' + '0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000004' + '0000000000000000000000000000000000000000000000000000000000000004' +
'0000000000000000000000000000000000000000000000000000000000000003' + '0000000000000000000000000000000000000000000000000000000000000100' +
'0000000000000000000000000000000000000000000000000000000000000009' +
'6761766f66796f726b0000000000000000000000000000000000000000000000' + '6761766f66796f726b0000000000000000000000000000000000000000000000' +
'0000000000000000000000000000000000000000000000000000000000000003' +
'0000000000000000000000000000000000000000000000000000000000000005' + '0000000000000000000000000000000000000000000000000000000000000005' +
'0000000000000000000000000000000000000000000000000000000000000006' + '0000000000000000000000000000000000000000000000000000000000000006' +
'0000000000000000000000000000000000000000000000000000000000000007'}); '0000000000000000000000000000000000000000000000000000000000000007'});
}); });
}); });

1
test/contract.js
View File

@ -345,6 +345,7 @@ describe('web3.eth.contract', function () {
assert.equal(payload.method, 'eth_call'); assert.equal(payload.method, 'eth_call');
assert.deepEqual(payload.params, [{ assert.deepEqual(payload.params, [{
data: sha3.slice(0, 10) + data: sha3.slice(0, 10) +
'0000000000000000000000000000000000000000000000000000000000000020' +
'0000000000000000000000000000000000000000000000000000000000000001' + '0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000003', '0000000000000000000000000000000000000000000000000000000000000003',
to: address to: address