@qevm/abi 5.7.1 → 5.7.2

package/lib/interface.js

@@ -1,40 +1,75 @@
 "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.Interface = exports.Indexed = exports.ErrorDescription = exports.TransactionDescription = exports.LogDescription = exports.checkResultErrors = void 0;
-const address_1 = require("@qevm/address");
-const bignumber_1 = require("@qevm/bignumber");
-const bytes_1 = require("@qevm/bytes");
-const hash_1 = require("@qevm/hash");
-const keccak256_1 = require("@ethersproject/keccak256");
-const properties_1 = require("@ethersproject/properties");
-const abi_coder_1 = require("./abi-coder");
-const abstract_coder_1 = require("./coders/abstract-coder");
+var address_1 = require("@qevm/address");
+var bignumber_1 = require("@qevm/bignumber");
+var bytes_1 = require("@qevm/bytes");
+var hash_1 = require("@qevm/hash");
+var keccak256_1 = require("@qevm/keccak256");
+var properties_1 = require("@ethersproject/properties");
+var abi_coder_1 = require("./abi-coder");
+var abstract_coder_1 = require("./coders/abstract-coder");
 Object.defineProperty(exports, "checkResultErrors", { enumerable: true, get: function () { return abstract_coder_1.checkResultErrors; } });
-const fragments_1 = require("./fragments");
-const logger_1 = require("@ethersproject/logger");
-const _version_1 = require("./_version");
-const logger = new logger_1.Logger(_version_1.version);
-class LogDescription extends properties_1.Description {
-}
+var fragments_1 = require("./fragments");
+var logger_1 = require("@ethersproject/logger");
+var _version_1 = require("./_version");
+var logger = new logger_1.Logger(_version_1.version);
+var LogDescription = /** @class */ (function (_super) {
+    __extends(LogDescription, _super);
+    function LogDescription() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return LogDescription;
+}(properties_1.Description));
 exports.LogDescription = LogDescription;
-class TransactionDescription extends properties_1.Description {
-}
+var TransactionDescription = /** @class */ (function (_super) {
+    __extends(TransactionDescription, _super);
+    function TransactionDescription() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return TransactionDescription;
+}(properties_1.Description));
 exports.TransactionDescription = TransactionDescription;
-class ErrorDescription extends properties_1.Description {
-}
+var ErrorDescription = /** @class */ (function (_super) {
+    __extends(ErrorDescription, _super);
+    function ErrorDescription() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return ErrorDescription;
+}(properties_1.Description));
 exports.ErrorDescription = ErrorDescription;
-class Indexed extends properties_1.Description {
-    static isIndexed(value) {
-        return !!(value && value._isIndexed);
+var Indexed = /** @class */ (function (_super) {
+    __extends(Indexed, _super);
+    function Indexed() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
+    Indexed.isIndexed = function (value) {
+        return !!(value && value._isIndexed);
+    };
+    return Indexed;
+}(properties_1.Description));
 exports.Indexed = Indexed;
-const BuiltinErrors = {
+var BuiltinErrors = {
     "0x08c379a0": { signature: "Error(string)", name: "Error", inputs: ["string"], reason: true },
     "0x4e487b71": { signature: "Panic(uint256)", name: "Panic", inputs: ["uint256"] }
 };
 function wrapAccessError(property, error) {
-    const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`);
+    var wrap = new Error("deferred error during ABI decoding triggered accessing ".concat(property));
     wrap.error = error;
     return wrap;
 }
@@ -51,51 +86,53 @@ function checkNames(fragment: Fragment, type: "input" | "output", params: Array<
     }, <{ [ name: string ]: boolean }>{ });
 }
 */
-class Interface {
-    constructor(fragments) {
-        let abi = [];
+var Interface = /** @class */ (function () {
+    function Interface(fragments) {
+        var _newTarget = this.constructor;
+        var _this = this;
+        var abi = [];
         if (typeof (fragments) === "string") {
             abi = JSON.parse(fragments);
         }
         else {
             abi = fragments;
         }
-        (0, properties_1.defineReadOnly)(this, "fragments", abi.map((fragment) => {
+        (0, properties_1.defineReadOnly)(this, "fragments", abi.map(function (fragment) {
             return fragments_1.Fragment.from(fragment);
-        }).filter((fragment) => (fragment != null)));
-        (0, properties_1.defineReadOnly)(this, "_abiCoder", (0, properties_1.getStatic)(new.target, "getAbiCoder")());
+        }).filter(function (fragment) { return (fragment != null); }));
+        (0, properties_1.defineReadOnly)(this, "_abiCoder", (0, properties_1.getStatic)(_newTarget, "getAbiCoder")());
         (0, properties_1.defineReadOnly)(this, "functions", {});
         (0, properties_1.defineReadOnly)(this, "errors", {});
         (0, properties_1.defineReadOnly)(this, "events", {});
         (0, properties_1.defineReadOnly)(this, "structs", {});
         // Add all fragments by their signature
-        this.fragments.forEach((fragment) => {
-            let bucket = null;
+        this.fragments.forEach(function (fragment) {
+            var bucket = null;
             switch (fragment.type) {
                 case "constructor":
-                    if (this.deploy) {
+                    if (_this.deploy) {
                         logger.warn("duplicate definition - constructor");
                         return;
                     }
                     //checkNames(fragment, "input", fragment.inputs);
-                    (0, properties_1.defineReadOnly)(this, "deploy", fragment);
+                    (0, properties_1.defineReadOnly)(_this, "deploy", fragment);
                     return;
                 case "function":
                     //checkNames(fragment, "input", fragment.inputs);
                     //checkNames(fragment, "output", (<FunctionFragment>fragment).outputs);
-                    bucket = this.functions;
+                    bucket = _this.functions;
                     break;
                 case "event":
                     //checkNames(fragment, "input", fragment.inputs);
-                    bucket = this.events;
+                    bucket = _this.events;
                     break;
                 case "error":
-                    bucket = this.errors;
+                    bucket = _this.errors;
                     break;
                 default:
                     return;
             }
-            let signature = fragment.format();
+            var signature = fragment.format();
             if (bucket[signature]) {
                 logger.warn("duplicate definition - " + signature);
                 return;
@@ -111,125 +148,125 @@ class Interface {
         }
         (0, properties_1.defineReadOnly)(this, "_isInterface", true);
     }
-    format(format) {
+    Interface.prototype.format = function (format) {
         if (!format) {
             format = fragments_1.FormatTypes.full;
         }
         if (format === fragments_1.FormatTypes.sighash) {
             logger.throwArgumentError("interface does not support formatting sighash", "format", format);
         }
-        const abi = this.fragments.map((fragment) => fragment.format(format));
+        var abi = this.fragments.map(function (fragment) { return fragment.format(format); });
         // We need to re-bundle the JSON fragments a bit
         if (format === fragments_1.FormatTypes.json) {
-            return JSON.stringify(abi.map((j) => JSON.parse(j)));
+            return JSON.stringify(abi.map(function (j) { return JSON.parse(j); }));
         }
         return abi;
-    }
+    };
     // Sub-classes can override these to handle other blockchains
-    static getAbiCoder() {
+    Interface.getAbiCoder = function () {
         return abi_coder_1.defaultAbiCoder;
-    }
-    static getAddress(address) {
+    };
+    Interface.getAddress = function (address) {
         return (0, address_1.getAddress)(address);
-    }
-    static getSighash(fragment) {
+    };
+    Interface.getSighash = function (fragment) {
         return (0, bytes_1.hexDataSlice)((0, hash_1.id)(fragment.format()), 0, 4);
-    }
-    static getEventTopic(eventFragment) {
+    };
+    Interface.getEventTopic = function (eventFragment) {
         return (0, hash_1.id)(eventFragment.format());
-    }
+    };
     // Find a function definition by any means necessary (unless it is ambiguous)
-    getFunction(nameOrSignatureOrSighash) {
+    Interface.prototype.getFunction = function (nameOrSignatureOrSighash) {
         if ((0, bytes_1.isHexString)(nameOrSignatureOrSighash)) {
-            for (const name in this.functions) {
-                if (nameOrSignatureOrSighash === this.getSighash(name)) {
-                    return this.functions[name];
+            for (var name_1 in this.functions) {
+                if (nameOrSignatureOrSighash === this.getSighash(name_1)) {
+                    return this.functions[name_1];
                 }
             }
             logger.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash);
         }
         // It is a bare name, look up the function (will return null if ambiguous)
         if (nameOrSignatureOrSighash.indexOf("(") === -1) {
-            const name = nameOrSignatureOrSighash.trim();
-            const matching = Object.keys(this.functions).filter((f) => (f.split("(" /* fix:) */)[0] === name));
+            var name_2 = nameOrSignatureOrSighash.trim();
+            var matching = Object.keys(this.functions).filter(function (f) { return (f.split("(" /* fix:) */)[0] === name_2); });
             if (matching.length === 0) {
-                logger.throwArgumentError("no matching function", "name", name);
+                logger.throwArgumentError("no matching function", "name", name_2);
             }
             else if (matching.length > 1) {
-                logger.throwArgumentError("multiple matching functions", "name", name);
+                logger.throwArgumentError("multiple matching functions", "name", name_2);
             }
             return this.functions[matching[0]];
         }
         // Normalize the signature and lookup the function
-        const result = this.functions[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
+        var result = this.functions[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
         if (!result) {
             logger.throwArgumentError("no matching function", "signature", nameOrSignatureOrSighash);
         }
         return result;
-    }
+    };
     // Find an event definition by any means necessary (unless it is ambiguous)
-    getEvent(nameOrSignatureOrTopic) {
+    Interface.prototype.getEvent = function (nameOrSignatureOrTopic) {
         if ((0, bytes_1.isHexString)(nameOrSignatureOrTopic)) {
-            const topichash = nameOrSignatureOrTopic.toLowerCase();
-            for (const name in this.events) {
-                if (topichash === this.getEventTopic(name)) {
-                    return this.events[name];
+            var topichash = nameOrSignatureOrTopic.toLowerCase();
+            for (var name_3 in this.events) {
+                if (topichash === this.getEventTopic(name_3)) {
+                    return this.events[name_3];
                 }
             }
             logger.throwArgumentError("no matching event", "topichash", topichash);
         }
         // It is a bare name, look up the function (will return null if ambiguous)
         if (nameOrSignatureOrTopic.indexOf("(") === -1) {
-            const name = nameOrSignatureOrTopic.trim();
-            const matching = Object.keys(this.events).filter((f) => (f.split("(" /* fix:) */)[0] === name));
+            var name_4 = nameOrSignatureOrTopic.trim();
+            var matching = Object.keys(this.events).filter(function (f) { return (f.split("(" /* fix:) */)[0] === name_4); });
             if (matching.length === 0) {
-                logger.throwArgumentError("no matching event", "name", name);
+                logger.throwArgumentError("no matching event", "name", name_4);
             }
             else if (matching.length > 1) {
-                logger.throwArgumentError("multiple matching events", "name", name);
+                logger.throwArgumentError("multiple matching events", "name", name_4);
             }
             return this.events[matching[0]];
         }
         // Normalize the signature and lookup the function
-        const result = this.events[fragments_1.EventFragment.fromString(nameOrSignatureOrTopic).format()];
+        var result = this.events[fragments_1.EventFragment.fromString(nameOrSignatureOrTopic).format()];
         if (!result) {
             logger.throwArgumentError("no matching event", "signature", nameOrSignatureOrTopic);
         }
         return result;
-    }
+    };
     // Find a function definition by any means necessary (unless it is ambiguous)
-    getError(nameOrSignatureOrSighash) {
+    Interface.prototype.getError = function (nameOrSignatureOrSighash) {
         if ((0, bytes_1.isHexString)(nameOrSignatureOrSighash)) {
-            const getSighash = (0, properties_1.getStatic)(this.constructor, "getSighash");
-            for (const name in this.errors) {
-                const error = this.errors[name];
+            var getSighash = (0, properties_1.getStatic)(this.constructor, "getSighash");
+            for (var name_5 in this.errors) {
+                var error = this.errors[name_5];
                 if (nameOrSignatureOrSighash === getSighash(error)) {
-                    return this.errors[name];
+                    return this.errors[name_5];
                 }
             }
             logger.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash);
         }
         // It is a bare name, look up the function (will return null if ambiguous)
         if (nameOrSignatureOrSighash.indexOf("(") === -1) {
-            const name = nameOrSignatureOrSighash.trim();
-            const matching = Object.keys(this.errors).filter((f) => (f.split("(" /* fix:) */)[0] === name));
+            var name_6 = nameOrSignatureOrSighash.trim();
+            var matching = Object.keys(this.errors).filter(function (f) { return (f.split("(" /* fix:) */)[0] === name_6); });
             if (matching.length === 0) {
-                logger.throwArgumentError("no matching error", "name", name);
+                logger.throwArgumentError("no matching error", "name", name_6);
             }
             else if (matching.length > 1) {
-                logger.throwArgumentError("multiple matching errors", "name", name);
+                logger.throwArgumentError("multiple matching errors", "name", name_6);
             }
             return this.errors[matching[0]];
         }
         // Normalize the signature and lookup the function
-        const result = this.errors[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
+        var result = this.errors[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
         if (!result) {
             logger.throwArgumentError("no matching error", "signature", nameOrSignatureOrSighash);
         }
         return result;
-    }
+    };
     // Get the sighash (the bytes4 selector) used by Solidity to identify a function
-    getSighash(fragment) {
+    Interface.prototype.getSighash = function (fragment) {
         if (typeof (fragment) === "string") {
             try {
                 fragment = this.getFunction(fragment);
@@ -244,34 +281,34 @@ class Interface {
             }
         }
         return (0, properties_1.getStatic)(this.constructor, "getSighash")(fragment);
-    }
+    };
     // Get the topic (the bytes32 hash) used by Solidity to identify an event
-    getEventTopic(eventFragment) {
+    Interface.prototype.getEventTopic = function (eventFragment) {
         if (typeof (eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
         return (0, properties_1.getStatic)(this.constructor, "getEventTopic")(eventFragment);
-    }
-    _decodeParams(params, data) {
+    };
+    Interface.prototype._decodeParams = function (params, data) {
         return this._abiCoder.decode(params, data);
-    }
-    _encodeParams(params, values) {
+    };
+    Interface.prototype._encodeParams = function (params, values) {
         return this._abiCoder.encode(params, values);
-    }
-    encodeDeploy(values) {
+    };
+    Interface.prototype.encodeDeploy = function (values) {
         return this._encodeParams(this.deploy.inputs, values || []);
-    }
-    decodeErrorResult(fragment, data) {
+    };
+    Interface.prototype.decodeErrorResult = function (fragment, data) {
         if (typeof (fragment) === "string") {
             fragment = this.getError(fragment);
         }
-        const bytes = (0, bytes_1.arrayify)(data);
+        var bytes = (0, bytes_1.arrayify)(data);
         if ((0, bytes_1.hexlify)(bytes.slice(0, 4)) !== this.getSighash(fragment)) {
-            logger.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", (0, bytes_1.hexlify)(bytes));
+            logger.throwArgumentError("data signature does not match error ".concat(fragment.name, "."), "data", (0, bytes_1.hexlify)(bytes));
         }
         return this._decodeParams(fragment.inputs, bytes.slice(4));
-    }
-    encodeErrorResult(fragment, values) {
+    };
+    Interface.prototype.encodeErrorResult = function (fragment, values) {
         if (typeof (fragment) === "string") {
             fragment = this.getError(fragment);
         }
@@ -279,20 +316,20 @@ class Interface {
             this.getSighash(fragment),
             this._encodeParams(fragment.inputs, values || [])
         ]));
-    }
+    };
     // Decode the data for a function call (e.g. tx.data)
-    decodeFunctionData(functionFragment, data) {
+    Interface.prototype.decodeFunctionData = function (functionFragment, data) {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        const bytes = (0, bytes_1.arrayify)(data);
+        var bytes = (0, bytes_1.arrayify)(data);
         if ((0, bytes_1.hexlify)(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {
-            logger.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", (0, bytes_1.hexlify)(bytes));
+            logger.throwArgumentError("data signature does not match function ".concat(functionFragment.name, "."), "data", (0, bytes_1.hexlify)(bytes));
         }
         return this._decodeParams(functionFragment.inputs, bytes.slice(4));
-    }
+    };
     // Encode the data for a function call (e.g. tx.data)
-    encodeFunctionData(functionFragment, values) {
+    Interface.prototype.encodeFunctionData = function (functionFragment, values) {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
@@ -300,18 +337,18 @@ class Interface {
             this.getSighash(functionFragment),
             this._encodeParams(functionFragment.inputs, values || [])
         ]));
-    }
+    };
     // Decode the result from a function call (e.g. from eth_call)
-    decodeFunctionResult(functionFragment, data) {
+    Interface.prototype.decodeFunctionResult = function (functionFragment, data) {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        let bytes = (0, bytes_1.arrayify)(data);
-        let reason = null;
-        let message = "";
-        let errorArgs = null;
-        let errorName = null;
-        let errorSignature = null;
+        var bytes = (0, bytes_1.arrayify)(data);
+        var reason = null;
+        var message = "";
+        var errorArgs = null;
+        var errorName = null;
+        var errorSignature = null;
         switch (bytes.length % this._abiCoder._getWordSize()) {
             case 0:
                 try {
@@ -320,8 +357,8 @@ class Interface {
                 catch (error) { }
                 break;
             case 4: {
-                const selector = (0, bytes_1.hexlify)(bytes.slice(0, 4));
-                const builtin = BuiltinErrors[selector];
+                var selector = (0, bytes_1.hexlify)(bytes.slice(0, 4));
+                var builtin = BuiltinErrors[selector];
                 if (builtin) {
                     errorArgs = this._abiCoder.decode(builtin.inputs, bytes.slice(4));
                     errorName = builtin.name;
@@ -330,15 +367,15 @@ class Interface {
                         reason = errorArgs[0];
                     }
                     if (errorName === "Error") {
-                        message = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(errorArgs[0])}`;
+                        message = "; VM Exception while processing transaction: reverted with reason string ".concat(JSON.stringify(errorArgs[0]));
                     }
                     else if (errorName === "Panic") {
-                        message = `; VM Exception while processing transaction: reverted with panic code ${errorArgs[0]}`;
+                        message = "; VM Exception while processing transaction: reverted with panic code ".concat(errorArgs[0]);
                     }
                 }
                 else {
                     try {
-                        const error = this.getError(selector);
+                        var error = this.getError(selector);
                         errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4));
                         errorName = error.name;
                         errorSignature = error.format();
@@ -350,18 +387,23 @@ class Interface {
         }
         return logger.throwError("call revert exception" + message, logger_1.Logger.errors.CALL_EXCEPTION, {
             method: functionFragment.format(),
-            data: (0, bytes_1.hexlify)(data), errorArgs, errorName, errorSignature, reason
+            data: (0, bytes_1.hexlify)(data),
+            errorArgs: errorArgs,
+            errorName: errorName,
+            errorSignature: errorSignature,
+            reason: reason
         });
-    }
+    };
     // Encode the result for a function call (e.g. for eth_call)
-    encodeFunctionResult(functionFragment, values) {
+    Interface.prototype.encodeFunctionResult = function (functionFragment, values) {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
         return (0, bytes_1.hexlify)(this._abiCoder.encode(functionFragment.outputs, values || []));
-    }
+    };
     // Create the filter for the event with search criteria (e.g. for eth_filterLog)
-    encodeFilterTopics(eventFragment, values) {
+    Interface.prototype.encodeFilterTopics = function (eventFragment, values) {
+        var _this = this;
         if (typeof (eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
@@ -371,11 +413,11 @@ class Interface {
                 value: values
             });
         }
-        let topics = [];
+        var topics = [];
         if (!eventFragment.anonymous) {
             topics.push(this.getEventTopic(eventFragment));
         }
-        const encodeTopic = (param, value) => {
+        var encodeTopic = function (param, value) {
             if (param.type === "string") {
                 return (0, hash_1.id)(value);
             }
@@ -390,12 +432,12 @@ class Interface {
             }
             // Check addresses are valid
             if (param.type === "address") {
-                this._abiCoder.encode(["address"], [value]);
+                _this._abiCoder.encode(["address"], [value]);
             }
             return (0, bytes_1.hexZeroPad)((0, bytes_1.hexlify)(value), 32);
         };
-        values.forEach((value, index) => {
-            let param = eventFragment.inputs[index];
+        values.forEach(function (value, index) {
+            var param = eventFragment.inputs[index];
             if (!param.indexed) {
                 if (value != null) {
                     logger.throwArgumentError("cannot filter non-indexed parameters; must be null", ("contract." + param.name), value);
@@ -409,7 +451,7 @@ class Interface {
                 logger.throwArgumentError("filtering with tuples or arrays not supported", ("contract." + param.name), value);
             }
             else if (Array.isArray(value)) {
-                topics.push(value.map((value) => encodeTopic(param, value)));
+                topics.push(value.map(function (value) { return encodeTopic(param, value); }));
             }
             else {
                 topics.push(encodeTopic(param, value));
@@ -420,22 +462,23 @@ class Interface {
             topics.pop();
         }
         return topics;
-    }
-    encodeEventLog(eventFragment, values) {
+    };
+    Interface.prototype.encodeEventLog = function (eventFragment, values) {
+        var _this = this;
         if (typeof (eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
-        const topics = [];
-        const dataTypes = [];
-        const dataValues = [];
+        var topics = [];
+        var dataTypes = [];
+        var dataValues = [];
         if (!eventFragment.anonymous) {
             topics.push(this.getEventTopic(eventFragment));
         }
         if (values.length !== eventFragment.inputs.length) {
             logger.throwArgumentError("event arguments/values mismatch", "values", values);
         }
-        eventFragment.inputs.forEach((param, index) => {
-            const value = values[index];
+        eventFragment.inputs.forEach(function (param, index) {
+            var value = values[index];
             if (param.indexed) {
                 if (param.type === "string") {
                     topics.push((0, hash_1.id)(value));
@@ -448,7 +491,7 @@ class Interface {
                     throw new Error("not implemented");
                 }
                 else {
-                    topics.push(this._abiCoder.encode([param.type], [value]));
+                    topics.push(_this._abiCoder.encode([param.type], [value]));
                 }
             }
             else {
@@ -460,23 +503,23 @@ class Interface {
             data: this._abiCoder.encode(dataTypes, dataValues),
             topics: topics
         };
-    }
+    };
     // Decode a filter for the event and the search criteria
-    decodeEventLog(eventFragment, data, topics) {
+    Interface.prototype.decodeEventLog = function (eventFragment, data, topics) {
         if (typeof (eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
         if (topics != null && !eventFragment.anonymous) {
-            let topicHash = this.getEventTopic(eventFragment);
+            var topicHash = this.getEventTopic(eventFragment);
             if (!(0, bytes_1.isHexString)(topics[0], 32) || topics[0].toLowerCase() !== topicHash) {
                 logger.throwError("fragment/topic mismatch", logger_1.Logger.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: topicHash, value: topics[0] });
             }
             topics = topics.slice(1);
         }
-        let indexed = [];
-        let nonIndexed = [];
-        let dynamic = [];
-        eventFragment.inputs.forEach((param, index) => {
+        var indexed = [];
+        var nonIndexed = [];
+        var dynamic = [];
+        eventFragment.inputs.forEach(function (param, index) {
             if (param.indexed) {
                 if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
                     indexed.push(fragments_1.ParamType.fromObject({ type: "bytes32", name: param.name }));
@@ -492,11 +535,11 @@ class Interface {
                 dynamic.push(false);
             }
         });
-        let resultIndexed = (topics != null) ? this._abiCoder.decode(indexed, (0, bytes_1.concat)(topics)) : null;
-        let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);
-        let result = [];
-        let nonIndexedIndex = 0, indexedIndex = 0;
-        eventFragment.inputs.forEach((param, index) => {
+        var resultIndexed = (topics != null) ? this._abiCoder.decode(indexed, (0, bytes_1.concat)(topics)) : null;
+        var resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);
+        var result = [];
+        var nonIndexedIndex = 0, indexedIndex = 0;
+        eventFragment.inputs.forEach(function (param, index) {
             if (param.indexed) {
                 if (resultIndexed == null) {
                     result[index] = new Indexed({ _isIndexed: true, hash: null });
@@ -523,35 +566,38 @@ class Interface {
             }
             // Add the keyword argument if named and safe
             if (param.name && result[param.name] == null) {
-                const value = result[index];
+                var value_1 = result[index];
                 // Make error named values throw on access
-                if (value instanceof Error) {
+                if (value_1 instanceof Error) {
                     Object.defineProperty(result, param.name, {
                         enumerable: true,
-                        get: () => { throw wrapAccessError(`property ${JSON.stringify(param.name)}`, value); }
+                        get: function () { throw wrapAccessError("property ".concat(JSON.stringify(param.name)), value_1); }
                     });
                 }
                 else {
-                    result[param.name] = value;
+                    result[param.name] = value_1;
                 }
             }
         });
-        // Make all error indexed values throw on access
-        for (let i = 0; i < result.length; i++) {
-            const value = result[i];
+        var _loop_1 = function (i) {
+            var value = result[i];
             if (value instanceof Error) {
                 Object.defineProperty(result, i, {
                     enumerable: true,
-                    get: () => { throw wrapAccessError(`index ${i}`, value); }
+                    get: function () { throw wrapAccessError("index ".concat(i), value); }
                 });
             }
+        };
+        // Make all error indexed values throw on access
+        for (var i = 0; i < result.length; i++) {
+            _loop_1(i);
         }
         return Object.freeze(result);
-    }
+    };
     // Given a transaction, find the matching function fragment (if any) and
     // determine all its properties and call parameters
-    parseTransaction(tx) {
-        let fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase());
+    Interface.prototype.parseTransaction = function (tx) {
+        var fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase());
         if (!fragment) {
             return null;
         }
@@ -563,13 +609,13 @@ class Interface {
             sighash: this.getSighash(fragment),
             value: bignumber_1.BigNumber.from(tx.value || "0"),
         });
-    }
+    };
     // @TODO
     //parseCallResult(data: BytesLike): ??
     // Given an event log, find the matching event fragment (if any) and
     // determine all its properties and values
-    parseLog(log) {
-        let fragment = this.getEvent(log.topics[0]);
+    Interface.prototype.parseLog = function (log) {
+        var fragment = this.getEvent(log.topics[0]);
         if (!fragment || fragment.anonymous) {
             return null;
         }
@@ -583,10 +629,10 @@ class Interface {
             topic: this.getEventTopic(fragment),
             args: this.decodeEventLog(fragment, log.data, log.topics)
         });
-    }
-    parseError(data) {
-        const hexData = (0, bytes_1.hexlify)(data);
-        let fragment = this.getError(hexData.substring(0, 10).toLowerCase());
+    };
+    Interface.prototype.parseError = function (data) {
+        var hexData = (0, bytes_1.hexlify)(data);
+        var fragment = this.getError(hexData.substring(0, 10).toLowerCase());
         if (!fragment) {
             return null;
         }
@@ -597,7 +643,7 @@ class Interface {
             signature: fragment.format(),
             sighash: this.getSighash(fragment),
         });
-    }
+    };
     /*
     static from(value: Array<Fragment | string | JsonAbi> | string | Interface) {
         if (Interface.isInterface(value)) {
@@ -609,9 +655,10 @@ class Interface {
         return new Interface(value);
     }
     */
-    static isInterface(value) {
+    Interface.isInterface = function (value) {
         return !!(value && value._isInterface);
-    }
-}
+    };
+    return Interface;
+}());
 exports.Interface = Interface;
 //# sourceMappingURL=interface.js.map