web3x
Version:
Typescript port of web3.js
920 lines • 71.7 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
const constants_1 = require("./constants");
const errors = tslib_1.__importStar(require("./errors"));
const address_1 = require("./address");
const bignumber_1 = require("./bignumber");
const bytes_1 = require("./bytes");
const utf8_1 = require("./utf8");
const properties_1 = require("./properties");
const address_2 = require("../address");
const util_1 = require("util");
///////////////////////////////
const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
exports.defaultCoerceFunc = function (type, value) {
var match = type.match(paramTypeNumber);
if (match && parseInt(match[2]) <= 48) {
return value.toNumber();
}
return value;
};
///////////////////////////////////
// Parsing for Solidity Signatures
const regexParen = new RegExp('^([^)(]*)\\((.*)\\)([^)(]*)$');
const regexIdentifier = new RegExp('^[A-Za-z_][A-Za-z0-9_]*$');
function verifyType(type) {
// These need to be transformed to their full description
if (type.match(/^uint($|[^1-9])/)) {
type = 'uint256' + type.substring(4);
}
else if (type.match(/^int($|[^1-9])/)) {
type = 'int256' + type.substring(3);
}
return type;
}
function parseParam(param, allowIndexed) {
function throwError(i) {
throw new Error('unexpected character "' + param[i] + '" at position ' + i + ' in "' + param + '"');
}
var parent = { type: '', name: '', state: { allowType: true } };
var node = parent;
for (var i = 0; i < param.length; i++) {
var c = param[i];
switch (c) {
case '(':
if (!node.state.allowParams) {
throwError(i);
}
node.state.allowType = false;
node.type = verifyType(node.type);
node.components = [{ type: '', name: '', parent: node, state: { allowType: true } }];
node = node.components[0];
break;
case ')':
delete node.state;
if (allowIndexed && node.name === 'indexed') {
node.indexed = true;
node.name = '';
}
node.type = verifyType(node.type);
var child = node;
node = node.parent;
if (!node) {
throwError(i);
}
delete child.parent;
node.state.allowParams = false;
node.state.allowName = true;
node.state.allowArray = true;
break;
case ',':
delete node.state;
if (allowIndexed && node.name === 'indexed') {
node.indexed = true;
node.name = '';
}
node.type = verifyType(node.type);
var sibling = { type: '', name: '', parent: node.parent, state: { allowType: true } };
node.parent.components.push(sibling);
delete node.parent;
node = sibling;
break;
// Hit a space...
case ' ':
// If reading type, the type is done and may read a param or name
if (node.state.allowType) {
if (node.type !== '') {
node.type = verifyType(node.type);
delete node.state.allowType;
node.state.allowName = true;
node.state.allowParams = true;
}
}
// If reading name, the name is done
if (node.state.allowName) {
if (node.name !== '') {
if (allowIndexed && node.name === 'indexed') {
node.indexed = true;
node.name = '';
}
else {
node.state.allowName = false;
}
}
}
break;
case '[':
if (!node.state.allowArray) {
throwError(i);
}
node.type += c;
node.state.allowArray = false;
node.state.allowName = false;
node.state.readArray = true;
break;
case ']':
if (!node.state.readArray) {
throwError(i);
}
node.type += c;
node.state.readArray = false;
node.state.allowArray = true;
node.state.allowName = true;
break;
default:
if (node.state.allowType) {
node.type += c;
node.state.allowParams = true;
node.state.allowArray = true;
}
else if (node.state.allowName) {
node.name += c;
delete node.state.allowArray;
}
else if (node.state.readArray) {
node.type += c;
}
else {
throwError(i);
}
}
}
if (node.parent) {
throw new Error('unexpected eof');
}
delete parent.state;
if (allowIndexed && node.name === 'indexed') {
node.indexed = true;
node.name = '';
}
parent.type = verifyType(parent.type);
return parent;
}
// @TODO: Better return type
function parseSignatureEvent(fragment) {
var abi = {
anonymous: false,
inputs: [],
name: '',
type: 'event',
};
var match = fragment.match(regexParen);
if (!match) {
throw new Error('invalid event: ' + fragment);
}
abi.name = match[1].trim();
splitNesting(match[2]).forEach(function (param) {
param = parseParam(param, true);
param.indexed = !!param.indexed;
abi.inputs.push(param);
});
match[3].split(' ').forEach(function (modifier) {
switch (modifier) {
case 'anonymous':
abi.anonymous = true;
break;
case '':
break;
default:
console.log('unknown modifier: ' + modifier);
}
});
if (abi.name && !abi.name.match(regexIdentifier)) {
throw new Error('invalid identifier: "' + abi.name + '"');
}
return abi;
}
function parseSignatureFunction(fragment) {
var abi = {
constant: false,
gas: null,
inputs: [],
name: '',
outputs: [],
payable: false,
stateMutability: null,
type: 'function',
};
let comps = fragment.split('@');
if (comps.length !== 1) {
if (comps.length > 2) {
throw new Error('invalid signature');
}
if (!comps[1].match(/^[0-9]+$/)) {
throw new Error('invalid signature gas');
}
abi.gas = bignumber_1.bigNumberify(comps[1]);
fragment = comps[0];
}
comps = fragment.split(' returns ');
var left = comps[0].match(regexParen);
if (!left) {
throw new Error('invalid signature');
}
abi.name = left[1].trim();
if (!abi.name.match(regexIdentifier)) {
throw new Error('invalid identifier: "' + left[1] + '"');
}
splitNesting(left[2]).forEach(function (param) {
abi.inputs.push(parseParam(param));
});
left[3].split(' ').forEach(function (modifier) {
switch (modifier) {
case 'constant':
abi.constant = true;
break;
case 'payable':
abi.payable = true;
abi.stateMutability = 'payable';
break;
case 'pure':
abi.constant = true;
abi.stateMutability = 'pure';
break;
case 'view':
abi.constant = true;
abi.stateMutability = 'view';
break;
case 'external':
case 'public':
case '':
break;
default:
console.log('unknown modifier: ' + modifier);
}
});
// We have outputs
if (comps.length > 1) {
var right = comps[1].match(regexParen);
if (right[1].trim() != '' || right[3].trim() != '') {
throw new Error('unexpected tokens');
}
splitNesting(right[2]).forEach(function (param) {
abi.outputs.push(parseParam(param));
});
}
if (abi.name === 'constructor') {
abi.type = 'constructor';
if (abi.outputs.length) {
throw new Error('constructor may not have outputs');
}
delete abi.name;
delete abi.outputs;
}
return abi;
}
function parseParamType(type) {
return parseParam(type, true);
}
exports.parseParamType = parseParamType;
// @TODO: Allow a second boolean to expose names
function formatParamType(paramType) {
return getParamCoder(exports.defaultCoerceFunc, paramType).type;
}
exports.formatParamType = formatParamType;
// @TODO: Allow a second boolean to expose names and modifiers
function formatSignature(fragment) {
return fragment.name + '(' + fragment.inputs.map(i => formatParamType(i)).join(',') + ')';
}
exports.formatSignature = formatSignature;
function parseSignature(fragment) {
if (typeof fragment === 'string') {
// Make sure the "returns" is surrounded by a space and all whitespace is exactly one space
fragment = fragment
.replace(/\(/g, ' (')
.replace(/\)/g, ') ')
.replace(/\s+/g, ' ');
fragment = fragment.trim();
if (fragment.substring(0, 6) === 'event ') {
return parseSignatureEvent(fragment.substring(6).trim());
}
else {
if (fragment.substring(0, 9) === 'function ') {
fragment = fragment.substring(9);
}
return parseSignatureFunction(fragment.trim());
}
}
throw new Error('unknown signature');
}
exports.parseSignature = parseSignature;
class Coder {
constructor(coerceFunc, name, type, localName = '', dynamic) {
this.coerceFunc = coerceFunc;
this.name = name;
this.type = type;
this.localName = localName;
this.dynamic = dynamic;
}
}
// Clones the functionality of an existing Coder, but without a localName
class CoderAnonymous extends Coder {
constructor(coder) {
super(coder.coerceFunc, coder.name, coder.type, undefined, coder.dynamic);
properties_1.defineReadOnly(this, 'coder', coder);
}
encode(value) {
return this.coder.encode(value);
}
decode(data, offset) {
return this.coder.decode(data, offset);
}
}
class CoderNull extends Coder {
constructor(coerceFunc, localName) {
super(coerceFunc, 'null', '', localName, false);
}
encode(value) {
return bytes_1.arrayify([]);
}
decode(data, offset) {
if (offset > data.length) {
throw new Error('invalid null');
}
return {
consumed: 0,
value: this.coerceFunc('null', undefined),
};
}
}
class CoderNumber extends Coder {
constructor(coerceFunc, size, signed, localName) {
const name = (signed ? 'int' : 'uint') + size * 8;
super(coerceFunc, name, name, localName, false);
this.size = size;
this.signed = signed;
}
encode(value) {
try {
let v = bignumber_1.bigNumberify(value);
if (this.signed) {
let bounds = constants_1.MaxUint256.maskn(this.size * 8 - 1);
if (v.gt(bounds)) {
throw new Error('out-of-bounds');
}
bounds = bounds.add(constants_1.One).mul(constants_1.NegativeOne);
if (v.lt(bounds)) {
throw new Error('out-of-bounds');
}
}
else if (v.lt(constants_1.Zero) || v.gt(constants_1.MaxUint256.maskn(this.size * 8))) {
throw new Error('out-of-bounds');
}
v = v.toTwos(this.size * 8).maskn(this.size * 8);
if (this.signed) {
v = v.fromTwos(this.size * 8).toTwos(256);
}
return bytes_1.padZeros(bytes_1.arrayify(v), 32);
}
catch (error) {
return errors.throwError('invalid number value', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: this.name,
value: value,
});
}
}
decode(data, offset) {
if (data.length < offset + 32) {
errors.throwError('insufficient data for ' + this.name + ' type', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: this.name,
value: bytes_1.hexlify(data.slice(offset, offset + 32)),
});
}
var junkLength = 32 - this.size;
var value = bignumber_1.bigNumberify(data.slice(offset + junkLength, offset + 32));
if (this.signed) {
value = value.fromTwos(this.size * 8);
}
else {
value = value.maskn(this.size * 8);
}
return {
consumed: 32,
value: this.coerceFunc(this.name, value),
};
}
}
var uint256Coder = new CoderNumber(function (type, value) {
return value;
}, 32, false, 'none');
class CoderBoolean extends Coder {
constructor(coerceFunc, localName) {
super(coerceFunc, 'bool', 'bool', localName, false);
}
encode(value) {
return uint256Coder.encode(!!value ? 1 : 0);
}
decode(data, offset) {
try {
var result = uint256Coder.decode(data, offset);
}
catch (error) {
if (error.reason === 'insufficient data for uint256 type') {
errors.throwError('insufficient data for boolean type', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'boolean',
value: error.value,
});
}
throw error;
}
return {
consumed: result.consumed,
value: this.coerceFunc('bool', !result.value.isZero()),
};
}
}
class CoderFixedBytes extends Coder {
constructor(coerceFunc, length, localName) {
const name = 'bytes' + length;
super(coerceFunc, name, name, localName, false);
this.length = length;
}
encode(value) {
var result = new Uint8Array(32);
try {
if (value.length % 2 !== 0) {
throw new Error(`hex string cannot be odd-length`);
}
let data = bytes_1.arrayify(value);
if (data.length > this.length) {
throw new Error(`incorrect data length`);
}
result.set(data);
}
catch (error) {
errors.throwError('invalid ' + this.name + ' value', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: this.name,
value: error.value || value,
});
}
return result;
}
decode(data, offset) {
if (data.length < offset + 32) {
errors.throwError('insufficient data for ' + name + ' type', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: this.name,
value: bytes_1.hexlify(data.slice(offset, offset + 32)),
});
}
return {
consumed: 32,
value: this.coerceFunc(this.name, bytes_1.hexlify(data.slice(offset, offset + this.length))),
};
}
}
class CoderAddress extends Coder {
constructor(coerceFunc, localName) {
super(coerceFunc, 'address', 'address', localName, false);
}
encode(value) {
let result = new Uint8Array(32);
value = util_1.isString(value) ? address_2.Address.fromString(value) : value;
try {
result.set(bytes_1.arrayify(value.toBuffer()), 12);
}
catch (error) {
errors.throwError(`invalid address (${error.message})`, errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'address',
value: value,
});
}
return result;
}
decode(data, offset) {
if (data.length < offset + 32) {
errors.throwError('insufficuent data for address type', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'address',
value: bytes_1.hexlify(data.slice(offset, offset + 32)),
});
}
return {
consumed: 32,
value: this.coerceFunc('address', address_1.getAddress(bytes_1.hexlify(data.slice(offset + 12, offset + 32)))),
};
}
}
function _encodeDynamicBytes(value) {
var dataLength = 32 * Math.ceil(value.length / 32);
var padding = new Uint8Array(dataLength - value.length);
return bytes_1.concat([uint256Coder.encode(value.length), value, padding]);
}
function _decodeDynamicBytes(data, offset, localName) {
if (data.length < offset + 32) {
errors.throwError('insufficient data for dynamicBytes length', errors.INVALID_ARGUMENT, {
arg: localName,
coderType: 'dynamicBytes',
value: bytes_1.hexlify(data.slice(offset, offset + 32)),
});
}
var length = uint256Coder.decode(data, offset).value;
try {
length = length.toNumber();
}
catch (error) {
errors.throwError('dynamic bytes count too large', errors.INVALID_ARGUMENT, {
arg: localName,
coderType: 'dynamicBytes',
value: length.toString(),
});
}
if (data.length < offset + 32 + length) {
errors.throwError('insufficient data for dynamicBytes type', errors.INVALID_ARGUMENT, {
arg: localName,
coderType: 'dynamicBytes',
value: bytes_1.hexlify(data.slice(offset, offset + 32 + length)),
});
}
return {
consumed: 32 + 32 * Math.ceil(length / 32),
value: data.slice(offset + 32, offset + 32 + length),
};
}
class CoderDynamicBytes extends Coder {
constructor(coerceFunc, localName) {
super(coerceFunc, 'bytes', 'bytes', localName, true);
}
encode(value) {
try {
return _encodeDynamicBytes(bytes_1.arrayify(value));
}
catch (error) {
return errors.throwError('invalid bytes value', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'bytes',
value: error.value,
});
}
}
decode(data, offset) {
var result = _decodeDynamicBytes(data, offset, this.localName);
result.value = this.coerceFunc('bytes', bytes_1.hexlify(result.value));
return result;
}
}
class CoderString extends Coder {
constructor(coerceFunc, localName) {
super(coerceFunc, 'string', 'string', localName, true);
}
encode(value) {
if (typeof value !== 'string') {
errors.throwError('invalid string value', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'string',
value: value,
});
}
return _encodeDynamicBytes(utf8_1.toUtf8Bytes(value));
}
decode(data, offset) {
var result = _decodeDynamicBytes(data, offset, this.localName);
result.value = this.coerceFunc('string', utf8_1.toUtf8String(result.value));
return result;
}
}
function alignSize(size) {
return 32 * Math.ceil(size / 32);
}
function pack(coders, values) {
if (Array.isArray(values)) {
// do nothing
}
else if (values && typeof values === 'object') {
var arrayValues = [];
coders.forEach(function (coder) {
arrayValues.push(values[coder.localName]);
});
values = arrayValues;
}
else {
errors.throwError('invalid tuple value', errors.INVALID_ARGUMENT, {
coderType: 'tuple',
value: values,
});
}
if (coders.length !== values.length) {
errors.throwError('types/value length mismatch', errors.INVALID_ARGUMENT, {
coderType: 'tuple',
value: values,
});
}
var parts = [];
coders.forEach(function (coder, index) {
parts.push({ dynamic: coder.dynamic, value: coder.encode(values[index]) });
});
var staticSize = 0, dynamicSize = 0;
parts.forEach(function (part) {
if (part.dynamic) {
staticSize += 32;
dynamicSize += alignSize(part.value.length);
}
else {
staticSize += alignSize(part.value.length);
}
});
var offset = 0, dynamicOffset = staticSize;
var data = new Uint8Array(staticSize + dynamicSize);
parts.forEach(function (part) {
if (part.dynamic) {
//uint256Coder.encode(dynamicOffset).copy(data, offset);
data.set(uint256Coder.encode(dynamicOffset), offset);
offset += 32;
//part.value.copy(data, dynamicOffset); @TODO
data.set(part.value, dynamicOffset);
dynamicOffset += alignSize(part.value.length);
}
else {
//part.value.copy(data, offset); @TODO
data.set(part.value, offset);
offset += alignSize(part.value.length);
}
});
return data;
}
function unpack(coders, data, offset) {
var baseOffset = offset;
var consumed = 0;
var value = [];
coders.forEach(function (coder) {
if (coder.dynamic) {
var dynamicOffset = uint256Coder.decode(data, offset);
var result = coder.decode(data, baseOffset + dynamicOffset.value.toNumber());
// The dynamic part is leap-frogged somewhere else; doesn't count towards size
result.consumed = dynamicOffset.consumed;
}
else {
var result = coder.decode(data, offset);
}
if (result.value != undefined) {
value.push(result.value);
}
offset += result.consumed;
consumed += result.consumed;
});
coders.forEach(function (coder, index) {
let name = coder.localName;
if (!name) {
return;
}
if (name === 'length') {
name = '_length';
}
if (value[name] != null) {
return;
}
value[name] = value[index];
});
return {
value: value,
consumed: consumed,
};
}
class CoderArray extends Coder {
constructor(coerceFunc, coder, length, localName) {
const type = coder.type + '[' + (length >= 0 ? length : '') + ']';
const dynamic = length === -1 || coder.dynamic;
super(coerceFunc, 'array', type, localName, dynamic);
this.coder = coder;
this.length = length;
}
encode(value) {
if (!Array.isArray(value)) {
errors.throwError('expected array value', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'array',
value: value,
});
}
var count = this.length;
var result = new Uint8Array(0);
if (count === -1) {
count = value.length;
result = uint256Coder.encode(count);
}
errors.checkArgumentCount(count, value.length, 'in coder array' + (this.localName ? ' ' + this.localName : ''));
var coders = [];
for (var i = 0; i < value.length; i++) {
coders.push(this.coder);
}
return bytes_1.concat([result, pack(coders, value)]);
}
decode(data, offset) {
// @TODO:
//if (data.length < offset + length * 32) { throw new Error('invalid array'); }
var consumed = 0;
var count = this.length;
if (count === -1) {
try {
var decodedLength = uint256Coder.decode(data, offset);
}
catch (error) {
return errors.throwError('insufficient data for dynamic array length', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'array',
value: error.value,
});
}
try {
count = decodedLength.value.toNumber();
}
catch (error) {
errors.throwError('array count too large', errors.INVALID_ARGUMENT, {
arg: this.localName,
coderType: 'array',
value: decodedLength.value.toString(),
});
}
consumed += decodedLength.consumed;
offset += decodedLength.consumed;
}
var coders = [];
for (var i = 0; i < count; i++) {
coders.push(new CoderAnonymous(this.coder));
}
var result = unpack(coders, data, offset);
result.consumed += consumed;
result.value = this.coerceFunc(this.type, result.value);
return result;
}
}
class CoderTuple extends Coder {
constructor(coerceFunc, coders, localName) {
var dynamic = false;
var types = [];
coders.forEach(function (coder) {
if (coder.dynamic) {
dynamic = true;
}
types.push(coder.type);
});
var type = 'tuple(' + types.join(',') + ')';
super(coerceFunc, 'tuple', type, localName, dynamic);
this.coders = coders;
}
encode(value) {
return pack(this.coders, value);
}
decode(data, offset) {
var result = unpack(this.coders, data, offset);
result.value = this.coerceFunc(this.type, result.value);
return result;
}
}
/*
function getTypes(coders) {
var type = coderTuple(coders).type;
return type.substring(6, type.length - 1);
}
*/
function splitNesting(value) {
value = value.trim();
var result = [];
var accum = '';
var depth = 0;
for (var offset = 0; offset < value.length; offset++) {
var c = value[offset];
if (c === ',' && depth === 0) {
result.push(accum);
accum = '';
}
else {
accum += c;
if (c === '(') {
depth++;
}
else if (c === ')') {
depth--;
if (depth === -1) {
throw new Error('unbalanced parenthsis');
}
}
}
}
if (accum) {
result.push(accum);
}
return result;
}
// @TODO: Is there a way to return "class"?
const paramTypeSimple = {
address: CoderAddress,
bool: CoderBoolean,
string: CoderString,
bytes: CoderDynamicBytes,
};
function getTupleParamCoder(coerceFunc, components, localName) {
if (!components) {
components = [];
}
var coders = [];
components.forEach(function (component) {
coders.push(getParamCoder(coerceFunc, component));
});
return new CoderTuple(coerceFunc, coders, localName);
}
function getParamCoder(coerceFunc, param) {
var coder = paramTypeSimple[param.type];
if (coder) {
return new coder(coerceFunc, param.name);
}
var match = param.type.match(paramTypeNumber);
if (match) {
let size = parseInt(match[2] || '256');
if (size === 0 || size > 256 || size % 8 !== 0) {
return errors.throwError('invalid ' + match[1] + ' bit length', errors.INVALID_ARGUMENT, {
arg: 'param',
value: param,
});
}
return new CoderNumber(coerceFunc, size / 8, match[1] === 'int', param.name);
}
var match = param.type.match(paramTypeBytes);
if (match) {
let size = parseInt(match[1]);
if (size === 0 || size > 32) {
errors.throwError('invalid bytes length', errors.INVALID_ARGUMENT, {
arg: 'param',
value: param,
});
}
return new CoderFixedBytes(coerceFunc, size, param.name);
}
var match = param.type.match(paramTypeArray);
if (match) {
let size = parseInt(match[2] || '-1');
param = properties_1.shallowCopy(param);
param.type = match[1];
param = properties_1.deepCopy(param);
return new CoderArray(coerceFunc, getParamCoder(coerceFunc, param), size, param.name);
}
if (param.type.substring(0, 5) === 'tuple') {
return getTupleParamCoder(coerceFunc, param.components, param.name);
}
if (param.type === '') {
return new CoderNull(coerceFunc, param.name);
}
return errors.throwError('invalid type', errors.INVALID_ARGUMENT, {
arg: 'type',
value: param.type,
});
}
class AbiCoder {
constructor(coerceFunc) {
errors.checkNew(this, AbiCoder);
if (!coerceFunc) {
coerceFunc = exports.defaultCoerceFunc;
}
properties_1.defineReadOnly(this, 'coerceFunc', coerceFunc);
}
encode(types, values) {
if (types.length !== values.length) {
errors.throwError('types/values length mismatch', errors.INVALID_ARGUMENT, {
count: { types: types.length, values: values.length },
value: { types: types, values: values },
});
}
var coders = [];
types.forEach(function (type) {
// Convert types to type objects
// - "uint foo" => { type: "uint", name: "foo" }
// - "tuple(uint, uint)" => { type: "tuple", components: [ { type: "uint" }, { type: "uint" }, ] }
let typeObject;
if (typeof type === 'string') {
typeObject = parseParam(type);
}
else {
typeObject = type;
}
coders.push(getParamCoder(this.coerceFunc, typeObject));
}, this);
return bytes_1.hexlify(new CoderTuple(this.coerceFunc, coders, '_').encode(values));
}
decode(types, data) {
var coders = [];
types.forEach(function (type) {
// See encode for details
let typeObject;
if (typeof type === 'string') {
typeObject = parseParam(type);
}
else {
typeObject = properties_1.deepCopy(type);
}
coders.push(getParamCoder(this.coerceFunc, typeObject));
}, this);
return new CoderTuple(this.coerceFunc, coders, '_').decode(bytes_1.arrayify(data), 0).value;
}
}
exports.AbiCoder = AbiCoder;
exports.defaultAbiCoder = new AbiCoder();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abi-coder.js","sourceRoot":"","sources":["../../src/ethers/abi-coder.ts"],"names":[],"mappings":"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