821 lines
30 KiB
JavaScript
821 lines
30 KiB
JavaScript
"use strict";
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var bignumber_1 = require("@ethersproject/bignumber");
|
|
var properties_1 = require("@ethersproject/properties");
|
|
var logger_1 = require("@ethersproject/logger");
|
|
var _version_1 = require("./_version");
|
|
var logger = new logger_1.Logger(_version_1.version);
|
|
;
|
|
var _constructorGuard = {};
|
|
var ModifiersBytes = { calldata: true, memory: true, storage: true };
|
|
var ModifiersNest = { calldata: true, memory: true };
|
|
function checkModifier(type, name) {
|
|
if (type === "bytes" || type === "string") {
|
|
if (ModifiersBytes[name]) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (type === "address") {
|
|
if (name === "payable") {
|
|
return true;
|
|
}
|
|
}
|
|
else if (type.indexOf("[") >= 0 || type === "tuple") {
|
|
if (ModifiersNest[name]) {
|
|
return true;
|
|
}
|
|
}
|
|
if (ModifiersBytes[name] || name === "payable") {
|
|
logger.throwArgumentError("invalid modifier", "name", name);
|
|
}
|
|
return false;
|
|
}
|
|
// @TODO: Make sure that children of an indexed tuple are marked with a null indexed
|
|
function parseParamType(param, allowIndexed) {
|
|
var originalParam = param;
|
|
function throwError(i) {
|
|
logger.throwArgumentError("unexpected character at position " + i, "param", param);
|
|
}
|
|
param = param.replace(/\s/g, " ");
|
|
function newNode(parent) {
|
|
var node = { type: "", name: "", parent: parent, state: { allowType: true } };
|
|
if (allowIndexed) {
|
|
node.indexed = false;
|
|
}
|
|
return node;
|
|
}
|
|
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.allowType && node.type === "") {
|
|
node.type = "tuple";
|
|
}
|
|
else if (!node.state.allowParams) {
|
|
throwError(i);
|
|
}
|
|
node.state.allowType = false;
|
|
node.type = verifyType(node.type);
|
|
node.components = [newNode(node)];
|
|
node = node.components[0];
|
|
break;
|
|
case ")":
|
|
delete node.state;
|
|
if (node.name === "indexed") {
|
|
if (!allowIndexed) {
|
|
throwError(i);
|
|
}
|
|
node.indexed = true;
|
|
node.name = "";
|
|
}
|
|
if (checkModifier(node.type, node.name)) {
|
|
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 (node.name === "indexed") {
|
|
if (!allowIndexed) {
|
|
throwError(i);
|
|
}
|
|
node.indexed = true;
|
|
node.name = "";
|
|
}
|
|
if (checkModifier(node.type, node.name)) {
|
|
node.name = "";
|
|
}
|
|
node.type = verifyType(node.type);
|
|
var sibling = newNode(node.parent);
|
|
//{ 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 (node.name === "indexed") {
|
|
if (!allowIndexed) {
|
|
throwError(i);
|
|
}
|
|
if (node.indexed) {
|
|
throwError(i);
|
|
}
|
|
node.indexed = true;
|
|
node.name = "";
|
|
}
|
|
else if (checkModifier(node.type, node.name)) {
|
|
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) {
|
|
logger.throwArgumentError("unexpected eof", "param", param);
|
|
}
|
|
delete parent.state;
|
|
if (node.name === "indexed") {
|
|
if (!allowIndexed) {
|
|
throwError(originalParam.length - 7);
|
|
}
|
|
if (node.indexed) {
|
|
throwError(originalParam.length - 7);
|
|
}
|
|
node.indexed = true;
|
|
node.name = "";
|
|
}
|
|
else if (checkModifier(node.type, node.name)) {
|
|
node.name = "";
|
|
}
|
|
parent.type = verifyType(parent.type);
|
|
return parent;
|
|
}
|
|
function populate(object, params) {
|
|
for (var key in params) {
|
|
properties_1.defineReadOnly(object, key, params[key]);
|
|
}
|
|
}
|
|
exports.FormatTypes = Object.freeze({
|
|
// Bare formatting, as is needed for computing a sighash of an event or function
|
|
sighash: "sighash",
|
|
// Human-Readable with Minimal spacing and without names (compact human-readable)
|
|
minimal: "minimal",
|
|
// Human-Readble with nice spacing, including all names
|
|
full: "full",
|
|
// JSON-format a la Solidity
|
|
json: "json"
|
|
});
|
|
var paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
|
|
var ParamType = /** @class */ (function () {
|
|
function ParamType(constructorGuard, params) {
|
|
if (constructorGuard !== _constructorGuard) {
|
|
logger.throwError("use fromString", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
|
|
operation: "new ParamType()"
|
|
});
|
|
}
|
|
populate(this, params);
|
|
var match = this.type.match(paramTypeArray);
|
|
if (match) {
|
|
populate(this, {
|
|
arrayLength: parseInt(match[2] || "-1"),
|
|
arrayChildren: ParamType.fromObject({
|
|
type: match[1],
|
|
components: this.components
|
|
}),
|
|
baseType: "array"
|
|
});
|
|
}
|
|
else {
|
|
populate(this, {
|
|
arrayLength: null,
|
|
arrayChildren: null,
|
|
baseType: ((this.components != null) ? "tuple" : this.type)
|
|
});
|
|
}
|
|
this._isParamType = true;
|
|
Object.freeze(this);
|
|
}
|
|
// Format the parameter fragment
|
|
// - sighash: "(uint256,address)"
|
|
// - minimal: "tuple(uint256,address) indexed"
|
|
// - full: "tuple(uint256 foo, addres bar) indexed baz"
|
|
ParamType.prototype.format = function (format) {
|
|
if (!format) {
|
|
format = exports.FormatTypes.sighash;
|
|
}
|
|
if (!exports.FormatTypes[format]) {
|
|
logger.throwArgumentError("invalid format type", "format", format);
|
|
}
|
|
if (format === exports.FormatTypes.json) {
|
|
var result_1 = {
|
|
type: ((this.baseType === "tuple") ? "tuple" : this.type),
|
|
name: (this.name || undefined)
|
|
};
|
|
if (typeof (this.indexed) === "boolean") {
|
|
result_1.indexed = this.indexed;
|
|
}
|
|
if (this.components) {
|
|
result_1.components = this.components.map(function (comp) { return JSON.parse(comp.format(format)); });
|
|
}
|
|
return JSON.stringify(result_1);
|
|
}
|
|
var result = "";
|
|
// Array
|
|
if (this.baseType === "array") {
|
|
result += this.arrayChildren.format(format);
|
|
result += "[" + (this.arrayLength < 0 ? "" : String(this.arrayLength)) + "]";
|
|
}
|
|
else {
|
|
if (this.baseType === "tuple") {
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
result += this.type;
|
|
}
|
|
result += "(" + this.components.map(function (comp) { return comp.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ")";
|
|
}
|
|
else {
|
|
result += this.type;
|
|
}
|
|
}
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
if (this.indexed === true) {
|
|
result += " indexed";
|
|
}
|
|
if (format === exports.FormatTypes.full && this.name) {
|
|
result += " " + this.name;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
ParamType.from = function (value, allowIndexed) {
|
|
if (typeof (value) === "string") {
|
|
return ParamType.fromString(value, allowIndexed);
|
|
}
|
|
return ParamType.fromObject(value);
|
|
};
|
|
ParamType.fromObject = function (value) {
|
|
if (ParamType.isParamType(value)) {
|
|
return value;
|
|
}
|
|
return new ParamType(_constructorGuard, {
|
|
name: (value.name || null),
|
|
type: verifyType(value.type),
|
|
indexed: ((value.indexed == null) ? null : !!value.indexed),
|
|
components: (value.components ? value.components.map(ParamType.fromObject) : null)
|
|
});
|
|
};
|
|
ParamType.fromString = function (value, allowIndexed) {
|
|
function ParamTypify(node) {
|
|
return ParamType.fromObject({
|
|
name: node.name,
|
|
type: node.type,
|
|
indexed: node.indexed,
|
|
components: node.components
|
|
});
|
|
}
|
|
return ParamTypify(parseParamType(value, !!allowIndexed));
|
|
};
|
|
ParamType.isParamType = function (value) {
|
|
return !!(value != null && value._isParamType);
|
|
};
|
|
return ParamType;
|
|
}());
|
|
exports.ParamType = ParamType;
|
|
;
|
|
function parseParams(value, allowIndex) {
|
|
return splitNesting(value).map(function (param) { return ParamType.fromString(param, allowIndex); });
|
|
}
|
|
var Fragment = /** @class */ (function () {
|
|
function Fragment(constructorGuard, params) {
|
|
if (constructorGuard !== _constructorGuard) {
|
|
logger.throwError("use a static from method", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
|
|
operation: "new Fragment()"
|
|
});
|
|
}
|
|
populate(this, params);
|
|
this._isFragment = true;
|
|
Object.freeze(this);
|
|
}
|
|
Fragment.from = function (value) {
|
|
if (Fragment.isFragment(value)) {
|
|
return value;
|
|
}
|
|
if (typeof (value) === "string") {
|
|
return Fragment.fromString(value);
|
|
}
|
|
return Fragment.fromObject(value);
|
|
};
|
|
Fragment.fromObject = function (value) {
|
|
if (Fragment.isFragment(value)) {
|
|
return value;
|
|
}
|
|
switch (value.type) {
|
|
case "function":
|
|
return FunctionFragment.fromObject(value);
|
|
case "event":
|
|
return EventFragment.fromObject(value);
|
|
case "constructor":
|
|
return ConstructorFragment.fromObject(value);
|
|
case "fallback":
|
|
case "receive":
|
|
// @TODO: Something? Maybe return a FunctionFragment? A custom DefaultFunctionFragment?
|
|
return null;
|
|
}
|
|
return logger.throwArgumentError("invalid fragment object", "value", value);
|
|
};
|
|
Fragment.fromString = function (value) {
|
|
// Make sure the "returns" is surrounded by a space and all whitespace is exactly one space
|
|
value = value.replace(/\s/g, " ");
|
|
value = value.replace(/\(/g, " (").replace(/\)/g, ") ").replace(/\s+/g, " ");
|
|
value = value.trim();
|
|
if (value.split(" ")[0] === "event") {
|
|
return EventFragment.fromString(value.substring(5).trim());
|
|
}
|
|
else if (value.split(" ")[0] === "function") {
|
|
return FunctionFragment.fromString(value.substring(8).trim());
|
|
}
|
|
else if (value.split("(")[0].trim() === "constructor") {
|
|
return ConstructorFragment.fromString(value.trim());
|
|
}
|
|
return logger.throwArgumentError("unsupported fragment", "value", value);
|
|
};
|
|
Fragment.isFragment = function (value) {
|
|
return !!(value && value._isFragment);
|
|
};
|
|
return Fragment;
|
|
}());
|
|
exports.Fragment = Fragment;
|
|
var EventFragment = /** @class */ (function (_super) {
|
|
__extends(EventFragment, _super);
|
|
function EventFragment() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
EventFragment.prototype.format = function (format) {
|
|
if (!format) {
|
|
format = exports.FormatTypes.sighash;
|
|
}
|
|
if (!exports.FormatTypes[format]) {
|
|
logger.throwArgumentError("invalid format type", "format", format);
|
|
}
|
|
if (format === exports.FormatTypes.json) {
|
|
return JSON.stringify({
|
|
type: "event",
|
|
anonymous: this.anonymous,
|
|
name: this.name,
|
|
inputs: this.inputs.map(function (input) { return JSON.parse(input.format(format)); })
|
|
});
|
|
}
|
|
var result = "";
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
result += "event ";
|
|
}
|
|
result += this.name + "(" + this.inputs.map(function (input) { return input.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ") ";
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
if (this.anonymous) {
|
|
result += "anonymous ";
|
|
}
|
|
}
|
|
return result.trim();
|
|
};
|
|
EventFragment.from = function (value) {
|
|
if (typeof (value) === "string") {
|
|
return EventFragment.fromString(value);
|
|
}
|
|
return EventFragment.fromObject(value);
|
|
};
|
|
EventFragment.fromObject = function (value) {
|
|
if (EventFragment.isEventFragment(value)) {
|
|
return value;
|
|
}
|
|
if (value.type !== "event") {
|
|
logger.throwArgumentError("invalid event object", "value", value);
|
|
}
|
|
var params = {
|
|
name: verifyIdentifier(value.name),
|
|
anonymous: value.anonymous,
|
|
inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),
|
|
type: "event"
|
|
};
|
|
return new EventFragment(_constructorGuard, params);
|
|
};
|
|
EventFragment.fromString = function (value) {
|
|
var match = value.match(regexParen);
|
|
if (!match) {
|
|
logger.throwArgumentError("invalid event string", "value", value);
|
|
}
|
|
var anonymous = false;
|
|
match[3].split(" ").forEach(function (modifier) {
|
|
switch (modifier.trim()) {
|
|
case "anonymous":
|
|
anonymous = true;
|
|
break;
|
|
case "":
|
|
break;
|
|
default:
|
|
logger.warn("unknown modifier: " + modifier);
|
|
}
|
|
});
|
|
return EventFragment.fromObject({
|
|
name: match[1].trim(),
|
|
anonymous: anonymous,
|
|
inputs: parseParams(match[2], true),
|
|
type: "event"
|
|
});
|
|
};
|
|
EventFragment.isEventFragment = function (value) {
|
|
return (value && value._isFragment && value.type === "event");
|
|
};
|
|
return EventFragment;
|
|
}(Fragment));
|
|
exports.EventFragment = EventFragment;
|
|
function parseGas(value, params) {
|
|
params.gas = null;
|
|
var comps = value.split("@");
|
|
if (comps.length !== 1) {
|
|
if (comps.length > 2) {
|
|
logger.throwArgumentError("invalid human-readable ABI signature", "value", value);
|
|
}
|
|
if (!comps[1].match(/^[0-9]+$/)) {
|
|
logger.throwArgumentError("invalid human-readable ABI signature gas", "value", value);
|
|
}
|
|
params.gas = bignumber_1.BigNumber.from(comps[1]);
|
|
return comps[0];
|
|
}
|
|
return value;
|
|
}
|
|
function parseModifiers(value, params) {
|
|
params.constant = false;
|
|
params.payable = false;
|
|
params.stateMutability = "nonpayable";
|
|
value.split(" ").forEach(function (modifier) {
|
|
switch (modifier.trim()) {
|
|
case "constant":
|
|
params.constant = true;
|
|
break;
|
|
case "payable":
|
|
params.payable = true;
|
|
params.stateMutability = "payable";
|
|
break;
|
|
case "nonpayable":
|
|
params.payable = false;
|
|
params.stateMutability = "nonpayable";
|
|
break;
|
|
case "pure":
|
|
params.constant = true;
|
|
params.stateMutability = "pure";
|
|
break;
|
|
case "view":
|
|
params.constant = true;
|
|
params.stateMutability = "view";
|
|
break;
|
|
case "external":
|
|
case "public":
|
|
case "":
|
|
break;
|
|
default:
|
|
console.log("unknown modifier: " + modifier);
|
|
}
|
|
});
|
|
}
|
|
function verifyState(value) {
|
|
var result = {
|
|
constant: false,
|
|
payable: true,
|
|
stateMutability: "payable"
|
|
};
|
|
if (value.stateMutability != null) {
|
|
result.stateMutability = value.stateMutability;
|
|
// Set (and check things are consistent) the constant property
|
|
result.constant = (result.stateMutability === "view" || result.stateMutability === "pure");
|
|
if (value.constant != null) {
|
|
if ((!!value.constant) !== result.constant) {
|
|
logger.throwArgumentError("cannot have constant function with mutability " + result.stateMutability, "value", value);
|
|
}
|
|
}
|
|
// Set (and check things are consistent) the payable property
|
|
result.payable = (result.stateMutability === "payable");
|
|
if (value.payable != null) {
|
|
if ((!!value.payable) !== result.payable) {
|
|
logger.throwArgumentError("cannot have payable function with mutability " + result.stateMutability, "value", value);
|
|
}
|
|
}
|
|
}
|
|
else if (value.payable != null) {
|
|
result.payable = !!value.payable;
|
|
// If payable we can assume non-constant; otherwise we can't assume
|
|
if (value.constant == null && !result.payable && value.type !== "constructor") {
|
|
logger.throwArgumentError("unable to determine stateMutability", "value", value);
|
|
}
|
|
result.constant = !!value.constant;
|
|
if (result.constant) {
|
|
result.stateMutability = "view";
|
|
}
|
|
else {
|
|
result.stateMutability = (result.payable ? "payable" : "nonpayable");
|
|
}
|
|
if (result.payable && result.constant) {
|
|
logger.throwArgumentError("cannot have constant payable function", "value", value);
|
|
}
|
|
}
|
|
else if (value.constant != null) {
|
|
result.constant = !!value.constant;
|
|
result.payable = !result.constant;
|
|
result.stateMutability = (result.constant ? "view" : "payable");
|
|
}
|
|
else if (value.type !== "constructor") {
|
|
logger.throwArgumentError("unable to determine stateMutability", "value", value);
|
|
}
|
|
return result;
|
|
}
|
|
var ConstructorFragment = /** @class */ (function (_super) {
|
|
__extends(ConstructorFragment, _super);
|
|
function ConstructorFragment() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
ConstructorFragment.prototype.format = function (format) {
|
|
if (!format) {
|
|
format = exports.FormatTypes.sighash;
|
|
}
|
|
if (!exports.FormatTypes[format]) {
|
|
logger.throwArgumentError("invalid format type", "format", format);
|
|
}
|
|
if (format === exports.FormatTypes.json) {
|
|
return JSON.stringify({
|
|
type: "constructor",
|
|
stateMutability: ((this.stateMutability !== "nonpayable") ? this.stateMutability : undefined),
|
|
payable: this.payable,
|
|
gas: (this.gas ? this.gas.toNumber() : undefined),
|
|
inputs: this.inputs.map(function (input) { return JSON.parse(input.format(format)); })
|
|
});
|
|
}
|
|
if (format === exports.FormatTypes.sighash) {
|
|
logger.throwError("cannot format a constructor for sighash", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
|
|
operation: "format(sighash)"
|
|
});
|
|
}
|
|
var result = "constructor(" + this.inputs.map(function (input) { return input.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ") ";
|
|
if (this.stateMutability && this.stateMutability !== "nonpayable") {
|
|
result += this.stateMutability + " ";
|
|
}
|
|
return result.trim();
|
|
};
|
|
ConstructorFragment.from = function (value) {
|
|
if (typeof (value) === "string") {
|
|
return ConstructorFragment.fromString(value);
|
|
}
|
|
return ConstructorFragment.fromObject(value);
|
|
};
|
|
ConstructorFragment.fromObject = function (value) {
|
|
if (ConstructorFragment.isConstructorFragment(value)) {
|
|
return value;
|
|
}
|
|
if (value.type !== "constructor") {
|
|
logger.throwArgumentError("invalid constructor object", "value", value);
|
|
}
|
|
var state = verifyState(value);
|
|
if (state.constant) {
|
|
logger.throwArgumentError("constructor cannot be constant", "value", value);
|
|
}
|
|
var params = {
|
|
name: null,
|
|
type: value.type,
|
|
inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),
|
|
payable: state.payable,
|
|
stateMutability: state.stateMutability,
|
|
gas: (value.gas ? bignumber_1.BigNumber.from(value.gas) : null)
|
|
};
|
|
return new ConstructorFragment(_constructorGuard, params);
|
|
};
|
|
ConstructorFragment.fromString = function (value) {
|
|
var params = { type: "constructor" };
|
|
value = parseGas(value, params);
|
|
var parens = value.match(regexParen);
|
|
if (!parens || parens[1].trim() !== "constructor") {
|
|
logger.throwArgumentError("invalid constructor string", "value", value);
|
|
}
|
|
params.inputs = parseParams(parens[2].trim(), false);
|
|
parseModifiers(parens[3].trim(), params);
|
|
return ConstructorFragment.fromObject(params);
|
|
};
|
|
ConstructorFragment.isConstructorFragment = function (value) {
|
|
return (value && value._isFragment && value.type === "constructor");
|
|
};
|
|
return ConstructorFragment;
|
|
}(Fragment));
|
|
exports.ConstructorFragment = ConstructorFragment;
|
|
var FunctionFragment = /** @class */ (function (_super) {
|
|
__extends(FunctionFragment, _super);
|
|
function FunctionFragment() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
FunctionFragment.prototype.format = function (format) {
|
|
if (!format) {
|
|
format = exports.FormatTypes.sighash;
|
|
}
|
|
if (!exports.FormatTypes[format]) {
|
|
logger.throwArgumentError("invalid format type", "format", format);
|
|
}
|
|
if (format === exports.FormatTypes.json) {
|
|
return JSON.stringify({
|
|
type: "function",
|
|
name: this.name,
|
|
constant: this.constant,
|
|
stateMutability: ((this.stateMutability !== "nonpayable") ? this.stateMutability : undefined),
|
|
payable: this.payable,
|
|
gas: (this.gas ? this.gas.toNumber() : undefined),
|
|
inputs: this.inputs.map(function (input) { return JSON.parse(input.format(format)); }),
|
|
outputs: this.outputs.map(function (output) { return JSON.parse(output.format(format)); }),
|
|
});
|
|
}
|
|
var result = "";
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
result += "function ";
|
|
}
|
|
result += this.name + "(" + this.inputs.map(function (input) { return input.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ") ";
|
|
if (format !== exports.FormatTypes.sighash) {
|
|
if (this.stateMutability) {
|
|
if (this.stateMutability !== "nonpayable") {
|
|
result += (this.stateMutability + " ");
|
|
}
|
|
}
|
|
else if (this.constant) {
|
|
result += "view ";
|
|
}
|
|
if (this.outputs && this.outputs.length) {
|
|
result += "returns (" + this.outputs.map(function (output) { return output.format(format); }).join(", ") + ") ";
|
|
}
|
|
if (this.gas != null) {
|
|
result += "@" + this.gas.toString() + " ";
|
|
}
|
|
}
|
|
return result.trim();
|
|
};
|
|
FunctionFragment.from = function (value) {
|
|
if (typeof (value) === "string") {
|
|
return FunctionFragment.fromString(value);
|
|
}
|
|
return FunctionFragment.fromObject(value);
|
|
};
|
|
FunctionFragment.fromObject = function (value) {
|
|
if (FunctionFragment.isFunctionFragment(value)) {
|
|
return value;
|
|
}
|
|
if (value.type !== "function") {
|
|
logger.throwArgumentError("invalid function object", "value", value);
|
|
}
|
|
var state = verifyState(value);
|
|
var params = {
|
|
type: value.type,
|
|
name: verifyIdentifier(value.name),
|
|
constant: state.constant,
|
|
inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),
|
|
outputs: (value.outputs ? value.outputs.map(ParamType.fromObject) : []),
|
|
payable: state.payable,
|
|
stateMutability: state.stateMutability,
|
|
gas: (value.gas ? bignumber_1.BigNumber.from(value.gas) : null)
|
|
};
|
|
return new FunctionFragment(_constructorGuard, params);
|
|
};
|
|
FunctionFragment.fromString = function (value) {
|
|
var params = { type: "function" };
|
|
value = parseGas(value, params);
|
|
var comps = value.split(" returns ");
|
|
if (comps.length > 2) {
|
|
logger.throwArgumentError("invalid function string", "value", value);
|
|
}
|
|
var parens = comps[0].match(regexParen);
|
|
if (!parens) {
|
|
logger.throwArgumentError("invalid function signature", "value", value);
|
|
}
|
|
params.name = parens[1].trim();
|
|
if (params.name) {
|
|
verifyIdentifier(params.name);
|
|
}
|
|
params.inputs = parseParams(parens[2], false);
|
|
parseModifiers(parens[3].trim(), params);
|
|
// We have outputs
|
|
if (comps.length > 1) {
|
|
var returns = comps[1].match(regexParen);
|
|
if (returns[1].trim() != "" || returns[3].trim() != "") {
|
|
logger.throwArgumentError("unexpected tokens", "value", value);
|
|
}
|
|
params.outputs = parseParams(returns[2], false);
|
|
}
|
|
else {
|
|
params.outputs = [];
|
|
}
|
|
return FunctionFragment.fromObject(params);
|
|
};
|
|
FunctionFragment.isFunctionFragment = function (value) {
|
|
return (value && value._isFragment && value.type === "function");
|
|
};
|
|
return FunctionFragment;
|
|
}(ConstructorFragment));
|
|
exports.FunctionFragment = FunctionFragment;
|
|
//export class ErrorFragment extends Fragment {
|
|
//}
|
|
//export class StructFragment extends Fragment {
|
|
//}
|
|
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);
|
|
}
|
|
// @TODO: more verification
|
|
return type;
|
|
}
|
|
var regexIdentifier = new RegExp("^[A-Za-z_][A-Za-z0-9_]*$");
|
|
function verifyIdentifier(value) {
|
|
if (!value || !value.match(regexIdentifier)) {
|
|
logger.throwArgumentError("invalid identifier \"" + value + "\"", "value", value);
|
|
}
|
|
return value;
|
|
}
|
|
var regexParen = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$");
|
|
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) {
|
|
logger.throwArgumentError("unbalanced parenthesis", "value", value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (accum) {
|
|
result.push(accum);
|
|
}
|
|
return result;
|
|
}
|
|
//# sourceMappingURL=fragments.js.map
|