@qevm/abi 5.7.2 → 5.7.3

package/lib/fragments.js

@@ -1,30 +1,21 @@
 "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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorFragment = exports.FunctionFragment = exports.ConstructorFragment = exports.EventFragment = exports.Fragment = exports.ParamType = exports.FormatTypes = void 0;
-var bignumber_1 = require("@qevm/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 };
+const bignumber_1 = require("@qevm/bignumber");
+const properties_1 = require("@qevm/properties");
+const logger_1 = require("@qevm/logger");
+const _version_1 = require("./_version");
+const logger = new logger_1.Logger(_version_1.version);
+const _constructorGuard = {};
+let ModifiersBytes = {
+    calldata: true,
+    memory: true,
+    storage: true,
+};
+let ModifiersNest = {
+    calldata: true,
+    memory: true,
+};
 function checkModifier(type, name) {
     if (type === "bytes" || type === "string") {
         if (ModifiersBytes[name]) {
@@ -48,22 +39,27 @@ function checkModifier(type, name) {
 }
 // @TODO: Make sure that children of an indexed tuple are marked with a null indexed
 function parseParamType(param, allowIndexed) {
-    var originalParam = param;
+    let originalParam = param;
     function throwError(i) {
-        logger.throwArgumentError("unexpected character at position ".concat(i), "param", param);
+        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 } };
+        let 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];
+    let parent = { type: "", name: "", state: { allowType: true } };
+    let node = parent;
+    for (let i = 0; i < param.length; i++) {
+        let c = param[i];
         switch (c) {
             case "(":
                 if (node.state.allowType && node.type === "") {
@@ -90,7 +86,7 @@ function parseParamType(param, allowIndexed) {
                     node.name = "";
                 }
                 node.type = verifyType(node.type);
-                var child = node;
+                let child = node;
                 node = node.parent;
                 if (!node) {
                     throwError(i);
@@ -113,7 +109,7 @@ function parseParamType(param, allowIndexed) {
                     node.name = "";
                 }
                 node.type = verifyType(node.type);
-                var sibling = newNode(node.parent);
+                let sibling = newNode(node.parent);
                 //{ type: "", name: "", parent: node.parent, state: { allowType: true } };
                 node.parent.components.push(sibling);
                 delete node.parent;
@@ -209,7 +205,7 @@ function parseParamType(param, allowIndexed) {
     return parent;
 }
 function populate(object, params) {
-    for (var key in params) {
+    for (let key in params) {
         (0, properties_1.defineReadOnly)(object, key, params[key]);
     }
 }
@@ -221,33 +217,33 @@ exports.FormatTypes = Object.freeze({
     // Human-Readable with nice spacing, including all names
     full: "full",
     // JSON-format a la Solidity
-    json: "json"
+    json: "json",
 });
-var paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
-var ParamType = /** @class */ (function () {
-    function ParamType(constructorGuard, params) {
+const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
+class ParamType {
+    constructor(constructorGuard, params) {
         if (constructorGuard !== _constructorGuard) {
             logger.throwError("use fromString", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "new ParamType()"
+                operation: "new ParamType()",
             });
         }
         populate(this, params);
-        var match = this.type.match(paramTypeArray);
+        let match = this.type.match(paramTypeArray);
         if (match) {
             populate(this, {
                 arrayLength: parseInt(match[2] || "-1"),
                 arrayChildren: ParamType.fromObject({
                     type: match[1],
-                    components: this.components
+                    components: this.components,
                 }),
-                baseType: "array"
+                baseType: "array",
             });
         }
         else {
             populate(this, {
                 arrayLength: null,
                 arrayChildren: null,
-                baseType: ((this.components != null) ? "tuple" : this.type)
+                baseType: this.components != null ? "tuple" : this.type,
             });
         }
         this._isParamType = true;
@@ -257,7 +253,7 @@ var ParamType = /** @class */ (function () {
     //   - sighash: "(uint256,address)"
     //   - minimal: "tuple(uint256,address) indexed"
     //   - full:    "tuple(uint256 foo, address bar) indexed baz"
-    ParamType.prototype.format = function (format) {
+    format(format) {
         if (!format) {
             format = exports.FormatTypes.sighash;
         }
@@ -265,30 +261,38 @@ var ParamType = /** @class */ (function () {
             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)
+            let result = {
+                type: this.baseType === "tuple" ? "tuple" : this.type,
+                name: this.name || undefined,
             };
-            if (typeof (this.indexed) === "boolean") {
-                result_1.indexed = this.indexed;
+            if (typeof this.indexed === "boolean") {
+                result.indexed = this.indexed;
             }
             if (this.components) {
-                result_1.components = this.components.map(function (comp) { return JSON.parse(comp.format(format)); });
+                result.components = this.components.map((comp) => JSON.parse(comp.format(format)));
             }
-            return JSON.stringify(result_1);
+            return JSON.stringify(result);
         }
-        var result = "";
+        let result = "";
         // Array
         if (this.baseType === "array") {
             result += this.arrayChildren.format(format);
-            result += "[" + (this.arrayLength < 0 ? "" : String(this.arrayLength)) + "]";
+            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) ? ", " : ",") + ")";
+                result +=
+                    "(" +
+                        this.components
+                            .map((comp) => comp.format(format))
+                            .join(format === exports.FormatTypes.full ? ", " : ",") +
+                        ")";
             }
             else {
                 result += this.type;
@@ -303,66 +307,66 @@ var ParamType = /** @class */ (function () {
             }
         }
         return result;
-    };
-    ParamType.from = function (value, allowIndexed) {
-        if (typeof (value) === "string") {
+    }
+    static from(value, allowIndexed) {
+        if (typeof value === "string") {
             return ParamType.fromString(value, allowIndexed);
         }
         return ParamType.fromObject(value);
-    };
-    ParamType.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (ParamType.isParamType(value)) {
             return value;
         }
         return new ParamType(_constructorGuard, {
-            name: (value.name || null),
+            name: value.name || null,
             type: verifyType(value.type),
-            indexed: ((value.indexed == null) ? null : !!value.indexed),
-            components: (value.components ? value.components.map(ParamType.fromObject) : null)
+            indexed: value.indexed == null ? null : !!value.indexed,
+            components: value.components
+                ? value.components.map(ParamType.fromObject)
+                : null,
         });
-    };
-    ParamType.fromString = function (value, allowIndexed) {
+    }
+    static fromString(value, allowIndexed) {
         function ParamTypify(node) {
             return ParamType.fromObject({
                 name: node.name,
                 type: node.type,
                 indexed: node.indexed,
-                components: node.components
+                components: node.components,
             });
         }
         return ParamTypify(parseParamType(value, !!allowIndexed));
-    };
-    ParamType.isParamType = function (value) {
+    }
+    static isParamType(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); });
+    return splitNesting(value).map((param) => ParamType.fromString(param, allowIndex));
 }
-var Fragment = /** @class */ (function () {
-    function Fragment(constructorGuard, params) {
+class Fragment {
+    constructor(constructorGuard, params) {
         if (constructorGuard !== _constructorGuard) {
             logger.throwError("use a static from method", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "new Fragment()"
+                operation: "new Fragment()",
             });
         }
         populate(this, params);
         this._isFragment = true;
         Object.freeze(this);
     }
-    Fragment.from = function (value) {
+    static from(value) {
         if (Fragment.isFragment(value)) {
             return value;
         }
-        if (typeof (value) === "string") {
+        if (typeof value === "string") {
             return Fragment.fromString(value);
         }
         return Fragment.fromObject(value);
-    };
-    Fragment.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (Fragment.isFragment(value)) {
             return value;
         }
@@ -381,11 +385,14 @@ var Fragment = /** @class */ (function () {
                 return null;
         }
         return logger.throwArgumentError("invalid fragment object", "value", value);
-    };
-    Fragment.fromString = function (value) {
+    }
+    static fromString(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
+            .replace(/\(/g, " (")
+            .replace(/\)/g, ") ")
+            .replace(/\s+/g, " ");
         value = value.trim();
         if (value.split(" ")[0] === "event") {
             return EventFragment.fromString(value.substring(5).trim());
@@ -400,19 +407,14 @@ var Fragment = /** @class */ (function () {
             return ErrorFragment.fromString(value.substring(5).trim());
         }
         return logger.throwArgumentError("unsupported fragment", "value", value);
-    };
-    Fragment.isFragment = function (value) {
+    }
+    static isFragment(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) {
+}
+exports.Fragment = Fragment;
+class EventFragment extends Fragment {
+    format(format) {
         if (!format) {
             format = exports.FormatTypes.sighash;
         }
@@ -424,49 +426,55 @@ var EventFragment = /** @class */ (function (_super) {
                 type: "event",
                 anonymous: this.anonymous,
                 name: this.name,
-                inputs: this.inputs.map(function (input) { return JSON.parse(input.format(format)); })
+                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),
             });
         }
-        var result = "";
+        let 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) ? ", " : ",") + ") ";
+        result +=
+            this.name +
+                "(" +
+                this.inputs
+                    .map((input) => 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") {
+    }
+    static from(value) {
+        if (typeof value === "string") {
             return EventFragment.fromString(value);
         }
         return EventFragment.fromObject(value);
-    };
-    EventFragment.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (EventFragment.isEventFragment(value)) {
             return value;
         }
         if (value.type !== "event") {
             logger.throwArgumentError("invalid event object", "value", value);
         }
-        var params = {
+        const params = {
             name: verifyIdentifier(value.name),
             anonymous: value.anonymous,
-            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),
-            type: "event"
+            inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+            type: "event",
         };
         return new EventFragment(_constructorGuard, params);
-    };
-    EventFragment.fromString = function (value) {
-        var match = value.match(regexParen);
+    }
+    static fromString(value) {
+        let match = value.match(regexParen);
         if (!match) {
             logger.throwArgumentError("invalid event string", "value", value);
         }
-        var anonymous = false;
-        match[3].split(" ").forEach(function (modifier) {
+        let anonymous = false;
+        match[3].split(" ").forEach((modifier) => {
             switch (modifier.trim()) {
                 case "anonymous":
                     anonymous = true;
@@ -481,18 +489,17 @@ var EventFragment = /** @class */ (function (_super) {
             name: match[1].trim(),
             anonymous: anonymous,
             inputs: parseParams(match[2], true),
-            type: "event"
+            type: "event",
         });
-    };
-    EventFragment.isEventFragment = function (value) {
-        return (value && value._isFragment && value.type === "event");
-    };
-    return EventFragment;
-}(Fragment));
+    }
+    static isEventFragment(value) {
+        return value && value._isFragment && value.type === "event";
+    }
+}
 exports.EventFragment = EventFragment;
 function parseGas(value, params) {
     params.gas = null;
-    var comps = value.split("@");
+    let comps = value.split("@");
     if (comps.length !== 1) {
         if (comps.length > 2) {
             logger.throwArgumentError("invalid human-readable ABI signature", "value", value);
@@ -509,7 +516,7 @@ function parseModifiers(value, params) {
     params.constant = false;
     params.payable = false;
     params.stateMutability = "nonpayable";
-    value.split(" ").forEach(function (modifier) {
+    value.split(" ").forEach((modifier) => {
         switch (modifier.trim()) {
             case "constant":
                 params.constant = true;
@@ -540,32 +547,38 @@ function parseModifiers(value, params) {
     });
 }
 function verifyState(value) {
-    var result = {
+    let result = {
         constant: false,
         payable: true,
-        stateMutability: "payable"
+        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");
+        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);
+            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");
+        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);
+            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") {
+        if (value.constant == null &&
+            !result.payable &&
+            value.type !== "constructor") {
             logger.throwArgumentError("unable to determine stateMutability", "value", value);
         }
         result.constant = !!value.constant;
@@ -573,7 +586,7 @@ function verifyState(value) {
             result.stateMutability = "view";
         }
         else {
-            result.stateMutability = (result.payable ? "payable" : "nonpayable");
+            result.stateMutability = result.payable ? "payable" : "nonpayable";
         }
         if (result.payable && result.constant) {
             logger.throwArgumentError("cannot have constant payable function", "value", value);
@@ -582,19 +595,15 @@ function verifyState(value) {
     else if (value.constant != null) {
         result.constant = !!value.constant;
         result.payable = !result.constant;
-        result.stateMutability = (result.constant ? "view" : "payable");
+        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) {
+class ConstructorFragment extends Fragment {
+    format(format) {
         if (!format) {
             format = exports.FormatTypes.sighash;
         }
@@ -604,73 +613,74 @@ var ConstructorFragment = /** @class */ (function (_super) {
         if (format === exports.FormatTypes.json) {
             return JSON.stringify({
                 type: "constructor",
-                stateMutability: ((this.stateMutability !== "nonpayable") ? this.stateMutability : undefined),
+                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)); })
+                gas: this.gas ? this.gas.toNumber() : undefined,
+                inputs: this.inputs.map((input) => 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)"
+                operation: "format(sighash)",
             });
         }
-        var result = "constructor(" + this.inputs.map(function (input) { return input.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ") ";
+        let result = "constructor(" +
+            this.inputs
+                .map((input) => 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") {
+    }
+    static from(value) {
+        if (typeof value === "string") {
             return ConstructorFragment.fromString(value);
         }
         return ConstructorFragment.fromObject(value);
-    };
-    ConstructorFragment.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (ConstructorFragment.isConstructorFragment(value)) {
             return value;
         }
         if (value.type !== "constructor") {
             logger.throwArgumentError("invalid constructor object", "value", value);
         }
-        var state = verifyState(value);
+        let state = verifyState(value);
         if (state.constant) {
             logger.throwArgumentError("constructor cannot be constant", "value", value);
         }
-        var params = {
+        const params = {
             name: null,
             type: value.type,
-            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),
+            inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
             payable: state.payable,
             stateMutability: state.stateMutability,
-            gas: (value.gas ? bignumber_1.BigNumber.from(value.gas) : null)
+            gas: value.gas ? bignumber_1.BigNumber.from(value.gas) : null,
         };
         return new ConstructorFragment(_constructorGuard, params);
-    };
-    ConstructorFragment.fromString = function (value) {
-        var params = { type: "constructor" };
+    }
+    static fromString(value) {
+        let params = { type: "constructor" };
         value = parseGas(value, params);
-        var parens = value.match(regexParen);
+        let 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) {
+    static isConstructorFragment(value) {
+        return value && value._isFragment && value.type === "constructor";
+    }
+}
+exports.ConstructorFragment = ConstructorFragment;
+class FunctionFragment extends ConstructorFragment {
+    format(format) {
         if (!format) {
             format = exports.FormatTypes.sighash;
         }
@@ -682,70 +692,85 @@ var FunctionFragment = /** @class */ (function (_super) {
                 type: "function",
                 name: this.name,
                 constant: this.constant,
-                stateMutability: ((this.stateMutability !== "nonpayable") ? this.stateMutability : undefined),
+                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)); }),
+                gas: this.gas ? this.gas.toNumber() : undefined,
+                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),
+                outputs: this.outputs.map((output) => JSON.parse(output.format(format))),
             });
         }
-        var result = "";
+        let 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) ? ", " : ",") + ") ";
+        result +=
+            this.name +
+                "(" +
+                this.inputs
+                    .map((input) => input.format(format))
+                    .join(format === exports.FormatTypes.full ? ", " : ",") +
+                ") ";
         if (format !== exports.FormatTypes.sighash) {
             if (this.stateMutability) {
                 if (this.stateMutability !== "nonpayable") {
-                    result += (this.stateMutability + " ");
+                    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(", ") + ") ";
+                result +=
+                    "returns (" +
+                        this.outputs
+                            .map((output) => output.format(format))
+                            .join(", ") +
+                        ") ";
             }
             if (this.gas != null) {
                 result += "@" + this.gas.toString() + " ";
             }
         }
         return result.trim();
-    };
-    FunctionFragment.from = function (value) {
-        if (typeof (value) === "string") {
+    }
+    static from(value) {
+        if (typeof value === "string") {
             return FunctionFragment.fromString(value);
         }
         return FunctionFragment.fromObject(value);
-    };
-    FunctionFragment.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (FunctionFragment.isFunctionFragment(value)) {
             return value;
         }
         if (value.type !== "function") {
             logger.throwArgumentError("invalid function object", "value", value);
         }
-        var state = verifyState(value);
-        var params = {
+        let state = verifyState(value);
+        const 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) : []),
+            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)
+            gas: value.gas ? bignumber_1.BigNumber.from(value.gas) : null,
         };
         return new FunctionFragment(_constructorGuard, params);
-    };
-    FunctionFragment.fromString = function (value) {
-        var params = { type: "function" };
+    }
+    static fromString(value) {
+        let params = { type: "function" };
         value = parseGas(value, params);
-        var comps = value.split(" returns ");
+        let comps = value.split(" returns ");
         if (comps.length > 2) {
             logger.throwArgumentError("invalid function string", "value", value);
         }
-        var parens = comps[0].match(regexParen);
+        let parens = comps[0].match(regexParen);
         if (!parens) {
             logger.throwArgumentError("invalid function signature", "value", value);
         }
@@ -757,7 +782,7 @@ var FunctionFragment = /** @class */ (function (_super) {
         parseModifiers(parens[3].trim(), params);
         // We have outputs
         if (comps.length > 1) {
-            var returns = comps[1].match(regexParen);
+            let returns = comps[1].match(regexParen);
             if (returns[1].trim() != "" || returns[3].trim() != "") {
                 logger.throwArgumentError("unexpected tokens", "value", value);
             }
@@ -767,28 +792,23 @@ var FunctionFragment = /** @class */ (function (_super) {
             params.outputs = [];
         }
         return FunctionFragment.fromObject(params);
-    };
-    FunctionFragment.isFunctionFragment = function (value) {
-        return (value && value._isFragment && value.type === "function");
-    };
-    return FunctionFragment;
-}(ConstructorFragment));
+    }
+    static isFunctionFragment(value) {
+        return value && value._isFragment && value.type === "function";
+    }
+}
 exports.FunctionFragment = FunctionFragment;
 //export class StructFragment extends Fragment {
 //}
 function checkForbidden(fragment) {
-    var sig = fragment.format();
+    const sig = fragment.format();
     if (sig === "Error(string)" || sig === "Panic(uint256)") {
-        logger.throwArgumentError("cannot specify user defined ".concat(sig, " error"), "fragment", fragment);
+        logger.throwArgumentError(`cannot specify user defined ${sig} error`, "fragment", fragment);
     }
     return fragment;
 }
-var ErrorFragment = /** @class */ (function (_super) {
-    __extends(ErrorFragment, _super);
-    function ErrorFragment() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ErrorFragment.prototype.format = function (format) {
+class ErrorFragment extends Fragment {
+    format(format) {
         if (!format) {
             format = exports.FormatTypes.sighash;
         }
@@ -799,39 +819,45 @@ var ErrorFragment = /** @class */ (function (_super) {
             return JSON.stringify({
                 type: "error",
                 name: this.name,
-                inputs: this.inputs.map(function (input) { return JSON.parse(input.format(format)); }),
+                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),
             });
         }
-        var result = "";
+        let result = "";
         if (format !== exports.FormatTypes.sighash) {
             result += "error ";
         }
-        result += this.name + "(" + this.inputs.map(function (input) { return input.format(format); }).join((format === exports.FormatTypes.full) ? ", " : ",") + ") ";
+        result +=
+            this.name +
+                "(" +
+                this.inputs
+                    .map((input) => input.format(format))
+                    .join(format === exports.FormatTypes.full ? ", " : ",") +
+                ") ";
         return result.trim();
-    };
-    ErrorFragment.from = function (value) {
-        if (typeof (value) === "string") {
+    }
+    static from(value) {
+        if (typeof value === "string") {
             return ErrorFragment.fromString(value);
         }
         return ErrorFragment.fromObject(value);
-    };
-    ErrorFragment.fromObject = function (value) {
+    }
+    static fromObject(value) {
         if (ErrorFragment.isErrorFragment(value)) {
             return value;
         }
         if (value.type !== "error") {
             logger.throwArgumentError("invalid error object", "value", value);
         }
-        var params = {
+        const params = {
             type: value.type,
             name: verifyIdentifier(value.name),
-            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : [])
+            inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
         };
         return checkForbidden(new ErrorFragment(_constructorGuard, params));
-    };
-    ErrorFragment.fromString = function (value) {
-        var params = { type: "error" };
-        var parens = value.match(regexParen);
+    }
+    static fromString(value) {
+        let params = { type: "error" };
+        let parens = value.match(regexParen);
         if (!parens) {
             logger.throwArgumentError("invalid error signature", "value", value);
         }
@@ -841,12 +867,11 @@ var ErrorFragment = /** @class */ (function (_super) {
         }
         params.inputs = parseParams(parens[2], false);
         return checkForbidden(ErrorFragment.fromObject(params));
-    };
-    ErrorFragment.isErrorFragment = function (value) {
-        return (value && value._isFragment && value.type === "error");
-    };
-    return ErrorFragment;
-}(Fragment));
+    }
+    static isErrorFragment(value) {
+        return value && value._isFragment && value.type === "error";
+    }
+}
 exports.ErrorFragment = ErrorFragment;
 function verifyType(type) {
     // These need to be transformed to their full description
@@ -860,21 +885,21 @@ function verifyType(type) {
     return type;
 }
 // See: https://github.com/ethereum/solidity/blob/1f8f1a3db93a548d0555e3e14cfc55a10e25b60e/docs/grammar/SolidityLexer.g4#L234
-var regexIdentifier = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$");
+const regexIdentifier = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$");
 function verifyIdentifier(value) {
     if (!value || !value.match(regexIdentifier)) {
-        logger.throwArgumentError("invalid identifier \"".concat(value, "\""), "value", value);
+        logger.throwArgumentError(`invalid identifier "${value}"`, "value", value);
     }
     return value;
 }
-var regexParen = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$");
+const 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];
+    let result = [];
+    let accum = "";
+    let depth = 0;
+    for (let offset = 0; offset < value.length; offset++) {
+        let c = value[offset];
         if (c === "," && depth === 0) {
             result.push(accum);
             accum = "";