quantumcoin 6.14.5 → 7.0.1

package/lib.esm/abi/interface.js

@@ -1,1101 +0,0 @@
-/**
- *  The Interface class is a low-level class that accepts an
- *  ABI and provides all the necessary functionality to encode
- *  and decode paramaters to and results from methods, events
- *  and errors.
- *
- *  It also provides several convenience methods to automatically
- *  search and find matching transactions and events to parse them.
- *
- *  @_subsection api/abi:Interfaces  [interfaces]
- */
-import { keccak256 } from "../crypto/index.js";
-import { id } from "../hash/index.js";
-import { concat, dataSlice, getBigInt, getBytes, getBytesCopy, hexlify, zeroPadBytes, zeroPadValue, isHexString, defineProperties, assertArgument, toBeHex, assert } from "../utils/index.js";
-import { AbiCoder } from "./abi-coder.js";
-import { checkResultErrors, Result } from "./coders/abstract-coder.js";
-import { ConstructorFragment, ErrorFragment, EventFragment, Fragment, FunctionFragment, ParamType } from "./fragments.js";
-import { Typed } from "./typed.js";
-export { checkResultErrors, Result };
-/**
- *  When using the [[Interface-parseLog]] to automatically match a Log to its event
- *  for parsing, a **LogDescription** is returned.
- */
-export class LogDescription {
-    /**
-     *  The matching fragment for the ``topic0``.
-     */
-    fragment;
-    /**
-     *  The name of the Event.
-     */
-    name;
-    /**
-     *  The full Event signature.
-     */
-    signature;
-    /**
-     *  The topic hash for the Event.
-     */
-    topic;
-    /**
-     *  The arguments passed into the Event with ``emit``.
-     */
-    args;
-    /**
-     *  @_ignore:
-     */
-    constructor(fragment, topic, args) {
-        const name = fragment.name, signature = fragment.format();
-        defineProperties(this, {
-            fragment, name, signature, topic, args
-        });
-    }
-}
-/**
- *  When using the [[Interface-parseTransaction]] to automatically match
- *  a transaction data to its function for parsing,
- *  a **TransactionDescription** is returned.
- */
-export class TransactionDescription {
-    /**
-     *  The matching fragment from the transaction ``data``.
-     */
-    fragment;
-    /**
-     *  The name of the Function from the transaction ``data``.
-     */
-    name;
-    /**
-     *  The arguments passed to the Function from the transaction ``data``.
-     */
-    args;
-    /**
-     *  The full Function signature from the transaction ``data``.
-     */
-    signature;
-    /**
-     *  The selector for the Function from the transaction ``data``.
-     */
-    selector;
-    /**
-     *  The ``value`` (in wei) from the transaction.
-     */
-    value;
-    /**
-     *  @_ignore:
-     */
-    constructor(fragment, selector, args, value) {
-        const name = fragment.name, signature = fragment.format();
-        defineProperties(this, {
-            fragment, name, args, signature, selector, value
-        });
-    }
-}
-/**
- *  When using the [[Interface-parseError]] to automatically match an
- *  error for a call result for parsing, an **ErrorDescription** is returned.
- */
-export class ErrorDescription {
-    /**
-     *  The matching fragment.
-     */
-    fragment;
-    /**
-     *  The name of the Error.
-     */
-    name;
-    /**
-     *  The arguments passed to the Error with ``revert``.
-     */
-    args;
-    /**
-     *  The full Error signature.
-     */
-    signature;
-    /**
-     *  The selector for the Error.
-     */
-    selector;
-    /**
-     *  @_ignore:
-     */
-    constructor(fragment, selector, args) {
-        const name = fragment.name, signature = fragment.format();
-        defineProperties(this, {
-            fragment, name, args, signature, selector
-        });
-    }
-}
-/**
- *  An **Indexed** is used as a value when a value that does not
- *  fit within a topic (i.e. not a fixed-length, 32-byte type). It
- *  is the ``keccak256`` of the value, and used for types such as
- *  arrays, tuples, bytes and strings.
- */
-export class Indexed {
-    /**
-     *  The ``keccak256`` of the value logged.
-     */
-    hash;
-    /**
-     *  @_ignore:
-     */
-    _isIndexed;
-    /**
-     *  Returns ``true`` if %%value%% is an **Indexed**.
-     *
-     *  This provides a Type Guard for property access.
-     */
-    static isIndexed(value) {
-        return !!(value && value._isIndexed);
-    }
-    /**
-     *  @_ignore:
-     */
-    constructor(hash) {
-        defineProperties(this, { hash, _isIndexed: true });
-    }
-}
-// https://docs.soliditylang.org/en/v0.8.13/control-structures.html?highlight=panic#panic-via-assert-and-error-via-require
-const PanicReasons = {
-    "0": "generic panic",
-    "1": "assert(false)",
-    "17": "arithmetic overflow",
-    "18": "division or modulo by zero",
-    "33": "enum overflow",
-    "34": "invalid encoded storage byte array accessed",
-    "49": "out-of-bounds array access; popping on an empty array",
-    "50": "out-of-bounds access of an array or bytesN",
-    "65": "out of memory",
-    "81": "uninitialized function",
-};
-const BuiltinErrors = {
-    "0x08c379a0": {
-        signature: "Error(string)",
-        name: "Error",
-        inputs: ["string"],
-        reason: (message) => {
-            return `reverted with reason string ${JSON.stringify(message)}`;
-        }
-    },
-    "0x4e487b71": {
-        signature: "Panic(uint256)",
-        name: "Panic",
-        inputs: ["uint256"],
-        reason: (code) => {
-            let reason = "unknown panic code";
-            if (code >= 0 && code <= 0xff && PanicReasons[code.toString()]) {
-                reason = PanicReasons[code.toString()];
-            }
-            return `reverted with panic code 0x${code.toString(16)} (${reason})`;
-        }
-    }
-};
-/**
- *  An Interface abstracts many of the low-level details for
- *  encoding and decoding the data on the blockchain.
- *
- *  An ABI provides information on how to encode data to send to
- *  a Contract, how to decode the results and events and how to
- *  interpret revert errors.
- *
- *  The ABI can be specified by [any supported format](InterfaceAbi).
- */
-export class Interface {
-    /**
-     *  All the Contract ABI members (i.e. methods, events, errors, etc).
-     */
-    fragments;
-    /**
-     *  The Contract constructor.
-     */
-    deploy;
-    /**
-     *  The Fallback method, if any.
-     */
-    fallback;
-    /**
-     *  If receiving ether is supported.
-     */
-    receive;
-    #errors;
-    #events;
-    #functions;
-    //    #structs: Map<string, StructFragment>;
-    #abiCoder;
-    /**
-     *  Create a new Interface for the %%fragments%%.
-     */
-    constructor(fragments) {
-        let abi = [];
-        if (typeof (fragments) === "string") {
-            abi = JSON.parse(fragments);
-        }
-        else {
-            abi = fragments;
-        }
-        this.#functions = new Map();
-        this.#errors = new Map();
-        this.#events = new Map();
-        //        this.#structs = new Map();
-        const frags = [];
-        for (const a of abi) {
-            try {
-                frags.push(Fragment.from(a));
-            }
-            catch (error) {
-                console.log(`[Warning] Invalid Fragment ${JSON.stringify(a)}:`, error.message);
-            }
-        }
-        defineProperties(this, {
-            fragments: Object.freeze(frags)
-        });
-        let fallback = null;
-        let receive = false;
-        this.#abiCoder = this.getAbiCoder();
-        // Add all fragments by their signature
-        this.fragments.forEach((fragment, index) => {
-            let bucket;
-            switch (fragment.type) {
-                case "constructor":
-                    if (this.deploy) {
-                        console.log("duplicate definition - constructor");
-                        return;
-                    }
-                    //checkNames(fragment, "input", fragment.inputs);
-                    defineProperties(this, { deploy: fragment });
-                    return;
-                case "fallback":
-                    if (fragment.inputs.length === 0) {
-                        receive = true;
-                    }
-                    else {
-                        assertArgument(!fallback || fragment.payable !== fallback.payable, "conflicting fallback fragments", `fragments[${index}]`, fragment);
-                        fallback = fragment;
-                        receive = fallback.payable;
-                    }
-                    return;
-                case "function":
-                    //checkNames(fragment, "input", fragment.inputs);
-                    //checkNames(fragment, "output", (<FunctionFragment>fragment).outputs);
-                    bucket = this.#functions;
-                    break;
-                case "event":
-                    //checkNames(fragment, "input", fragment.inputs);
-                    bucket = this.#events;
-                    break;
-                case "error":
-                    bucket = this.#errors;
-                    break;
-                default:
-                    return;
-            }
-            // Two identical entries; ignore it
-            const signature = fragment.format();
-            if (bucket.has(signature)) {
-                return;
-            }
-            bucket.set(signature, fragment);
-        });
-        // If we do not have a constructor add a default
-        if (!this.deploy) {
-            defineProperties(this, {
-                deploy: ConstructorFragment.from("constructor()")
-            });
-        }
-        defineProperties(this, { fallback, receive });
-    }
-    /**
-     *  Returns the entire Human-Readable ABI, as an array of
-     *  signatures, optionally as %%minimal%% strings, which
-     *  removes parameter names and unneceesary spaces.
-     */
-    format(minimal) {
-        const format = (minimal ? "minimal" : "full");
-        const abi = this.fragments.map((f) => f.format(format));
-        return abi;
-    }
-    /**
-     *  Return the JSON-encoded ABI. This is the format Solidiy
-     *  returns.
-     */
-    formatJson() {
-        const abi = this.fragments.map((f) => f.format("json"));
-        // We need to re-bundle the JSON fragments a bit
-        return JSON.stringify(abi.map((j) => JSON.parse(j)));
-    }
-    /**
-     *  The ABI coder that will be used to encode and decode binary
-     *  data.
-     */
-    getAbiCoder() {
-        return AbiCoder.defaultAbiCoder();
-    }
-    // Find a function definition by any means necessary (unless it is ambiguous)
-    #getFunction(key, values, forceUnique) {
-        // Selector
-        if (isHexString(key)) {
-            const selector = key.toLowerCase();
-            for (const fragment of this.#functions.values()) {
-                if (selector === fragment.selector) {
-                    return fragment;
-                }
-            }
-            return null;
-        }
-        // It is a bare name, look up the function (will return null if ambiguous)
-        if (key.indexOf("(") === -1) {
-            const matching = [];
-            for (const [name, fragment] of this.#functions) {
-                if (name.split("(" /* fix:) */)[0] === key) {
-                    matching.push(fragment);
-                }
-            }
-            if (values) {
-                const lastValue = (values.length > 0) ? values[values.length - 1] : null;
-                let valueLength = values.length;
-                let allowOptions = true;
-                if (Typed.isTyped(lastValue) && lastValue.type === "overrides") {
-                    allowOptions = false;
-                    valueLength--;
-                }
-                // Remove all matches that don't have a compatible length. The args
-                // may contain an overrides, so the match may have n or n - 1 parameters
-                for (let i = matching.length - 1; i >= 0; i--) {
-                    const inputs = matching[i].inputs.length;
-                    if (inputs !== valueLength && (!allowOptions || inputs !== valueLength - 1)) {
-                        matching.splice(i, 1);
-                    }
-                }
-                // Remove all matches that don't match the Typed signature
-                for (let i = matching.length - 1; i >= 0; i--) {
-                    const inputs = matching[i].inputs;
-                    for (let j = 0; j < values.length; j++) {
-                        // Not a typed value
-                        if (!Typed.isTyped(values[j])) {
-                            continue;
-                        }
-                        // We are past the inputs
-                        if (j >= inputs.length) {
-                            if (values[j].type === "overrides") {
-                                continue;
-                            }
-                            matching.splice(i, 1);
-                            break;
-                        }
-                        // Make sure the value type matches the input type
-                        if (values[j].type !== inputs[j].baseType) {
-                            matching.splice(i, 1);
-                            break;
-                        }
-                    }
-                }
-            }
-            // We found a single matching signature with an overrides, but the
-            // last value is something that cannot possibly be an options
-            if (matching.length === 1 && values && values.length !== matching[0].inputs.length) {
-                const lastArg = values[values.length - 1];
-                if (lastArg == null || Array.isArray(lastArg) || typeof (lastArg) !== "object") {
-                    matching.splice(0, 1);
-                }
-            }
-            if (matching.length === 0) {
-                return null;
-            }
-            if (matching.length > 1 && forceUnique) {
-                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(", ");
-                assertArgument(false, `ambiguous function description (i.e. matches ${matchStr})`, "key", key);
-            }
-            return matching[0];
-        }
-        // Normalize the signature and lookup the function
-        const result = this.#functions.get(FunctionFragment.from(key).format());
-        if (result) {
-            return result;
-        }
-        return null;
-    }
-    /**
-     *  Get the function name for %%key%%, which may be a function selector,
-     *  function name or function signature that belongs to the ABI.
-     */
-    getFunctionName(key) {
-        const fragment = this.#getFunction(key, null, false);
-        assertArgument(fragment, "no matching function", "key", key);
-        return fragment.name;
-    }
-    /**
-     *  Returns true if %%key%% (a function selector, function name or
-     *  function signature) is present in the ABI.
-     *
-     *  In the case of a function name, the name may be ambiguous, so
-     *  accessing the [[FunctionFragment]] may require refinement.
-     */
-    hasFunction(key) {
-        return !!this.#getFunction(key, null, false);
-    }
-    /**
-     *  Get the [[FunctionFragment]] for %%key%%, which may be a function
-     *  selector, function name or function signature that belongs to the ABI.
-     *
-     *  If %%values%% is provided, it will use the Typed API to handle
-     *  ambiguous cases where multiple functions match by name.
-     *
-     *  If the %%key%% and %%values%% do not refine to a single function in
-     *  the ABI, this will throw.
-     */
-    getFunction(key, values) {
-        return this.#getFunction(key, values || null, true);
-    }
-    /**
-     *  Iterate over all functions, calling %%callback%%, sorted by their name.
-     */
-    forEachFunction(callback) {
-        const names = Array.from(this.#functions.keys());
-        names.sort((a, b) => a.localeCompare(b));
-        for (let i = 0; i < names.length; i++) {
-            const name = names[i];
-            callback((this.#functions.get(name)), i);
-        }
-    }
-    // Find an event definition by any means necessary (unless it is ambiguous)
-    #getEvent(key, values, forceUnique) {
-        // EventTopic
-        if (isHexString(key)) {
-            const eventTopic = key.toLowerCase();
-            for (const fragment of this.#events.values()) {
-                if (eventTopic === fragment.topicHash) {
-                    return fragment;
-                }
-            }
-            return null;
-        }
-        // It is a bare name, look up the function (will return null if ambiguous)
-        if (key.indexOf("(") === -1) {
-            const matching = [];
-            for (const [name, fragment] of this.#events) {
-                if (name.split("(" /* fix:) */)[0] === key) {
-                    matching.push(fragment);
-                }
-            }
-            if (values) {
-                // Remove all matches that don't have a compatible length.
-                for (let i = matching.length - 1; i >= 0; i--) {
-                    if (matching[i].inputs.length < values.length) {
-                        matching.splice(i, 1);
-                    }
-                }
-                // Remove all matches that don't match the Typed signature
-                for (let i = matching.length - 1; i >= 0; i--) {
-                    const inputs = matching[i].inputs;
-                    for (let j = 0; j < values.length; j++) {
-                        // Not a typed value
-                        if (!Typed.isTyped(values[j])) {
-                            continue;
-                        }
-                        // Make sure the value type matches the input type
-                        if (values[j].type !== inputs[j].baseType) {
-                            matching.splice(i, 1);
-                            break;
-                        }
-                    }
-                }
-            }
-            if (matching.length === 0) {
-                return null;
-            }
-            if (matching.length > 1 && forceUnique) {
-                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(", ");
-                assertArgument(false, `ambiguous event description (i.e. matches ${matchStr})`, "key", key);
-            }
-            return matching[0];
-        }
-        // Normalize the signature and lookup the function
-        const result = this.#events.get(EventFragment.from(key).format());
-        if (result) {
-            return result;
-        }
-        return null;
-    }
-    /**
-     *  Get the event name for %%key%%, which may be a topic hash,
-     *  event name or event signature that belongs to the ABI.
-     */
-    getEventName(key) {
-        const fragment = this.#getEvent(key, null, false);
-        assertArgument(fragment, "no matching event", "key", key);
-        return fragment.name;
-    }
-    /**
-     *  Returns true if %%key%% (an event topic hash, event name or
-     *  event signature) is present in the ABI.
-     *
-     *  In the case of an event name, the name may be ambiguous, so
-     *  accessing the [[EventFragment]] may require refinement.
-     */
-    hasEvent(key) {
-        return !!this.#getEvent(key, null, false);
-    }
-    /**
-     *  Get the [[EventFragment]] for %%key%%, which may be a topic hash,
-     *  event name or event signature that belongs to the ABI.
-     *
-     *  If %%values%% is provided, it will use the Typed API to handle
-     *  ambiguous cases where multiple events match by name.
-     *
-     *  If the %%key%% and %%values%% do not refine to a single event in
-     *  the ABI, this will throw.
-     */
-    getEvent(key, values) {
-        return this.#getEvent(key, values || null, true);
-    }
-    /**
-     *  Iterate over all events, calling %%callback%%, sorted by their name.
-     */
-    forEachEvent(callback) {
-        const names = Array.from(this.#events.keys());
-        names.sort((a, b) => a.localeCompare(b));
-        for (let i = 0; i < names.length; i++) {
-            const name = names[i];
-            callback((this.#events.get(name)), i);
-        }
-    }
-    /**
-     *  Get the [[ErrorFragment]] for %%key%%, which may be an error
-     *  selector, error name or error signature that belongs to the ABI.
-     *
-     *  If %%values%% is provided, it will use the Typed API to handle
-     *  ambiguous cases where multiple errors match by name.
-     *
-     *  If the %%key%% and %%values%% do not refine to a single error in
-     *  the ABI, this will throw.
-     */
-    getError(key, values) {
-        if (isHexString(key)) {
-            const selector = key.toLowerCase();
-            if (BuiltinErrors[selector]) {
-                return ErrorFragment.from(BuiltinErrors[selector].signature);
-            }
-            for (const fragment of this.#errors.values()) {
-                if (selector === fragment.selector) {
-                    return fragment;
-                }
-            }
-            return null;
-        }
-        // It is a bare name, look up the function (will return null if ambiguous)
-        if (key.indexOf("(") === -1) {
-            const matching = [];
-            for (const [name, fragment] of this.#errors) {
-                if (name.split("(" /* fix:) */)[0] === key) {
-                    matching.push(fragment);
-                }
-            }
-            if (matching.length === 0) {
-                if (key === "Error") {
-                    return ErrorFragment.from("error Error(string)");
-                }
-                if (key === "Panic") {
-                    return ErrorFragment.from("error Panic(uint256)");
-                }
-                return null;
-            }
-            else if (matching.length > 1) {
-                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(", ");
-                assertArgument(false, `ambiguous error description (i.e. ${matchStr})`, "name", key);
-            }
-            return matching[0];
-        }
-        // Normalize the signature and lookup the function
-        key = ErrorFragment.from(key).format();
-        if (key === "Error(string)") {
-            return ErrorFragment.from("error Error(string)");
-        }
-        if (key === "Panic(uint256)") {
-            return ErrorFragment.from("error Panic(uint256)");
-        }
-        const result = this.#errors.get(key);
-        if (result) {
-            return result;
-        }
-        return null;
-    }
-    /**
-     *  Iterate over all errors, calling %%callback%%, sorted by their name.
-     */
-    forEachError(callback) {
-        const names = Array.from(this.#errors.keys());
-        names.sort((a, b) => a.localeCompare(b));
-        for (let i = 0; i < names.length; i++) {
-            const name = names[i];
-            callback((this.#errors.get(name)), i);
-        }
-    }
-    // Get the 4-byte selector used by Solidity to identify a function
-    /*
-getSelector(fragment: ErrorFragment | FunctionFragment): string {
-    if (typeof(fragment) === "string") {
-        const matches: Array<Fragment> = [ ];
-
-        try { matches.push(this.getFunction(fragment)); } catch (error) { }
-        try { matches.push(this.getError(<string>fragment)); } catch (_) { }
-
-        if (matches.length === 0) {
-            logger.throwArgumentError("unknown fragment", "key", fragment);
-        } else if (matches.length > 1) {
-            logger.throwArgumentError("ambiguous fragment matches function and error", "key", fragment);
-        }
-
-        fragment = matches[0];
-    }
-
-    return dataSlice(id(fragment.format()), 0, 4);
-}
-    */
-    // Get the 32-byte topic hash used by Solidity to identify an event
-    /*
-    getEventTopic(fragment: EventFragment): string {
-        //if (typeof(fragment) === "string") { fragment = this.getEvent(eventFragment); }
-        return id(fragment.format());
-    }
-    */
-    _decodeParams(params, data) {
-        return this.#abiCoder.decode(params, data);
-    }
-    _encodeParams(params, values) {
-        return this.#abiCoder.encode(params, values);
-    }
-    /**
-     *  Encodes a ``tx.data`` object for deploying the Contract with
-     *  the %%values%% as the constructor arguments.
-     */
-    encodeDeploy(values) {
-        return this._encodeParams(this.deploy.inputs, values || []);
-    }
-    /**
-     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
-     *  specified error (see [[getError]] for valid values for
-     *  %%key%%).
-     *
-     *  Most developers should prefer the [[parseCallResult]] method instead,
-     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
-     *  corresponding error.
-     */
-    decodeErrorResult(fragment, data) {
-        if (typeof (fragment) === "string") {
-            const f = this.getError(fragment);
-            assertArgument(f, "unknown error", "fragment", fragment);
-            fragment = f;
-        }
-        assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match error ${fragment.name}.`, "data", data);
-        return this._decodeParams(fragment.inputs, dataSlice(data, 4));
-    }
-    /**
-     *  Encodes the transaction revert data for a call result that
-     *  reverted from the the Contract with the sepcified %%error%%
-     *  (see [[getError]] for valid values for %%fragment%%) with the %%values%%.
-     *
-     *  This is generally not used by most developers, unless trying to mock
-     *  a result from a Contract.
-     */
-    encodeErrorResult(fragment, values) {
-        if (typeof (fragment) === "string") {
-            const f = this.getError(fragment);
-            assertArgument(f, "unknown error", "fragment", fragment);
-            fragment = f;
-        }
-        return concat([
-            fragment.selector,
-            this._encodeParams(fragment.inputs, values || [])
-        ]);
-    }
-    /**
-     *  Decodes the %%data%% from a transaction ``tx.data`` for
-     *  the function specified (see [[getFunction]] for valid values
-     *  for %%fragment%%).
-     *
-     *  Most developers should prefer the [[parseTransaction]] method
-     *  instead, which will automatically detect the fragment.
-     */
-    decodeFunctionData(fragment, data) {
-        if (typeof (fragment) === "string") {
-            const f = this.getFunction(fragment);
-            assertArgument(f, "unknown function", "fragment", fragment);
-            fragment = f;
-        }
-        assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match function ${fragment.name}.`, "data", data);
-        return this._decodeParams(fragment.inputs, dataSlice(data, 4));
-    }
-    /**
-     *  Encodes the ``tx.data`` for a transaction that calls the function
-     *  specified (see [[getFunction]] for valid values for %%fragment%%) with
-     *  the %%values%%.
-     */
-    encodeFunctionData(fragment, values) {
-        if (typeof (fragment) === "string") {
-            const f = this.getFunction(fragment);
-            assertArgument(f, "unknown function", "fragment", fragment);
-            fragment = f;
-        }
-        return concat([
-            fragment.selector,
-            this._encodeParams(fragment.inputs, values || [])
-        ]);
-    }
-    /**
-     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
-     *  specified function (see [[getFunction]] for valid values for
-     *  %%key%%).
-     *
-     *  Most developers should prefer the [[parseCallResult]] method instead,
-     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
-     *  corresponding error.
-     */
-    decodeFunctionResult(fragment, data) {
-        if (typeof (fragment) === "string") {
-            const f = this.getFunction(fragment);
-            assertArgument(f, "unknown function", "fragment", fragment);
-            fragment = f;
-        }
-        let message = "invalid length for result data";
-        const bytes = getBytesCopy(data);
-        if ((bytes.length % 32) === 0) {
-            try {
-                return this.#abiCoder.decode(fragment.outputs, bytes);
-            }
-            catch (error) {
-                message = "could not decode result data";
-            }
-        }
-        // Call returned data with no error, but the data is junk
-        assert(false, message, "BAD_DATA", {
-            value: hexlify(bytes),
-            info: { method: fragment.name, signature: fragment.format() }
-        });
-    }
-    makeError(_data, tx) {
-        const data = getBytes(_data, "data");
-        const error = AbiCoder.getBuiltinCallException("call", tx, data);
-        // Not a built-in error; try finding a custom error
-        const customPrefix = "execution reverted (unknown custom error)";
-        if (error.message.startsWith(customPrefix)) {
-            const selector = hexlify(data.slice(0, 4));
-            const ef = this.getError(selector);
-            if (ef) {
-                try {
-                    const args = this.#abiCoder.decode(ef.inputs, data.slice(4));
-                    error.revert = {
-                        name: ef.name, signature: ef.format(), args
-                    };
-                    error.reason = error.revert.signature;
-                    error.message = `execution reverted: ${error.reason}`;
-                }
-                catch (e) {
-                    error.message = `execution reverted (coult not decode custom error)`;
-                }
-            }
-        }
-        // Add the invocation, if available
-        const parsed = this.parseTransaction(tx);
-        if (parsed) {
-            error.invocation = {
-                method: parsed.name,
-                signature: parsed.signature,
-                args: parsed.args
-            };
-        }
-        return error;
-    }
-    /**
-     *  Encodes the result data (e.g. from an ``eth_call``) for the
-     *  specified function (see [[getFunction]] for valid values
-     *  for %%fragment%%) with %%values%%.
-     *
-     *  This is generally not used by most developers, unless trying to mock
-     *  a result from a Contract.
-     */
-    encodeFunctionResult(fragment, values) {
-        if (typeof (fragment) === "string") {
-            const f = this.getFunction(fragment);
-            assertArgument(f, "unknown function", "fragment", fragment);
-            fragment = f;
-        }
-        return hexlify(this.#abiCoder.encode(fragment.outputs, values || []));
-    }
-    /*
-        spelunk(inputs: Array<ParamType>, values: ReadonlyArray<any>, processfunc: (type: string, value: any) => Promise<any>): Promise<Array<any>> {
-            const promises: Array<Promise<>> = [ ];
-            const process = function(type: ParamType, value: any): any {
-                if (type.baseType === "array") {
-                    return descend(type.child
-                }
-                if (type. === "address") {
-                }
-            };
-    
-            const descend = function (inputs: Array<ParamType>, values: ReadonlyArray<any>) {
-                if (inputs.length !== values.length) { throw new Error("length mismatch"); }
-                
-            };
-    
-            const result: Array<any> = [ ];
-            values.forEach((value, index) => {
-                if (value == null) {
-                    topics.push(null);
-                } else if (param.baseType === "array" || param.baseType === "tuple") {
-                    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)));
-                } else {
-                    topics.push(encodeTopic(param, value));
-                }
-            });
-        }
-    */
-    // Create the filter for the event with search criteria (e.g. for eth_filterLog)
-    encodeFilterTopics(fragment, values) {
-        if (typeof (fragment) === "string") {
-            const f = this.getEvent(fragment);
-            assertArgument(f, "unknown event", "eventFragment", fragment);
-            fragment = f;
-        }
-        assert(values.length <= fragment.inputs.length, `too many arguments for ${fragment.format()}`, "UNEXPECTED_ARGUMENT", { count: values.length, expectedCount: fragment.inputs.length });
-        const topics = [];
-        if (!fragment.anonymous) {
-            topics.push(fragment.topicHash);
-        }
-        // @TODO: Use the coders for this; to properly support tuples, etc.
-        const encodeTopic = (param, value) => {
-            if (param.type === "string") {
-                return id(value);
-            }
-            else if (param.type === "bytes") {
-                return keccak256(hexlify(value));
-            }
-            if (param.type === "bool" && typeof (value) === "boolean") {
-                value = (value ? "0x01" : "0x00");
-            }
-            else if (param.type.match(/^u?int/)) {
-                value = toBeHex(value); // @TODO: Should this toTwos??
-            }
-            else if (param.type.match(/^bytes/)) {
-                value = zeroPadBytes(value, 32);
-            }
-            else if (param.type === "address") {
-                // Check addresses are valid
-                this.#abiCoder.encode(["address"], [value]);
-            }
-            return zeroPadValue(hexlify(value), 32);
-        };
-        values.forEach((value, index) => {
-            const param = fragment.inputs[index];
-            if (!param.indexed) {
-                assertArgument(value == null, "cannot filter non-indexed parameters; must be null", ("contract." + param.name), value);
-                return;
-            }
-            if (value == null) {
-                topics.push(null);
-            }
-            else if (param.baseType === "array" || param.baseType === "tuple") {
-                assertArgument(false, "filtering with tuples or arrays not supported", ("contract." + param.name), value);
-            }
-            else if (Array.isArray(value)) {
-                topics.push(value.map((value) => encodeTopic(param, value)));
-            }
-            else {
-                topics.push(encodeTopic(param, value));
-            }
-        });
-        // Trim off trailing nulls
-        while (topics.length && topics[topics.length - 1] === null) {
-            topics.pop();
-        }
-        return topics;
-    }
-    encodeEventLog(fragment, values) {
-        if (typeof (fragment) === "string") {
-            const f = this.getEvent(fragment);
-            assertArgument(f, "unknown event", "eventFragment", fragment);
-            fragment = f;
-        }
-        const topics = [];
-        const dataTypes = [];
-        const dataValues = [];
-        if (!fragment.anonymous) {
-            topics.push(fragment.topicHash);
-        }
-        assertArgument(values.length === fragment.inputs.length, "event arguments/values mismatch", "values", values);
-        fragment.inputs.forEach((param, index) => {
-            const value = values[index];
-            if (param.indexed) {
-                if (param.type === "string") {
-                    topics.push(id(value));
-                }
-                else if (param.type === "bytes") {
-                    topics.push(keccak256(value));
-                }
-                else if (param.baseType === "tuple" || param.baseType === "array") {
-                    // @TODO
-                    throw new Error("not implemented");
-                }
-                else {
-                    topics.push(this.#abiCoder.encode([param.type], [value]));
-                }
-            }
-            else {
-                dataTypes.push(param);
-                dataValues.push(value);
-            }
-        });
-        return {
-            data: this.#abiCoder.encode(dataTypes, dataValues),
-            topics: topics
-        };
-    }
-    // Decode a filter for the event and the search criteria
-    decodeEventLog(fragment, data, topics) {
-        if (typeof (fragment) === "string") {
-            const f = this.getEvent(fragment);
-            assertArgument(f, "unknown event", "eventFragment", fragment);
-            fragment = f;
-        }
-        if (topics != null && !fragment.anonymous) {
-            const eventTopic = fragment.topicHash;
-            assertArgument(isHexString(topics[0], 32) && topics[0].toLowerCase() === eventTopic, "fragment/topic mismatch", "topics[0]", topics[0]);
-            topics = topics.slice(1);
-        }
-        const indexed = [];
-        const nonIndexed = [];
-        const dynamic = [];
-        fragment.inputs.forEach((param, index) => {
-            if (param.indexed) {
-                if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
-                    indexed.push(ParamType.from({ type: "bytes32", name: param.name }));
-                    dynamic.push(true);
-                }
-                else {
-                    indexed.push(param);
-                    dynamic.push(false);
-                }
-            }
-            else {
-                nonIndexed.push(param);
-                dynamic.push(false);
-            }
-        });
-        const resultIndexed = (topics != null) ? this.#abiCoder.decode(indexed, concat(topics)) : null;
-        const resultNonIndexed = this.#abiCoder.decode(nonIndexed, data, true);
-        //const result: (Array<any> & { [ key: string ]: any }) = [ ];
-        const values = [];
-        const keys = [];
-        let nonIndexedIndex = 0, indexedIndex = 0;
-        fragment.inputs.forEach((param, index) => {
-            let value = null;
-            if (param.indexed) {
-                if (resultIndexed == null) {
-                    value = new Indexed(null);
-                }
-                else if (dynamic[index]) {
-                    value = new Indexed(resultIndexed[indexedIndex++]);
-                }
-                else {
-                    try {
-                        value = resultIndexed[indexedIndex++];
-                    }
-                    catch (error) {
-                        value = error;
-                    }
-                }
-            }
-            else {
-                try {
-                    value = resultNonIndexed[nonIndexedIndex++];
-                }
-                catch (error) {
-                    value = error;
-                }
-            }
-            values.push(value);
-            keys.push(param.name || null);
-        });
-        return Result.fromItems(values, keys);
-    }
-    /**
-     *  Parses a transaction, finding the matching function and extracts
-     *  the parameter values along with other useful function details.
-     *
-     *  If the matching function cannot be found, return null.
-     */
-    parseTransaction(tx) {
-        const data = getBytes(tx.data, "tx.data");
-        const value = getBigInt((tx.value != null) ? tx.value : 0, "tx.value");
-        const fragment = this.getFunction(hexlify(data.slice(0, 4)));
-        if (!fragment) {
-            return null;
-        }
-        const args = this.#abiCoder.decode(fragment.inputs, data.slice(4));
-        return new TransactionDescription(fragment, fragment.selector, args, value);
-    }
-    parseCallResult(data) {
-        throw new Error("@TODO");
-    }
-    /**
-     *  Parses a receipt log, finding the matching event and extracts
-     *  the parameter values along with other useful event details.
-     *
-     *  If the matching event cannot be found, returns null.
-     */
-    parseLog(log) {
-        const fragment = this.getEvent(log.topics[0]);
-        if (!fragment || fragment.anonymous) {
-            return null;
-        }
-        // @TODO: If anonymous, and the only method, and the input count matches, should we parse?
-        //        Probably not, because just because it is the only event in the ABI does
-        //        not mean we have the full ABI; maybe just a fragment?
-        return new LogDescription(fragment, fragment.topicHash, this.decodeEventLog(fragment, log.data, log.topics));
-    }
-    /**
-     *  Parses a revert data, finding the matching error and extracts
-     *  the parameter values along with other useful error details.
-     *
-     *  If the matching error cannot be found, returns null.
-     */
-    parseError(data) {
-        const hexData = hexlify(data);
-        const fragment = this.getError(dataSlice(hexData, 0, 4));
-        if (!fragment) {
-            return null;
-        }
-        const args = this.#abiCoder.decode(fragment.inputs, dataSlice(hexData, 4));
-        return new ErrorDescription(fragment, fragment.selector, args);
-    }
-    /**
-     *  Creates a new [[Interface]] from the ABI %%value%%.
-     *
-     *  The %%value%% may be provided as an existing [[Interface]] object,
-     *  a JSON-encoded ABI or any Human-Readable ABI format.
-     */
-    static from(value) {
-        // Already an Interface, which is immutable
-        if (value instanceof Interface) {
-            return value;
-        }
-        // JSON
-        if (typeof (value) === "string") {
-            return new Interface(JSON.parse(value));
-        }
-        // An Interface; possibly from another v6 instance
-        if (typeof (value.formatJson) === "function") {
-            return new Interface(value.formatJson());
-        }
-        // A legacy Interface; from an older version
-        if (typeof (value.format) === "function") {
-            return new Interface(value.format("json"));
-        }
-        // Array of fragments
-        return new Interface(value);
-    }
-}
-//# sourceMappingURL=interface.js.map