superstack-wallet-sdk 0.4.4 → 0.4.7

package/dist/esm/node_modules/abitype/dist/esm/human-readable/runtime/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../../../../../../../node_modules/abitype/dist/esm/human-readable/runtime/utils.js"],"sourcesContent":["import { bytesRegex, execTyped, integerRegex, isTupleRegex, } from '../../regex.js';\nimport { UnknownSolidityTypeError } from '../errors/abiItem.js';\nimport { InvalidFunctionModifierError, InvalidModifierError, InvalidParameterError, SolidityProtectedKeywordError, } from '../errors/abiParameter.js';\nimport { InvalidSignatureError, UnknownSignatureError, } from '../errors/signature.js';\nimport { InvalidParenthesisError } from '../errors/splitParameters.js';\nimport { getParameterCacheKey, parameterCache } from './cache.js';\nimport { eventModifiers, execConstructorSignature, execErrorSignature, execEventSignature, execFallbackSignature, execFunctionSignature, functionModifiers, isConstructorSignature, isErrorSignature, isEventSignature, isFallbackSignature, isFunctionSignature, isReceiveSignature, } from './signatures.js';\nexport function parseSignature(signature, structs = {}) {\n    if (isFunctionSignature(signature))\n        return parseFunctionSignature(signature, structs);\n    if (isEventSignature(signature))\n        return parseEventSignature(signature, structs);\n    if (isErrorSignature(signature))\n        return parseErrorSignature(signature, structs);\n    if (isConstructorSignature(signature))\n        return parseConstructorSignature(signature, structs);\n    if (isFallbackSignature(signature))\n        return parseFallbackSignature(signature);\n    if (isReceiveSignature(signature))\n        return {\n            type: 'receive',\n            stateMutability: 'payable',\n        };\n    throw new UnknownSignatureError({ signature });\n}\nexport function parseFunctionSignature(signature, structs = {}) {\n    const match = execFunctionSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'function' });\n    const inputParams = splitParameters(match.parameters);\n    const inputs = [];\n    const inputLength = inputParams.length;\n    for (let i = 0; i < inputLength; i++) {\n        inputs.push(parseAbiParameter(inputParams[i], {\n            modifiers: functionModifiers,\n            structs,\n            type: 'function',\n        }));\n    }\n    const outputs = [];\n    if (match.returns) {\n        const outputParams = splitParameters(match.returns);\n        const outputLength = outputParams.length;\n        for (let i = 0; i < outputLength; i++) {\n            outputs.push(parseAbiParameter(outputParams[i], {\n                modifiers: functionModifiers,\n                structs,\n                type: 'function',\n            }));\n        }\n    }\n    return {\n        name: match.name,\n        type: 'function',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n        inputs,\n        outputs,\n    };\n}\nexport function parseEventSignature(signature, structs = {}) {\n    const match = execEventSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'event' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], {\n            modifiers: eventModifiers,\n            structs,\n            type: 'event',\n        }));\n    return { name: match.name, type: 'event', inputs: abiParameters };\n}\nexport function parseErrorSignature(signature, structs = {}) {\n    const match = execErrorSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'error' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'error' }));\n    return { name: match.name, type: 'error', inputs: abiParameters };\n}\nexport function parseConstructorSignature(signature, structs = {}) {\n    const match = execConstructorSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'constructor' });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++)\n        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'constructor' }));\n    return {\n        type: 'constructor',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n        inputs: abiParameters,\n    };\n}\nexport function parseFallbackSignature(signature) {\n    const match = execFallbackSignature(signature);\n    if (!match)\n        throw new InvalidSignatureError({ signature, type: 'fallback' });\n    return {\n        type: 'fallback',\n        stateMutability: match.stateMutability ?? 'nonpayable',\n    };\n}\nconst abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\\spayable)?)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;\nconst abiParameterWithTupleRegex = /^\\((?<type>.+?)\\)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;\nconst dynamicIntegerRegex = /^u?int$/;\nexport function parseAbiParameter(param, options) {\n    // optional namespace cache by `type`\n    const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);\n    if (parameterCache.has(parameterCacheKey))\n        return parameterCache.get(parameterCacheKey);\n    const isTuple = isTupleRegex.test(param);\n    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);\n    if (!match)\n        throw new InvalidParameterError({ param });\n    if (match.name && isSolidityKeyword(match.name))\n        throw new SolidityProtectedKeywordError({ param, name: match.name });\n    const name = match.name ? { name: match.name } : {};\n    const indexed = match.modifier === 'indexed' ? { indexed: true } : {};\n    const structs = options?.structs ?? {};\n    let type;\n    let components = {};\n    if (isTuple) {\n        type = 'tuple';\n        const params = splitParameters(match.type);\n        const components_ = [];\n        const length = params.length;\n        for (let i = 0; i < length; i++) {\n            // remove `modifiers` from `options` to prevent from being added to tuple components\n            components_.push(parseAbiParameter(params[i], { structs }));\n        }\n        components = { components: components_ };\n    }\n    else if (match.type in structs) {\n        type = 'tuple';\n        components = { components: structs[match.type] };\n    }\n    else if (dynamicIntegerRegex.test(match.type)) {\n        type = `${match.type}256`;\n    }\n    else if (match.type === 'address payable') {\n        type = 'address';\n    }\n    else {\n        type = match.type;\n        if (!(options?.type === 'struct') && !isSolidityType(type))\n            throw new UnknownSolidityTypeError({ type });\n    }\n    if (match.modifier) {\n        // Check if modifier exists, but is not allowed (e.g. `indexed` in `functionModifiers`)\n        if (!options?.modifiers?.has?.(match.modifier))\n            throw new InvalidModifierError({\n                param,\n                type: options?.type,\n                modifier: match.modifier,\n            });\n        // Check if resolved `type` is valid if there is a function modifier\n        if (functionModifiers.has(match.modifier) &&\n            !isValidDataLocation(type, !!match.array))\n            throw new InvalidFunctionModifierError({\n                param,\n                type: options?.type,\n                modifier: match.modifier,\n            });\n    }\n    const abiParameter = {\n        type: `${type}${match.array ?? ''}`,\n        ...name,\n        ...indexed,\n        ...components,\n    };\n    parameterCache.set(parameterCacheKey, abiParameter);\n    return abiParameter;\n}\n// s/o latika for this\nexport function splitParameters(params, result = [], current = '', depth = 0) {\n    const length = params.trim().length;\n    // biome-ignore lint/correctness/noUnreachable: recursive\n    for (let i = 0; i < length; i++) {\n        const char = params[i];\n        const tail = params.slice(i + 1);\n        switch (char) {\n            case ',':\n                return depth === 0\n                    ? splitParameters(tail, [...result, current.trim()])\n                    : splitParameters(tail, result, `${current}${char}`, depth);\n            case '(':\n                return splitParameters(tail, result, `${current}${char}`, depth + 1);\n            case ')':\n                return splitParameters(tail, result, `${current}${char}`, depth - 1);\n            default:\n                return splitParameters(tail, result, `${current}${char}`, depth);\n        }\n    }\n    if (current === '')\n        return result;\n    if (depth !== 0)\n        throw new InvalidParenthesisError({ current, depth });\n    result.push(current.trim());\n    return result;\n}\nexport function isSolidityType(type) {\n    return (type === 'address' ||\n        type === 'bool' ||\n        type === 'function' ||\n        type === 'string' ||\n        bytesRegex.test(type) ||\n        integerRegex.test(type));\n}\nconst protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;\n/** @internal */\nexport function isSolidityKeyword(name) {\n    return (name === 'address' ||\n        name === 'bool' ||\n        name === 'function' ||\n        name === 'string' ||\n        name === 'tuple' ||\n        bytesRegex.test(name) ||\n        integerRegex.test(name) ||\n        protectedKeywordsRegex.test(name));\n}\n/** @internal */\nexport function isValidDataLocation(type, isArray) {\n    return isArray || type === 'bytes' || type === 'string' || type === 'tuple';\n}\n//# sourceMappingURL=utils.js.map"],"names":["parseSignature","signature","structs","isFunctionSignature","parseFunctionSignature","isEventSignature","parseEventSignature","isErrorSignature","parseErrorSignature","isConstructorSignature","parseConstructorSignature","isFallbackSignature","parseFallbackSignature","isReceiveSignature","type","stateMutability","UnknownSignatureError","match","execFunctionSignature","InvalidSignatureError","inputParams","splitParameters","parameters","inputs","inputLength","length","i","push","parseAbiParameter","modifiers","functionModifiers","outputs","returns","outputParams","outputLength","name","execEventSignature","params","abiParameters","eventModifiers","execErrorSignature","execConstructorSignature","execFallbackSignature","abiParameterWithoutTupleRegex","abiParameterWithTupleRegex","dynamicIntegerRegex","param","options","parameterCacheKey","getParameterCacheKey","parameterCache","has","get","isTuple","isTupleRegex","test","execTyped","InvalidParameterError","isSolidityKeyword","SolidityProtectedKeywordError","indexed","modifier","components","components_","isSolidityType","UnknownSolidityTypeError","InvalidModifierError","isValidDataLocation","array","InvalidFunctionModifierError","abiParameter","set","result","current","depth","trim","char","tail","slice","InvalidParenthesisError","bytesRegex","integerRegex","protectedKeywordsRegex","isArray"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/abitype/dist/esm/regex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regex.js","sources":["../../../../../../node_modules/abitype/dist/esm/regex.js"],"sourcesContent":["// TODO: This looks cool. Need to check the performance of `new RegExp` versus defined inline though.\n// https://twitter.com/GabrielVergnaud/status/1622906834343366657\nexport function execTyped(regex, string) {\n    const match = regex.exec(string);\n    return match?.groups;\n}\n// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n// https://regexr.com/6va55\nexport const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;\n// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n// https://regexr.com/6v8hp\nexport const integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;\nexport const isTupleRegex = /^\\(.+?\\).*?$/;\n//# sourceMappingURL=regex.js.map"],"names":["execTyped","regex","string","match","exec","groups","bytesRegex","integerRegex","isTupleRegex"],"mappings":"AAEO,SAASA,EAAUC,EAAOC,GAC7B,MAAMC,EAAQF,EAAMG,KAAKF,GACzB,OAAOC,GAAOE,MAClB,CAGY,MAACC,EAAa,uCAGbC,EAAe,+HACfC,EAAe","x_google_ignoreList":[0]}

package/dist/esm/node_modules/abitype/dist/esm/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sources":["../../../../../../node_modules/abitype/dist/esm/version.js"],"sourcesContent":["export const version = '1.1.0';\n//# sourceMappingURL=version.js.map"],"names":["version"],"mappings":"AAAY,MAACA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/_version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_version.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.15.0\";\n//# sourceMappingURL=_version.js.map"],"names":["version"],"mappings":"AAIY,MAACA,EAAU","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/data.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/data.js"],"sourcesContent":["/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map"],"names":["getBytes","value","name","Uint8Array","match","result","length","offset","i","parseInt","substring","assertArgument","_getBytes"],"mappings":"6CAgCO,SAASA,EAASC,EAAOC,GAC5B,OA1BJ,SAAmBD,EAAOC,GACtB,GAAID,aAAiBE,WAIjB,OAAOF,EAEX,GAAuB,iBAAnB,GAA+BA,EAAMG,MAAM,8BAA+B,CAC1E,MAAMC,EAAS,IAAIF,YAAYF,EAAMK,OAAS,GAAK,GACnD,IAAIC,EAAS,EACb,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAOC,OAAQE,IAC/BH,EAAOG,GAAKC,SAASR,EAAMS,UAAUH,EAAQA,EAAS,GAAI,IAC1DA,GAAU,EAEd,OAAOF,CACX,CACAM,GAAe,EAAO,0BAA2BT,EAAiBD,EACtE,CASWW,CAAUX,EAAOC,EAC5B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/errors.js"],"sourcesContent":["/**\n *  All errors in ethers include properties to ensure they are both\n *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).\n *\n *  The [[isError]] function can be used to check the error ``code`` and\n *  provide a type guard for the properties present on that error interface.\n *\n *  @_section: api/utils/errors:Errors  [about-errors]\n */\nimport { version } from \"../_version.js\";\nimport { defineProperties } from \"./properties.js\";\nfunction stringify(value, seen) {\n    if (value == null) {\n        return \"null\";\n    }\n    if (seen == null) {\n        seen = new Set();\n    }\n    if (typeof (value) === \"object\") {\n        if (seen.has(value)) {\n            return \"[Circular]\";\n        }\n        seen.add(value);\n    }\n    if (Array.isArray(value)) {\n        return \"[ \" + (value.map((v) => stringify(v, seen))).join(\", \") + \" ]\";\n    }\n    if (value instanceof Uint8Array) {\n        const HEX = \"0123456789abcdef\";\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            result += HEX[value[i] >> 4];\n            result += HEX[value[i] & 0xf];\n        }\n        return result;\n    }\n    if (typeof (value) === \"object\" && typeof (value.toJSON) === \"function\") {\n        return stringify(value.toJSON(), seen);\n    }\n    switch (typeof (value)) {\n        case \"boolean\":\n        case \"number\":\n        case \"symbol\":\n            return value.toString();\n        case \"bigint\":\n            return BigInt(value).toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"object\": {\n            const keys = Object.keys(value);\n            keys.sort();\n            return \"{ \" + keys.map((k) => `${stringify(k, seen)}: ${stringify(value[k], seen)}`).join(\", \") + \" }\";\n        }\n    }\n    return `[ COULD NOT SERIALIZE ]`;\n}\n/**\n *  Returns true if the %%error%% matches an error thrown by ethers\n *  that matches the error %%code%%.\n *\n *  In TypeScript environments, this can be used to check that %%error%%\n *  matches an EthersError type, which means the expected properties will\n *  be set.\n *\n *  @See [ErrorCodes](api:ErrorCode)\n *  @example\n *    try {\n *      // code....\n *    } catch (e) {\n *      if (isError(e, \"CALL_EXCEPTION\")) {\n *          // The Type Guard has validated this object\n *          console.log(e.data);\n *      }\n *    }\n */\nexport function isError(error, code) {\n    return (error && error.code === code);\n}\n/**\n *  Returns true if %%error%% is a [[CallExceptionError].\n */\nexport function isCallException(error) {\n    return isError(error, \"CALL_EXCEPTION\");\n}\n/**\n *  Returns a new Error configured to the format ethers emits errors, with\n *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties\n *  for the corresponding EthersError.\n *\n *  Each error in ethers includes the version of ethers, a\n *  machine-readable [[ErrorCode]], and depending on %%code%%, additional\n *  required properties. The error message will also include the %%message%%,\n *  ethers version, %%code%% and all additional properties, serialized.\n */\nexport function makeError(message, code, info) {\n    let shortMessage = message;\n    {\n        const details = [];\n        if (info) {\n            if (\"message\" in info || \"code\" in info || \"name\" in info) {\n                throw new Error(`value will overwrite populated values: ${stringify(info)}`);\n            }\n            for (const key in info) {\n                if (key === \"shortMessage\") {\n                    continue;\n                }\n                const value = (info[key]);\n                //                try {\n                details.push(key + \"=\" + stringify(value));\n                //                } catch (error: any) {\n                //                console.log(\"MMM\", error.message);\n                //                    details.push(key + \"=[could not serialize object]\");\n                //                }\n            }\n        }\n        details.push(`code=${code}`);\n        details.push(`version=${version}`);\n        if (details.length) {\n            message += \" (\" + details.join(\", \") + \")\";\n        }\n    }\n    let error;\n    switch (code) {\n        case \"INVALID_ARGUMENT\":\n            error = new TypeError(message);\n            break;\n        case \"NUMERIC_FAULT\":\n        case \"BUFFER_OVERRUN\":\n            error = new RangeError(message);\n            break;\n        default:\n            error = new Error(message);\n    }\n    defineProperties(error, { code });\n    if (info) {\n        Object.assign(error, info);\n    }\n    if (error.shortMessage == null) {\n        defineProperties(error, { shortMessage });\n    }\n    return error;\n}\n/**\n *  Throws an EthersError with %%message%%, %%code%% and additional error\n *  %%info%% when %%check%% is falsish..\n *\n *  @see [[api:makeError]]\n */\nexport function assert(check, message, code, info) {\n    if (!check) {\n        throw makeError(message, code, info);\n    }\n}\n/**\n *  A simple helper to simply ensuring provided arguments match expected\n *  constraints, throwing if not.\n *\n *  In TypeScript environments, the %%check%% has been asserted true, so\n *  any further code does not need additional compile-time checks.\n */\nexport function assertArgument(check, message, name, value) {\n    assert(check, message, \"INVALID_ARGUMENT\", { argument: name, value: value });\n}\nexport function assertArgumentCount(count, expectedCount, message) {\n    if (message == null) {\n        message = \"\";\n    }\n    if (message) {\n        message = \": \" + message;\n    }\n    assert(count >= expectedCount, \"missing argument\" + message, \"MISSING_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n    assert(count <= expectedCount, \"too many arguments\" + message, \"UNEXPECTED_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n}\nconst _normalizeForms = [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].reduce((accum, form) => {\n    try {\n        // General test for normalize\n        /* c8 ignore start */\n        if (\"test\".normalize(form) !== \"test\") {\n            throw new Error(\"bad\");\n        }\n        ;\n        /* c8 ignore stop */\n        if (form === \"NFD\") {\n            const check = String.fromCharCode(0xe9).normalize(\"NFD\");\n            const expected = String.fromCharCode(0x65, 0x0301);\n            /* c8 ignore start */\n            if (check !== expected) {\n                throw new Error(\"broken\");\n            }\n            /* c8 ignore stop */\n        }\n        accum.push(form);\n    }\n    catch (error) { }\n    return accum;\n}, []);\n/**\n *  Throws if the normalization %%form%% is not supported.\n */\nexport function assertNormalize(form) {\n    assert(_normalizeForms.indexOf(form) >= 0, \"platform missing String.prototype.normalize\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"String.prototype.normalize\", info: { form }\n    });\n}\n/**\n *  Many classes use file-scoped values to guard the constructor,\n *  making it effectively private. This facilitates that pattern\n *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,\n *  throwing if not, indicating the %%className%% if provided.\n */\nexport function assertPrivate(givenGuard, guard, className) {\n    if (className == null) {\n        className = \"\";\n    }\n    if (givenGuard !== guard) {\n        let method = className, operation = \"new\";\n        if (className) {\n            method += \".\";\n            operation += \" \" + className;\n        }\n        assert(false, `private constructor; use ${method}from* methods`, \"UNSUPPORTED_OPERATION\", {\n            operation\n        });\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":["stringify","value","seen","Set","has","add","Array","isArray","map","v","join","Uint8Array","HEX","result","i","length","toJSON","toString","BigInt","JSON","keys","Object","sort","k","makeError","message","code","info","error","shortMessage","details","Error","key","push","version","TypeError","RangeError","defineProperties","assign","assert","check","assertArgument","name","argument","assertPrivate","givenGuard","guard","className","method","operation","reduce","accum","form","normalize","String","fromCharCode"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/fixednumber.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixednumber.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/fixednumber.js"],"sourcesContent":["/**\n *  The **FixedNumber** class permits using values with decimal places,\n *  using fixed-pont math.\n *\n *  Fixed-point math is still based on integers under-the-hood, but uses an\n *  internal offset to store fractional components below, and each operation\n *  corrects for this after each operation.\n *\n *  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]\n */\nimport { getBytes } from \"./data.js\";\nimport { assert, assertArgument, assertPrivate } from \"./errors.js\";\nimport { getBigInt, getNumber, fromTwos, mask, toBigInt } from \"./maths.js\";\nimport { defineProperties } from \"./properties.js\";\nconst BN_N1 = BigInt(-1);\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_5 = BigInt(5);\nconst _guard = {};\n// Constant to pull zeros from for multipliers\nlet Zeros = \"0000\";\nwhile (Zeros.length < 80) {\n    Zeros += Zeros;\n}\n// Returns a string \"1\" followed by decimal \"0\"s\nfunction getTens(decimals) {\n    let result = Zeros;\n    while (result.length < decimals) {\n        result += result;\n    }\n    return BigInt(\"1\" + result.substring(0, decimals));\n}\nfunction checkValue(val, format, safeOp) {\n    const width = BigInt(format.width);\n    if (format.signed) {\n        const limit = (BN_1 << (width - BN_1));\n        assert(safeOp == null || (val >= -limit && val < limit), \"overflow\", \"NUMERIC_FAULT\", {\n            operation: safeOp, fault: \"overflow\", value: val\n        });\n        if (val > BN_0) {\n            val = fromTwos(mask(val, width), width);\n        }\n        else {\n            val = -fromTwos(mask(-val, width), width);\n        }\n    }\n    else {\n        const limit = (BN_1 << width);\n        assert(safeOp == null || (val >= 0 && val < limit), \"overflow\", \"NUMERIC_FAULT\", {\n            operation: safeOp, fault: \"overflow\", value: val\n        });\n        val = (((val % limit) + limit) % limit) & (limit - BN_1);\n    }\n    return val;\n}\nfunction getFormat(value) {\n    if (typeof (value) === \"number\") {\n        value = `fixed128x${value}`;\n    }\n    let signed = true;\n    let width = 128;\n    let decimals = 18;\n    if (typeof (value) === \"string\") {\n        // Parse the format string\n        if (value === \"fixed\") {\n            // defaults...\n        }\n        else if (value === \"ufixed\") {\n            signed = false;\n        }\n        else {\n            const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);\n            assertArgument(match, \"invalid fixed format\", \"format\", value);\n            signed = (match[1] !== \"u\");\n            width = parseInt(match[2]);\n            decimals = parseInt(match[3]);\n        }\n    }\n    else if (value) {\n        // Extract the values from the object\n        const v = value;\n        const check = (key, type, defaultValue) => {\n            if (v[key] == null) {\n                return defaultValue;\n            }\n            assertArgument(typeof (v[key]) === type, \"invalid fixed format (\" + key + \" not \" + type + \")\", \"format.\" + key, v[key]);\n            return v[key];\n        };\n        signed = check(\"signed\", \"boolean\", signed);\n        width = check(\"width\", \"number\", width);\n        decimals = check(\"decimals\", \"number\", decimals);\n    }\n    assertArgument((width % 8) === 0, \"invalid FixedNumber width (not byte aligned)\", \"format.width\", width);\n    assertArgument(decimals <= 80, \"invalid FixedNumber decimals (too large)\", \"format.decimals\", decimals);\n    const name = (signed ? \"\" : \"u\") + \"fixed\" + String(width) + \"x\" + String(decimals);\n    return { signed, width, decimals, name };\n}\nfunction toString(val, decimals) {\n    let negative = \"\";\n    if (val < BN_0) {\n        negative = \"-\";\n        val *= BN_N1;\n    }\n    let str = val.toString();\n    // No decimal point for whole values\n    if (decimals === 0) {\n        return (negative + str);\n    }\n    // Pad out to the whole component (including a whole digit)\n    while (str.length <= decimals) {\n        str = Zeros + str;\n    }\n    // Insert the decimal point\n    const index = str.length - decimals;\n    str = str.substring(0, index) + \".\" + str.substring(index);\n    // Trim the whole component (leaving at least one 0)\n    while (str[0] === \"0\" && str[1] !== \".\") {\n        str = str.substring(1);\n    }\n    // Trim the decimal component (leaving at least one 0)\n    while (str[str.length - 1] === \"0\" && str[str.length - 2] !== \".\") {\n        str = str.substring(0, str.length - 1);\n    }\n    return (negative + str);\n}\n/**\n *  A FixedNumber represents a value over its [[FixedFormat]]\n *  arithmetic field.\n *\n *  A FixedNumber can be used to perform math, losslessly, on\n *  values which have decmial places.\n *\n *  A FixedNumber has a fixed bit-width to store values in, and stores all\n *  values internally by multiplying the value by 10 raised to the power of\n *  %%decimals%%.\n *\n *  If operations are performed that cause a value to grow too high (close to\n *  positive infinity) or too low (close to negative infinity), the value\n *  is said to //overflow//.\n *\n *  For example, an 8-bit signed value, with 0 decimals may only be within\n *  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become\n *  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.\n *\n *  Many operation have a normal and //unsafe// variant. The normal variant\n *  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//\n *  variant will silently allow overflow, corrupting its value value.\n *\n *  If operations are performed that cause a value to become too small\n *  (close to zero), the value loses precison and is said to //underflow//.\n *\n *  For example, a value with 1 decimal place may store a number as small\n *  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit\n *  into 1 decimal place, so underflow occurs which means precision is lost\n *  and the value becomes ``0``.\n *\n *  Some operations have a normal and //signalling// variant. The normal\n *  variant will silently ignore underflow, while the //signalling// variant\n *  will thow a [[NumericFaultError]] on underflow.\n */\nexport class FixedNumber {\n    /**\n     *  The specific fixed-point arithmetic field for this value.\n     */\n    format;\n    #format;\n    // The actual value (accounting for decimals)\n    #val;\n    // A base-10 value to multiple values by to maintain the magnitude\n    #tens;\n    /**\n     *  This is a property so console.log shows a human-meaningful value.\n     *\n     *  @private\n     */\n    _value;\n    // Use this when changing this file to get some typing info,\n    // but then switch to any to mask the internal type\n    //constructor(guard: any, value: bigint, format: _FixedFormat) {\n    /**\n     *  @private\n     */\n    constructor(guard, value, format) {\n        assertPrivate(guard, _guard, \"FixedNumber\");\n        this.#val = value;\n        this.#format = format;\n        const _value = toString(value, format.decimals);\n        defineProperties(this, { format: format.name, _value });\n        this.#tens = getTens(format.decimals);\n    }\n    /**\n     *  If true, negative values are permitted, otherwise only\n     *  positive values and zero are allowed.\n     */\n    get signed() { return this.#format.signed; }\n    /**\n     *  The number of bits available to store the value.\n     */\n    get width() { return this.#format.width; }\n    /**\n     *  The number of decimal places in the fixed-point arithment field.\n     */\n    get decimals() { return this.#format.decimals; }\n    /**\n     *  The value as an integer, based on the smallest unit the\n     *  [[decimals]] allow.\n     */\n    get value() { return this.#val; }\n    #checkFormat(other) {\n        assertArgument(this.format === other.format, \"incompatible format; use fixedNumber.toFormat\", \"other\", other);\n    }\n    #checkValue(val, safeOp) {\n        /*\n                const width = BigInt(this.width);\n                if (this.signed) {\n                    const limit = (BN_1 << (width - BN_1));\n                    assert(safeOp == null || (val >= -limit  && val < limit), \"overflow\", \"NUMERIC_FAULT\", {\n                        operation: <string>safeOp, fault: \"overflow\", value: val\n                    });\n        \n                    if (val > BN_0) {\n                        val = fromTwos(mask(val, width), width);\n                    } else {\n                        val = -fromTwos(mask(-val, width), width);\n                    }\n        \n                } else {\n                    const masked = mask(val, width);\n                    assert(safeOp == null || (val >= 0 && val === masked), \"overflow\", \"NUMERIC_FAULT\", {\n                        operation: <string>safeOp, fault: \"overflow\", value: val\n                    });\n                    val = masked;\n                }\n        */\n        val = checkValue(val, this.#format, safeOp);\n        return new FixedNumber(_guard, val, this.#format);\n    }\n    #add(o, safeOp) {\n        this.#checkFormat(o);\n        return this.#checkValue(this.#val + o.#val, safeOp);\n    }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% added\n     *  to %%other%%, ignoring overflow.\n     */\n    addUnsafe(other) { return this.#add(other); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% added\n     *  to %%other%%. A [[NumericFaultError]] is thrown if overflow\n     *  occurs.\n     */\n    add(other) { return this.#add(other, \"add\"); }\n    #sub(o, safeOp) {\n        this.#checkFormat(o);\n        return this.#checkValue(this.#val - o.#val, safeOp);\n    }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted\n     *  from %%this%%, ignoring overflow.\n     */\n    subUnsafe(other) { return this.#sub(other); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted\n     *  from %%this%%. A [[NumericFaultError]] is thrown if overflow\n     *  occurs.\n     */\n    sub(other) { return this.#sub(other, \"sub\"); }\n    #mul(o, safeOp) {\n        this.#checkFormat(o);\n        return this.#checkValue((this.#val * o.#val) / this.#tens, safeOp);\n    }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied\n     *  by %%other%%, ignoring overflow and underflow (precision loss).\n     */\n    mulUnsafe(other) { return this.#mul(other); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied\n     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow\n     *  occurs.\n     */\n    mul(other) { return this.#mul(other, \"mul\"); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied\n     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow\n     *  occurs or if underflow (precision loss) occurs.\n     */\n    mulSignal(other) {\n        this.#checkFormat(other);\n        const value = this.#val * other.#val;\n        assert((value % this.#tens) === BN_0, \"precision lost during signalling mul\", \"NUMERIC_FAULT\", {\n            operation: \"mulSignal\", fault: \"underflow\", value: this\n        });\n        return this.#checkValue(value / this.#tens, \"mulSignal\");\n    }\n    #div(o, safeOp) {\n        assert(o.#val !== BN_0, \"division by zero\", \"NUMERIC_FAULT\", {\n            operation: \"div\", fault: \"divide-by-zero\", value: this\n        });\n        this.#checkFormat(o);\n        return this.#checkValue((this.#val * this.#tens) / o.#val, safeOp);\n    }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% divided\n     *  by %%other%%, ignoring underflow (precision loss). A\n     *  [[NumericFaultError]] is thrown if overflow occurs.\n     */\n    divUnsafe(other) { return this.#div(other); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% divided\n     *  by %%other%%, ignoring underflow (precision loss). A\n     *  [[NumericFaultError]] is thrown if overflow occurs.\n     */\n    div(other) { return this.#div(other, \"div\"); }\n    /**\n     *  Returns a new [[FixedNumber]] with the result of %%this%% divided\n     *  by %%other%%. A [[NumericFaultError]] is thrown if underflow\n     *  (precision loss) occurs.\n     */\n    divSignal(other) {\n        assert(other.#val !== BN_0, \"division by zero\", \"NUMERIC_FAULT\", {\n            operation: \"div\", fault: \"divide-by-zero\", value: this\n        });\n        this.#checkFormat(other);\n        const value = (this.#val * this.#tens);\n        assert((value % other.#val) === BN_0, \"precision lost during signalling div\", \"NUMERIC_FAULT\", {\n            operation: \"divSignal\", fault: \"underflow\", value: this\n        });\n        return this.#checkValue(value / other.#val, \"divSignal\");\n    }\n    /**\n     *  Returns a comparison result between %%this%% and %%other%%.\n     *\n     *  This is suitable for use in sorting, where ``-1`` implies %%this%%\n     *  is smaller, ``1`` implies %%this%% is larger and ``0`` implies\n     *  both are equal.\n     */\n    cmp(other) {\n        let a = this.value, b = other.value;\n        // Coerce a and b to the same magnitude\n        const delta = this.decimals - other.decimals;\n        if (delta > 0) {\n            b *= getTens(delta);\n        }\n        else if (delta < 0) {\n            a *= getTens(-delta);\n        }\n        // Comnpare\n        if (a < b) {\n            return -1;\n        }\n        if (a > b) {\n            return 1;\n        }\n        return 0;\n    }\n    /**\n     *  Returns true if %%other%% is equal to %%this%%.\n     */\n    eq(other) { return this.cmp(other) === 0; }\n    /**\n     *  Returns true if %%other%% is less than to %%this%%.\n     */\n    lt(other) { return this.cmp(other) < 0; }\n    /**\n     *  Returns true if %%other%% is less than or equal to %%this%%.\n     */\n    lte(other) { return this.cmp(other) <= 0; }\n    /**\n     *  Returns true if %%other%% is greater than to %%this%%.\n     */\n    gt(other) { return this.cmp(other) > 0; }\n    /**\n     *  Returns true if %%other%% is greater than or equal to %%this%%.\n     */\n    gte(other) { return this.cmp(other) >= 0; }\n    /**\n     *  Returns a new [[FixedNumber]] which is the largest **integer**\n     *  that is less than or equal to %%this%%.\n     *\n     *  The decimal component of the result will always be ``0``.\n     */\n    floor() {\n        let val = this.#val;\n        if (this.#val < BN_0) {\n            val -= this.#tens - BN_1;\n        }\n        val = (this.#val / this.#tens) * this.#tens;\n        return this.#checkValue(val, \"floor\");\n    }\n    /**\n     *  Returns a new [[FixedNumber]] which is the smallest **integer**\n     *  that is greater than or equal to %%this%%.\n     *\n     *  The decimal component of the result will always be ``0``.\n     */\n    ceiling() {\n        let val = this.#val;\n        if (this.#val > BN_0) {\n            val += this.#tens - BN_1;\n        }\n        val = (this.#val / this.#tens) * this.#tens;\n        return this.#checkValue(val, \"ceiling\");\n    }\n    /**\n     *  Returns a new [[FixedNumber]] with the decimal component\n     *  rounded up on ties at %%decimals%% places.\n     */\n    round(decimals) {\n        if (decimals == null) {\n            decimals = 0;\n        }\n        // Not enough precision to not already be rounded\n        if (decimals >= this.decimals) {\n            return this;\n        }\n        const delta = this.decimals - decimals;\n        const bump = BN_5 * getTens(delta - 1);\n        let value = this.value + bump;\n        const tens = getTens(delta);\n        value = (value / tens) * tens;\n        checkValue(value, this.#format, \"round\");\n        return new FixedNumber(_guard, value, this.#format);\n    }\n    /**\n     *  Returns true if %%this%% is equal to ``0``.\n     */\n    isZero() { return (this.#val === BN_0); }\n    /**\n     *  Returns true if %%this%% is less than ``0``.\n     */\n    isNegative() { return (this.#val < BN_0); }\n    /**\n     *  Returns the string representation of %%this%%.\n     */\n    toString() { return this._value; }\n    /**\n     *  Returns a float approximation.\n     *\n     *  Due to IEEE 754 precission (or lack thereof), this function\n     *  can only return an approximation and most values will contain\n     *  rounding errors.\n     */\n    toUnsafeFloat() { return parseFloat(this.toString()); }\n    /**\n     *  Return a new [[FixedNumber]] with the same value but has had\n     *  its field set to %%format%%.\n     *\n     *  This will throw if the value cannot fit into %%format%%.\n     */\n    toFormat(format) {\n        return FixedNumber.fromString(this.toString(), format);\n    }\n    /**\n     *  Creates a new [[FixedNumber]] for %%value%% divided by\n     *  %%decimal%% places with %%format%%.\n     *\n     *  This will throw a [[NumericFaultError]] if %%value%% (once adjusted\n     *  for %%decimals%%) cannot fit in %%format%%, either due to overflow\n     *  or underflow (precision loss).\n     */\n    static fromValue(_value, _decimals, _format) {\n        const decimals = (_decimals == null) ? 0 : getNumber(_decimals);\n        const format = getFormat(_format);\n        let value = getBigInt(_value, \"value\");\n        const delta = decimals - format.decimals;\n        if (delta > 0) {\n            const tens = getTens(delta);\n            assert((value % tens) === BN_0, \"value loses precision for format\", \"NUMERIC_FAULT\", {\n                operation: \"fromValue\", fault: \"underflow\", value: _value\n            });\n            value /= tens;\n        }\n        else if (delta < 0) {\n            value *= getTens(-delta);\n        }\n        checkValue(value, format, \"fromValue\");\n        return new FixedNumber(_guard, value, format);\n    }\n    /**\n     *  Creates a new [[FixedNumber]] for %%value%% with %%format%%.\n     *\n     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit\n     *  in %%format%%, either due to overflow or underflow (precision loss).\n     */\n    static fromString(_value, _format) {\n        const match = _value.match(/^(-?)([0-9]*)\\.?([0-9]*)$/);\n        assertArgument(match && (match[2].length + match[3].length) > 0, \"invalid FixedNumber string value\", \"value\", _value);\n        const format = getFormat(_format);\n        let whole = (match[2] || \"0\"), decimal = (match[3] || \"\");\n        // Pad out the decimals\n        while (decimal.length < format.decimals) {\n            decimal += Zeros;\n        }\n        // Check precision is safe\n        assert(decimal.substring(format.decimals).match(/^0*$/), \"too many decimals for format\", \"NUMERIC_FAULT\", {\n            operation: \"fromString\", fault: \"underflow\", value: _value\n        });\n        // Remove extra padding\n        decimal = decimal.substring(0, format.decimals);\n        const value = BigInt(match[1] + whole + decimal);\n        checkValue(value, format, \"fromString\");\n        return new FixedNumber(_guard, value, format);\n    }\n    /**\n     *  Creates a new [[FixedNumber]] with the big-endian representation\n     *  %%value%% with %%format%%.\n     *\n     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit\n     *  in %%format%% due to overflow.\n     */\n    static fromBytes(_value, _format) {\n        let value = toBigInt(getBytes(_value, \"value\"));\n        const format = getFormat(_format);\n        if (format.signed) {\n            value = fromTwos(value, format.width);\n        }\n        checkValue(value, format, \"fromBytes\");\n        return new FixedNumber(_guard, value, format);\n    }\n}\n//const f1 = FixedNumber.fromString(\"12.56\", \"fixed16x2\");\n//const f2 = FixedNumber.fromString(\"0.3\", \"fixed16x2\");\n//console.log(f1.divSignal(f2));\n//const BUMP = FixedNumber.from(\"0.5\");\n//# sourceMappingURL=fixednumber.js.map"],"names":["BN_N1","BigInt","BN_0","BN_1","BN_5","_guard","Zeros","length","getTens","decimals","result","substring","checkValue","val","format","safeOp","width","signed","limit","assert","operation","fault","value","fromTwos","mask","getFormat","match","assertArgument","parseInt","v","check","key","type","defaultValue","name","String","FixedNumber","tens","_value","constructor","guard","assertPrivate","this","negative","str","toString","index","defineProperties","checkFormat","other","add","o","addUnsafe","sub","subUnsafe","mul","mulUnsafe","mulSignal","div","divUnsafe","divSignal","cmp","a","b","delta","eq","lt","lte","gt","gte","floor","ceiling","round","bump","isZero","isNegative","toUnsafeFloat","parseFloat","toFormat","fromString","fromValue","_decimals","_format","getNumber","getBigInt","whole","decimal","fromBytes","toBigInt","getBytes"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/maths.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"maths.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/maths.js"],"sourcesContent":["/**\n *  Some mathematic operations.\n *\n *  @_subsection: api/utils:Math Helpers  [about-maths]\n */\nimport { hexlify, isBytesLike } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\n//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;\n// IEEE 754 support 53-bits of mantissa\nconst maxValue = 0x1fffffffffffff;\n/**\n *  Convert %%value%% from a twos-compliment representation of %%width%%\n *  bits to its value.\n *\n *  If the highest bit is ``1``, the result will be negative.\n */\nexport function fromTwos(_value, _width) {\n    const value = getUint(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    assert((value >> width) === BN_0, \"overflow\", \"NUMERIC_FAULT\", {\n        operation: \"fromTwos\", fault: \"overflow\", value: _value\n    });\n    // Top bit set; treat as a negative value\n    if (value >> (width - BN_1)) {\n        const mask = (BN_1 << width) - BN_1;\n        return -(((~value) & mask) + BN_1);\n    }\n    return value;\n}\n/**\n *  Convert %%value%% to a twos-compliment representation of\n *  %%width%% bits.\n *\n *  The result will always be positive.\n */\nexport function toTwos(_value, _width) {\n    let value = getBigInt(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    const limit = (BN_1 << (width - BN_1));\n    if (value < BN_0) {\n        value = -value;\n        assert(value <= limit, \"too low\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n        const mask = (BN_1 << width) - BN_1;\n        return ((~value) & mask) + BN_1;\n    }\n    else {\n        assert(value < limit, \"too high\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n    }\n    return value;\n}\n/**\n *  Mask %%value%% with a bitmask of %%bits%% ones.\n */\nexport function mask(_value, _bits) {\n    const value = getUint(_value, \"value\");\n    const bits = BigInt(getNumber(_bits, \"bits\"));\n    return value & ((BN_1 << bits) - BN_1);\n}\n/**\n *  Gets a BigInt from %%value%%. If it is an invalid value for\n *  a BigInt, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getBigInt(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\": return value;\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return BigInt(value);\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                if (value[0] === \"-\" && value[1] !== \"-\") {\n                    return -BigInt(value.substring(1));\n                }\n                return BigInt(value);\n            }\n            catch (e) {\n                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid BigNumberish value\", name || \"value\", value);\n}\n/**\n *  Returns %%value%% as a bigint, validating it is valid as a bigint\n *  value and that it is positive.\n */\nexport function getUint(value, name) {\n    const result = getBigInt(value, name);\n    assert(result >= BN_0, \"unsigned value cannot be negative\", \"NUMERIC_FAULT\", {\n        fault: \"overflow\", operation: \"getUint\", value\n    });\n    return result;\n}\nconst Nibbles = \"0123456789abcdef\";\n/*\n * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it\n * is treated as Big Endian data.\n */\nexport function toBigInt(value) {\n    if (value instanceof Uint8Array) {\n        let result = \"0x0\";\n        for (const v of value) {\n            result += Nibbles[v >> 4];\n            result += Nibbles[v & 0x0f];\n        }\n        return BigInt(result);\n    }\n    return getBigInt(value);\n}\n/**\n *  Gets a //number// from %%value%%. If it is an invalid value for\n *  a //number//, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getNumber(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\":\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return Number(value);\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return value;\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                return getNumber(BigInt(value), name);\n            }\n            catch (e) {\n                assertArgument(false, `invalid numeric string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid numeric value\", name || \"value\", value);\n}\n/**\n *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it\n *  is treated as Big Endian data. Throws if the value is not safe.\n */\nexport function toNumber(value) {\n    return getNumber(toBigInt(value));\n}\n/**\n *  Converts %%value%% to a Big Endian hexstring, optionally padded to\n *  %%width%% bytes.\n */\nexport function toBeHex(_value, _width) {\n    const value = getUint(_value, \"value\");\n    let result = value.toString(16);\n    if (_width == null) {\n        // Ensure the value is of even length\n        if (result.length % 2) {\n            result = \"0\" + result;\n        }\n    }\n    else {\n        const width = getNumber(_width, \"width\");\n        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, \"NUMERIC_FAULT\", {\n            operation: \"toBeHex\",\n            fault: \"overflow\",\n            value: _value\n        });\n        // Pad the value to the required width\n        while (result.length < (width * 2)) {\n            result = \"0\" + result;\n        }\n    }\n    return \"0x\" + result;\n}\n/**\n *  Converts %%value%% to a Big Endian Uint8Array.\n */\nexport function toBeArray(_value) {\n    const value = getUint(_value, \"value\");\n    if (value === BN_0) {\n        return new Uint8Array([]);\n    }\n    let hex = value.toString(16);\n    if (hex.length % 2) {\n        hex = \"0\" + hex;\n    }\n    const result = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < result.length; i++) {\n        const offset = i * 2;\n        result[i] = parseInt(hex.substring(offset, offset + 2), 16);\n    }\n    return result;\n}\n/**\n *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.\n *\n *  A //Quantity// does not have and leading 0 values unless the value is\n *  the literal value `0x0`. This is most commonly used for JSSON-RPC\n *  numeric values.\n */\nexport function toQuantity(value) {\n    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);\n    while (result.startsWith(\"0\")) {\n        result = result.substring(1);\n    }\n    if (result === \"\") {\n        result = \"0\";\n    }\n    return \"0x\" + result;\n}\n//# sourceMappingURL=maths.js.map"],"names":["BN_0","BigInt","BN_1","maxValue","fromTwos","_value","_width","value","getUint","width","getNumber","assert","operation","fault","mask","_bits","bits","getBigInt","name","assertArgument","Number","isInteger","Error","substring","e","message","result","Nibbles","toBigInt","Uint8Array","v"],"mappings":"yDAOA,MAAMA,EAAOC,OAAO,GACdC,EAAOD,OAAO,GAGdE,EAAW,iBAOV,SAASC,EAASC,EAAQC,GAC7B,MAAMC,EAAQC,EAAQH,EAAQ,SACxBI,EAAQR,OAAOS,EAAUJ,EAAQ,UAKvC,GAJAK,EAAQJ,GAASE,IAAWT,EAAM,WAAY,gBAAiB,CAC3DY,UAAW,WAAYC,MAAO,WAAYN,MAAOF,IAGjDE,GAAUE,EAAQP,EAAO,CAEzB,UAAYK,GADEL,GAAQO,GAASP,GACFA,EACjC,CACA,OAAOK,CACX,CA6BO,SAASO,EAAKT,EAAQU,GACzB,MAAMR,EAAQC,EAAQH,EAAQ,SACxBW,EAAOf,OAAOS,EAAUK,EAAO,SACrC,OAAOR,GAAUL,GAAQc,GAAQd,CACrC,CAKO,SAASe,EAAUV,EAAOW,GAC7B,cAAQ,GACJ,IAAK,SAAU,OAAOX,EACtB,IAAK,SAGD,OAFAY,EAAeC,OAAOC,UAAUd,GAAQ,YAAaW,GAAQ,QAASX,GACtEY,EAAeZ,IAAUJ,GAAYI,GAASJ,EAAU,WAAYe,GAAQ,QAASX,GAC9EN,OAAOM,GAClB,IAAK,SACD,IACI,GAAc,KAAVA,EACA,MAAM,IAAIe,MAAM,gBAEpB,MAAiB,MAAbf,EAAM,IAA2B,MAAbA,EAAM,IAClBN,OAAOM,EAAMgB,UAAU,IAE5BtB,OAAOM,EAClB,CACA,MAAOiB,GACHL,GAAe,EAAO,gCAAgCK,EAAEC,UAAWP,GAAQ,QAASX,EACxF,EAERY,GAAe,EAAO,6BAA8BD,GAAQ,QAASX,EACzE,CAKO,SAASC,EAAQD,EAAOW,GAC3B,MAAMQ,EAAST,EAAUV,EAAOW,GAIhC,OAHAP,EAAOe,GAAU1B,EAAM,oCAAqC,gBAAiB,CACzEa,MAAO,WAAYD,UAAW,UAAWL,UAEtCmB,CACX,CACA,MAAMC,EAAU,mBAKT,SAASC,EAASrB,GACrB,GAAIA,aAAiBsB,WAAY,CAC7B,IAAIH,EAAS,MACb,IAAK,MAAMI,KAAKvB,EACZmB,GAAUC,EAAQG,GAAK,GACvBJ,GAAUC,EAAY,GAAJG,GAEtB,OAAO7B,OAAOyB,EAClB,CACA,OAAOT,EAAUV,EACrB,CAKO,SAASG,EAAUH,EAAOW,GAC7B,cAAQ,GACJ,IAAK,SAED,OADAC,EAAeZ,IAAUJ,GAAYI,GAASJ,EAAU,WAAYe,GAAQ,QAASX,GAC9Ea,OAAOb,GAClB,IAAK,SAGD,OAFAY,EAAeC,OAAOC,UAAUd,GAAQ,YAAaW,GAAQ,QAASX,GACtEY,EAAeZ,IAAUJ,GAAYI,GAASJ,EAAU,WAAYe,GAAQ,QAASX,GAC9EA,EACX,IAAK,SACD,IACI,GAAc,KAAVA,EACA,MAAM,IAAIe,MAAM,gBAEpB,OAAOZ,EAAUT,OAAOM,GAAQW,EACpC,CACA,MAAOM,GACHL,GAAe,EAAO,2BAA2BK,EAAEC,UAAWP,GAAQ,QAASX,EACnF,EAERY,GAAe,EAAO,wBAAyBD,GAAQ,QAASX,EACpE","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/properties.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"properties.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/properties.js"],"sourcesContent":["/**\n *  Property helper functions.\n *\n *  @_subsection api/utils:Properties  [about-properties]\n */\nfunction checkType(value, type, name) {\n    const types = type.split(\"|\").map(t => t.trim());\n    for (let i = 0; i < types.length; i++) {\n        switch (type) {\n            case \"any\":\n                return;\n            case \"bigint\":\n            case \"boolean\":\n            case \"number\":\n            case \"string\":\n                if (typeof (value) === type) {\n                    return;\n                }\n        }\n    }\n    const error = new Error(`invalid value for type ${type}`);\n    error.code = \"INVALID_ARGUMENT\";\n    error.argument = `value.${name}`;\n    error.value = value;\n    throw error;\n}\n/**\n *  Resolves to a new object that is a copy of %%value%%, but with all\n *  values resolved.\n */\nexport async function resolveProperties(value) {\n    const keys = Object.keys(value);\n    const results = await Promise.all(keys.map((k) => Promise.resolve(value[k])));\n    return results.reduce((accum, v, index) => {\n        accum[keys[index]] = v;\n        return accum;\n    }, {});\n}\n/**\n *  Assigns the %%values%% to %%target%% as read-only values.\n *\n *  It %%types%% is specified, the values are checked.\n */\nexport function defineProperties(target, values, types) {\n    for (let key in values) {\n        let value = values[key];\n        const type = (types ? types[key] : null);\n        if (type) {\n            checkType(value, type, key);\n        }\n        Object.defineProperty(target, key, { enumerable: true, value, writable: false });\n    }\n}\n//# sourceMappingURL=properties.js.map"],"names":["defineProperties","target","values","types","key","value","Object","defineProperty","enumerable","writable"],"mappings":"AA2CO,SAASA,EAAiBC,EAAQC,EAAQC,GAC7C,IAAK,IAAIC,KAAOF,EAAQ,CACpB,IAAIG,EAAQH,EAAOE,GAKnBE,OAAOC,eAAeN,EAAQG,EAAK,CAAEI,YAAY,EAAMH,QAAOI,UAAU,GAC5E,CACJ","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ethers/lib.esm/utils/units.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"units.js","sources":["../../../../../../node_modules/ethers/lib.esm/utils/units.js"],"sourcesContent":["/**\n *  Most interactions with Ethereum requires integer values, which use\n *  the smallest magnitude unit.\n *\n *  For example, imagine dealing with dollars and cents. Since dollars\n *  are divisible, non-integer values are possible, such as ``$10.77``.\n *  By using the smallest indivisible unit (i.e. cents), the value can\n *  be kept as the integer ``1077``.\n *\n *  When receiving decimal input from the user (as a decimal string),\n *  the value should be converted to an integer and when showing a user\n *  a value, the integer value should be converted to a decimal string.\n *\n *  This creates a clear distinction, between values to be used by code\n *  (integers) and values used for display logic to users (decimals).\n *\n *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,\n *  where each individual unit is called a //wei//.\n *\n *  @_subsection api/utils:Unit Conversion  [about-units]\n */\nimport { assertArgument } from \"./errors.js\";\nimport { FixedNumber } from \"./fixednumber.js\";\nimport { getNumber } from \"./maths.js\";\nconst names = [\n    \"wei\",\n    \"kwei\",\n    \"mwei\",\n    \"gwei\",\n    \"szabo\",\n    \"finney\",\n    \"ether\",\n];\n/**\n *  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal\n *  places. The %%unit%% may be the number of decimal places or the name of\n *  a unit (e.g. ``\"gwei\"`` for 9 decimal places).\n *\n */\nexport function formatUnits(value, unit) {\n    let decimals = 18;\n    if (typeof (unit) === \"string\") {\n        const index = names.indexOf(unit);\n        assertArgument(index >= 0, \"invalid unit\", \"unit\", unit);\n        decimals = 3 * index;\n    }\n    else if (unit != null) {\n        decimals = getNumber(unit, \"unit\");\n    }\n    return FixedNumber.fromValue(value, decimals, { decimals, width: 512 }).toString();\n}\n/**\n *  Converts the //decimal string// %%value%% to a BigInt, assuming\n *  %%unit%% decimal places. The %%unit%% may the number of decimal places\n *  or the name of a unit (e.g. ``\"gwei\"`` for 9 decimal places).\n */\nexport function parseUnits(value, unit) {\n    assertArgument(typeof (value) === \"string\", \"value must be a string\", \"value\", value);\n    let decimals = 18;\n    if (typeof (unit) === \"string\") {\n        const index = names.indexOf(unit);\n        assertArgument(index >= 0, \"invalid unit\", \"unit\", unit);\n        decimals = 3 * index;\n    }\n    else if (unit != null) {\n        decimals = getNumber(unit, \"unit\");\n    }\n    return FixedNumber.fromString(value, { decimals, width: 512 }).value;\n}\n/**\n *  Converts %%value%% into a //decimal string// using 18 decimal places.\n */\nexport function formatEther(wei) {\n    return formatUnits(wei, 18);\n}\n/**\n *  Converts the //decimal string// %%ether%% to a BigInt, using 18\n *  decimal places.\n */\nexport function parseEther(ether) {\n    return parseUnits(ether, 18);\n}\n//# sourceMappingURL=units.js.map"],"names":["formatUnits","value","unit","decimals","getNumber","FixedNumber","fromValue","width","toString","formatEther","wei"],"mappings":"sFAuCO,SAASA,EAAYC,EAAOC,GAC/B,IAAIC,EAAW,GASf,OAFIA,EAAWC,EAAUF,EAAM,QAExBG,EAAYC,UAAUL,EAAOE,EAAU,CAAEA,WAAUI,MAAO,MAAOC,UAC5E,CAsBO,SAASC,EAAYC,GACxB,OAAOV,EAAYU,EAAK,GAC5B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/eventemitter3/index.js

@@ -1,2 +0,0 @@
-import{getDefaultExportFromCjs as e}from"../../_virtual/_commonjsHelpers.js";import{__module as t}from"../../_virtual/index.js";!function(e){var t=Object.prototype.hasOwnProperty,n="~";function r(){}function o(e,t,n){this.fn=e,this.context=t,this.once=n||!1}function s(e,t,r,s,i){if("function"!=typeof r)throw new TypeError("The listener must be a function");var c=new o(r,s||e,i),f=n?n+t:t;return e._events[f]?e._events[f].fn?e._events[f]=[e._events[f],c]:e._events[f].push(c):(e._events[f]=c,e._eventsCount++),e}function i(e,t){0===--e._eventsCount?e._events=new r:delete e._events[t]}function c(){this._events=new r,this._eventsCount=0}Object.create&&(r.prototype=Object.create(null),(new r).__proto__||(n=!1)),c.prototype.eventNames=function(){var e,r,o=[];if(0===this._eventsCount)return o;for(r in e=this._events)t.call(e,r)&&o.push(n?r.slice(1):r);return Object.getOwnPropertySymbols?o.concat(Object.getOwnPropertySymbols(e)):o},c.prototype.listeners=function(e){var t=n?n+e:e,r=this._events[t];if(!r)return[];if(r.fn)return[r.fn];for(var o=0,s=r.length,i=new Array(s);o<s;o++)i[o]=r[o].fn;return i},c.prototype.listenerCount=function(e){var t=n?n+e:e,r=this._events[t];return r?r.fn?1:r.length:0},c.prototype.emit=function(e,t,r,o,s,i){var c=n?n+e:e;if(!this._events[c])return!1;var f,a,u=this._events[c],l=arguments.length;if(u.fn){switch(u.once&&this.removeListener(e,u.fn,void 0,!0),l){case 1:return u.fn.call(u.context),!0;case 2:return u.fn.call(u.context,t),!0;case 3:return u.fn.call(u.context,t,r),!0;case 4:return u.fn.call(u.context,t,r,o),!0;case 5:return u.fn.call(u.context,t,r,o,s),!0;case 6:return u.fn.call(u.context,t,r,o,s,i),!0}for(a=1,f=new Array(l-1);a<l;a++)f[a-1]=arguments[a];u.fn.apply(u.context,f)}else{var v,p=u.length;for(a=0;a<p;a++)switch(u[a].once&&this.removeListener(e,u[a].fn,void 0,!0),l){case 1:u[a].fn.call(u[a].context);break;case 2:u[a].fn.call(u[a].context,t);break;case 3:u[a].fn.call(u[a].context,t,r);break;case 4:u[a].fn.call(u[a].context,t,r,o);break;default:if(!f)for(v=1,f=new Array(l-1);v<l;v++)f[v-1]=arguments[v];u[a].fn.apply(u[a].context,f)}}return!0},c.prototype.on=function(e,t,n){return s(this,e,t,n,!1)},c.prototype.once=function(e,t,n){return s(this,e,t,n,!0)},c.prototype.removeListener=function(e,t,r,o){var s=n?n+e:e;if(!this._events[s])return this;if(!t)return i(this,s),this;var c=this._events[s];if(c.fn)c.fn!==t||o&&!c.once||r&&c.context!==r||i(this,s);else{for(var f=0,a=[],u=c.length;f<u;f++)(c[f].fn!==t||o&&!c[f].once||r&&c[f].context!==r)&&a.push(c[f]);a.length?this._events[s]=1===a.length?a[0]:a:i(this,s)}return this},c.prototype.removeAllListeners=function(e){var t;return e?(t=n?n+e:e,this._events[t]&&i(this,t)):(this._events=new r,this._eventsCount=0),this},c.prototype.off=c.prototype.removeListener,c.prototype.addListener=c.prototype.on,c.prefixed=n,c.EventEmitter=c,e.exports=c}(t);var n=e(t.exports);export{n as default};
-//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/eventemitter3/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/eventemitter3/index.js"],"sourcesContent":["'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n"],"names":["has","Object","prototype","hasOwnProperty","prefix","Events","EE","fn","context","once","this","addListener","emitter","event","TypeError","listener","evt","_events","push","_eventsCount","clearEvent","EventEmitter","create","__proto__","eventNames","events","name","names","call","slice","getOwnPropertySymbols","concat","listeners","handlers","i","l","length","ee","Array","listenerCount","emit","a1","a2","a3","a4","a5","args","len","arguments","removeListener","undefined","apply","j","on","removeAllListeners","off","prefixed","module"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/AbiConstructor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AbiConstructor.js","sources":["../../../../../../node_modules/ox/_esm/core/AbiConstructor.js"],"sourcesContent":["import * as abitype from 'abitype';\nimport * as AbiItem from './AbiItem.js';\nimport * as AbiParameters from './AbiParameters.js';\nimport * as Hex from './Hex.js';\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function decode(...parameters) {\n    const [abiConstructor, options] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, options] = parameters;\n            return [fromAbi(abi), options];\n        }\n        return parameters;\n    })();\n    const { bytecode } = options;\n    if (abiConstructor.inputs.length === 0)\n        return undefined;\n    const data = options.data.replace(bytecode, '0x');\n    return AbiParameters.decode(abiConstructor.inputs, data);\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function encode(...parameters) {\n    const [abiConstructor, options] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, options] = parameters;\n            return [fromAbi(abi), options];\n        }\n        return parameters;\n    })();\n    const { bytecode, args } = options;\n    return Hex.concat(bytecode, abiConstructor.inputs?.length && args?.length\n        ? AbiParameters.encode(abiConstructor.inputs, args)\n        : '0x');\n}\n/** @internal */\nexport function format(abiConstructor) {\n    return abitype.formatAbiItem(abiConstructor);\n}\n/** @internal */\nexport function from(abiConstructor) {\n    return AbiItem.from(abiConstructor);\n}\n/** @internal */\nexport function fromAbi(abi) {\n    const item = abi.find((item) => item.type === 'constructor');\n    if (!item)\n        throw new AbiItem.NotFoundError({ name: 'constructor' });\n    return item;\n}\n//# sourceMappingURL=AbiConstructor.js.map"],"names":["encode","parameters","abiConstructor","options","Array","isArray","abi","fromAbi","bytecode","args","Hex.concat","inputs","length","AbiParameters.encode","from","AbiItem.from","item","find","type","AbiItem.NotFoundError","name"],"mappings":"qIAoBO,SAASA,KAAUC,GACtB,MAAOC,EAAgBC,GAAW,MAC9B,GAAIC,MAAMC,QAAQJ,EAAW,IAAK,CAC9B,MAAOK,EAAKH,GAAWF,EACvB,MAAO,CAACM,EAAQD,GAAMH,EAC1B,CACA,OAAOF,CACV,EANiC,IAO5BO,SAAEA,EAAQC,KAAEA,GAASN,EAC3B,OAAOO,EAAWF,EAAUN,EAAeS,QAAQC,QAAUH,GAAMG,OAC7DC,EAAqBX,EAAeS,OAAQF,GAC5C,KACV,CAMO,SAASK,EAAKZ,GACjB,OAAOa,EAAab,EACxB,CAEO,SAASK,EAAQD,GACpB,MAAMU,EAAOV,EAAIW,KAAMD,GAAuB,gBAAdA,EAAKE,MACrC,IAAKF,EACD,MAAM,IAAIG,EAAsB,CAAEC,KAAM,gBAC5C,OAAOJ,CACX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/AbiFunction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AbiFunction.js","sources":["../../../../../../node_modules/ox/_esm/core/AbiFunction.js"],"sourcesContent":["import * as abitype from 'abitype';\nimport * as AbiItem from './AbiItem.js';\nimport * as AbiParameters from './AbiParameters.js';\nimport * as Hex from './Hex.js';\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function decodeData(...parameters) {\n    const [abiFunction, data] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name, data] = parameters;\n            return [fromAbi(abi, name), data];\n        }\n        return parameters;\n    })();\n    const { overloads } = abiFunction;\n    if (Hex.size(data) < 4)\n        throw new AbiItem.InvalidSelectorSizeError({ data });\n    if (abiFunction.inputs.length === 0)\n        return undefined;\n    const item = overloads\n        ? fromAbi([abiFunction, ...overloads], data)\n        : abiFunction;\n    if (Hex.size(data) <= 4)\n        return undefined;\n    return AbiParameters.decode(item.inputs, Hex.slice(data, 4));\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function decodeResult(...parameters) {\n    const [abiFunction, data, options = {}] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name, data, options] = parameters;\n            return [fromAbi(abi, name), data, options];\n        }\n        return parameters;\n    })();\n    const values = AbiParameters.decode(abiFunction.outputs, data, options);\n    if (values && Object.keys(values).length === 0)\n        return undefined;\n    if (values && Object.keys(values).length === 1) {\n        if (Array.isArray(values))\n            return values[0];\n        return Object.values(values)[0];\n    }\n    return values;\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function encodeData(...parameters) {\n    const [abiFunction, args = []] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name, args] = parameters;\n            return [fromAbi(abi, name, { args }), args];\n        }\n        const [abiFunction, args] = parameters;\n        return [abiFunction, args];\n    })();\n    const { overloads } = abiFunction;\n    const item = overloads\n        ? fromAbi([abiFunction, ...overloads], abiFunction.name, {\n            args,\n        })\n        : abiFunction;\n    const selector = getSelector(item);\n    const data = args.length > 0 ? AbiParameters.encode(item.inputs, args) : undefined;\n    return data ? Hex.concat(selector, data) : selector;\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function encodeResult(...parameters) {\n    const [abiFunction, output, options = {}] = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name, output, options] = parameters;\n            return [fromAbi(abi, name), output, options];\n        }\n        return parameters;\n    })();\n    const { as = 'Array' } = options;\n    const values = (() => {\n        if (abiFunction.outputs.length === 1)\n            return [output];\n        if (Array.isArray(output))\n            return output;\n        if (as === 'Object')\n            return Object.values(output);\n        return [output];\n    })();\n    return AbiParameters.encode(abiFunction.outputs, values);\n}\n/**\n * Formats an {@link ox#AbiFunction.AbiFunction} into a **Human Readable ABI Function**.\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const formatted = AbiFunction.format({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param abiFunction - The ABI Function to format.\n * @returns The formatted ABI Function.\n */\nexport function format(abiFunction) {\n    return abitype.formatAbiItem(abiFunction);\n}\n/**\n * Parses an arbitrary **JSON ABI Function** or **Human Readable ABI Function** into a typed {@link ox#AbiFunction.AbiFunction}.\n *\n * @example\n * ### JSON ABIs\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable ABIs\n *\n * A Human Readable ABI can be parsed into a typed ABI object:\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from(\n *   'function approve(address spender, uint256 amount) returns (bool)' // [!code hl]\n * )\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'function approve(Foo foo) returns (bool)',\n * ])\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param abiFunction - The ABI Function to parse.\n * @returns Typed ABI Function.\n */\nexport function from(abiFunction, options = {}) {\n    return AbiItem.from(abiFunction, options);\n}\n/**\n * Extracts an {@link ox#AbiFunction.AbiFunction} from an {@link ox#Abi.Abi} given a name and optional arguments.\n *\n * @example\n * ### Extracting by Name\n *\n * ABI Functions can be extracted by their name using the `name` option:\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n *\n * const item = AbiFunction.fromAbi(abi, 'foo') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Extracting by Selector\n *\n * ABI Functions can be extract by their selector when {@link ox#Hex.Hex} is provided to `name`.\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n * const item = AbiFunction.fromAbi(abi, '0x095ea7b3') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * :::note\n *\n * Extracting via a hex selector is useful when extracting an ABI Function from an `eth_call` RPC response or\n * from a Transaction `input`.\n *\n * :::\n *\n * @param abi - The ABI to extract from.\n * @param name - The name (or selector) of the ABI item to extract.\n * @param options - Extraction options.\n * @returns The ABI item.\n */\nexport function fromAbi(abi, name, options) {\n    const item = AbiItem.fromAbi(abi, name, options);\n    if (item.type !== 'function')\n        throw new AbiItem.NotFoundError({ name, type: 'function' });\n    return item;\n}\n/**\n * Computes the [4-byte selector](https://solidity-by-example.org/function-selector/) for an {@link ox#AbiFunction.AbiFunction}.\n *\n * Useful for computing function selectors for calldata.\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const selector = AbiFunction.getSelector('function ownerOf(uint256 tokenId)')\n * // @log: '0x6352211e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const selector = AbiFunction.getSelector({\n *   inputs: [{ type: 'uint256' }],\n *   name: 'ownerOf',\n *   outputs: [],\n *   stateMutability: 'view',\n *   type: 'function'\n * })\n * // @log: '0x6352211e'\n * ```\n *\n * @param abiItem - The ABI item to compute the selector for.\n * @returns The first 4 bytes of the {@link ox#Hash.(keccak256:function)} hash of the function signature.\n */\nexport function getSelector(abiItem) {\n    return AbiItem.getSelector(abiItem);\n}\n//# sourceMappingURL=AbiFunction.js.map"],"names":["encodeData","parameters","abiFunction","args","Array","isArray","abi","name","fromAbi","overloads","item","selector","getSelector","data","length","AbiParameters.encode","inputs","undefined","Hex.concat","from","options","AbiItem.from","AbiItem.fromAbi","type","AbiItem.NotFoundError","abiItem","AbiItem.getSelector"],"mappings":"mKA6CO,SAASA,KAAcC,GAC1B,MAAOC,EAAaC,EAAO,IAAM,MAC7B,GAAIC,MAAMC,QAAQJ,EAAW,IAAK,CAC9B,MAAOK,EAAKC,EAAMJ,GAAQF,EAC1B,MAAO,CAACO,EAAQF,EAAKC,EAAM,CAAEJ,SAASA,EAC1C,CACA,MAAOD,EAAaC,GAAQF,EAC5B,MAAO,CAACC,EAAaC,EACxB,EAPgC,IAQ3BM,UAAEA,GAAcP,EAChBQ,EAAOD,EACPD,EAAQ,CAACN,KAAgBO,GAAYP,EAAYK,KAAM,CACrDJ,SAEFD,EACAS,EAAWC,EAAYF,GACvBG,EAAOV,EAAKW,OAAS,EAAIC,EAAqBL,EAAKM,OAAQb,QAAQc,EACzE,OAAOJ,EAAOK,EAAWP,EAAUE,GAAQF,CAC/C,CAiKO,SAASQ,EAAKjB,EAAakB,EAAU,IACxC,OAAOC,EAAanB,EAAakB,EACrC,CAkEO,SAASZ,EAAQF,EAAKC,EAAMa,GAC/B,MAAMV,EAAOY,EAAgBhB,EAAKC,EAAMa,GACxC,GAAkB,aAAdV,EAAKa,KACL,MAAM,IAAIC,EAAsB,CAAEjB,OAAMgB,KAAM,aAClD,OAAOb,CACX,CA+BO,SAASE,EAAYa,GACxB,OAAOC,EAAoBD,EAC/B","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/AbiItem.js

@@ -1,2 +0,0 @@
-import{BaseError as t}from"./Errors.js";import{keccak256 as e}from"./Hash.js";import{validate as n,slice as r,fromString as i}from"./Hex.js";import{isArgOfType as s,normalizeSignature as o,getAmbiguousTypes as a}from"./internal/abiItem.js";import{parseAbiItem as u}from"../../../abitype/dist/esm/human-readable/parseAbiItem.js";import{formatAbiItem as m}from"../../../abitype/dist/esm/human-readable/formatAbiItem.js";function f(t,e={}){const{prepare:n=!0}=e,r=Array.isArray(t)||"string"==typeof t?u(t):t;return{...r,...n?{hash:y(r)}:{}}}function p(t,e,i){const{args:o=[],prepare:u=!0}=i??{},m=n(e,{strict:!1}),f=t.filter(t=>m?"function"===t.type||"error"===t.type?c(t)===r(e,0,4):"event"===t.type&&y(t)===e:"name"in t&&t.name===e);if(0===f.length)throw new l({name:e});if(1===f.length)return{...f[0],...u?{hash:y(f[0])}:{}};let p;for(const t of f){if(!("inputs"in t))continue;if(!o||0===o.length){if(!t.inputs||0===t.inputs.length)return{...t,...u?{hash:y(t)}:{}};continue}if(!t.inputs)continue;if(0===t.inputs.length)continue;if(t.inputs.length!==o.length)continue;if(o.every((e,n)=>{const r="inputs"in t&&t.inputs[n];return!!r&&s(e,r)})){if(p&&"inputs"in p&&p.inputs){const e=a(t.inputs,p.inputs,o);if(e)throw new b({abiItem:t,type:e[0]},{abiItem:p,type:e[1]})}p=t}}const h=(()=>{if(p)return p;const[t,...e]=f;return{...t,overloads:e}})();if(!h)throw new l({name:e});return{...h,...u?{hash:y(h)}:{}}}function c(...t){const e=(()=>{if(Array.isArray(t[0])){const[e,n]=t;return p(e,n)}return t[0]})();return r(y(e),0,4)}function h(...t){const e=(()=>{if(Array.isArray(t[0])){const[e,n]=t;return p(e,n)}return t[0]})(),n="string"==typeof e?e:m(e);return o(n)}function y(...t){const n=(()=>{if(Array.isArray(t[0])){const[e,n]=t;return p(e,n)}return t[0]})();return"string"!=typeof n&&"hash"in n&&n.hash?n.hash:e(i(h(n)))}class b extends t{constructor(t,e){super("Found ambiguous types in overloaded ABI Items.",{metaMessages:[`\`${t.type}\` in \`${o(m(t.abiItem))}\`, and`,`\`${e.type}\` in \`${o(m(e.abiItem))}\``,"","These types encode differently and cannot be distinguished at runtime.","Remove one of the ambiguous items in the ABI."]}),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiItem.AmbiguityError"})}}class l extends t{constructor({name:t,data:e,type:n="item"}){super(`ABI ${n}${t?` with name "${t}"`:e?` with data "${e}"`:""} not found.`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiItem.NotFoundError"})}}export{b as AmbiguityError,l as NotFoundError,f as from,p as fromAbi,c as getSelector,h as getSignature,y as getSignatureHash};
-//# sourceMappingURL=AbiItem.js.map

package/dist/esm/node_modules/ox/_esm/core/AbiItem.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AbiItem.js","sources":["../../../../../../node_modules/ox/_esm/core/AbiItem.js"],"sourcesContent":["import * as abitype from 'abitype';\nimport * as Errors from './Errors.js';\nimport * as Hash from './Hash.js';\nimport * as Hex from './Hex.js';\nimport * as internal from './internal/abiItem.js';\n/**\n * Formats an {@link ox#AbiItem.AbiItem} into a **Human Readable ABI Item**.\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const formatted = AbiItem.format({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param abiItem - The ABI Item to format.\n * @returns The formatted ABI Item  .\n */\nexport function format(abiItem) {\n    return abitype.formatAbiItem(abiItem);\n}\n/**\n * Parses an arbitrary **JSON ABI Item** or **Human Readable ABI Item** into a typed {@link ox#AbiItem.AbiItem}.\n *\n * @example\n * ### JSON ABIs\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable ABIs\n *\n * A Human Readable ABI can be parsed into a typed ABI object:\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from(\n *   'function approve(address spender, uint256 amount) returns (bool)' // [!code hl]\n * )\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'function approve(Foo foo) returns (bool)',\n * ])\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param abiItem - The ABI Item to parse.\n * @returns The typed ABI Item.\n */\nexport function from(abiItem, options = {}) {\n    const { prepare = true } = options;\n    const item = (() => {\n        if (Array.isArray(abiItem))\n            return abitype.parseAbiItem(abiItem);\n        if (typeof abiItem === 'string')\n            return abitype.parseAbiItem(abiItem);\n        return abiItem;\n    })();\n    return {\n        ...item,\n        ...(prepare ? { hash: getSignatureHash(item) } : {}),\n    };\n}\n/**\n * Extracts an {@link ox#AbiItem.AbiItem} from an {@link ox#Abi.Abi} given a name and optional arguments.\n *\n * @example\n * ABI Items can be extracted by their name using the `name` option:\n *\n * ```ts twoslash\n * import { Abi, AbiItem } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n *\n * const item = AbiItem.fromAbi(abi, 'Transfer') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Extracting by Selector\n *\n * ABI Items can be extract by their selector when {@link ox#Hex.Hex} is provided to `name`.\n *\n * ```ts twoslash\n * import { Abi, AbiItem } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n * const item = AbiItem.fromAbi(abi, '0x095ea7b3') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * :::note\n *\n * Extracting via a hex selector is useful when extracting an ABI Item from an `eth_call` RPC response,\n * a Transaction `input`, or from Event Log `topics`.\n *\n * :::\n *\n * @param abi - The ABI to extract from.\n * @param name - The name (or selector) of the ABI item to extract.\n * @param options - Extraction options.\n * @returns The ABI item.\n */\nexport function fromAbi(abi, name, options) {\n    const { args = [], prepare = true } = (options ??\n        {});\n    const isSelector = Hex.validate(name, { strict: false });\n    const abiItems = abi.filter((abiItem) => {\n        if (isSelector) {\n            if (abiItem.type === 'function' || abiItem.type === 'error')\n                return getSelector(abiItem) === Hex.slice(name, 0, 4);\n            if (abiItem.type === 'event')\n                return getSignatureHash(abiItem) === name;\n            return false;\n        }\n        return 'name' in abiItem && abiItem.name === name;\n    });\n    if (abiItems.length === 0)\n        throw new NotFoundError({ name: name });\n    if (abiItems.length === 1)\n        return {\n            ...abiItems[0],\n            ...(prepare ? { hash: getSignatureHash(abiItems[0]) } : {}),\n        };\n    let matchedAbiItem;\n    for (const abiItem of abiItems) {\n        if (!('inputs' in abiItem))\n            continue;\n        if (!args || args.length === 0) {\n            if (!abiItem.inputs || abiItem.inputs.length === 0)\n                return {\n                    ...abiItem,\n                    ...(prepare ? { hash: getSignatureHash(abiItem) } : {}),\n                };\n            continue;\n        }\n        if (!abiItem.inputs)\n            continue;\n        if (abiItem.inputs.length === 0)\n            continue;\n        if (abiItem.inputs.length !== args.length)\n            continue;\n        const matched = args.every((arg, index) => {\n            const abiParameter = 'inputs' in abiItem && abiItem.inputs[index];\n            if (!abiParameter)\n                return false;\n            return internal.isArgOfType(arg, abiParameter);\n        });\n        if (matched) {\n            // Check for ambiguity against already matched parameters (e.g. `address` vs `bytes20`).\n            if (matchedAbiItem &&\n                'inputs' in matchedAbiItem &&\n                matchedAbiItem.inputs) {\n                const ambiguousTypes = internal.getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);\n                if (ambiguousTypes)\n                    throw new AmbiguityError({\n                        abiItem,\n                        type: ambiguousTypes[0],\n                    }, {\n                        abiItem: matchedAbiItem,\n                        type: ambiguousTypes[1],\n                    });\n            }\n            matchedAbiItem = abiItem;\n        }\n    }\n    const abiItem = (() => {\n        if (matchedAbiItem)\n            return matchedAbiItem;\n        const [abiItem, ...overloads] = abiItems;\n        return { ...abiItem, overloads };\n    })();\n    if (!abiItem)\n        throw new NotFoundError({ name: name });\n    return {\n        ...abiItem,\n        ...(prepare ? { hash: getSignatureHash(abiItem) } : {}),\n    };\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function getSelector(...parameters) {\n    const abiItem = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name] = parameters;\n            return fromAbi(abi, name);\n        }\n        return parameters[0];\n    })();\n    return Hex.slice(getSignatureHash(abiItem), 0, 4);\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function getSignature(...parameters) {\n    const abiItem = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name] = parameters;\n            return fromAbi(abi, name);\n        }\n        return parameters[0];\n    })();\n    const signature = (() => {\n        if (typeof abiItem === 'string')\n            return abiItem;\n        return abitype.formatAbiItem(abiItem);\n    })();\n    return internal.normalizeSignature(signature);\n}\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function getSignatureHash(...parameters) {\n    const abiItem = (() => {\n        if (Array.isArray(parameters[0])) {\n            const [abi, name] = parameters;\n            return fromAbi(abi, name);\n        }\n        return parameters[0];\n    })();\n    if (typeof abiItem !== 'string' && 'hash' in abiItem && abiItem.hash)\n        return abiItem.hash;\n    return Hash.keccak256(Hex.fromString(getSignature(abiItem)));\n}\n/**\n * Throws when ambiguous types are found on overloaded ABI items.\n *\n * @example\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from(['function foo(address)', 'function foo(bytes20)'])\n * AbiFunction.fromAbi(foo, 'foo', {\n *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n * })\n * // @error: AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.\n * // @error: `bytes20` in `foo(bytes20)`, and\n * // @error: `address` in `foo(address)`\n * // @error: These types encode differently and cannot be distinguished at runtime.\n * // @error: Remove one of the ambiguous items in the ABI.\n * ```\n *\n * ### Solution\n *\n * Remove one of the ambiguous types from the ABI.\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function foo(bytes20)' // [!code --]\n * ])\n * AbiFunction.fromAbi(foo, 'foo', {\n *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n * })\n * // @error: AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.\n * // @error: `bytes20` in `foo(bytes20)`, and\n * // @error: `address` in `foo(address)`\n * // @error: These types encode differently and cannot be distinguished at runtime.\n * // @error: Remove one of the ambiguous items in the ABI.\n * ```\n */\nexport class AmbiguityError extends Errors.BaseError {\n    constructor(x, y) {\n        super('Found ambiguous types in overloaded ABI Items.', {\n            metaMessages: [\n                // TODO: abitype to add support for signature-formatted ABI items.\n                `\\`${x.type}\\` in \\`${internal.normalizeSignature(abitype.formatAbiItem(x.abiItem))}\\`, and`,\n                `\\`${y.type}\\` in \\`${internal.normalizeSignature(abitype.formatAbiItem(y.abiItem))}\\``,\n                '',\n                'These types encode differently and cannot be distinguished at runtime.',\n                'Remove one of the ambiguous items in the ABI.',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.AmbiguityError'\n        });\n    }\n}\n/**\n * Throws when an ABI item is not found in the ABI.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, 'baz')\n * // @error: AbiItem.NotFoundError: ABI function with name \"baz\" not found.\n * ```\n *\n * ### Solution\n *\n * Ensure the ABI item exists on the ABI.\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)',\n *   'function baz(bool)' // [!code ++]\n * ])\n * AbiFunction.fromAbi(foo, 'baz')\n * ```\n */\nexport class NotFoundError extends Errors.BaseError {\n    constructor({ name, data, type = 'item', }) {\n        const selector = (() => {\n            if (name)\n                return ` with name \"${name}\"`;\n            if (data)\n                return ` with data \"${data}\"`;\n            return '';\n        })();\n        super(`ABI ${type}${selector} not found.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.NotFoundError'\n        });\n    }\n}\n/**\n * Throws when the selector size is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, '0xaaa')\n * // @error: AbiItem.InvalidSelectorSizeError: Selector size is invalid. Expected 4 bytes. Received 2 bytes (\"0xaaa\").\n * ```\n *\n * ### Solution\n *\n * Ensure the selector size is 4 bytes.\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, '0x7af82b1a')\n * ```\n */\nexport class InvalidSelectorSizeError extends Errors.BaseError {\n    constructor({ data }) {\n        super(`Selector size is invalid. Expected 4 bytes. Received ${Hex.size(data)} bytes (\"${data}\").`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.InvalidSelectorSizeError'\n        });\n    }\n}\n//# sourceMappingURL=AbiItem.js.map"],"names":["from","abiItem","options","prepare","item","Array","isArray","abitype.parseAbiItem","hash","getSignatureHash","fromAbi","abi","name","args","isSelector","Hex.validate","strict","abiItems","filter","type","getSelector","Hex.slice","length","NotFoundError","matchedAbiItem","inputs","every","arg","index","abiParameter","internal.isArgOfType","ambiguousTypes","internal.getAmbiguousTypes","AmbiguityError","overloads","parameters","getSignature","signature","abitype.formatAbiItem","internal.normalizeSignature","Hash.keccak256","Hex.fromString","Errors.BaseError","constructor","x","y","super","metaMessages","Object","defineProperty","this","enumerable","configurable","writable","value","data"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/AbiParameters.js

@@ -1,2 +0,0 @@
-import{assert as e}from"./Address.js";import{fromHex as r,size as t}from"./Bytes.js";import{BaseError as s}from"./Errors.js";import{fromBytes as n,size as a,padLeft as o,fromString as i,fromBoolean as c,fromNumber as l,padRight as m,concat as u}from"./Hex.js";import{prepareParameters as h,encode as p,decodeParameter as d}from"./internal/abiParameters.js";import{create as f}from"./internal/cursor.js";import{integerRegex as b,bytesRegex as g,arrayRegex as y}from"./Solidity.js";import{parseAbiParameters as A}from"../../../abitype/dist/esm/human-readable/parseAbiParameters.js";import{formatAbiParameters as v}from"../../../abitype/dist/esm/human-readable/formatAbiParameters.js";function w(e,s,a={}){const{as:o="Array",checksumAddress:i=!1}=a,c="string"==typeof s?r(s):s,l=f(c);if(0===t(c)&&e.length>0)throw new z;if(t(c)&&t(c)<32)throw new $({data:"string"==typeof s?s:n(s),parameters:e,size:t(c)});let m=0;const u="Array"===o?[]:{};for(let r=0;r<e.length;++r){const t=e[r];l.setPosition(m);const[s,n]=d(l,t,{checksumAddress:i,staticPosition:0});m+=n,"Array"===o?u.push(s):u[t.name??r]=s}return u}function x(e,r,t){const{checksumAddress:s=!1}={};if(e.length!==r.length)throw new I({expectedLength:e.length,givenLength:r.length});const n=h({checksumAddress:s,parameters:e,values:r}),a=p(n);return 0===a.length?"0x":a}function P(e,r){if(e.length!==r.length)throw new I({expectedLength:e.length,givenLength:r.length});const t=[];for(let s=0;s<e.length;s++){const n=e[s],a=r[s];t.push(P.encode(n,a))}return u(...t)}function j(e){return Array.isArray(e)&&"string"==typeof e[0]||"string"==typeof e?A(e):e}!function(r){r.encode=function r(t,s,n=!1){if("address"===t){const r=s;return e(r),o(r.toLowerCase(),n?32:0)}if("string"===t)return i(s);if("bytes"===t)return s;if("bool"===t)return o(c(s),n?32:1);const a=t.match(b);if(a){const[e,r,t="256"]=a,o=Number.parseInt(t,10)/8;return l(s,{size:n?32:o,signed:"int"===r})}const h=t.match(g);if(h){const[e,r]=h;if(Number.parseInt(r,10)!==(s.length-2)/2)throw new E({expectedSize:Number.parseInt(r,10),value:s});return m(s,n?32:0)}const p=t.match(y);if(p&&Array.isArray(s)){const[e,t]=p,n=[];for(let e=0;e<s.length;e++)n.push(r(t,s[e],!0));return 0===n.length?"0x":u(...n)}throw new S(t)}}(P||(P={}));class $ extends s{constructor({data:e,parameters:r,size:t}){super(`Data size of ${t} bytes is too small for given parameters.`,{metaMessages:[`Params: (${v(r)})`,`Data:   ${e} (${t} bytes)`]}),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.DataSizeTooSmallError"})}}class z extends s{constructor(){super('Cannot decode zero data ("0x") with ABI parameters.'),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.ZeroDataError"})}}class L extends s{constructor({expectedLength:e,givenLength:r,type:t}){super(`Array length mismatch for type \`${t}\`. Expected: \`${e}\`. Given: \`${r}\`.`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.ArrayLengthMismatchError"})}}class E extends s{constructor({expectedSize:e,value:r}){super(`Size of bytes "${r}" (bytes${a(r)}) does not match expected size (bytes${e}).`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.BytesSizeMismatchError"})}}class I extends s{constructor({expectedLength:e,givenLength:r}){super(["ABI encoding parameters/values length mismatch.",`Expected length (parameters): ${e}`,`Given length (values): ${r}`].join("\n")),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.LengthMismatchError"})}}class O extends s{constructor(e){super(`Value \`${e}\` is not a valid array.`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.InvalidArrayError"})}}class S extends s{constructor(e){super(`Type \`${e}\` is not a valid ABI Type.`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"AbiParameters.InvalidTypeError"})}}export{L as ArrayLengthMismatchError,E as BytesSizeMismatchError,$ as DataSizeTooSmallError,O as InvalidArrayError,S as InvalidTypeError,I as LengthMismatchError,z as ZeroDataError,w as decode,x as encode,P as encodePacked,j as from};
-//# sourceMappingURL=AbiParameters.js.map

package/dist/esm/node_modules/ox/_esm/core/AbiParameters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AbiParameters.js","sources":["../../../../../../node_modules/ox/_esm/core/AbiParameters.js"],"sourcesContent":["import * as abitype from 'abitype';\nimport * as Address from './Address.js';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as internal from './internal/abiParameters.js';\nimport * as Cursor from './internal/cursor.js';\nimport * as Solidity from './Solidity.js';\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function decode(parameters, data, options = {}) {\n    const { as = 'Array', checksumAddress = false } = options;\n    const bytes = typeof data === 'string' ? Bytes.fromHex(data) : data;\n    const cursor = Cursor.create(bytes);\n    if (Bytes.size(bytes) === 0 && parameters.length > 0)\n        throw new ZeroDataError();\n    if (Bytes.size(bytes) && Bytes.size(bytes) < 32)\n        throw new DataSizeTooSmallError({\n            data: typeof data === 'string' ? data : Hex.fromBytes(data),\n            parameters: parameters,\n            size: Bytes.size(bytes),\n        });\n    let consumed = 0;\n    const values = as === 'Array' ? [] : {};\n    for (let i = 0; i < parameters.length; ++i) {\n        const param = parameters[i];\n        cursor.setPosition(consumed);\n        const [data, consumed_] = internal.decodeParameter(cursor, param, {\n            checksumAddress,\n            staticPosition: 0,\n        });\n        consumed += consumed_;\n        if (as === 'Array')\n            values.push(data);\n        else\n            values[param.name ?? i] = data;\n    }\n    return values;\n}\n/**\n * Encodes primitive values into ABI encoded data as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec).\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const data = AbiParameters.encode(\n *   AbiParameters.from(['string', 'uint', 'bool']),\n *   ['wagmi', 420n, true],\n * )\n * ```\n *\n * @example\n * ### JSON Parameters\n *\n * Specify **JSON ABI** Parameters as schema:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const data = AbiParameters.encode(\n *   [\n *     { type: 'string', name: 'name' },\n *     { type: 'uint', name: 'age' },\n *     { type: 'bool', name: 'isOwner' },\n *   ],\n *   ['wagmi', 420n, true],\n * )\n * ```\n *\n * @param parameters - The set of ABI parameters to encode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).\n * @param values - The set of primitive values that correspond to the ABI types defined in `parameters`.\n * @returns ABI encoded data.\n */\nexport function encode(parameters, values, options) {\n    const { checksumAddress = false } = options ?? {};\n    if (parameters.length !== values.length)\n        throw new LengthMismatchError({\n            expectedLength: parameters.length,\n            givenLength: values.length,\n        });\n    // Prepare the parameters to determine dynamic types to encode.\n    const preparedParameters = internal.prepareParameters({\n        checksumAddress,\n        parameters: parameters,\n        values: values,\n    });\n    const data = internal.encode(preparedParameters);\n    if (data.length === 0)\n        return '0x';\n    return data;\n}\n/**\n * Encodes an array of primitive values to a [packed ABI encoding](https://docs.soliditylang.org/en/latest/abi-spec.html#non-standard-packed-mode).\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const encoded = AbiParameters.encodePacked(\n *   ['address', 'string'],\n *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 'hello world'],\n * )\n * // @log: '0xd8da6bf26964af9d7eed9e03e53415d37aa9604568656c6c6f20776f726c64'\n * ```\n *\n * @param types - Set of ABI types to pack encode.\n * @param values - The set of primitive values that correspond to the ABI types defined in `types`.\n * @returns The encoded packed data.\n */\nexport function encodePacked(types, values) {\n    if (types.length !== values.length)\n        throw new LengthMismatchError({\n            expectedLength: types.length,\n            givenLength: values.length,\n        });\n    const data = [];\n    for (let i = 0; i < types.length; i++) {\n        const type = types[i];\n        const value = values[i];\n        data.push(encodePacked.encode(type, value));\n    }\n    return Hex.concat(...data);\n}\n(function (encodePacked) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function encode(type, value, isArray = false) {\n        if (type === 'address') {\n            const address = value;\n            Address.assert(address);\n            return Hex.padLeft(address.toLowerCase(), isArray ? 32 : 0);\n        }\n        if (type === 'string')\n            return Hex.fromString(value);\n        if (type === 'bytes')\n            return value;\n        if (type === 'bool')\n            return Hex.padLeft(Hex.fromBoolean(value), isArray ? 32 : 1);\n        const intMatch = type.match(Solidity.integerRegex);\n        if (intMatch) {\n            const [_type, baseType, bits = '256'] = intMatch;\n            const size = Number.parseInt(bits, 10) / 8;\n            return Hex.fromNumber(value, {\n                size: isArray ? 32 : size,\n                signed: baseType === 'int',\n            });\n        }\n        const bytesMatch = type.match(Solidity.bytesRegex);\n        if (bytesMatch) {\n            const [_type, size] = bytesMatch;\n            if (Number.parseInt(size, 10) !== (value.length - 2) / 2)\n                throw new BytesSizeMismatchError({\n                    expectedSize: Number.parseInt(size, 10),\n                    value: value,\n                });\n            return Hex.padRight(value, isArray ? 32 : 0);\n        }\n        const arrayMatch = type.match(Solidity.arrayRegex);\n        if (arrayMatch && Array.isArray(value)) {\n            const [_type, childType] = arrayMatch;\n            const data = [];\n            for (let i = 0; i < value.length; i++) {\n                data.push(encode(childType, value[i], true));\n            }\n            if (data.length === 0)\n                return '0x';\n            return Hex.concat(...data);\n        }\n        throw new InvalidTypeError(type);\n    }\n    encodePacked.encode = encode;\n})(encodePacked || (encodePacked = {}));\n/**\n * Formats {@link ox#AbiParameters.AbiParameters} into **Human Readable ABI Parameters**.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const formatted = AbiParameters.format([\n *   {\n *     name: 'spender',\n *     type: 'address',\n *   },\n *   {\n *     name: 'amount',\n *     type: 'uint256',\n *   },\n * ])\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param parameters - The ABI Parameters to format.\n * @returns The formatted ABI Parameters  .\n */\nexport function format(parameters) {\n    return abitype.formatAbiParameters(parameters);\n}\n/**\n * Parses arbitrary **JSON ABI Parameters** or **Human Readable ABI Parameters** into typed {@link ox#AbiParameters.AbiParameters}.\n *\n * @example\n * ### JSON Parameters\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from([\n *   {\n *     name: 'spender',\n *     type: 'address',\n *   },\n *   {\n *     name: 'amount',\n *     type: 'uint256',\n *   },\n * ])\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable Parameters\n *\n * Human Readable ABI Parameters can be parsed into a typed {@link ox#AbiParameters.AbiParameters}:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from('address spender, uint256 amount')\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'Foo foo, address bar',\n * ])\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param parameters - The ABI Parameters to parse.\n * @returns The typed ABI Parameters.\n */\nexport function from(parameters) {\n    if (Array.isArray(parameters) && typeof parameters[0] === 'string')\n        return abitype.parseAbiParameters(parameters);\n    if (typeof parameters === 'string')\n        return abitype.parseAbiParameters(parameters);\n    return parameters;\n}\n/**\n * Throws when the data size is too small for the given parameters.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x010f')\n * //                                             ↑ ❌ 2 bytes\n * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.\n * // @error: Params: (uint256)\n * // @error: Data:   0x010f (2 bytes)\n * ```\n *\n * ### Solution\n *\n * Pass a valid data size.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                                             ↑ ✅ 32 bytes\n * ```\n */\nexport class DataSizeTooSmallError extends Errors.BaseError {\n    constructor({ data, parameters, size, }) {\n        super(`Data size of ${size} bytes is too small for given parameters.`, {\n            metaMessages: [\n                `Params: (${abitype.formatAbiParameters(parameters)})`,\n                `Data:   ${data} (${size} bytes)`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.DataSizeTooSmallError'\n        });\n    }\n}\n/**\n * Throws when zero data is provided, but data is expected.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x')\n * //                                           ↑ ❌ zero data\n * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.\n * // @error: Params: (uint256)\n * // @error: Data:   0x010f (2 bytes)\n * ```\n *\n * ### Solution\n *\n * Pass valid data.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                                             ↑ ✅ 32 bytes\n * ```\n */\nexport class ZeroDataError extends Errors.BaseError {\n    constructor() {\n        super('Cannot decode zero data (\"0x\") with ABI parameters.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.ZeroDataError'\n        });\n    }\n}\n/**\n * The length of the array value does not match the length specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from('uint256[3]'), [[69n, 420n]])\n * //                                               ↑ expected: 3  ↑ ❌ length: 2\n * // @error: AbiParameters.ArrayLengthMismatchError: ABI encoding array length mismatch\n * // @error: for type `uint256[3]`. Expected: `3`. Given: `2`.\n * ```\n *\n * ### Solution\n *\n * Pass an array of the correct length.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [[69n, 420n, 69n]])\n * //                                                         ↑ ✅ length: 3\n * ```\n */\nexport class ArrayLengthMismatchError extends Errors.BaseError {\n    constructor({ expectedLength, givenLength, type, }) {\n        super(`Array length mismatch for type \\`${type}\\`. Expected: \\`${expectedLength}\\`. Given: \\`${givenLength}\\`.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.ArrayLengthMismatchError'\n        });\n    }\n}\n/**\n * The size of the bytes value does not match the size specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from('bytes8'), [['0xdeadbeefdeadbeefdeadbeef']])\n * //                                            ↑ expected: 8 bytes  ↑ ❌ size: 12 bytes\n * // @error: BytesSizeMismatchError: Size of bytes \"0xdeadbeefdeadbeefdeadbeef\"\n * // @error: (bytes12) does not match expected size (bytes8).\n * ```\n *\n * ### Solution\n *\n * Pass a bytes value of the correct size.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['bytes8']), ['0xdeadbeefdeadbeef'])\n * //                                                       ↑ ✅ size: 8 bytes\n * ```\n */\nexport class BytesSizeMismatchError extends Errors.BaseError {\n    constructor({ expectedSize, value, }) {\n        super(`Size of bytes \"${value}\" (bytes${Hex.size(value)}) does not match expected size (bytes${expectedSize}).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.BytesSizeMismatchError'\n        });\n    }\n}\n/**\n * The length of the values to encode does not match the length of the ABI parameters.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['string', 'uint256']), ['hello'])\n * // @error: LengthMismatchError: ABI encoding params/values length mismatch.\n * // @error: Expected length (params): 2\n * // @error: Given length (values): 1\n * ```\n *\n * ### Solution\n *\n * Pass the correct number of values to encode.\n *\n * ### Solution\n *\n * Pass a [valid ABI type](https://docs.soliditylang.org/en/develop/abi-spec.html#types).\n */\nexport class LengthMismatchError extends Errors.BaseError {\n    constructor({ expectedLength, givenLength, }) {\n        super([\n            'ABI encoding parameters/values length mismatch.',\n            `Expected length (parameters): ${expectedLength}`,\n            `Given length (values): ${givenLength}`,\n        ].join('\\n'));\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.LengthMismatchError'\n        });\n    }\n}\n/**\n * The value provided is not a valid array as specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [69])\n * ```\n *\n * ### Solution\n *\n * Pass an array value.\n */\nexport class InvalidArrayError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${value}\\` is not a valid array.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.InvalidArrayError'\n        });\n    }\n}\n/**\n * Throws when the ABI parameter type is invalid.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'lol' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                             ↑ ❌ invalid type\n * // @error: AbiParameters.InvalidTypeError: Type `lol` is not a valid ABI Type.\n * ```\n */\nexport class InvalidTypeError extends Errors.BaseError {\n    constructor(type) {\n        super(`Type \\`${type}\\` is not a valid ABI Type.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.InvalidTypeError'\n        });\n    }\n}\n//# sourceMappingURL=AbiParameters.js.map"],"names":["decode","parameters","data","options","as","checksumAddress","bytes","Bytes.fromHex","cursor","Cursor.create","Bytes.size","length","ZeroDataError","DataSizeTooSmallError","Hex.fromBytes","size","consumed","values","i","param","setPosition","consumed_","internal.decodeParameter","staticPosition","push","name","encode","LengthMismatchError","expectedLength","givenLength","preparedParameters","internal.prepareParameters","internal.encode","encodePacked","types","type","value","Hex.concat","from","Array","isArray","abitype.parseAbiParameters","address","Address.assert","Hex.padLeft","toLowerCase","Hex.fromString","Hex.fromBoolean","intMatch","match","Solidity.integerRegex","_type","baseType","bits","Number","parseInt","Hex.fromNumber","signed","bytesMatch","Solidity.bytesRegex","BytesSizeMismatchError","expectedSize","Hex.padRight","arrayMatch","Solidity.arrayRegex","childType","InvalidTypeError","Errors.BaseError","constructor","super","metaMessages","abitype.formatAbiParameters","Object","defineProperty","this","enumerable","configurable","writable","ArrayLengthMismatchError","Hex.size","join","InvalidArrayError"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/Address.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Address.js","sources":["../../../../../../node_modules/ox/_esm/core/Address.js"],"sourcesContent":["import * as Bytes from './Bytes.js';\nimport * as Caches from './Caches.js';\nimport * as Errors from './Errors.js';\nimport * as Hash from './Hash.js';\nimport * as PublicKey from './PublicKey.js';\nconst addressRegex = /^0x[a-fA-F0-9]{40}$/;\n/**\n * Asserts that the given value is a valid {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.assert('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.assert('0xdeadbeef')\n * // @error: InvalidAddressError: Address \"0xdeadbeef\" is invalid.\n * ```\n *\n * @param value - Value to assert if it is a valid address.\n * @param options - Assertion options.\n */\nexport function assert(value, options = {}) {\n    const { strict = true } = options;\n    if (!addressRegex.test(value))\n        throw new InvalidAddressError({\n            address: value,\n            cause: new InvalidInputError(),\n        });\n    if (strict) {\n        if (value.toLowerCase() === value)\n            return;\n        if (checksum(value) !== value)\n            throw new InvalidAddressError({\n                address: value,\n                cause: new InvalidChecksumError(),\n            });\n    }\n}\n/**\n * Computes the checksum address for the given {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.checksum('0xa0cf798816d4b9b9866b5330eea46a18382f251e')\n * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * ```\n *\n * @param address - The address to compute the checksum for.\n * @returns The checksummed address.\n */\nexport function checksum(address) {\n    if (Caches.checksum.has(address))\n        return Caches.checksum.get(address);\n    assert(address, { strict: false });\n    const hexAddress = address.substring(2).toLowerCase();\n    const hash = Hash.keccak256(Bytes.fromString(hexAddress), { as: 'Bytes' });\n    const characters = hexAddress.split('');\n    for (let i = 0; i < 40; i += 2) {\n        if (hash[i >> 1] >> 4 >= 8 && characters[i]) {\n            characters[i] = characters[i].toUpperCase();\n        }\n        if ((hash[i >> 1] & 0x0f) >= 8 && characters[i + 1]) {\n            characters[i + 1] = characters[i + 1].toUpperCase();\n        }\n    }\n    const result = `0x${characters.join('')}`;\n    Caches.checksum.set(address, result);\n    return result;\n}\n/**\n * Converts a stringified address to a typed (checksummed) {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e')\n * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e', {\n *   checksum: false\n * })\n * // @log: '0xa0cf798816d4b9b9866b5330eea46a18382f251e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('hello')\n * // @error: InvalidAddressError: Address \"0xa\" is invalid.\n * ```\n *\n * @param address - An address string to convert to a typed Address.\n * @param options - Conversion options.\n * @returns The typed Address.\n */\nexport function from(address, options = {}) {\n    const { checksum: checksumVal = false } = options;\n    assert(address);\n    if (checksumVal)\n        return checksum(address);\n    return address;\n}\n/**\n * Converts an ECDSA public key to an {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address, PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from(\n *   '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',\n * )\n * const address = Address.fromPublicKey(publicKey)\n * // @log: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'\n * ```\n *\n * @param publicKey - The ECDSA public key to convert to an {@link ox#Address.Address}.\n * @param options - Conversion options.\n * @returns The {@link ox#Address.Address} corresponding to the public key.\n */\nexport function fromPublicKey(publicKey, options = {}) {\n    const address = Hash.keccak256(`0x${PublicKey.toHex(publicKey).slice(4)}`).substring(26);\n    return from(`0x${address}`, options);\n}\n/**\n * Checks if two {@link ox#Address.Address} are equal.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.isEqual(\n *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',\n *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * )\n * // @log: true\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.isEqual(\n *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',\n *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251f'\n * )\n * // @log: false\n * ```\n *\n * @param addressA - The first address to compare.\n * @param addressB - The second address to compare.\n * @returns Whether the addresses are equal.\n */\nexport function isEqual(addressA, addressB) {\n    assert(addressA, { strict: false });\n    assert(addressB, { strict: false });\n    return addressA.toLowerCase() === addressB.toLowerCase();\n}\n/**\n * Checks if the given address is a valid {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.validate('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')\n * // @log: true\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.validate('0xdeadbeef')\n * // @log: false\n * ```\n *\n * @param address - Value to check if it is a valid address.\n * @param options - Check options.\n * @returns Whether the address is a valid address.\n */\nexport function validate(address, options = {}) {\n    const { strict = true } = options ?? {};\n    try {\n        assert(address, { strict });\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Thrown when an address is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0x123')\n * // @error: Address.InvalidAddressError: Address `0x123` is invalid.\n * ```\n */\nexport class InvalidAddressError extends Errors.BaseError {\n    constructor({ address, cause }) {\n        super(`Address \"${address}\" is invalid.`, {\n            cause,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidAddressError'\n        });\n    }\n}\n/** Thrown when an address is not a 20 byte (40 hexadecimal character) value. */\nexport class InvalidInputError extends Errors.BaseError {\n    constructor() {\n        super('Address is not a 20 byte (40 hexadecimal character) value.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidInputError'\n        });\n    }\n}\n/** Thrown when an address does not match its checksum counterpart. */\nexport class InvalidChecksumError extends Errors.BaseError {\n    constructor() {\n        super('Address does not match its checksum counterpart.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidChecksumError'\n        });\n    }\n}\n//# sourceMappingURL=Address.js.map"],"names":["addressRegex","assert","value","options","strict","test","InvalidAddressError","address","cause","InvalidInputError","toLowerCase","checksum","InvalidChecksumError","Caches.checksum","has","get","hexAddress","substring","hash","Hash.keccak256","Bytes.fromString","as","characters","split","i","toUpperCase","result","join","set","validate","Errors.BaseError","constructor","super","Object","defineProperty","this","enumerable","configurable","writable"],"mappings":"6JAKA,MAAMA,EAAe,sBAsBd,SAASC,EAAOC,EAAOC,EAAU,IACpC,MAAMC,OAAEA,GAAS,GAASD,EAC1B,IAAKH,EAAaK,KAAKH,GACnB,MAAM,IAAII,EAAoB,CAC1BC,QAASL,EACTM,MAAO,IAAIC,IAEnB,GAAIL,EAAQ,CACR,GAAIF,EAAMQ,gBAAkBR,EACxB,OACJ,GAAIS,EAAST,KAAWA,EACpB,MAAM,IAAII,EAAoB,CAC1BC,QAASL,EACTM,MAAO,IAAII,GAEvB,CACJ,CAeO,SAASD,EAASJ,GACrB,GAAIM,EAAgBC,IAAIP,GACpB,OAAOM,EAAgBE,IAAIR,GAC/BN,EAAOM,EAAS,CAAEH,QAAQ,IAC1B,MAAMY,EAAaT,EAAQU,UAAU,GAAGP,cAClCQ,EAAOC,EAAeC,EAAiBJ,GAAa,CAAEK,GAAI,UAC1DC,EAAaN,EAAWO,MAAM,IACpC,IAAK,IAAIC,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACrBN,EAAKM,GAAK,IAAM,GAAK,GAAKF,EAAWE,KACrCF,EAAWE,GAAKF,EAAWE,GAAGC,gBAEd,GAAfP,EAAKM,GAAK,KAAc,GAAKF,EAAWE,EAAI,KAC7CF,EAAWE,EAAI,GAAKF,EAAWE,EAAI,GAAGC,eAG9C,MAAMC,EAAS,KAAKJ,EAAWK,KAAK,MAEpC,OADAd,EAAgBe,IAAIrB,EAASmB,GACtBA,CACX,CAwHO,SAASG,EAAStB,EAASJ,EAAU,IACxC,MAAMC,OAAEA,GAAS,GAASD,GAAW,CAAA,EACrC,IAEI,OADAF,EAAOM,EAAS,CAAEH,YACX,CACX,CACA,MACI,OAAO,CACX,CACJ,CAYO,MAAME,UAA4BwB,EACrC,WAAAC,EAAYxB,QAAEA,EAAOC,MAAEA,IACnBwB,MAAM,YAAYzB,iBAAwB,CACtCC,UAEJyB,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVpC,MAAO,+BAEf,EAGG,MAAMO,UAA0BqB,EACnC,WAAAC,GACIC,MAAM,8DACNC,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVpC,MAAO,6BAEf,EAGG,MAAMU,UAA6BkB,EACtC,WAAAC,GACIC,MAAM,oDACNC,OAAOC,eAAeC,KAAM,OAAQ,CAChCC,YAAY,EACZC,cAAc,EACdC,UAAU,EACVpC,MAAO,gCAEf","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/Authorization.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Authorization.js","sources":["../../../../../../node_modules/ox/_esm/core/Authorization.js"],"sourcesContent":["import * as Hash from './Hash.js';\nimport * as Hex from './Hex.js';\nimport * as Rlp from './Rlp.js';\nimport * as Signature from './Signature.js';\n/**\n * Converts an [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization object into a typed {@link ox#Authorization.Authorization}.\n *\n * @example\n * An Authorization can be instantiated from an [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple in object format.\n *\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 1,\n *   nonce: 69n,\n * })\n * ```\n *\n * @example\n * ### Attaching Signatures\n *\n * A {@link ox#Signature.Signature} can be attached with the `signature` option. The example below demonstrates signing\n * an Authorization with {@link ox#Secp256k1.(sign:function)}.\n *\n * ```ts twoslash\n * import { Authorization, Secp256k1 } from 'ox'\n *\n * const authorization = Authorization.from({\n *   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n *   chainId: 1,\n *   nonce: 40n,\n * })\n *\n * const signature = Secp256k1.sign({\n *   payload: Authorization.getSignPayload(authorization),\n *   privateKey: '0x...',\n * })\n *\n * const authorization_signed = Authorization.from(authorization, { signature }) // [!code focus]\n * ```\n *\n * @param authorization - An [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple in object format.\n * @param options - Authorization options.\n * @returns The {@link ox#Authorization.Authorization}.\n */\nexport function from(authorization, options = {}) {\n    if (typeof authorization.chainId === 'string')\n        return fromRpc(authorization);\n    return { ...authorization, ...options.signature };\n}\n/**\n * Converts an {@link ox#Authorization.Rpc} to an {@link ox#Authorization.Authorization}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.fromRpc({\n *   address: '0x0000000000000000000000000000000000000000',\n *   chainId: '0x1',\n *   nonce: '0x1',\n *   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',\n *   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',\n *   yParity: '0x0',\n * })\n * ```\n *\n * @param authorization - The RPC-formatted Authorization.\n * @returns A signed {@link ox#Authorization.Authorization}.\n */\nexport function fromRpc(authorization) {\n    const { address, chainId, nonce } = authorization;\n    const signature = Signature.extract(authorization);\n    return {\n        address,\n        chainId: Number(chainId),\n        nonce: BigInt(nonce),\n        ...signature,\n    };\n}\n/**\n * Converts an {@link ox#Authorization.ListRpc} to an {@link ox#Authorization.List}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorizationList = Authorization.fromRpcList([{\n *   address: '0x0000000000000000000000000000000000000000',\n *   chainId: '0x1',\n *   nonce: '0x1',\n *   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',\n *   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',\n *   yParity: '0x0',\n * }])\n * ```\n *\n * @param authorizationList - The RPC-formatted Authorization list.\n * @returns A signed {@link ox#Authorization.List}.\n */\nexport function fromRpcList(authorizationList) {\n    return authorizationList.map(fromRpc);\n}\n/**\n * Converts an {@link ox#Authorization.Tuple} to an {@link ox#Authorization.Authorization}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.fromTuple([\n *   '0x1',\n *   '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n *   '0x3'\n * ])\n * // @log: {\n * // @log:   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:   chainId: 1,\n * // @log:   nonce: 3n\n * // @log: }\n * ```\n *\n * @example\n * It is also possible to append a Signature tuple to the end of an Authorization tuple.\n *\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.fromTuple([\n *   '0x1',\n *   '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n *   '0x3',\n *   '0x1',\n *   '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',\n *   '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',\n * ])\n * // @log: {\n * // @log:   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:   chainId: 1,\n * // @log:   nonce: 3n\n * // @log:   r: BigInt('0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90'),\n * // @log:   s: BigInt('0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'),\n * // @log:   yParity: 0,\n * // @log: }\n * ```\n *\n * @param tuple - The [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple.\n * @returns The {@link ox#Authorization.Authorization}.\n */\nexport function fromTuple(tuple) {\n    const [chainId, address, nonce, yParity, r, s] = tuple;\n    let args = {\n        address,\n        chainId: chainId === '0x' ? 0 : Number(chainId),\n        nonce: nonce === '0x' ? 0n : BigInt(nonce),\n    };\n    if (yParity && r && s)\n        args = { ...args, ...Signature.fromTuple([yParity, r, s]) };\n    return from(args);\n}\n/**\n * Converts an {@link ox#Authorization.TupleList} to an {@link ox#Authorization.List}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorizationList = Authorization.fromTupleList([\n *   ['0x1', '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c', '0x3'],\n *   ['0x3', '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c', '0x14'],\n * ])\n * // @log: [\n * // @log:   {\n * // @log:     address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:     chainId: 1,\n * // @log:     nonce: 3n,\n * // @log:   },\n * // @log:   {\n * // @log:     address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:     chainId: 3,\n * // @log:     nonce: 20n,\n * // @log:   },\n * // @log: ]\n * ```\n *\n * @example\n * It is also possible to append a Signature tuple to the end of an Authorization tuple.\n *\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorizationList = Authorization.fromTupleList([\n *   ['0x1', '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c', '0x3', '0x1', '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90', '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'],\n *   ['0x3', '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c', '0x14', '0x1', '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90', '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'],\n * ])\n * // @log: [\n * // @log:   {\n * // @log:     address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:     chainId: 1,\n * // @log:     nonce: 3n,\n * // @log:     r: BigInt('0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90'),\n * // @log:     s: BigInt('0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'),\n * // @log:     yParity: 0,\n * // @log:   },\n * // @log:   {\n * // @log:     address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',\n * // @log:     chainId: 3,\n * // @log:     nonce: 20n,\n * // @log:     r: BigInt('0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90'),\n * // @log:     s: BigInt('0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064'),\n * // @log:     yParity: 0,\n * // @log:   },\n * // @log: ]\n * ```\n *\n * @param tupleList - The [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple list.\n * @returns An {@link ox#Authorization.List}.\n */\nexport function fromTupleList(tupleList) {\n    const list = [];\n    for (const tuple of tupleList)\n        list.push(fromTuple(tuple));\n    return list;\n}\n/**\n * Computes the sign payload for an {@link ox#Authorization.Authorization} in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`.\n *\n * @example\n * The example below demonstrates computing the sign payload for an {@link ox#Authorization.Authorization}. This payload\n * can then be passed to signing functions like {@link ox#Secp256k1.(sign:function)}.\n *\n * ```ts twoslash\n * import { Authorization, Secp256k1 } from 'ox'\n *\n * const authorization = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 1,\n *   nonce: 69n,\n * })\n *\n * const payload = Authorization.getSignPayload(authorization) // [!code focus]\n *\n * const signature = Secp256k1.sign({\n *   payload,\n *   privateKey: '0x...',\n * })\n * ```\n *\n * @param authorization - The {@link ox#Authorization.Authorization}.\n * @returns The sign payload.\n */\nexport function getSignPayload(authorization) {\n    return hash(authorization, { presign: true });\n}\n/**\n * Computes the hash for an {@link ox#Authorization.Authorization} in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 1,\n *   nonce: 69n,\n * })\n *\n * const hash = Authorization.hash(authorization) // [!code focus]\n * ```\n *\n * @param authorization - The {@link ox#Authorization.Authorization}.\n * @returns The hash.\n */\nexport function hash(authorization, options = {}) {\n    const { presign } = options;\n    return Hash.keccak256(Hex.concat('0x05', Rlp.fromHex(toTuple(presign\n        ? {\n            address: authorization.address,\n            chainId: authorization.chainId,\n            nonce: authorization.nonce,\n        }\n        : authorization))));\n}\n/**\n * Converts an {@link ox#Authorization.Authorization} to an {@link ox#Authorization.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.toRpc({\n *   address: '0x0000000000000000000000000000000000000000',\n *   chainId: 1,\n *   nonce: 1n,\n *   r: 44944627813007772897391531230081695102703289123332187696115181104739239197517n,\n *   s: 36528503505192438307355164441104001310566505351980369085208178712678799181120n,\n *   yParity: 0,\n * })\n * ```\n *\n * @param authorization - An Authorization.\n * @returns An RPC-formatted Authorization.\n */\nexport function toRpc(authorization) {\n    const { address, chainId, nonce, ...signature } = authorization;\n    return {\n        address,\n        chainId: Hex.fromNumber(chainId),\n        nonce: Hex.fromNumber(nonce),\n        ...Signature.toRpc(signature),\n    };\n}\n/**\n * Converts an {@link ox#Authorization.List} to an {@link ox#Authorization.ListRpc}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.toRpcList([{\n *   address: '0x0000000000000000000000000000000000000000',\n *   chainId: 1,\n *   nonce: 1n,\n *   r: 44944627813007772897391531230081695102703289123332187696115181104739239197517n,\n *   s: 36528503505192438307355164441104001310566505351980369085208178712678799181120n,\n *   yParity: 0,\n * }])\n * ```\n *\n * @param authorizationList - An Authorization List.\n * @returns An RPC-formatted Authorization List.\n */\nexport function toRpcList(authorizationList) {\n    return authorizationList.map(toRpc);\n}\n/**\n * Converts an {@link ox#Authorization.Authorization} to an {@link ox#Authorization.Tuple}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 1,\n *   nonce: 69n,\n * })\n *\n * const tuple = Authorization.toTuple(authorization) // [!code focus]\n * // @log: [\n * // @log:   address: '0x1234567890abcdef1234567890abcdef12345678',\n * // @log:   chainId: 1,\n * // @log:   nonce: 69n,\n * // @log: ]\n * ```\n *\n * @param authorization - The {@link ox#Authorization.Authorization}.\n * @returns An [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple.\n */\nexport function toTuple(authorization) {\n    const { address, chainId, nonce } = authorization;\n    const signature = Signature.extract(authorization);\n    return [\n        chainId ? Hex.fromNumber(chainId) : '0x',\n        address,\n        nonce ? Hex.fromNumber(nonce) : '0x',\n        ...(signature ? Signature.toTuple(signature) : []),\n    ];\n}\n/**\n * Converts an {@link ox#Authorization.List} to an {@link ox#Authorization.TupleList}.\n *\n * @example\n * ```ts twoslash\n * import { Authorization } from 'ox'\n *\n * const authorization_1 = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 1,\n *   nonce: 69n,\n * })\n * const authorization_2 = Authorization.from({\n *   address: '0x1234567890abcdef1234567890abcdef12345678',\n *   chainId: 3,\n *   nonce: 20n,\n * })\n *\n * const tuple = Authorization.toTupleList([authorization_1, authorization_2]) // [!code focus]\n * // @log: [\n * // @log:   [\n * // @log:     address: '0x1234567890abcdef1234567890abcdef12345678',\n * // @log:     chainId: 1,\n * // @log:     nonce: 69n,\n * // @log:   ],\n * // @log:   [\n * // @log:     address: '0x1234567890abcdef1234567890abcdef12345678',\n * // @log:     chainId: 3,\n * // @log:     nonce: 20n,\n * // @log:   ],\n * // @log: ]\n * ```\n *\n * @param list - An {@link ox#Authorization.List}.\n * @returns An [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple list.\n */\nexport function toTupleList(list) {\n    if (!list || list.length === 0)\n        return [];\n    const tupleList = [];\n    for (const authorization of list)\n        tupleList.push(toTuple(authorization));\n    return tupleList;\n}\n//# sourceMappingURL=Authorization.js.map"],"names":["from","authorization","options","chainId","fromRpc","signature","address","nonce","Signature.extract","Number","BigInt"],"mappings":"yCA+CO,SAASA,EAAKC,EAAeC,EAAU,IAC1C,MAAqC,iBAA1BD,EAAcE,QACdC,EAAQH,GACZ,IAAKA,KAAkBC,EAAQG,UAC1C,CAqBO,SAASD,EAAQH,GACpB,MAAMK,QAAEA,EAAOH,QAAEA,EAAOI,MAAEA,GAAUN,EAC9BI,EAAYG,EAAkBP,GACpC,MAAO,CACHK,UACAH,QAASM,OAAON,GAChBI,MAAOG,OAAOH,MACXF,EAEX","x_google_ignoreList":[0]}

package/dist/esm/node_modules/ox/_esm/core/BlockOverrides.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BlockOverrides.js","sources":["../../../../../../node_modules/ox/_esm/core/BlockOverrides.js"],"sourcesContent":["import * as Hex from './Hex.js';\nimport * as Withdrawal from './Withdrawal.js';\n/**\n * Converts an {@link ox#BlockOverrides.Rpc} to an {@link ox#BlockOverrides.BlockOverrides}.\n *\n * @example\n * ```ts twoslash\n * import { BlockOverrides } from 'ox'\n *\n * const blockOverrides = BlockOverrides.fromRpc({\n *   baseFeePerGas: '0x1',\n *   blobBaseFee: '0x2',\n *   feeRecipient: '0x0000000000000000000000000000000000000000',\n *   gasLimit: '0x4',\n *   number: '0x5',\n *   prevRandao: '0x6',\n *   time: '0x1234567890',\n *   withdrawals: [\n *     {\n *       address: '0x0000000000000000000000000000000000000000',\n *       amount: '0x1',\n *       index: '0x0',\n *       validatorIndex: '0x1',\n *     },\n *   ],\n * })\n * ```\n *\n * @param rpcBlockOverrides - The RPC block overrides to convert.\n * @returns An instantiated {@link ox#BlockOverrides.BlockOverrides}.\n */\nexport function fromRpc(rpcBlockOverrides) {\n    return {\n        ...(rpcBlockOverrides.baseFeePerGas && {\n            baseFeePerGas: BigInt(rpcBlockOverrides.baseFeePerGas),\n        }),\n        ...(rpcBlockOverrides.blobBaseFee && {\n            blobBaseFee: BigInt(rpcBlockOverrides.blobBaseFee),\n        }),\n        ...(rpcBlockOverrides.feeRecipient && {\n            feeRecipient: rpcBlockOverrides.feeRecipient,\n        }),\n        ...(rpcBlockOverrides.gasLimit && {\n            gasLimit: BigInt(rpcBlockOverrides.gasLimit),\n        }),\n        ...(rpcBlockOverrides.number && {\n            number: BigInt(rpcBlockOverrides.number),\n        }),\n        ...(rpcBlockOverrides.prevRandao && {\n            prevRandao: BigInt(rpcBlockOverrides.prevRandao),\n        }),\n        ...(rpcBlockOverrides.time && {\n            time: BigInt(rpcBlockOverrides.time),\n        }),\n        ...(rpcBlockOverrides.withdrawals && {\n            withdrawals: rpcBlockOverrides.withdrawals.map(Withdrawal.fromRpc),\n        }),\n    };\n}\n/**\n * Converts an {@link ox#BlockOverrides.BlockOverrides} to an {@link ox#BlockOverrides.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { BlockOverrides } from 'ox'\n *\n * const blockOverrides = BlockOverrides.toRpc({\n *   baseFeePerGas: 1n,\n *   blobBaseFee: 2n,\n *   feeRecipient: '0x0000000000000000000000000000000000000000',\n *   gasLimit: 4n,\n *   number: 5n,\n *   prevRandao: 6n,\n *   time: 78187493520n,\n *   withdrawals: [\n *     {\n *       address: '0x0000000000000000000000000000000000000000',\n *       amount: 1n,\n *       index: 0,\n *       validatorIndex: 1,\n *     },\n *   ],\n * })\n * ```\n *\n * @param blockOverrides - The block overrides to convert.\n * @returns An instantiated {@link ox#BlockOverrides.Rpc}.\n */\nexport function toRpc(blockOverrides) {\n    return {\n        ...(typeof blockOverrides.baseFeePerGas === 'bigint' && {\n            baseFeePerGas: Hex.fromNumber(blockOverrides.baseFeePerGas),\n        }),\n        ...(typeof blockOverrides.blobBaseFee === 'bigint' && {\n            blobBaseFee: Hex.fromNumber(blockOverrides.blobBaseFee),\n        }),\n        ...(typeof blockOverrides.feeRecipient === 'string' && {\n            feeRecipient: blockOverrides.feeRecipient,\n        }),\n        ...(typeof blockOverrides.gasLimit === 'bigint' && {\n            gasLimit: Hex.fromNumber(blockOverrides.gasLimit),\n        }),\n        ...(typeof blockOverrides.number === 'bigint' && {\n            number: Hex.fromNumber(blockOverrides.number),\n        }),\n        ...(typeof blockOverrides.prevRandao === 'bigint' && {\n            prevRandao: Hex.fromNumber(blockOverrides.prevRandao),\n        }),\n        ...(typeof blockOverrides.time === 'bigint' && {\n            time: Hex.fromNumber(blockOverrides.time),\n        }),\n        ...(blockOverrides.withdrawals && {\n            withdrawals: blockOverrides.withdrawals.map(Withdrawal.toRpc),\n        }),\n    };\n}\n//# sourceMappingURL=BlockOverrides.js.map"],"names":["toRpc","blockOverrides","baseFeePerGas","Hex.fromNumber","blobBaseFee","feeRecipient","gasLimit","number","prevRandao","time","withdrawals","map","Withdrawal.toRpc"],"mappings":"8EAwFO,SAASA,EAAMC,GAClB,MAAO,IACyC,iBAAjCA,EAAeC,eAA8B,CACpDA,cAAeC,EAAeF,EAAeC,mBAEP,iBAA/BD,EAAeG,aAA4B,CAClDA,YAAaD,EAAeF,EAAeG,iBAEJ,iBAAhCH,EAAeI,cAA6B,CACnDA,aAAcJ,EAAeI,iBAEM,iBAA5BJ,EAAeK,UAAyB,CAC/CA,SAAUH,EAAeF,EAAeK,cAEP,iBAA1BL,EAAeM,QAAuB,CAC7CA,OAAQJ,EAAeF,EAAeM,YAED,iBAA9BN,EAAeO,YAA2B,CACjDA,WAAYL,EAAeF,EAAeO,gBAEX,iBAAxBP,EAAeQ,MAAqB,CAC3CA,KAAMN,EAAeF,EAAeQ,UAEpCR,EAAeS,aAAe,CAC9BA,YAAaT,EAAeS,YAAYC,IAAIC,IAGxD","x_google_ignoreList":[0]}