@hashgraphonline/standards-sdk 0.0.96 → 0.0.97

package/dist/es/standards-sdk.es29.js.map

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

package/dist/es/standards-sdk.es30.js

@@ -1,5 +1,5 @@
-import { getDefaultExportFromCjs } from "./standards-sdk.es51.js";
-import { __require as requireBrowser } from "./standards-sdk.es48.js";
+import { getDefaultExportFromCjs } from "./standards-sdk.es108.js";
+import { __require as requireBrowser } from "./standards-sdk.es53.js";
 var browserExports = requireBrowser();
 const pino = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
 export {

package/dist/es/standards-sdk.es32.js

@@ -1,20 +1,20 @@
-import utils from "./standards-sdk.es52.js";
-import bind from "./standards-sdk.es53.js";
-import Axios from "./standards-sdk.es54.js";
-import mergeConfig from "./standards-sdk.es55.js";
-import defaults from "./standards-sdk.es56.js";
-import formDataToJSON from "./standards-sdk.es57.js";
-import CanceledError from "./standards-sdk.es58.js";
-import CancelToken from "./standards-sdk.es59.js";
-import isCancel from "./standards-sdk.es60.js";
-import { VERSION } from "./standards-sdk.es61.js";
-import toFormData from "./standards-sdk.es62.js";
-import AxiosError from "./standards-sdk.es63.js";
-import spread from "./standards-sdk.es64.js";
-import isAxiosError from "./standards-sdk.es65.js";
-import AxiosHeaders from "./standards-sdk.es66.js";
-import adapters from "./standards-sdk.es67.js";
-import HttpStatusCode from "./standards-sdk.es68.js";
+import utils from "./standards-sdk.es36.js";
+import bind from "./standards-sdk.es37.js";
+import Axios from "./standards-sdk.es38.js";
+import mergeConfig from "./standards-sdk.es39.js";
+import defaults from "./standards-sdk.es40.js";
+import formDataToJSON from "./standards-sdk.es41.js";
+import CanceledError from "./standards-sdk.es42.js";
+import CancelToken from "./standards-sdk.es43.js";
+import isCancel from "./standards-sdk.es44.js";
+import { VERSION } from "./standards-sdk.es45.js";
+import toFormData from "./standards-sdk.es46.js";
+import AxiosError from "./standards-sdk.es47.js";
+import spread from "./standards-sdk.es48.js";
+import isAxiosError from "./standards-sdk.es49.js";
+import AxiosHeaders from "./standards-sdk.es50.js";
+import adapters from "./standards-sdk.es51.js";
+import HttpStatusCode from "./standards-sdk.es52.js";
 function createInstance(defaultConfig) {
   const context = new Axios(defaultConfig);
   const instance = bind(Axios.prototype.request, context);

package/dist/es/standards-sdk.es33.js

@@ -1,4 +1,4 @@
-import { getBytes } from "./standards-sdk.es95.js";
+import { getBytes } from "./standards-sdk.es69.js";
 function decodeBase64(textData) {
   textData = atob(textData);
   const data = new Uint8Array(textData.length);

package/dist/es/standards-sdk.es35.js

@@ -1,104 +1,5 @@
-import { __exports as mimeTypes } from "./standards-sdk.es36.js";
-import { __require as requireMimeDb } from "./standards-sdk.es37.js";
-import { __require as requirePathBrowserify } from "./standards-sdk.es38.js";
-/*!
- * mime-types
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-var hasRequiredMimeTypes;
-function requireMimeTypes() {
-  if (hasRequiredMimeTypes) return mimeTypes;
-  hasRequiredMimeTypes = 1;
-  (function(exports) {
-    var db = requireMimeDb();
-    var extname = requirePathBrowserify().extname;
-    var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
-    var TEXT_TYPE_REGEXP = /^text\//i;
-    exports.charset = charset;
-    exports.charsets = { lookup: charset };
-    exports.contentType = contentType;
-    exports.extension = extension;
-    exports.extensions = /* @__PURE__ */ Object.create(null);
-    exports.lookup = lookup;
-    exports.types = /* @__PURE__ */ Object.create(null);
-    populateMaps(exports.extensions, exports.types);
-    function charset(type) {
-      if (!type || typeof type !== "string") {
-        return false;
-      }
-      var match = EXTRACT_TYPE_REGEXP.exec(type);
-      var mime = match && db[match[1].toLowerCase()];
-      if (mime && mime.charset) {
-        return mime.charset;
-      }
-      if (match && TEXT_TYPE_REGEXP.test(match[1])) {
-        return "UTF-8";
-      }
-      return false;
-    }
-    function contentType(str) {
-      if (!str || typeof str !== "string") {
-        return false;
-      }
-      var mime = str.indexOf("/") === -1 ? exports.lookup(str) : str;
-      if (!mime) {
-        return false;
-      }
-      if (mime.indexOf("charset") === -1) {
-        var charset2 = exports.charset(mime);
-        if (charset2) mime += "; charset=" + charset2.toLowerCase();
-      }
-      return mime;
-    }
-    function extension(type) {
-      if (!type || typeof type !== "string") {
-        return false;
-      }
-      var match = EXTRACT_TYPE_REGEXP.exec(type);
-      var exts = match && exports.extensions[match[1].toLowerCase()];
-      if (!exts || !exts.length) {
-        return false;
-      }
-      return exts[0];
-    }
-    function lookup(path) {
-      if (!path || typeof path !== "string") {
-        return false;
-      }
-      var extension2 = extname("x." + path).toLowerCase().substr(1);
-      if (!extension2) {
-        return false;
-      }
-      return exports.types[extension2] || false;
-    }
-    function populateMaps(extensions, types) {
-      var preference = ["nginx", "apache", void 0, "iana"];
-      Object.keys(db).forEach(function forEachMimeType(type) {
-        var mime = db[type];
-        var exts = mime.extensions;
-        if (!exts || !exts.length) {
-          return;
-        }
-        extensions[type] = exts;
-        for (var i = 0; i < exts.length; i++) {
-          var extension2 = exts[i];
-          if (types[extension2]) {
-            var from = preference.indexOf(db[types[extension2]].source);
-            var to = preference.indexOf(mime.source);
-            if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
-              continue;
-            }
-          }
-          types[extension2] = type;
-        }
-      });
-    }
-  })(mimeTypes);
-  return mimeTypes;
-}
+const version = "6.13.5";
 export {
-  requireMimeTypes as __require
+  version
 };
 //# sourceMappingURL=standards-sdk.es35.js.map

package/dist/es/standards-sdk.es35.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es35.js","sources":["../../node_modules/mime-types/index.js"],"sourcesContent":["/*!\n * mime-types\n * Copyright(c) 2014 Jonathan Ong\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict'\n\n/**\n * Module dependencies.\n * @private\n */\n\nvar db = require('mime-db')\nvar extname = require('path').extname\n\n/**\n * Module variables.\n * @private\n */\n\nvar EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/\nvar TEXT_TYPE_REGEXP = /^text\\//i\n\n/**\n * Module exports.\n * @public\n */\n\nexports.charset = charset\nexports.charsets = { lookup: charset }\nexports.contentType = contentType\nexports.extension = extension\nexports.extensions = Object.create(null)\nexports.lookup = lookup\nexports.types = Object.create(null)\n\n// Populate the extensions/types maps\npopulateMaps(exports.extensions, exports.types)\n\n/**\n * Get the default charset for a MIME type.\n *\n * @param {string} type\n * @return {boolean|string}\n */\n\nfunction charset (type) {\n  if (!type || typeof type !== 'string') {\n    return false\n  }\n\n  // TODO: use media-typer\n  var match = EXTRACT_TYPE_REGEXP.exec(type)\n  var mime = match && db[match[1].toLowerCase()]\n\n  if (mime && mime.charset) {\n    return mime.charset\n  }\n\n  // default text/* to utf-8\n  if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n    return 'UTF-8'\n  }\n\n  return false\n}\n\n/**\n * Create a full Content-Type header given a MIME type or extension.\n *\n * @param {string} str\n * @return {boolean|string}\n */\n\nfunction contentType (str) {\n  // TODO: should this even be in this module?\n  if (!str || typeof str !== 'string') {\n    return false\n  }\n\n  var mime = str.indexOf('/') === -1\n    ? exports.lookup(str)\n    : str\n\n  if (!mime) {\n    return false\n  }\n\n  // TODO: use content-type or other module\n  if (mime.indexOf('charset') === -1) {\n    var charset = exports.charset(mime)\n    if (charset) mime += '; charset=' + charset.toLowerCase()\n  }\n\n  return mime\n}\n\n/**\n * Get the default extension for a MIME type.\n *\n * @param {string} type\n * @return {boolean|string}\n */\n\nfunction extension (type) {\n  if (!type || typeof type !== 'string') {\n    return false\n  }\n\n  // TODO: use media-typer\n  var match = EXTRACT_TYPE_REGEXP.exec(type)\n\n  // get extensions\n  var exts = match && exports.extensions[match[1].toLowerCase()]\n\n  if (!exts || !exts.length) {\n    return false\n  }\n\n  return exts[0]\n}\n\n/**\n * Lookup the MIME type for a file path/extension.\n *\n * @param {string} path\n * @return {boolean|string}\n */\n\nfunction lookup (path) {\n  if (!path || typeof path !== 'string') {\n    return false\n  }\n\n  // get the extension (\"ext\" or \".ext\" or full path)\n  var extension = extname('x.' + path)\n    .toLowerCase()\n    .substr(1)\n\n  if (!extension) {\n    return false\n  }\n\n  return exports.types[extension] || false\n}\n\n/**\n * Populate the extensions and types maps.\n * @private\n */\n\nfunction populateMaps (extensions, types) {\n  // source preference (least -> most)\n  var preference = ['nginx', 'apache', undefined, 'iana']\n\n  Object.keys(db).forEach(function forEachMimeType (type) {\n    var mime = db[type]\n    var exts = mime.extensions\n\n    if (!exts || !exts.length) {\n      return\n    }\n\n    // mime -> extensions\n    extensions[type] = exts\n\n    // extension -> mime\n    for (var i = 0; i < exts.length; i++) {\n      var extension = exts[i]\n\n      if (types[extension]) {\n        var from = preference.indexOf(db[types[extension]].source)\n        var to = preference.indexOf(mime.source)\n\n        if (types[extension] !== 'application/octet-stream' &&\n          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {\n          // skip the remapping\n          continue\n        }\n      }\n\n      // set the extension -> mime\n      types[extension] = type\n    }\n  })\n}\n"],"names":["require$$0","require$$1","charset","extension"],"mappings":";;;;;;;;;;;;;;AAcA,QAAI,KAAKA,cAAA;AACT,QAAI,UAAUC,wBAAgB;AAO9B,QAAI,sBAAsB;AAC1B,QAAI,mBAAmB;AAOvB,YAAkB,UAAA;AAClB,YAAmB,WAAA,EAAE,QAAQ,QAAO;AACpC,YAAsB,cAAA;AACtB,YAAoB,YAAA;AACpB,YAAA,aAAqB,uBAAO,OAAO,IAAI;AACvC,YAAiB,SAAA;AACjB,YAAA,QAAgB,uBAAO,OAAO,IAAI;AAGlC,iBAAa,QAAQ,YAAY,QAAQ,KAAK;AAS9C,aAAS,QAAS,MAAM;AACtB,UAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACrC,eAAO;AAAA,MACX;AAGE,UAAI,QAAQ,oBAAoB,KAAK,IAAI;AACzC,UAAI,OAAO,SAAS,GAAG,MAAM,CAAC,EAAE,YAAa,CAAA;AAE7C,UAAI,QAAQ,KAAK,SAAS;AACxB,eAAO,KAAK;AAAA,MAChB;AAGE,UAAI,SAAS,iBAAiB,KAAK,MAAM,CAAC,CAAC,GAAG;AAC5C,eAAO;AAAA,MACX;AAEE,aAAO;AAAA,IACT;AASA,aAAS,YAAa,KAAK;AAEzB,UAAI,CAAC,OAAO,OAAO,QAAQ,UAAU;AACnC,eAAO;AAAA,MACX;AAEE,UAAI,OAAO,IAAI,QAAQ,GAAG,MAAM,KAC5B,QAAQ,OAAO,GAAG,IAClB;AAEJ,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,MACX;AAGE,UAAI,KAAK,QAAQ,SAAS,MAAM,IAAI;AAClC,YAAIC,WAAU,QAAQ,QAAQ,IAAI;AAClC,YAAIA,SAAS,SAAQ,eAAeA,SAAQ,YAAW;AAAA,MAC3D;AAEE,aAAO;AAAA,IACT;AASA,aAAS,UAAW,MAAM;AACxB,UAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACrC,eAAO;AAAA,MACX;AAGE,UAAI,QAAQ,oBAAoB,KAAK,IAAI;AAGzC,UAAI,OAAO,SAAS,QAAQ,WAAW,MAAM,CAAC,EAAE,YAAa,CAAA;AAE7D,UAAI,CAAC,QAAQ,CAAC,KAAK,QAAQ;AACzB,eAAO;AAAA,MACX;AAEE,aAAO,KAAK,CAAC;AAAA,IACf;AASA,aAAS,OAAQ,MAAM;AACrB,UAAI,CAAC,QAAQ,OAAO,SAAS,UAAU;AACrC,eAAO;AAAA,MACX;AAGE,UAAIC,aAAY,QAAQ,OAAO,IAAI,EAChC,YAAW,EACX,OAAO,CAAC;AAEX,UAAI,CAACA,YAAW;AACd,eAAO;AAAA,MACX;AAEE,aAAO,QAAQ,MAAMA,UAAS,KAAK;AAAA,IACrC;AAOA,aAAS,aAAc,YAAY,OAAO;AAExC,UAAI,aAAa,CAAC,SAAS,UAAU,QAAW,MAAM;AAEtD,aAAO,KAAK,EAAE,EAAE,QAAQ,SAAS,gBAAiB,MAAM;AACtD,YAAI,OAAO,GAAG,IAAI;AAClB,YAAI,OAAO,KAAK;AAEhB,YAAI,CAAC,QAAQ,CAAC,KAAK,QAAQ;AACzB;AAAA,QACN;AAGI,mBAAW,IAAI,IAAI;AAGnB,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,cAAIA,aAAY,KAAK,CAAC;AAEtB,cAAI,MAAMA,UAAS,GAAG;AACpB,gBAAI,OAAO,WAAW,QAAQ,GAAG,MAAMA,UAAS,CAAC,EAAE,MAAM;AACzD,gBAAI,KAAK,WAAW,QAAQ,KAAK,MAAM;AAEvC,gBAAI,MAAMA,UAAS,MAAM,+BACtB,OAAO,MAAO,SAAS,MAAM,MAAMA,UAAS,EAAE,OAAO,GAAG,EAAE,MAAM,iBAAkB;AAEnF;AAAA,YACV;AAAA,UACA;AAGM,gBAAMA,UAAS,IAAI;AAAA,QACzB;AAAA,MACG,CAAA;AAAA,IACH;AAAA;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es35.js","sources":["../../node_modules/ethers/lib.esm/_version.js"],"sourcesContent":["/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */\n/**\n *  The current version of Ethers.\n */\nexport const version = \"6.13.5\";\n//# sourceMappingURL=_version.js.map"],"names":[],"mappings":"AAIY,MAAC,UAAU;","x_google_ignoreList":[0]}