@qevm/abi 5.7.2 → 5.7.3

package/src.ts/fragments.ts

@@ -1,9 +1,9 @@
 "use strict";
 
 import { BigNumber } from "@qevm/bignumber";
-import { defineReadOnly } from "@ethersproject/properties";
+import { defineReadOnly } from "@qevm/properties";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "./_version";
 const logger = new Logger(version);
 
@@ -29,38 +29,51 @@ export interface JsonFragment {
     readonly outputs?: ReadonlyArray<JsonFragmentType>;
 
     readonly gas?: string;
-};
+}
 
-const _constructorGuard = { };
+const _constructorGuard = {};
 
 // AST Node parser state
 type ParseState = {
-    allowArray?: boolean,
-    allowName?: boolean,
-    allowParams?: boolean,
-    allowType?: boolean,
-    readArray?: boolean,
+    allowArray?: boolean;
+    allowName?: boolean;
+    allowParams?: boolean;
+    allowType?: boolean;
+    readArray?: boolean;
 };
 
 // AST Node
 type ParseNode = {
-    parent?: any,
-    type?: string,
-    name?: string,
-    state?: ParseState,
-    indexed?: boolean,
-    components?: Array<ParseNode>
+    parent?: any;
+    type?: string;
+    name?: string;
+    state?: ParseState;
+    indexed?: boolean;
+    components?: Array<ParseNode>;
 };
 
-let ModifiersBytes: { [ name: string ]: boolean } = { calldata: true, memory: true, storage: true };
-let ModifiersNest: { [ name: string ]: boolean } = { calldata: true, memory: true };
+let ModifiersBytes: { [name: string]: boolean } = {
+    calldata: true,
+    memory: true,
+    storage: true,
+};
+let ModifiersNest: { [name: string]: boolean } = {
+    calldata: true,
+    memory: true,
+};
 function checkModifier(type: string, name: string): boolean {
     if (type === "bytes" || type === "string") {
-        if (ModifiersBytes[name]) { return true; }
+        if (ModifiersBytes[name]) {
+            return true;
+        }
     } else if (type === "address") {
-        if (name === "payable") { return true; }
+        if (name === "payable") {
+            return true;
+        }
     } else if (type.indexOf("[") >= 0 || type === "tuple") {
-        if (ModifiersNest[name]) { return true; }
+        if (ModifiersNest[name]) {
+            return true;
+        }
     }
     if (ModifiersBytes[name] || name === "payable") {
         logger.throwArgumentError("invalid modifier", "name", name);
@@ -70,17 +83,27 @@ function checkModifier(type: string, name: string): boolean {
 
 // @TODO: Make sure that children of an indexed tuple are marked with a null indexed
 function parseParamType(param: string, allowIndexed: boolean): ParseNode {
-
     let originalParam = param;
     function throwError(i: number) {
-        logger.throwArgumentError(`unexpected character at position ${ i }`, "param", param);
+        logger.throwArgumentError(
+            `unexpected character at position ${i}`,
+            "param",
+            param,
+        );
     }
     param = param.replace(/\s/g, " ");
 
     function newNode(parent: ParseNode): ParseNode {
-        let node: ParseNode = { type: "", name: "", parent: parent, state: { allowType: true } };
-        if (allowIndexed) { node.indexed = false; }
-        return node
+        let node: ParseNode = {
+            type: "",
+            name: "",
+            parent: parent,
+            state: { allowType: true },
+        };
+        if (allowIndexed) {
+            node.indexed = false;
+        }
+        return node;
     }
 
     let parent: ParseNode = { type: "", name: "", state: { allowType: true } };
@@ -97,7 +120,7 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 }
                 node.state.allowType = false;
                 node.type = verifyType(node.type);
-                node.components = [ newNode(node) ];
+                node.components = [newNode(node)];
                 node = node.components[0];
                 break;
 
@@ -105,18 +128,24 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 delete node.state;
 
                 if (node.name === "indexed") {
-                    if (!allowIndexed) { throwError(i); }
+                    if (!allowIndexed) {
+                        throwError(i);
+                    }
                     node.indexed = true;
                     node.name = "";
                 }
 
-                if (checkModifier(node.type, node.name)) { node.name = ""; }
+                if (checkModifier(node.type, node.name)) {
+                    node.name = "";
+                }
 
                 node.type = verifyType(node.type);
 
                 let child = node;
                 node = node.parent;
-                if (!node) { throwError(i); }
+                if (!node) {
+                    throwError(i);
+                }
                 delete child.parent;
                 node.state.allowParams = false;
                 node.state.allowName = true;
@@ -127,17 +156,21 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 delete node.state;
 
                 if (node.name === "indexed") {
-                    if (!allowIndexed) { throwError(i); }
+                    if (!allowIndexed) {
+                        throwError(i);
+                    }
                     node.indexed = true;
                     node.name = "";
                 }
 
-                if (checkModifier(node.type, node.name)) { node.name = ""; }
+                if (checkModifier(node.type, node.name)) {
+                    node.name = "";
+                }
 
                 node.type = verifyType(node.type);
 
                 let sibling: ParseNode = newNode(node.parent);
-                 //{ type: "", name: "", parent: node.parent, state: { allowType: true } };
+                //{ type: "", name: "", parent: node.parent, state: { allowType: true } };
                 node.parent.components.push(sibling);
                 delete node.parent;
                 node = sibling;
@@ -145,7 +178,6 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
 
             // 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 !== "") {
@@ -160,8 +192,12 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 if (node.state.allowName) {
                     if (node.name !== "") {
                         if (node.name === "indexed") {
-                            if (!allowIndexed) { throwError(i); }
-                            if (node.indexed) { throwError(i); }
+                            if (!allowIndexed) {
+                                throwError(i);
+                            }
+                            if (node.indexed) {
+                                throwError(i);
+                            }
                             node.indexed = true;
                             node.name = "";
                         } else if (checkModifier(node.type, node.name)) {
@@ -175,7 +211,9 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 break;
 
             case "[":
-                if (!node.state.allowArray) { throwError(i); }
+                if (!node.state.allowArray) {
+                    throwError(i);
+                }
 
                 node.type += c;
 
@@ -185,7 +223,9 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                 break;
 
             case "]":
-                if (!node.state.readArray) { throwError(i); }
+                if (!node.state.readArray) {
+                    throwError(i);
+                }
 
                 node.type += c;
 
@@ -206,17 +246,23 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
                     node.type += c;
                 } else {
                     throwError(i);
-               }
+                }
         }
     }
 
-    if (node.parent) { logger.throwArgumentError("unexpected eof", "param", param); }
+    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); }
+        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)) {
@@ -229,10 +275,12 @@ function parseParamType(param: string, allowIndexed: boolean): ParseNode {
 }
 
 function populate(object: any, params: any) {
-    for (let key in params) { defineReadOnly(object, key, params[key]); }
+    for (let key in params) {
+        defineReadOnly(object, key, params[key]);
+    }
 }
 
-export const FormatTypes: { [ name: string ]: string } = Object.freeze({
+export const FormatTypes: { [name: string]: string } = Object.freeze({
     // Bare formatting, as is needed for computing a sighash of an event or function
     sighash: "sighash",
 
@@ -243,13 +291,12 @@ export const FormatTypes: { [ name: string ]: string } = Object.freeze({
     full: "full",
 
     // JSON-format a la Solidity
-    json: "json"
+    json: "json",
 });
 
 const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
 
 export class ParamType {
-
     // The local name of the parameter (of null if unbound)
     readonly name: string;
 
@@ -275,9 +322,15 @@ export class ParamType {
     readonly _isParamType: boolean;
 
     constructor(constructorGuard: any, params: any) {
-        if (constructorGuard !== _constructorGuard) { logger.throwError("use fromString", Logger.errors.UNSUPPORTED_OPERATION, {
-            operation: "new ParamType()"
-        }); }
+        if (constructorGuard !== _constructorGuard) {
+            logger.throwError(
+                "use fromString",
+                Logger.errors.UNSUPPORTED_OPERATION,
+                {
+                    operation: "new ParamType()",
+                },
+            );
+        }
         populate(this, params);
 
         let match = this.type.match(paramTypeArray);
@@ -286,15 +339,15 @@ export class ParamType {
                 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,
             });
         }
 
@@ -308,19 +361,25 @@ export class ParamType {
     //   - minimal: "tuple(uint256,address) indexed"
     //   - full:    "tuple(uint256 foo, address bar) indexed baz"
     format(format?: string): string {
-        if (!format) { format = FormatTypes.sighash; }
+        if (!format) {
+            format = FormatTypes.sighash;
+        }
         if (!FormatTypes[format]) {
             logger.throwArgumentError("invalid format type", "format", format);
         }
 
         if (format === FormatTypes.json) {
             let result: any = {
-                type: ((this.baseType === "tuple") ? "tuple": this.type),
-                name: (this.name || undefined)
+                type: this.baseType === "tuple" ? "tuple" : this.type,
+                name: this.name || undefined,
             };
-            if (typeof(this.indexed) === "boolean") { result.indexed = this.indexed; }
+            if (typeof this.indexed === "boolean") {
+                result.indexed = this.indexed;
+            }
             if (this.components) {
-                result.components = this.components.map((comp) => JSON.parse(comp.format(format)));
+                result.components = this.components.map((comp) =>
+                    JSON.parse(comp.format(format)),
+                );
             }
             return JSON.stringify(result);
         }
@@ -330,22 +389,30 @@ export class ParamType {
         // 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 !== FormatTypes.sighash) {
                     result += this.type;
                 }
-                result += "(" + this.components.map(
-                    (comp) => comp.format(format)
-                ).join((format === FormatTypes.full) ? ", ": ",") + ")";
+                result +=
+                    "(" +
+                    this.components
+                        .map((comp) => comp.format(format))
+                        .join(format === FormatTypes.full ? ", " : ",") +
+                    ")";
             } else {
                 result += this.type;
             }
         }
 
         if (format !== FormatTypes.sighash) {
-            if (this.indexed === true) { result += " indexed"; }
+            if (this.indexed === true) {
+                result += " indexed";
+            }
             if (format === FormatTypes.full && this.name) {
                 result += " " + this.name;
             }
@@ -354,21 +421,28 @@ export class ParamType {
         return result;
     }
 
-    static from(value: string | JsonFragmentType | ParamType, allowIndexed?: boolean): ParamType {
-        if (typeof(value) === "string") {
+    static from(
+        value: string | JsonFragmentType | ParamType,
+        allowIndexed?: boolean,
+    ): ParamType {
+        if (typeof value === "string") {
             return ParamType.fromString(value, allowIndexed);
         }
         return ParamType.fromObject(value);
     }
 
     static fromObject(value: JsonFragmentType | ParamType): ParamType {
-        if (ParamType.isParamType(value)) { return 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,
         });
     }
 
@@ -378,7 +452,7 @@ export class ParamType {
                 name: node.name,
                 type: node.type,
                 indexed: node.indexed,
-                components: node.components
+                components: node.components,
             });
         }
 
@@ -388,13 +462,15 @@ export class ParamType {
     static isParamType(value: any): value is ParamType {
         return !!(value != null && value._isParamType);
     }
-};
+}
 
 function parseParams(value: string, allowIndex: boolean): Array<ParamType> {
-    return splitNesting(value).map((param) => ParamType.fromString(param, allowIndex));
+    return splitNesting(value).map((param) =>
+        ParamType.fromString(param, allowIndex),
+    );
 }
 
-type TypeCheck<T> = { -readonly [ K in keyof T ]: T[K] };
+type TypeCheck<T> = { -readonly [K in keyof T]: T[K] };
 
 interface _Fragment {
     readonly type: string;
@@ -403,7 +479,6 @@ interface _Fragment {
 }
 
 export abstract class Fragment {
-
     readonly type: string;
     readonly name: string;
     readonly inputs: Array<ParamType>;
@@ -412,9 +487,13 @@ export abstract class Fragment {
 
     constructor(constructorGuard: any, params: any) {
         if (constructorGuard !== _constructorGuard) {
-            logger.throwError("use a static from method", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "new Fragment()"
-            });
+            logger.throwError(
+                "use a static from method",
+                Logger.errors.UNSUPPORTED_OPERATION,
+                {
+                    operation: "new Fragment()",
+                },
+            );
         }
         populate(this, params);
 
@@ -426,9 +505,11 @@ export abstract class Fragment {
     abstract format(format?: string): string;
 
     static from(value: Fragment | JsonFragment | string): Fragment {
-        if (Fragment.isFragment(value)) { return value; }
+        if (Fragment.isFragment(value)) {
+            return value;
+        }
 
-        if (typeof(value) === "string") {
+        if (typeof value === "string") {
             return Fragment.fromString(value);
         }
 
@@ -436,7 +517,9 @@ export abstract class Fragment {
     }
 
     static fromObject(value: Fragment | JsonFragment): Fragment {
-        if (Fragment.isFragment(value)) { return value; }
+        if (Fragment.isFragment(value)) {
+            return value;
+        }
 
         switch (value.type) {
             case "function":
@@ -453,26 +536,37 @@ export abstract class Fragment {
                 return null;
         }
 
-        return logger.throwArgumentError("invalid fragment object", "value", value);
+        return logger.throwArgumentError(
+            "invalid fragment object",
+            "value",
+            value,
+        );
     }
 
     static fromString(value: string): Fragment {
         // 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());
+            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());
         } else if (value.split(" ")[0] === "error") {
-           return ErrorFragment.fromString(value.substring(5).trim());
+            return ErrorFragment.fromString(value.substring(5).trim());
         }
 
-        return logger.throwArgumentError("unsupported fragment", "value", value);
+        return logger.throwArgumentError(
+            "unsupported fragment",
+            "value",
+            value,
+        );
     }
 
     static isFragment(value: any): value is Fragment {
@@ -488,7 +582,9 @@ export class EventFragment extends Fragment {
     readonly anonymous: boolean;
 
     format(format?: string): string {
-        if (!format) { format = FormatTypes.sighash; }
+        if (!format) {
+            format = FormatTypes.sighash;
+        }
         if (!FormatTypes[format]) {
             logger.throwArgumentError("invalid format type", "format", format);
         }
@@ -498,7 +594,9 @@ export class EventFragment extends Fragment {
                 type: "event",
                 anonymous: this.anonymous,
                 name: this.name,
-                inputs: this.inputs.map((input) => JSON.parse(input.format(format)))
+                inputs: this.inputs.map((input) =>
+                    JSON.parse(input.format(format)),
+                ),
             });
         }
 
@@ -508,9 +606,13 @@ export class EventFragment extends Fragment {
             result += "event ";
         }
 
-        result += this.name + "(" + this.inputs.map(
-            (input) => input.format(format)
-        ).join((format === FormatTypes.full) ? ", ": ",") + ") ";
+        result +=
+            this.name +
+            "(" +
+            this.inputs
+                .map((input) => input.format(format))
+                .join(format === FormatTypes.full ? ", " : ",") +
+            ") ";
 
         if (format !== FormatTypes.sighash) {
             if (this.anonymous) {
@@ -522,14 +624,16 @@ export class EventFragment extends Fragment {
     }
 
     static from(value: EventFragment | JsonFragment | string): EventFragment {
-        if (typeof(value) === "string") {
+        if (typeof value === "string") {
             return EventFragment.fromString(value);
         }
         return EventFragment.fromObject(value);
     }
 
     static fromObject(value: JsonFragment | EventFragment): EventFragment {
-        if (EventFragment.isEventFragment(value)) { return value; }
+        if (EventFragment.isEventFragment(value)) {
+            return value;
+        }
 
         if (value.type !== "event") {
             logger.throwArgumentError("invalid event object", "value", value);
@@ -538,15 +642,14 @@ export class EventFragment extends Fragment {
         const params: TypeCheck<_EventFragment> = {
             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);
     }
 
     static fromString(value: string): EventFragment {
-
         let match = value.match(regexParen);
         if (!match) {
             logger.throwArgumentError("invalid event string", "value", value);
@@ -554,7 +657,7 @@ export class EventFragment extends Fragment {
 
         let anonymous = false;
         match[3].split(" ").forEach((modifier) => {
-            switch(modifier.trim()) {
+            switch (modifier.trim()) {
                 case "anonymous":
                     anonymous = true;
                     break;
@@ -569,12 +672,12 @@ export class EventFragment extends Fragment {
             name: match[1].trim(),
             anonymous: anonymous,
             inputs: parseParams(match[2], true),
-            type: "event"
+            type: "event",
         });
     }
 
     static isEventFragment(value: any): value is EventFragment {
-        return (value && value._isFragment && value.type === "event");
+        return value && value._isFragment && value.type === "event";
     }
 }
 
@@ -584,10 +687,18 @@ function parseGas(value: string, params: any): string {
     let comps = value.split("@");
     if (comps.length !== 1) {
         if (comps.length > 2) {
-            logger.throwArgumentError("invalid human-readable ABI signature", "value", value);
+            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);
+            logger.throwArgumentError(
+                "invalid human-readable ABI signature gas",
+                "value",
+                value,
+            );
         }
         params.gas = BigNumber.from(comps[1]);
         return comps[0];
@@ -649,34 +760,53 @@ function verifyState(value: StateInputValue): StateOutputValue {
     let result: any = {
         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") {
-            logger.throwArgumentError("unable to determine stateMutability", "value", value);
+        if (
+            value.constant == null &&
+            !result.payable &&
+            value.type !== "constructor"
+        ) {
+            logger.throwArgumentError(
+                "unable to determine stateMutability",
+                "value",
+                value,
+            );
         }
 
         result.constant = !!value.constant;
@@ -684,20 +814,26 @@ function verifyState(value: StateInputValue): StateOutputValue {
         if (result.constant) {
             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);
+            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");
-
+        result.stateMutability = result.constant ? "view" : "payable";
     } else if (value.type !== "constructor") {
-        logger.throwArgumentError("unable to determine stateMutability", "value", value);
+        logger.throwArgumentError(
+            "unable to determine stateMutability",
+            "value",
+            value,
+        );
     }
 
     return result;
@@ -715,7 +851,9 @@ export class ConstructorFragment extends Fragment {
     gas?: BigNumber;
 
     format(format?: string): string {
-        if (!format) { format = FormatTypes.sighash; }
+        if (!format) {
+            format = FormatTypes.sighash;
+        }
         if (!FormatTypes[format]) {
             logger.throwArgumentError("invalid format type", "format", format);
         }
@@ -723,22 +861,34 @@ export class ConstructorFragment extends Fragment {
         if (format === 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((input) => JSON.parse(input.format(format)))
+                gas: this.gas ? this.gas.toNumber() : undefined,
+                inputs: this.inputs.map((input) =>
+                    JSON.parse(input.format(format)),
+                ),
             });
         }
 
         if (format === FormatTypes.sighash) {
-            logger.throwError("cannot format a constructor for sighash", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "format(sighash)"
-            });
+            logger.throwError(
+                "cannot format a constructor for sighash",
+                Logger.errors.UNSUPPORTED_OPERATION,
+                {
+                    operation: "format(sighash)",
+                },
+            );
         }
 
-        let result = "constructor(" + this.inputs.map(
-            (input) => input.format(format)
-        ).join((format === FormatTypes.full) ? ", ": ",") + ") ";
+        let result =
+            "constructor(" +
+            this.inputs
+                .map((input) => input.format(format))
+                .join(format === FormatTypes.full ? ", " : ",") +
+            ") ";
 
         if (this.stateMutability && this.stateMutability !== "nonpayable") {
             result += this.stateMutability + " ";
@@ -747,32 +897,46 @@ export class ConstructorFragment extends Fragment {
         return result.trim();
     }
 
-    static from(value: ConstructorFragment | JsonFragment | string): ConstructorFragment {
-        if (typeof(value) === "string") {
+    static from(
+        value: ConstructorFragment | JsonFragment | string,
+    ): ConstructorFragment {
+        if (typeof value === "string") {
             return ConstructorFragment.fromString(value);
         }
         return ConstructorFragment.fromObject(value);
     }
 
-    static fromObject(value: ConstructorFragment | JsonFragment): ConstructorFragment {
-        if (ConstructorFragment.isConstructorFragment(value)) { return value; }
+    static fromObject(
+        value: ConstructorFragment | JsonFragment,
+    ): ConstructorFragment {
+        if (ConstructorFragment.isConstructorFragment(value)) {
+            return value;
+        }
 
         if (value.type !== "constructor") {
-            logger.throwArgumentError("invalid constructor object", "value", value);
+            logger.throwArgumentError(
+                "invalid constructor object",
+                "value",
+                value,
+            );
         }
 
         let state = verifyState(value);
         if (state.constant) {
-            logger.throwArgumentError("constructor cannot be constant", "value", value);
+            logger.throwArgumentError(
+                "constructor cannot be constant",
+                "value",
+                value,
+            );
         }
 
         const params: TypeCheck<_ConstructorFragment> = {
             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.from(value.gas): null)
+            gas: value.gas ? BigNumber.from(value.gas) : null,
         };
 
         return new ConstructorFragment(_constructorGuard, params);
@@ -785,7 +949,11 @@ export class ConstructorFragment extends Fragment {
 
         let parens = value.match(regexParen);
         if (!parens || parens[1].trim() !== "constructor") {
-            logger.throwArgumentError("invalid constructor string", "value", value);
+            logger.throwArgumentError(
+                "invalid constructor string",
+                "value",
+                value,
+            );
         }
 
         params.inputs = parseParams(parens[2].trim(), false);
@@ -796,7 +964,7 @@ export class ConstructorFragment extends Fragment {
     }
 
     static isConstructorFragment(value: any): value is ConstructorFragment {
-        return (value && value._isFragment && value.type === "constructor");
+        return value && value._isFragment && value.type === "constructor";
     }
 }
 
@@ -810,7 +978,9 @@ export class FunctionFragment extends ConstructorFragment {
     outputs?: Array<ParamType>;
 
     format(format?: string): string {
-        if (!format) { format = FormatTypes.sighash; }
+        if (!format) {
+            format = FormatTypes.sighash;
+        }
         if (!FormatTypes[format]) {
             logger.throwArgumentError("invalid format type", "format", format);
         }
@@ -820,11 +990,18 @@ export class FunctionFragment extends ConstructorFragment {
                 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((input) => JSON.parse(input.format(format))),
-                outputs: this.outputs.map((output) => 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)),
+                ),
             });
         }
 
@@ -834,23 +1011,30 @@ export class FunctionFragment extends ConstructorFragment {
             result += "function ";
         }
 
-        result += this.name + "(" + this.inputs.map(
-            (input) => input.format(format)
-        ).join((format === FormatTypes.full) ? ", ": ",") + ") ";
+        result +=
+            this.name +
+            "(" +
+            this.inputs
+                .map((input) => input.format(format))
+                .join(format === FormatTypes.full ? ", " : ",") +
+            ") ";
 
         if (format !== 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(
-                    (output) => output.format(format)
-                ).join(", ") + ") ";
+                result +=
+                    "returns (" +
+                    this.outputs
+                        .map((output) => output.format(format))
+                        .join(", ") +
+                    ") ";
             }
 
             if (this.gas != null) {
@@ -861,18 +1045,28 @@ export class FunctionFragment extends ConstructorFragment {
         return result.trim();
     }
 
-    static from(value: FunctionFragment | JsonFragment | string): FunctionFragment {
-        if (typeof(value) === "string") {
+    static from(
+        value: FunctionFragment | JsonFragment | string,
+    ): FunctionFragment {
+        if (typeof value === "string") {
             return FunctionFragment.fromString(value);
         }
         return FunctionFragment.fromObject(value);
     }
 
-    static fromObject(value: FunctionFragment | JsonFragment): FunctionFragment {
-        if (FunctionFragment.isFunctionFragment(value)) { return value; }
+    static fromObject(
+        value: FunctionFragment | JsonFragment,
+    ): FunctionFragment {
+        if (FunctionFragment.isFunctionFragment(value)) {
+            return value;
+        }
 
         if (value.type !== "function") {
-            logger.throwArgumentError("invalid function object", "value", value);
+            logger.throwArgumentError(
+                "invalid function object",
+                "value",
+                value,
+            );
         }
 
         let state = verifyState(value);
@@ -881,11 +1075,13 @@ export class FunctionFragment extends ConstructorFragment {
             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.from(value.gas): null)
+            gas: value.gas ? BigNumber.from(value.gas) : null,
         };
 
         return new FunctionFragment(_constructorGuard, params);
@@ -897,16 +1093,26 @@ export class FunctionFragment extends ConstructorFragment {
 
         let comps = value.split(" returns ");
         if (comps.length > 2) {
-            logger.throwArgumentError("invalid function string", "value", value);
+            logger.throwArgumentError(
+                "invalid function string",
+                "value",
+                value,
+            );
         }
 
         let parens = comps[0].match(regexParen);
         if (!parens) {
-            logger.throwArgumentError("invalid function signature", "value", value);
+            logger.throwArgumentError(
+                "invalid function signature",
+                "value",
+                value,
+            );
         }
 
         params.name = parens[1].trim();
-        if (params.name) { verifyIdentifier(params.name); }
+        if (params.name) {
+            verifyIdentifier(params.name);
+        }
 
         params.inputs = parseParams(parens[2], false);
 
@@ -914,20 +1120,20 @@ export class FunctionFragment extends ConstructorFragment {
 
         // We have outputs
         if (comps.length > 1) {
-           let returns = comps[1].match(regexParen);
+            let 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 = [ ];
+            params.outputs = [];
         }
 
         return FunctionFragment.fromObject(params);
     }
 
     static isFunctionFragment(value: any): value is FunctionFragment {
-        return (value && value._isFragment && value.type === "function");
+        return value && value._isFragment && value.type === "function";
     }
 }
 
@@ -937,15 +1143,20 @@ export class FunctionFragment extends ConstructorFragment {
 function checkForbidden(fragment: ErrorFragment): ErrorFragment {
     const sig = fragment.format();
     if (sig === "Error(string)" || sig === "Panic(uint256)") {
-        logger.throwArgumentError(`cannot specify user defined ${ sig } error`, "fragment", fragment);
+        logger.throwArgumentError(
+            `cannot specify user defined ${sig} error`,
+            "fragment",
+            fragment,
+        );
     }
     return fragment;
 }
 
 export class ErrorFragment extends Fragment {
-
     format(format?: string): string {
-        if (!format) { format = FormatTypes.sighash; }
+        if (!format) {
+            format = FormatTypes.sighash;
+        }
         if (!FormatTypes[format]) {
             logger.throwArgumentError("invalid format type", "format", format);
         }
@@ -954,7 +1165,9 @@ export class ErrorFragment extends Fragment {
             return JSON.stringify({
                 type: "error",
                 name: this.name,
-                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),
+                inputs: this.inputs.map((input) =>
+                    JSON.parse(input.format(format)),
+                ),
             });
         }
 
@@ -964,22 +1177,28 @@ export class ErrorFragment extends Fragment {
             result += "error ";
         }
 
-        result += this.name + "(" + this.inputs.map(
-            (input) => input.format(format)
-        ).join((format === FormatTypes.full) ? ", ": ",") + ") ";
+        result +=
+            this.name +
+            "(" +
+            this.inputs
+                .map((input) => input.format(format))
+                .join(format === FormatTypes.full ? ", " : ",") +
+            ") ";
 
         return result.trim();
     }
 
     static from(value: ErrorFragment | JsonFragment | string): ErrorFragment {
-        if (typeof(value) === "string") {
+        if (typeof value === "string") {
             return ErrorFragment.fromString(value);
         }
         return ErrorFragment.fromObject(value);
     }
 
     static fromObject(value: ErrorFragment | JsonFragment): ErrorFragment {
-        if (ErrorFragment.isErrorFragment(value)) { return value; }
+        if (ErrorFragment.isErrorFragment(value)) {
+            return value;
+        }
 
         if (value.type !== "error") {
             logger.throwArgumentError("invalid error object", "value", value);
@@ -988,7 +1207,7 @@ export class ErrorFragment extends Fragment {
         const params: TypeCheck<_Fragment> = {
             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));
@@ -999,11 +1218,17 @@ export class ErrorFragment extends Fragment {
 
         let parens = value.match(regexParen);
         if (!parens) {
-            logger.throwArgumentError("invalid error signature", "value", value);
+            logger.throwArgumentError(
+                "invalid error signature",
+                "value",
+                value,
+            );
         }
 
         params.name = parens[1].trim();
-        if (params.name) { verifyIdentifier(params.name); }
+        if (params.name) {
+            verifyIdentifier(params.name);
+        }
 
         params.inputs = parseParams(parens[2], false);
 
@@ -1011,12 +1236,11 @@ export class ErrorFragment extends Fragment {
     }
 
     static isErrorFragment(value: any): value is ErrorFragment {
-        return (value && value._isFragment && value.type === "error");
+        return value && value._isFragment && value.type === "error";
     }
 }
 
 function verifyType(type: string): string {
-
     // These need to be transformed to their full description
     if (type.match(/^uint($|[^1-9])/)) {
         type = "uint256" + type.substring(4);
@@ -1033,7 +1257,11 @@ function verifyType(type: string): string {
 const regexIdentifier = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$");
 function verifyIdentifier(value: string): string {
     if (!value || !value.match(regexIdentifier)) {
-        logger.throwArgumentError(`invalid identifier "${ value }"`, "value", value);
+        logger.throwArgumentError(
+            `invalid identifier "${value}"`,
+            "value",
+            value,
+        );
     }
     return value;
 }
@@ -1058,13 +1286,18 @@ function splitNesting(value: string): Array<any> {
             } else if (c === ")") {
                 depth--;
                 if (depth === -1) {
-                    logger.throwArgumentError("unbalanced parenthesis", "value", value);
+                    logger.throwArgumentError(
+                        "unbalanced parenthesis",
+                        "value",
+                        value,
+                    );
                 }
             }
         }
     }
-    if (accum) { result.push(accum); }
+    if (accum) {
+        result.push(accum);
+    }
 
     return result;
 }
-