{"version":3,"file":"static/chunks/5031-5b99c41671357f41.js","mappings":"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","sources":["webpack://_N_E/./node_modules/lodash/_isIterateeCall.js","webpack://_N_E/./node_modules/lodash/toFinite.js","webpack://_N_E/./node_modules/@chakra-ui/layout/dist/chunk-IWVFML3N.mjs","webpack://_N_E/./node_modules/@chakra-ui/media-query/dist/chunk-OLSEFBIG.mjs","webpack://_N_E/./node_modules/viem/_esm/actions/ens/getEnsResolver.js","webpack://_N_E/./node_modules/viem/_esm/utils/filters/createFilterRequestScope.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/createBlockFilter.js","webpack://_N_E/./node_modules/viem/_esm/errors/log.js","webpack://_N_E/./node_modules/viem/_esm/utils/abi/encodeEventTopics.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/createContractEventFilter.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/createEventFilter.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/createPendingTransactionFilter.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/estimateContractGas.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getBlobBaseFee.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getBlockTransactionCount.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getBytecode.js","webpack://_N_E/./node_modules/viem/_esm/utils/abi/decodeEventLog.js","webpack://_N_E/./node_modules/viem/_esm/utils/abi/parseEventLogs.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getLogs.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getContractEvents.js","webpack://_N_E/./node_modules/viem/_esm/utils/formatters/feeHistory.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getFeeHistory.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getFilterChanges.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getFilterLogs.js","webpack://_N_E/./node_modules/viem/_esm/utils/formatters/proof.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getProof.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getStorageAt.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/getTransactionConfirmations.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/uninstallFilter.js","webpack://_N_E/./node_modules/viem/_esm/constants/strings.js","webpack://_N_E/./node_modules/viem/_esm/utils/signature/hashMessage.js","webpack://_N_E/./node_modules/viem/_esm/constants/contracts.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js","webpack://_N_E/./node_modules/viem/_esm/utils/data/isBytesEqual.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/hashes/esm/hmac.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/abstract/weierstrass.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js","webpack://_N_E/./node_modules/viem/node_modules/@noble/curves/esm/secp256k1.js","webpack://_N_E/./node_modules/viem/_esm/utils/signature/serializeSignature.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/verifyHash.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/verifyMessage.js","webpack://_N_E/./node_modules/viem/_esm/utils/signature/hashTypedData.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/verifyTypedData.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/watchBlocks.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/watchContractEvent.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/watchEvent.js","webpack://_N_E/./node_modules/viem/_esm/actions/public/watchPendingTransactions.js","webpack://_N_E/./node_modules/viem/_esm/clients/decorators/public.js","webpack://_N_E/./node_modules/viem/_esm/utils/abi/encodeDeployData.js","webpack://_N_E/./node_modules/viem/_esm/utils/regex.js","webpack://_N_E/./node_modules/viem/_esm/utils/typedData.js"],"sourcesContent":["var eq = require('./eq'),\n    isArrayLike = require('./isArrayLike'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n","var toNumber = require('./toNumber');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\nmodule.exports = toFinite;\n","// src/grid-item.tsx\nimport {\n  forwardRef,\n  chakra\n} from \"@chakra-ui/system\";\nimport { compact } from \"@chakra-ui/object-utils\";\nimport { mapResponsive } from \"@chakra-ui/breakpoint-utils\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction spanFn(span) {\n  return mapResponsive(\n    span,\n    (value) => value === \"auto\" ? \"auto\" : `span ${value}/span ${value}`\n  );\n}\nvar GridItem = forwardRef(function GridItem2(props, ref) {\n  const {\n    area,\n    colSpan,\n    colStart,\n    colEnd,\n    rowEnd,\n    rowSpan,\n    rowStart,\n    ...rest\n  } = props;\n  const styles = compact({\n    gridArea: area,\n    gridColumn: spanFn(colSpan),\n    gridRow: spanFn(rowSpan),\n    gridColumnStart: colStart,\n    gridColumnEnd: colEnd,\n    gridRowStart: rowStart,\n    gridRowEnd: rowEnd\n  });\n  return /* @__PURE__ */ jsx(chakra.div, { ref, __css: styles, ...rest });\n});\nGridItem.displayName = \"GridItem\";\n\nexport {\n  GridItem\n};\n","import {\n  Visibility\n} from \"./chunk-DZU5YH7Z.mjs\";\nimport {\n  useQuery\n} from \"./chunk-R3K6W4OF.mjs\";\n\n// src/show.tsx\nimport { jsx } from \"react/jsx-runtime\";\nfunction Show(props) {\n  const { children, ssr } = props;\n  const query = useQuery(props);\n  return /* @__PURE__ */ jsx(Visibility, { breakpoint: query, ssr, children });\n}\nShow.displayName = \"Show\";\n\nexport {\n  Show\n};\n","import { getChainContractAddress, } from '../../utils/chain/getChainContractAddress.js';\nimport { toHex } from '../../utils/encoding/toHex.js';\nimport { packetToBytes, } from '../../utils/ens/packetToBytes.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { readContract, } from '../public/readContract.js';\n/**\n * Gets resolver for ENS name.\n *\n * - Docs: https://viem.sh/docs/ens/actions/getEnsResolver\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/ens\n *\n * Calls `findResolver(bytes)` on ENS Universal Resolver Contract to retrieve the resolver of an ENS name.\n *\n * Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.\n *\n * @param client - Client to use\n * @param parameters - {@link GetEnsResolverParameters}\n * @returns Address for ENS resolver. {@link GetEnsResolverReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getEnsResolver, normalize } from 'viem/ens'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const resolverAddress = await getEnsResolver(client, {\n *   name: normalize('wevm.eth'),\n * })\n * // '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41'\n */\nexport async function getEnsResolver(client, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_, }) {\n    let universalResolverAddress = universalResolverAddress_;\n    if (!universalResolverAddress) {\n        if (!client.chain)\n            throw new Error('client chain not configured. universalResolverAddress is required.');\n        universalResolverAddress = getChainContractAddress({\n            blockNumber,\n            chain: client.chain,\n            contract: 'ensUniversalResolver',\n        });\n    }\n    const [resolverAddress] = await getAction(client, readContract, 'readContract')({\n        address: universalResolverAddress,\n        abi: [\n            {\n                inputs: [{ type: 'bytes' }],\n                name: 'findResolver',\n                outputs: [{ type: 'address' }, { type: 'bytes32' }],\n                stateMutability: 'view',\n                type: 'function',\n            },\n        ],\n        functionName: 'findResolver',\n        args: [toHex(packetToBytes(name))],\n        blockNumber,\n        blockTag,\n    });\n    return resolverAddress;\n}\n//# sourceMappingURL=getEnsResolver.js.map","/**\n * Scopes `request` to the filter ID. If the client is a fallback, it will\n * listen for responses and scope the child transport `request` function\n * to the successful filter ID.\n */\nexport function createFilterRequestScope(client, { method }) {\n    const requestMap = {};\n    if (client.transport.type === 'fallback')\n        client.transport.onResponse?.(({ method: method_, response: id, status, transport, }) => {\n            if (status === 'success' && method === method_)\n                requestMap[id] = transport.request;\n        });\n    return ((id) => requestMap[id] || client.request);\n}\n//# sourceMappingURL=createFilterRequestScope.js.map","import { createFilterRequestScope } from '../../utils/filters/createFilterRequestScope.js';\n/**\n * Creates a [`Filter`](https://viem.sh/docs/glossary/types#filter) to listen for new block hashes that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).\n *\n * - Docs: https://viem.sh/docs/actions/public/createBlockFilter\n * - JSON-RPC Methods: [`eth_newBlockFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newBlockFilter)\n *\n * @param client - Client to use\n * @returns [`Filter`](https://viem.sh/docs/glossary/types#filter). {@link CreateBlockFilterReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createBlockFilter } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createBlockFilter(client)\n * // { id: \"0x345a6572337856574a76364e457a4366\", type: 'block' }\n */\nexport async function createBlockFilter(client) {\n    const getRequest = createFilterRequestScope(client, {\n        method: 'eth_newBlockFilter',\n    });\n    const id = await client.request({\n        method: 'eth_newBlockFilter',\n    });\n    return { id, request: getRequest(id), type: 'block' };\n}\n//# sourceMappingURL=createBlockFilter.js.map","import { BaseError } from './base.js';\nexport class FilterTypeNotSupportedError extends BaseError {\n    constructor(type) {\n        super(`Filter type \"${type}\" is not supported.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'FilterTypeNotSupportedError'\n        });\n    }\n}\n//# sourceMappingURL=log.js.map","import { AbiEventNotFoundError, } from '../../errors/abi.js';\nimport { FilterTypeNotSupportedError, } from '../../errors/log.js';\nimport { toBytes } from '../encoding/toBytes.js';\nimport { keccak256 } from '../hash/keccak256.js';\nimport { toEventSelector, } from '../hash/toEventSelector.js';\nimport { encodeAbiParameters, } from './encodeAbiParameters.js';\nimport { formatAbiItem } from './formatAbiItem.js';\nimport { getAbiItem } from './getAbiItem.js';\nconst docsPath = '/docs/contract/encodeEventTopics';\nexport function encodeEventTopics(parameters) {\n    const { abi, eventName, args } = parameters;\n    let abiItem = abi[0];\n    if (eventName) {\n        const item = getAbiItem({ abi, name: eventName });\n        if (!item)\n            throw new AbiEventNotFoundError(eventName, { docsPath });\n        abiItem = item;\n    }\n    if (abiItem.type !== 'event')\n        throw new AbiEventNotFoundError(undefined, { docsPath });\n    const definition = formatAbiItem(abiItem);\n    const signature = toEventSelector(definition);\n    let topics = [];\n    if (args && 'inputs' in abiItem) {\n        const indexedInputs = abiItem.inputs?.filter((param) => 'indexed' in param && param.indexed);\n        const args_ = Array.isArray(args)\n            ? args\n            : Object.values(args).length > 0\n                ? indexedInputs?.map((x) => args[x.name]) ?? []\n                : [];\n        if (args_.length > 0) {\n            topics =\n                indexedInputs?.map((param, i) => Array.isArray(args_[i])\n                    ? args_[i].map((_, j) => encodeArg({ param, value: args_[i][j] }))\n                    : args_[i]\n                        ? encodeArg({ param, value: args_[i] })\n                        : null) ?? [];\n        }\n    }\n    return [signature, ...topics];\n}\nfunction encodeArg({ param, value, }) {\n    if (param.type === 'string' || param.type === 'bytes')\n        return keccak256(toBytes(value));\n    if (param.type === 'tuple' || param.type.match(/^(.*)\\[(\\d+)?\\]$/))\n        throw new FilterTypeNotSupportedError(param.type);\n    return encodeAbiParameters([param], [value]);\n}\n//# sourceMappingURL=encodeEventTopics.js.map","import { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { createFilterRequestScope } from '../../utils/filters/createFilterRequestScope.js';\n/**\n * Creates a Filter to retrieve event logs that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges) or [`getFilterLogs`](https://viem.sh/docs/actions/public/getFilterLogs).\n *\n * - Docs: https://viem.sh/docs/contract/createContractEventFilter\n *\n * @param client - Client to use\n * @param parameters - {@link CreateContractEventFilterParameters}\n * @returns [`Filter`](https://viem.sh/docs/glossary/types#filter). {@link CreateContractEventFilterReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createContractEventFilter } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createContractEventFilter(client, {\n *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),\n * })\n */\nexport async function createContractEventFilter(client, parameters) {\n    const { address, abi, args, eventName, fromBlock, strict, toBlock } = parameters;\n    const getRequest = createFilterRequestScope(client, {\n        method: 'eth_newFilter',\n    });\n    const topics = eventName\n        ? encodeEventTopics({\n            abi,\n            args,\n            eventName,\n        })\n        : undefined;\n    const id = await client.request({\n        method: 'eth_newFilter',\n        params: [\n            {\n                address,\n                fromBlock: typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,\n                toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,\n                topics,\n            },\n        ],\n    });\n    return {\n        abi,\n        args,\n        eventName,\n        id,\n        request: getRequest(id),\n        strict: Boolean(strict),\n        type: 'event',\n    };\n}\n//# sourceMappingURL=createContractEventFilter.js.map","import { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { createFilterRequestScope } from '../../utils/filters/createFilterRequestScope.js';\n/**\n * Creates a [`Filter`](https://viem.sh/docs/glossary/types#filter) to listen for new events that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).\n *\n * - Docs: https://viem.sh/docs/actions/public/createEventFilter\n * - JSON-RPC Methods: [`eth_newFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newfilter)\n *\n * @param client - Client to use\n * @param parameters - {@link CreateEventFilterParameters}\n * @returns [`Filter`](https://viem.sh/docs/glossary/types#filter). {@link CreateEventFilterReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createEventFilter } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createEventFilter(client, {\n *   address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',\n * })\n */\nexport async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock, } = {}) {\n    const events = events_ ?? (event ? [event] : undefined);\n    const getRequest = createFilterRequestScope(client, {\n        method: 'eth_newFilter',\n    });\n    let topics = [];\n    if (events) {\n        topics = [\n            events.flatMap((event) => encodeEventTopics({\n                abi: [event],\n                eventName: event.name,\n                args,\n            })),\n        ];\n        if (event)\n            topics = topics[0];\n    }\n    const id = await client.request({\n        method: 'eth_newFilter',\n        params: [\n            {\n                address,\n                fromBlock: typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,\n                toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,\n                ...(topics.length ? { topics } : {}),\n            },\n        ],\n    });\n    return {\n        abi: events,\n        args,\n        eventName: event ? event.name : undefined,\n        fromBlock,\n        id,\n        request: getRequest(id),\n        strict: Boolean(strict),\n        toBlock,\n        type: 'event',\n    };\n}\n//# sourceMappingURL=createEventFilter.js.map","import { createFilterRequestScope } from '../../utils/filters/createFilterRequestScope.js';\n/**\n * Creates a Filter to listen for new pending transaction hashes that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).\n *\n * - Docs: https://viem.sh/docs/actions/public/createPendingTransactionFilter\n * - JSON-RPC Methods: [`eth_newPendingTransactionFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newpendingtransactionfilter)\n *\n * @param client - Client to use\n * @returns [`Filter`](https://viem.sh/docs/glossary/types#filter). {@link CreateBlockFilterReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createPendingTransactionFilter } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createPendingTransactionFilter(client)\n * // { id: \"0x345a6572337856574a76364e457a4366\", type: 'transaction' }\n */\nexport async function createPendingTransactionFilter(client) {\n    const getRequest = createFilterRequestScope(client, {\n        method: 'eth_newPendingTransactionFilter',\n    });\n    const id = await client.request({\n        method: 'eth_newPendingTransactionFilter',\n    });\n    return { id, request: getRequest(id), type: 'transaction' };\n}\n//# sourceMappingURL=createPendingTransactionFilter.js.map","import { parseAccount, } from '../../accounts/utils/parseAccount.js';\nimport { encodeFunctionData, } from '../../utils/abi/encodeFunctionData.js';\nimport { getContractError, } from '../../utils/errors/getContractError.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { estimateGas, } from './estimateGas.js';\n/**\n * Estimates the gas required to successfully execute a contract write function call.\n *\n * - Docs: https://viem.sh/docs/contract/estimateContractGas\n *\n * Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`estimateGas` action](https://viem.sh/docs/actions/public/estimateGas) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).\n *\n * @param client - Client to use\n * @param parameters - {@link EstimateContractGasParameters}\n * @returns The gas estimate (in wei). {@link EstimateContractGasReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { estimateContractGas } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const gas = await estimateContractGas(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   abi: parseAbi(['function mint() public']),\n *   functionName: 'mint',\n *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',\n * })\n */\nexport async function estimateContractGas(client, parameters) {\n    const { abi, address, args, functionName, ...request } = parameters;\n    const data = encodeFunctionData({\n        abi,\n        args,\n        functionName,\n    });\n    try {\n        const gas = await getAction(client, estimateGas, 'estimateGas')({\n            data,\n            to: address,\n            ...request,\n        });\n        return gas;\n    }\n    catch (error) {\n        const account = request.account ? parseAccount(request.account) : undefined;\n        throw getContractError(error, {\n            abi,\n            address,\n            args,\n            docsPath: '/docs/contract/estimateContractGas',\n            functionName,\n            sender: account?.address,\n        });\n    }\n}\n//# sourceMappingURL=estimateContractGas.js.map","/**\n * Returns the base fee per blob gas in wei.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlobBaseFee\n * - JSON-RPC Methods: [`eth_blobBaseFee`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blobBaseFee)\n *\n * @param client - Client to use\n * @returns The blob base fee (in wei). {@link GetBlobBaseFeeReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlobBaseFee } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const blobBaseFee = await getBlobBaseFee(client)\n */\nexport async function getBlobBaseFee(client) {\n    const baseFee = await client.request({\n        method: 'eth_blobBaseFee',\n    });\n    return BigInt(baseFee);\n}\n//# sourceMappingURL=getBlobBaseFee.js.map","import { hexToNumber, } from '../../utils/encoding/fromHex.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the number of Transactions at a block number, hash, or tag.\n *\n * - Docs: https://viem.sh/docs/actions/public/getBlockTransactionCount\n * - JSON-RPC Methods:\n *   - Calls [`eth_getBlockTransactionCountByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbynumber) for `blockNumber` & `blockTag`.\n *   - Calls [`eth_getBlockTransactionCountByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbyhash) for `blockHash`.\n *\n * @param client - Client to use\n * @param parameters - {@link GetBlockTransactionCountParameters}\n * @returns The block transaction count. {@link GetBlockTransactionCountReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBlockTransactionCount } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const count = await getBlockTransactionCount(client)\n */\nexport async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = 'latest', } = {}) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    let count;\n    if (blockHash) {\n        count = await client.request({\n            method: 'eth_getBlockTransactionCountByHash',\n            params: [blockHash],\n        });\n    }\n    else {\n        count = await client.request({\n            method: 'eth_getBlockTransactionCountByNumber',\n            params: [blockNumberHex || blockTag],\n        });\n    }\n    return hexToNumber(count);\n}\n//# sourceMappingURL=getBlockTransactionCount.js.map","import { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Retrieves the bytecode at an address.\n *\n * - Docs: https://viem.sh/docs/contract/getBytecode\n * - JSON-RPC Methods: [`eth_getCode`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getcode)\n *\n * @param client - Client to use\n * @param parameters - {@link GetBytecodeParameters}\n * @returns The contract's bytecode. {@link GetBytecodeReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getBytecode } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const code = await getBytecode(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n * })\n */\nexport async function getBytecode(client, { address, blockNumber, blockTag = 'latest' }) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const hex = await client.request({\n        method: 'eth_getCode',\n        params: [address, blockNumberHex || blockTag],\n    });\n    if (hex === '0x')\n        return undefined;\n    return hex;\n}\n//# sourceMappingURL=getBytecode.js.map","import { AbiDecodingDataSizeTooSmallError, AbiEventSignatureEmptyTopicsError, AbiEventSignatureNotFoundError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, } from '../../errors/abi.js';\nimport { size } from '../data/size.js';\nimport { toEventSelector, } from '../hash/toEventSelector.js';\nimport { PositionOutOfBoundsError } from '../../errors/cursor.js';\nimport { decodeAbiParameters, } from './decodeAbiParameters.js';\nimport { formatAbiItem } from './formatAbiItem.js';\nconst docsPath = '/docs/contract/decodeEventLog';\nexport function decodeEventLog(parameters) {\n    const { abi, data, strict: strict_, topics, } = parameters;\n    const strict = strict_ ?? true;\n    const [signature, ...argTopics] = topics;\n    if (!signature)\n        throw new AbiEventSignatureEmptyTopicsError({ docsPath });\n    const abiItem = abi.find((x) => x.type === 'event' &&\n        signature === toEventSelector(formatAbiItem(x)));\n    if (!(abiItem && 'name' in abiItem) || abiItem.type !== 'event')\n        throw new AbiEventSignatureNotFoundError(signature, { docsPath });\n    const { name, inputs } = abiItem;\n    const isUnnamed = inputs?.some((x) => !('name' in x && x.name));\n    let args = isUnnamed ? [] : {};\n    // Decode topics (indexed args).\n    const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed);\n    for (let i = 0; i < indexedInputs.length; i++) {\n        const param = indexedInputs[i];\n        const topic = argTopics[i];\n        if (!topic)\n            throw new DecodeLogTopicsMismatch({\n                abiItem,\n                param: param,\n            });\n        args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic });\n    }\n    // Decode data (non-indexed args).\n    const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed));\n    if (nonIndexedInputs.length > 0) {\n        if (data && data !== '0x') {\n            try {\n                const decodedData = decodeAbiParameters(nonIndexedInputs, data);\n                if (decodedData) {\n                    if (isUnnamed)\n                        args = [...args, ...decodedData];\n                    else {\n                        for (let i = 0; i < nonIndexedInputs.length; i++) {\n                            args[nonIndexedInputs[i].name] = decodedData[i];\n                        }\n                    }\n                }\n            }\n            catch (err) {\n                if (strict) {\n                    if (err instanceof AbiDecodingDataSizeTooSmallError ||\n                        err instanceof PositionOutOfBoundsError)\n                        throw new DecodeLogDataMismatch({\n                            abiItem,\n                            data: data,\n                            params: nonIndexedInputs,\n                            size: size(data),\n                        });\n                    throw err;\n                }\n            }\n        }\n        else if (strict) {\n            throw new DecodeLogDataMismatch({\n                abiItem,\n                data: '0x',\n                params: nonIndexedInputs,\n                size: 0,\n            });\n        }\n    }\n    return {\n        eventName: name,\n        args: Object.values(args).length > 0 ? args : undefined,\n    };\n}\nfunction decodeTopic({ param, value }) {\n    if (param.type === 'string' ||\n        param.type === 'bytes' ||\n        param.type === 'tuple' ||\n        param.type.match(/^(.*)\\[(\\d+)?\\]$/))\n        return value;\n    const decodedArg = decodeAbiParameters([param], value) || [];\n    return decodedArg[0];\n}\n//# sourceMappingURL=decodeEventLog.js.map","// TODO(v3): checksum address.\nimport { AbiEventSignatureNotFoundError, DecodeLogDataMismatch, DecodeLogTopicsMismatch, } from '../../errors/abi.js';\nimport { decodeEventLog, } from './decodeEventLog.js';\n/**\n * Extracts & decodes logs matching the provided signature(s) (`abi` + optional `eventName`)\n * from a set of opaque logs.\n *\n * @param parameters - {@link ParseEventLogsParameters}\n * @returns The logs. {@link ParseEventLogsReturnType}\n *\n * @example\n * import { createClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { parseEventLogs } from 'viem/op-stack'\n *\n * const client = createClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n *\n * const receipt = await getTransactionReceipt(client, {\n *   hash: '0xec23b2ba4bc59ba61554507c1b1bc91649e6586eb2dd00c728e8ed0db8bb37ea',\n * })\n *\n * const logs = parseEventLogs({ logs: receipt.logs })\n * // [{ args: { ... }, eventName: 'TransactionDeposited', ... }, ...]\n */\nexport function parseEventLogs({ abi, eventName, logs, strict = true, }) {\n    return logs\n        .map((log) => {\n        try {\n            const event = decodeEventLog({\n                ...log,\n                abi,\n                strict,\n            });\n            if (eventName && !eventName.includes(event.eventName))\n                return null;\n            return { ...event, ...log };\n        }\n        catch (err) {\n            let eventName;\n            let isUnnamed;\n            if (err instanceof AbiEventSignatureNotFoundError)\n                return null;\n            if (err instanceof DecodeLogDataMismatch ||\n                err instanceof DecodeLogTopicsMismatch) {\n                // If strict mode is on, and log data/topics do not match event definition, skip.\n                if (strict)\n                    return null;\n                eventName = err.abiItem.name;\n                isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name));\n            }\n            // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).\n            return { ...log, args: isUnnamed ? [] : {}, eventName };\n        }\n    })\n        .filter(Boolean);\n}\n//# sourceMappingURL=parseEventLogs.js.map","import { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of event logs matching the provided parameters.\n *\n * - Docs: https://viem.sh/docs/actions/public/getLogs\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/filters-and-logs/event-logs\n * - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)\n *\n * @param client - Client to use\n * @param parameters - {@link GetLogsParameters}\n * @returns A list of event logs. {@link GetLogsReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getLogs } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const logs = await getLogs(client)\n */\nexport async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_, } = {}) {\n    const strict = strict_ ?? false;\n    const events = events_ ?? (event ? [event] : undefined);\n    let topics = [];\n    if (events) {\n        topics = [\n            events.flatMap((event) => encodeEventTopics({\n                abi: [event],\n                eventName: event.name,\n                args,\n            })),\n        ];\n        if (event)\n            topics = topics[0];\n    }\n    let logs;\n    if (blockHash) {\n        logs = await client.request({\n            method: 'eth_getLogs',\n            params: [{ address, topics, blockHash }],\n        });\n    }\n    else {\n        logs = await client.request({\n            method: 'eth_getLogs',\n            params: [\n                {\n                    address,\n                    topics,\n                    fromBlock: typeof fromBlock === 'bigint' ? numberToHex(fromBlock) : fromBlock,\n                    toBlock: typeof toBlock === 'bigint' ? numberToHex(toBlock) : toBlock,\n                },\n            ],\n        });\n    }\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!events)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: events,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getLogs.js.map","import { getAbiItem, } from '../../utils/abi/getAbiItem.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { getLogs, } from './getLogs.js';\n/**\n * Returns a list of event logs emitted by a contract.\n *\n * - Docs: https://viem.sh/docs/actions/public/getContractEvents\n * - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)\n *\n * @param client - Client to use\n * @param parameters - {@link GetContractEventsParameters}\n * @returns A list of event logs. {@link GetContractEventsReturnType}\n *\n * @example\n * import { createClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getContractEvents } from 'viem/public'\n * import { wagmiAbi } from './abi'\n *\n * const client = createClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const logs = await getContractEvents(client, {\n *  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *  abi: wagmiAbi,\n *  eventName: 'Transfer'\n * })\n */\nexport async function getContractEvents(client, parameters) {\n    const { abi, address, args, blockHash, eventName, fromBlock, toBlock, strict, } = parameters;\n    const event = eventName\n        ? getAbiItem({ abi, name: eventName })\n        : undefined;\n    const events = !event\n        ? abi.filter((x) => x.type === 'event')\n        : undefined;\n    return getAction(client, getLogs, 'getLogs')({\n        address,\n        args,\n        blockHash,\n        event,\n        events,\n        fromBlock,\n        toBlock,\n        strict,\n    });\n}\n//# sourceMappingURL=getContractEvents.js.map","export function formatFeeHistory(feeHistory) {\n    return {\n        baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),\n        gasUsedRatio: feeHistory.gasUsedRatio,\n        oldestBlock: BigInt(feeHistory.oldestBlock),\n        reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value))),\n    };\n}\n//# sourceMappingURL=feeHistory.js.map","import { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatFeeHistory, } from '../../utils/formatters/feeHistory.js';\n/**\n * Returns a collection of historical gas information.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFeeHistory\n * - JSON-RPC Methods: [`eth_feeHistory`](https://docs.alchemy.com/reference/eth-feehistory)\n *\n * @param client - Client to use\n * @param parameters - {@link GetFeeHistoryParameters}\n * @returns The gas estimate (in wei). {@link GetFeeHistoryReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getFeeHistory } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const feeHistory = await getFeeHistory(client, {\n *   blockCount: 4,\n *   rewardPercentiles: [25, 75],\n * })\n */\nexport async function getFeeHistory(client, { blockCount, blockNumber, blockTag = 'latest', rewardPercentiles, }) {\n    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined;\n    const feeHistory = await client.request({\n        method: 'eth_feeHistory',\n        params: [\n            numberToHex(blockCount),\n            blockNumberHex || blockTag,\n            rewardPercentiles,\n        ],\n    });\n    return formatFeeHistory(feeHistory);\n}\n//# sourceMappingURL=getFeeHistory.js.map","import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of logs or hashes based on a [Filter](/docs/glossary/terms#filter) since the last time it was called.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFilterChanges\n * - JSON-RPC Methods: [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges)\n *\n * A Filter can be created from the following actions:\n *\n * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)\n * - [`createContractEventFilter`](https://viem.sh/docs/contract/createContractEventFilter)\n * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)\n * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)\n *\n * Depending on the type of filter, the return value will be different:\n *\n * - If the filter was created with `createContractEventFilter` or `createEventFilter`, it returns a list of logs.\n * - If the filter was created with `createPendingTransactionFilter`, it returns a list of transaction hashes.\n * - If the filter was created with `createBlockFilter`, it returns a list of block hashes.\n *\n * @param client - Client to use\n * @param parameters - {@link GetFilterChangesParameters}\n * @returns Logs or hashes. {@link GetFilterChangesReturnType}\n *\n * @example\n * // Blocks\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createBlockFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createBlockFilter(client)\n * const hashes = await getFilterChanges(client, { filter })\n *\n * @example\n * // Contract Events\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createContractEventFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createContractEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),\n *   eventName: 'Transfer',\n * })\n * const logs = await getFilterChanges(client, { filter })\n *\n * @example\n * // Raw Events\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createEventFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),\n * })\n * const logs = await getFilterChanges(client, { filter })\n *\n * @example\n * // Transactions\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createPendingTransactionFilter, getFilterChanges } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createPendingTransactionFilter(client)\n * const hashes = await getFilterChanges(client, { filter })\n */\nexport async function getFilterChanges(_client, { filter, }) {\n    const strict = 'strict' in filter && filter.strict;\n    const logs = await filter.request({\n        method: 'eth_getFilterChanges',\n        params: [filter.id],\n    });\n    if (typeof logs[0] === 'string')\n        return logs;\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!('abi' in filter) || !filter.abi)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: filter.abi,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getFilterChanges.js.map","import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';\nimport { formatLog, } from '../../utils/formatters/log.js';\n/**\n * Returns a list of event logs since the filter was created.\n *\n * - Docs: https://viem.sh/docs/actions/public/getFilterLogs\n * - JSON-RPC Methods: [`eth_getFilterLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterlogs)\n *\n * `getFilterLogs` is only compatible with **event filters**.\n *\n * @param client - Client to use\n * @param parameters - {@link GetFilterLogsParameters}\n * @returns A list of event logs. {@link GetFilterLogsReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbiItem } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createEventFilter, getFilterLogs } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const filter = await createEventFilter(client, {\n *   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',\n *   event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),\n * })\n * const logs = await getFilterLogs(client, { filter })\n */\nexport async function getFilterLogs(_client, { filter, }) {\n    const strict = filter.strict ?? false;\n    const logs = await filter.request({\n        method: 'eth_getFilterLogs',\n        params: [filter.id],\n    });\n    const formattedLogs = logs.map((log) => formatLog(log));\n    if (!filter.abi)\n        return formattedLogs;\n    return parseEventLogs({\n        abi: filter.abi,\n        logs: formattedLogs,\n        strict,\n    });\n}\n//# sourceMappingURL=getFilterLogs.js.map","import { hexToNumber } from '../index.js';\nfunction formatStorageProof(storageProof) {\n    return storageProof.map((proof) => ({\n        ...proof,\n        value: BigInt(proof.value),\n    }));\n}\nexport function formatProof(proof) {\n    return {\n        ...proof,\n        balance: proof.balance ? BigInt(proof.balance) : undefined,\n        nonce: proof.nonce ? hexToNumber(proof.nonce) : undefined,\n        storageProof: proof.storageProof\n            ? formatStorageProof(proof.storageProof)\n            : undefined,\n    };\n}\n//# sourceMappingURL=proof.js.map","import { numberToHex, } from '../../utils/encoding/toHex.js';\nimport { formatProof, } from '../../utils/formatters/proof.js';\n/**\n * Returns the account and storage values of the specified account including the Merkle-proof.\n *\n * - Docs: https://viem.sh/docs/actions/public/getProof\n * - JSON-RPC Methods:\n *   - Calls [`eth_getProof`](https://eips.ethereum.org/EIPS/eip-1186)\n *\n * @param client - Client to use\n * @param parameters - {@link GetProofParameters}\n * @returns Proof data. {@link GetProofReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getProof } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const block = await getProof(client, {\n *  address: '0x...',\n *  storageKeys: ['0x...'],\n * })\n */\nexport async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys, }) {\n    const blockTag = blockTag_ ?? 'latest';\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const proof = await client.request({\n        method: 'eth_getProof',\n        params: [address, storageKeys, blockNumberHex || blockTag],\n    });\n    return formatProof(proof);\n}\n//# sourceMappingURL=getProof.js.map","import { numberToHex, } from '../../utils/encoding/toHex.js';\n/**\n * Returns the value from a storage slot at a given address.\n *\n * - Docs: https://viem.sh/docs/contract/getStorageAt\n * - JSON-RPC Methods: [`eth_getStorageAt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getstorageat)\n *\n * @param client - Client to use\n * @param parameters - {@link GetStorageAtParameters}\n * @returns The value of the storage slot. {@link GetStorageAtReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getStorageAt } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const code = await getStorageAt(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   slot: toHex(0),\n * })\n */\nexport async function getStorageAt(client, { address, blockNumber, blockTag = 'latest', slot }) {\n    const blockNumberHex = blockNumber !== undefined ? numberToHex(blockNumber) : undefined;\n    const data = await client.request({\n        method: 'eth_getStorageAt',\n        params: [address, slot, blockNumberHex || blockTag],\n    });\n    return data;\n}\n//# sourceMappingURL=getStorageAt.js.map","import { getAction } from '../../utils/getAction.js';\nimport { getBlockNumber, } from './getBlockNumber.js';\nimport { getTransaction, } from './getTransaction.js';\n/**\n * Returns the number of blocks passed (confirmations) since the transaction was processed on a block.\n *\n * - Docs: https://viem.sh/docs/actions/public/getTransactionConfirmations\n * - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/fetching-transactions\n * - JSON-RPC Methods: [`eth_getTransactionConfirmations`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionConfirmations)\n *\n * @param client - Client to use\n * @param parameters - {@link GetTransactionConfirmationsParameters}\n * @returns The number of blocks passed since the transaction was processed. If confirmations is 0, then the Transaction has not been confirmed & processed yet. {@link GetTransactionConfirmationsReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getTransactionConfirmations } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const confirmations = await getTransactionConfirmations(client, {\n *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',\n * })\n */\nexport async function getTransactionConfirmations(client, { hash, transactionReceipt }) {\n    const [blockNumber, transaction] = await Promise.all([\n        getAction(client, getBlockNumber, 'getBlockNumber')({}),\n        hash\n            ? getAction(client, getTransaction, 'getBlockNumber')({ hash })\n            : undefined,\n    ]);\n    const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;\n    if (!transactionBlockNumber)\n        return 0n;\n    return blockNumber - transactionBlockNumber + 1n;\n}\n//# sourceMappingURL=getTransactionConfirmations.js.map","/**\n * Destroys a [`Filter`](https://viem.sh/docs/glossary/types#filter).\n *\n * - Docs: https://viem.sh/docs/actions/public/uninstallFilter\n * - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)\n *\n * Destroys a Filter that was created from one of the following Actions:\n * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)\n * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)\n * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)\n *\n * @param client - Client to use\n * @param parameters - {@link UninstallFilterParameters}\n * @returns A boolean indicating if the Filter was successfully uninstalled. {@link UninstallFilterReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'\n *\n * const filter = await createPendingTransactionFilter(client)\n * const uninstalled = await uninstallFilter(client, { filter })\n * // true\n */\nexport async function uninstallFilter(_client, { filter }) {\n    return filter.request({\n        method: 'eth_uninstallFilter',\n        params: [filter.id],\n    });\n}\n//# sourceMappingURL=uninstallFilter.js.map","export const presignMessagePrefix = '\\x19Ethereum Signed Message:\\n';\n//# sourceMappingURL=strings.js.map","import { presignMessagePrefix } from '../../constants/strings.js';\nimport { concat } from '../data/concat.js';\nimport { stringToBytes, toBytes, } from '../encoding/toBytes.js';\nimport { keccak256 } from '../hash/keccak256.js';\nexport function hashMessage(message, to_) {\n    const messageBytes = (() => {\n        if (typeof message === 'string')\n            return stringToBytes(message);\n        if (message.raw instanceof Uint8Array)\n            return message.raw;\n        return toBytes(message.raw);\n    })();\n    const prefixBytes = stringToBytes(`${presignMessagePrefix}${messageBytes.length}`);\n    return keccak256(concat([prefixBytes, messageBytes]), to_);\n}\n//# sourceMappingURL=hashMessage.js.map","export const universalSignatureValidatorByteCode = '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';\n//# sourceMappingURL=contracts.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst u8a = (a) => a instanceof Uint8Array;\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? `0${hex}` : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(`${title} must be valid hex string, got \"${hex}\". Cause: ${e}`);\n        }\n    }\n    else if (u8a(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(`${title} must be hex string or Uint8Array`);\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\nexport function equalBytes(b1, b2) {\n    // We don't care about timing attacks here\n    if (b1.length !== b2.length)\n        return false;\n    for (let i = 0; i < b1.length; i++)\n        if (b1[i] !== b2[i])\n            return false;\n    return true;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport const bitSet = (n, pos, value) => {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n};\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || val instanceof Uint8Array,\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error(`Invalid validator \"${type}\", expected function`);\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n//# sourceMappingURL=utils.js.map","import { equalBytes } from '@noble/curves/abstract/utils';\nimport { toBytes } from '../encoding/toBytes.js';\nimport { isHex } from './isHex.js';\nexport function isBytesEqual(a_, b_) {\n    const a = isHex(a_) ? toBytes(a_) : a_;\n    const b = isHex(b_) ? toBytes(b_) : b_;\n    return equalBytes(a, b);\n}\n//# sourceMappingURL=isBytesEqual.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Utilities for modular arithmetics and finite fields\nimport { bitMask, numberToBytesBE, numberToBytesLE, bytesToNumberBE, bytesToNumberLE, ensureBytes, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);\n// prettier-ignore\nconst _9n = BigInt(9), _16n = BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\n// TODO: use field version && remove\nexport function pow(num, power, modulo) {\n    if (modulo <= _0n || power < _0n)\n        throw new Error('Expected power/modulo > 0');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n// Inverses number over modulo\nexport function invert(number, modulo) {\n    if (number === _0n || modulo <= _0n) {\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n    }\n    // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++)\n        ;\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\nexport function FpSqrt(P) {\n    // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.\n    // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('Expected power > 0');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic\n    return (x) => {\n        const p = f.pow(x, legendreConst);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime. **Non-primes are not supported.**\n * Do not init in loop: slow. Very fragile: always run a benchmark on a change.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('Field lengths over 2048 bytes are not supported');\n    const sqrtP = FpSqrt(ORDER);\n    const f = Object.freeze({\n        ORDER,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt || ((n) => sqrtP(f, n)),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use mapKeyToField instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);\n    const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","import { hash as assertHash, bytes as assertBytes, exists as assertExists } from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        assertHash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        assertExists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        assertExists(this);\n        assertBytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF(c, bits) {\n    const constTimeNegate = (condition, item) => {\n        const neg = item.negate();\n        return condition ? neg : item;\n    };\n    const opts = (W) => {\n        const windows = Math.ceil(bits / W) + 1; // +1, because\n        const windowSize = 2 ** (W - 1); // -1 because we skip zero\n        return { windows, windowSize };\n    };\n    return {\n        constTimeNegate,\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n) {\n            let p = c.ZERO;\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = opts(W);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = opts(W);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        wNAFCached(P, precomputesMap, n, transform) {\n            // @ts-ignore\n            const W = P._WINDOW_SIZE || 1;\n            // Calculate precomputes on a first run, reuse them after\n            let comp = precomputesMap.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1) {\n                    precomputesMap.set(P, transform(comp));\n                }\n            }\n            return this.wNAF(W, comp, n);\n        },\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Short Weierstrass curve. The formula is: y² = x³ + ax + b\nimport * as mod from './modular.js';\nimport * as ut from './utils.js';\nimport { ensureBytes } from './utils.js';\nimport { wNAF, validateBasic } from './curve.js';\nfunction validatePointOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        a: 'field',\n        b: 'field',\n    }, {\n        allowedPrivateKeyLengths: 'array',\n        wrapPrivateKey: 'boolean',\n        isTorsionFree: 'function',\n        clearCofactor: 'function',\n        allowInfinityPoint: 'boolean',\n        fromBytes: 'function',\n        toBytes: 'function',\n    });\n    const { endo, Fp, a } = opts;\n    if (endo) {\n        if (!Fp.eql(a, Fp.ZERO)) {\n            throw new Error('Endomorphism can only be defined for Koblitz curves that have a=0');\n        }\n        if (typeof endo !== 'object' ||\n            typeof endo.beta !== 'bigint' ||\n            typeof endo.splitScalar !== 'function') {\n            throw new Error('Expected endomorphism with beta: bigint and splitScalar: function');\n        }\n    }\n    return Object.freeze({ ...opts });\n}\n// ASN.1 DER encoding utilities\nconst { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: class DERErr extends Error {\n        constructor(m = '') {\n            super(m);\n        }\n    },\n    _parseInt(data) {\n        const { Err: E } = DER;\n        if (data.length < 2 || data[0] !== 0x02)\n            throw new E('Invalid signature integer tag');\n        const len = data[1];\n        const res = data.subarray(2, len + 2);\n        if (!len || res.length !== len)\n            throw new E('Invalid signature integer: wrong length');\n        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n        // since we always use positive integers here. It must always be empty:\n        // - add zero byte if exists\n        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n        if (res[0] & 0b10000000)\n            throw new E('Invalid signature integer: negative');\n        if (res[0] === 0x00 && !(res[1] & 0b10000000))\n            throw new E('Invalid signature integer: unnecessary leading zero');\n        return { d: b2n(res), l: data.subarray(len + 2) }; // d is data, l is left\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E } = DER;\n        const data = typeof hex === 'string' ? h2b(hex) : hex;\n        if (!(data instanceof Uint8Array))\n            throw new Error('ui8a expected');\n        let l = data.length;\n        if (l < 2 || data[0] != 0x30)\n            throw new E('Invalid signature tag');\n        if (data[1] !== l - 2)\n            throw new E('Invalid signature: incorrect length');\n        const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));\n        const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);\n        if (rBytesLeft.length)\n            throw new E('Invalid signature: left bytes after parsing');\n        return { r, s };\n    },\n    hexFromSig(sig) {\n        // Add leading zero if first byte has negative bit enabled. More details in '_parseInt'\n        const slice = (s) => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);\n        const h = (num) => {\n            const hex = num.toString(16);\n            return hex.length & 1 ? `0${hex}` : hex;\n        };\n        const s = slice(h(sig.s));\n        const r = slice(h(sig.r));\n        const shl = s.length / 2;\n        const rhl = r.length / 2;\n        const sl = h(shl);\n        const rl = h(rhl);\n        return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;\n    },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function weierstrassPoints(opts) {\n    const CURVE = validatePointOpts(opts);\n    const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n    const toBytes = CURVE.toBytes ||\n        ((_c, point, _isCompressed) => {\n            const a = point.toAffine();\n            return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n        });\n    const fromBytes = CURVE.fromBytes ||\n        ((bytes) => {\n            // const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n            const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n            const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n            return { x, y };\n        });\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const { a, b } = CURVE;\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x2 * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x3 + a * x + b\n    }\n    // Validate whether the passed curve params are valid.\n    // We check if curve equation works for generator point.\n    // `assertValidity()` won't work: `isTorsionFree()` is not available at this point in bls12-381.\n    // ProjectivePoint class has not been initialized yet.\n    if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))\n        throw new Error('bad generator point: equation left != right');\n    // Valid group elements reside in range 1..n-1\n    function isWithinCurveOrder(num) {\n        return typeof num === 'bigint' && _0n < num && num < CURVE.n;\n    }\n    function assertGE(num) {\n        if (!isWithinCurveOrder(num))\n            throw new Error('Expected valid bigint: 0 < bigint < curve.n');\n    }\n    // Validates if priv key is valid and converts it to bigint.\n    // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n    function normPrivateKeyToScalar(key) {\n        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;\n        if (lengths && typeof key !== 'bigint') {\n            if (key instanceof Uint8Array)\n                key = ut.bytesToHex(key);\n            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n            if (typeof key !== 'string' || !lengths.includes(key.length))\n                throw new Error('Invalid key');\n            key = key.padStart(nByteLength * 2, '0');\n        }\n        let num;\n        try {\n            num =\n                typeof key === 'bigint'\n                    ? key\n                    : ut.bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n        }\n        catch (error) {\n            throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);\n        }\n        if (wrapPrivateKey)\n            num = mod.mod(num, n); // disabled by default, enabled for BLS\n        assertGE(num); // num in range [1..N-1]\n        return num;\n    }\n    const pointPrecomputes = new Map();\n    function assertPrjPoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)\n     * Default Point works in 2d / affine coordinates: (x, y)\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        constructor(px, py, pz) {\n            this.px = px;\n            this.py = py;\n            this.pz = pz;\n            if (px == null || !Fp.isValid(px))\n                throw new Error('x required');\n            if (py == null || !Fp.isValid(py))\n                throw new Error('y required');\n            if (pz == null || !Fp.isValid(pz))\n                throw new Error('z required');\n        }\n        // Does not validate if the point is on-curve.\n        // Use fromHex instead, or call assertValidity() later.\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            const is0 = (i) => Fp.eql(i, Fp.ZERO);\n            // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n            if (is0(x) && is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         * Takes a bunch of Projective Points but executes only one\n         * inversion on all of them. Inversion is very slow operation,\n         * so this improves performance massively.\n         * Optimization: converts a list of projective points to a list of identical points with Z=1.\n         */\n        static normalizeZ(points) {\n            const toInv = Fp.invertBatch(points.map((p) => p.pz));\n            return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n        }\n        /**\n         * Converts hash string or Uint8Array to Point.\n         * @param hex short/long ECDSA hex\n         */\n        static fromHex(hex) {\n            const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n            P.assertValidity();\n            return P;\n        }\n        // Multiplies generator point by privateKey.\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n        }\n        // \"Private method\", don't use it directly\n        _setWindowSize(windowSize) {\n            this._WINDOW_SIZE = windowSize;\n            pointPrecomputes.delete(this);\n        }\n        // A point on curve is valid if it conforms to equation.\n        assertValidity() {\n            if (this.is0()) {\n                // (0, 1, 0) aka ZERO is invalid in most contexts.\n                // In BLS, ZERO can be serialized, so we allow it.\n                // (0, 0, 0) is wrong representation of ZERO and is always invalid.\n                if (CURVE.allowInfinityPoint && !Fp.is0(this.py))\n                    return;\n                throw new Error('bad point: ZERO');\n            }\n            // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n            const { x, y } = this.toAffine();\n            // Check if x, y are valid field elements\n            if (!Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('bad point: x or y not FE');\n            const left = Fp.sqr(y); // y²\n            const right = weierstrassEquation(x); // x³ + ax + b\n            if (!Fp.eql(left, right))\n                throw new Error('bad point: equation left != right');\n            if (!this.isTorsionFree())\n                throw new Error('bad point: not in prime-order subgroup');\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (Fp.isOdd)\n                return !Fp.isOdd(y);\n            throw new Error(\"Field doesn't support isOdd\");\n        }\n        /**\n         * Compare one point to another.\n         */\n        equals(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /**\n         * Flips point to one corresponding to (x, -y) in Affine coordinates.\n         */\n        negate() {\n            return new Point(this.px, Fp.neg(this.py), this.pz);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        wNAF(n) {\n            return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {\n                const toInv = Fp.invertBatch(comp.map((p) => p.pz));\n                return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n            });\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed private key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(n) {\n            const I = Point.ZERO;\n            if (n === _0n)\n                return I;\n            assertGE(n); // Will throw on 0\n            if (n === _1n)\n                return this;\n            const { endo } = CURVE;\n            if (!endo)\n                return wnaf.unsafeLadder(this, n);\n            // Apply endomorphism\n            let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n            let k1p = I;\n            let k2p = I;\n            let d = this;\n            while (k1 > _0n || k2 > _0n) {\n                if (k1 & _1n)\n                    k1p = k1p.add(d);\n                if (k2 & _1n)\n                    k2p = k2p.add(d);\n                d = d.double();\n                k1 >>= _1n;\n                k2 >>= _1n;\n            }\n            if (k1neg)\n                k1p = k1p.negate();\n            if (k2neg)\n                k2p = k2p.negate();\n            k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n            return k1p.add(k2p);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            assertGE(scalar);\n            let n = scalar;\n            let point, fake; // Fake point is used to const-time mult\n            const { endo } = CURVE;\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n                let { p: k1p, f: f1p } = this.wNAF(k1);\n                let { p: k2p, f: f2p } = this.wNAF(k2);\n                k1p = wnaf.constTimeNegate(k1neg, k1p);\n                k2p = wnaf.constTimeNegate(k2neg, k2p);\n                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n                point = k1p.add(k2p);\n                fake = f1p.add(f2p);\n            }\n            else {\n                const { p, f } = this.wNAF(n);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return Point.normalizeZ([point, fake])[0];\n        }\n        /**\n         * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n         * Not using Strauss-Shamir trick: precomputation tables are faster.\n         * The trick could be useful if both P and Q are not G (not in our case).\n         * @returns non-zero affine point\n         */\n        multiplyAndAddUnsafe(Q, a, b) {\n            const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n            const mul = (P, a // Select faster multiply() method\n            ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n            const sum = mul(this, a).add(mul(Q, b));\n            return sum.is0() ? undefined : sum;\n        }\n        // Converts Projective point to affine (x, y) coordinates.\n        // Can accept precomputed Z^-1 - for example, from invertBatch.\n        // (x, y, z) ∋ (x=x/z, y=y/z)\n        toAffine(iz) {\n            const { px: x, py: y, pz: z } = this;\n            const is0 = this.is0();\n            // If invZ was 0, we return zero point. However we still want to execute\n            // all operations, so we replace invZ with a random number, 1.\n            if (iz == null)\n                iz = is0 ? Fp.ONE : Fp.inv(z);\n            const ax = Fp.mul(x, iz);\n            const ay = Fp.mul(y, iz);\n            const zz = Fp.mul(z, iz);\n            if (is0)\n                return { x: Fp.ZERO, y: Fp.ZERO };\n            if (!Fp.eql(zz, Fp.ONE))\n                throw new Error('invZ was invalid');\n            return { x: ax, y: ay };\n        }\n        isTorsionFree() {\n            const { h: cofactor, isTorsionFree } = CURVE;\n            if (cofactor === _1n)\n                return true; // No subgroups, always torsion-free\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n        }\n        clearCofactor() {\n            const { h: cofactor, clearCofactor } = CURVE;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(CURVE.h);\n        }\n        toRawBytes(isCompressed = true) {\n            this.assertValidity();\n            return toBytes(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            return ut.bytesToHex(this.toRawBytes(isCompressed));\n        }\n    }\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);\n    const _bits = CURVE.nBitLength;\n    const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);\n    // Validate if generator point is on curve\n    return {\n        CURVE,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar,\n        weierstrassEquation,\n        isWithinCurveOrder,\n    };\n}\nfunction validateOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        hash: 'hash',\n        hmac: 'function',\n        randomBytes: 'function',\n    }, {\n        bits2int: 'function',\n        bits2int_modN: 'function',\n        lowS: 'boolean',\n    });\n    return Object.freeze({ lowS: true, ...opts });\n}\nexport function weierstrass(curveDef) {\n    const CURVE = validateOpts(curveDef);\n    const { Fp, n: CURVE_ORDER } = CURVE;\n    const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n    const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n    function isValidFieldElement(num) {\n        return _0n < num && num < Fp.ORDER; // 0 is banned since it's not invertible FE\n    }\n    function modN(a) {\n        return mod.mod(a, CURVE_ORDER);\n    }\n    function invN(a) {\n        return mod.invert(a, CURVE_ORDER);\n    }\n    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({\n        ...CURVE,\n        toBytes(_c, point, isCompressed) {\n            const a = point.toAffine();\n            const x = Fp.toBytes(a.x);\n            const cat = ut.concatBytes;\n            if (isCompressed) {\n                return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n            }\n            else {\n                return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n            }\n        },\n        fromBytes(bytes) {\n            const len = bytes.length;\n            const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // this.assertValidity() is done inside of fromHex\n            if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n                const x = ut.bytesToNumberBE(tail);\n                if (!isValidFieldElement(x))\n                    throw new Error('Point is not on curve');\n                const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n                let y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n                const isYOdd = (y & _1n) === _1n;\n                // ECDSA\n                const isHeadOdd = (head & 1) === 1;\n                if (isHeadOdd !== isYOdd)\n                    y = Fp.neg(y);\n                return { x, y };\n            }\n            else if (len === uncompressedLen && head === 0x04) {\n                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n                return { x, y };\n            }\n            else {\n                throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);\n            }\n        },\n    });\n    const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function normalizeS(s) {\n        return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n    }\n    // slice bytes num\n    const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));\n    /**\n     * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            this.r = r;\n            this.s = s;\n            this.recovery = recovery;\n            this.assertValidity();\n        }\n        // pair (bytes of r, bytes of s)\n        static fromCompact(hex) {\n            const l = CURVE.nByteLength;\n            hex = ensureBytes('compactSignature', hex, l * 2);\n            return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n        }\n        // DER encoded ECDSA signature\n        // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n        static fromDER(hex) {\n            const { r, s } = DER.toSig(ensureBytes('DER', hex));\n            return new Signature(r, s);\n        }\n        assertValidity() {\n            // can use assertGE here\n            if (!isWithinCurveOrder(this.r))\n                throw new Error('r must be 0 < r < CURVE.n');\n            if (!isWithinCurveOrder(this.s))\n                throw new Error('s must be 0 < s < CURVE.n');\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(msgHash) {\n            const { r, s, recovery: rec } = this;\n            const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n            if (radj >= Fp.ORDER)\n                throw new Error('recovery id 2 or 3 invalid');\n            const prefix = (rec & 1) === 0 ? '02' : '03';\n            const R = Point.fromHex(prefix + numToNByteStr(radj));\n            const ir = invN(radj); // r^-1\n            const u1 = modN(-h * ir); // -hr^-1\n            const u2 = modN(s * ir); // sr^-1\n            const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n            if (!Q)\n                throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n        }\n        // DER-encoded\n        toDERRawBytes() {\n            return ut.hexToBytes(this.toDERHex());\n        }\n        toDERHex() {\n            return DER.hexFromSig({ r: this.r, s: this.s });\n        }\n        // padded bytes of r, then padded bytes of s\n        toCompactRawBytes() {\n            return ut.hexToBytes(this.toCompactHex());\n        }\n        toCompactHex() {\n            return numToNByteStr(this.r) + numToNByteStr(this.s);\n        }\n    }\n    const utils = {\n        isValidPrivateKey(privateKey) {\n            try {\n                normPrivateKeyToScalar(privateKey);\n                return true;\n            }\n            catch (error) {\n                return false;\n            }\n        },\n        normPrivateKeyToScalar: normPrivateKeyToScalar,\n        /**\n         * Produces cryptographically secure private key from random of size\n         * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n         */\n        randomPrivateKey: () => {\n            const length = mod.getMinHashLength(CURVE.n);\n            return mod.mapHashToField(CURVE.randomBytes(length), CURVE.n);\n        },\n        /**\n         * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n         * Allows to massively speed-up `point.multiply(scalar)`.\n         * @returns cached point\n         * @example\n         * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n         * fast.multiply(privKey); // much faster ECDH now\n         */\n        precompute(windowSize = 8, point = Point.BASE) {\n            point._setWindowSize(windowSize);\n            point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n            return point;\n        },\n    };\n    /**\n     * Computes public key for a private key. Checks for validity of the private key.\n     * @param privateKey private key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(privateKey, isCompressed = true) {\n        return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        const arr = item instanceof Uint8Array;\n        const str = typeof item === 'string';\n        const len = (arr || str) && item.length;\n        if (arr)\n            return len === compressedLen || len === uncompressedLen;\n        if (str)\n            return len === 2 * compressedLen || len === 2 * uncompressedLen;\n        if (item instanceof Point)\n            return true;\n        return false;\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from private key and public key.\n     * Checks: 1) private key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param privateA private key\n     * @param publicB different public key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(privateA, publicB, isCompressed = true) {\n        if (isProbPub(privateA))\n            throw new Error('first arg must be private key');\n        if (!isProbPub(publicB))\n            throw new Error('second arg must be public key');\n        const b = Point.fromHex(publicB); // check for being on-curve\n        return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = CURVE.bits2int ||\n        function (bytes) {\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = ut.bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - CURVE.nBitLength; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = CURVE.bits2int_modN ||\n        function (bytes) {\n            return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // NOTE: pads output with zero as per spec\n    const ORDER_MASK = ut.bitMask(CURVE.nBitLength);\n    /**\n     * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n     */\n    function int2octets(num) {\n        if (typeof num !== 'bigint')\n            throw new Error('bigint expected');\n        if (!(_0n <= num && num < ORDER_MASK))\n            throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);\n        // works with order, can have different size than numToField!\n        return ut.numberToBytesBE(num, CURVE.nByteLength);\n    }\n    // Steps A, D of RFC6979 3.2\n    // Creates RFC6979 seed; converts msg/privKey to numbers.\n    // Used only in sign, not in verify.\n    // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order, this will be wrong at least for P521.\n    // Also it can be bigger for P224 + SHA256\n    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { hash, randomBytes } = CURVE;\n        let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n        if (lowS == null)\n            lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n        msgHash = ensureBytes('msgHash', msgHash);\n        if (prehash)\n            msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(msgHash);\n        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (ent != null) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = ut.concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n            if (!isWithinCurveOrder(k))\n                return; // Important: all mod() calls here must be done over N\n            const ik = invN(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n            const r = modN(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n            // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n            // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n            const s = modN(ik * modN(m + r * d)); // Not using blinding here\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = normalizeS(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };\n    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };\n    /**\n     * Signs message hash with a private key.\n     * ```\n     * sign(m, d, k) where\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr)/k mod n\n     * ```\n     * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n     * @param privKey private key\n     * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n     * @returns signature with recovery param\n     */\n    function sign(msgHash, privKey, opts = defaultSigOpts) {\n        const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n        const C = CURVE;\n        const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);\n        return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    }\n    // Enable precomputes. Slows down first publicKey computation by 20ms.\n    Point.BASE._setWindowSize(8);\n    // utils.precompute(8, ProjectivePoint.BASE)\n    /**\n     * Verifies a signature against message hash and public key.\n     * Rejects lowS signatures by default: to override,\n     * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   U1 = hs^-1 mod n\n     *   U2 = rs^-1 mod n\n     *   R = U1⋅G - U2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {\n        const sg = signature;\n        msgHash = ensureBytes('msgHash', msgHash);\n        publicKey = ensureBytes('publicKey', publicKey);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        const { lowS, prehash } = opts;\n        let _sig = undefined;\n        let P;\n        try {\n            if (typeof sg === 'string' || sg instanceof Uint8Array) {\n                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n                // Since DER can also be 2*nByteLength bytes, we check for it first.\n                try {\n                    _sig = Signature.fromDER(sg);\n                }\n                catch (derError) {\n                    if (!(derError instanceof DER.Err))\n                        throw derError;\n                    _sig = Signature.fromCompact(sg);\n                }\n            }\n            else if (typeof sg === 'object' && typeof sg.r === 'bigint' && typeof sg.s === 'bigint') {\n                const { r, s } = sg;\n                _sig = new Signature(r, s);\n            }\n            else {\n                throw new Error('PARSE');\n            }\n            P = Point.fromHex(publicKey);\n        }\n        catch (error) {\n            if (error.message === 'PARSE')\n                throw new Error(`signature must be Signature instance, Uint8Array or hex string`);\n            return false;\n        }\n        if (lowS && _sig.hasHighS())\n            return false;\n        if (prehash)\n            msgHash = CURVE.hash(msgHash);\n        const { r, s } = _sig;\n        const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n        const is = invN(s); // s^-1\n        const u1 = modN(h * is); // u1 = hs^-1 mod n\n        const u2 = modN(r * is); // u2 = rs^-1 mod n\n        const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n        if (!R)\n            return false;\n        const v = modN(R.x);\n        return v === r;\n    }\n    return {\n        CURVE,\n        getPublicKey,\n        getSharedSecret,\n        sign,\n        verify,\n        ProjectivePoint: Point,\n        Signature,\n        utils,\n    };\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    mod.validateField(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        x = Fp.div(x, tv4); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\n//# sourceMappingURL=weierstrass.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha256';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { Field, mod, pow2 } from './abstract/modular.js';\nimport { mapToCurveSimpleSWU } from './abstract/weierstrass.js';\nimport { bytesToNumberBE, concatBytes, ensureBytes, numberToBytesBE } from './abstract/utils.js';\nimport { createHasher, isogenyMap } from './abstract/hash-to-curve.js';\nimport { createCurve } from './_shortw_utils.js';\nconst secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');\nconst secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst divNearest = (a, b) => (a + b / _2n) / b;\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n    const P = secp256k1P;\n    // prettier-ignore\n    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n    // prettier-ignore\n    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n    const b2 = (y * y * y) % P; // x^3, 11\n    const b3 = (b2 * b2 * y) % P; // x^7\n    const b6 = (pow2(b3, _3n, P) * b3) % P;\n    const b9 = (pow2(b6, _3n, P) * b3) % P;\n    const b11 = (pow2(b9, _2n, P) * b2) % P;\n    const b22 = (pow2(b11, _11n, P) * b11) % P;\n    const b44 = (pow2(b22, _22n, P) * b22) % P;\n    const b88 = (pow2(b44, _44n, P) * b44) % P;\n    const b176 = (pow2(b88, _88n, P) * b88) % P;\n    const b220 = (pow2(b176, _44n, P) * b44) % P;\n    const b223 = (pow2(b220, _3n, P) * b3) % P;\n    const t1 = (pow2(b223, _23n, P) * b22) % P;\n    const t2 = (pow2(t1, _6n, P) * b2) % P;\n    const root = pow2(t2, _2n, P);\n    if (!Fp.eql(Fp.sqr(root), y))\n        throw new Error('Cannot find square root');\n    return root;\n}\nconst Fp = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });\nexport const secp256k1 = createCurve({\n    a: BigInt(0),\n    b: BigInt(7),\n    Fp,\n    n: secp256k1N,\n    // Base point (x, y) aka generator point\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n    h: BigInt(1),\n    lowS: true,\n    /**\n     * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.\n     * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.\n     * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.\n     * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066\n     */\n    endo: {\n        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n        splitScalar: (k) => {\n            const n = secp256k1N;\n            const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n            const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n            const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n            const b2 = a1;\n            const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)\n            const c1 = divNearest(b2 * k, n);\n            const c2 = divNearest(-b1 * k, n);\n            let k1 = mod(k - c1 * a1 - c2 * a2, n);\n            let k2 = mod(-c1 * b1 - c2 * b2, n);\n            const k1neg = k1 > POW_2_128;\n            const k2neg = k2 > POW_2_128;\n            if (k1neg)\n                k1 = n - k1;\n            if (k2neg)\n                k2 = n - k2;\n            if (k1 > POW_2_128 || k2 > POW_2_128) {\n                throw new Error('splitScalar: Endomorphism failed, k=' + k);\n            }\n            return { k1neg, k1, k2neg, k2 };\n        },\n    },\n}, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\nconst _0n = BigInt(0);\nconst fe = (x) => typeof x === 'bigint' && _0n < x && x < secp256k1P;\nconst ge = (x) => typeof x === 'bigint' && _0n < x && x < secp256k1N;\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n    let tagP = TAGGED_HASH_PREFIXES[tag];\n    if (tagP === undefined) {\n        const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n        tagP = concatBytes(tagH, tagH);\n        TAGGED_HASH_PREFIXES[tag] = tagP;\n    }\n    return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toRawBytes(true).slice(1);\nconst numTo32b = (n) => numberToBytesBE(n, 32);\nconst modP = (x) => mod(x, secp256k1P);\nconst modN = (x) => mod(x, secp256k1N);\nconst Point = secp256k1.ProjectivePoint;\nconst GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv); // same method executed in fromPrivateKey\n    let p = Point.fromPrivateKey(d_); // P = d'⋅G; 0 < d' < n check is done inside\n    const scalar = p.hasEvenY() ? d_ : modN(-d_);\n    return { scalar: scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n    if (!fe(x))\n        throw new Error('bad x: need 0 < x < p'); // Fail if x ≥ p.\n    const xx = modP(x * x);\n    const c = modP(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n    let y = sqrtMod(c); // Let y = c^(p+1)/4 mod p.\n    if (y % _2n !== _0n)\n        y = modP(-y); // Return the unique point P such that x(P) = x and\n    const p = new Point(x, y, _1n); // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n    p.assertValidity();\n    return p;\n}\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n    return modN(bytesToNumberBE(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(privateKey) {\n    return schnorrGetExtPubKey(privateKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, privateKey, auxRand = randomBytes(32)) {\n    const m = ensureBytes('message', message);\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey); // checks for isWithinCurveOrder\n    const a = ensureBytes('auxRand', auxRand, 32); // Auxiliary random data a: a 32-byte array\n    const t = numTo32b(d ^ bytesToNumberBE(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n    const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n    const k_ = modN(bytesToNumberBE(rand)); // Let k' = int(rand) mod n\n    if (k_ === _0n)\n        throw new Error('sign failed: k is zero'); // Fail if k' = 0.\n    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_); // Let R = k'⋅G.\n    const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n    const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n    sig.set(rx, 0);\n    sig.set(numTo32b(modN(k + e * d)), 32);\n    // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n    if (!schnorrVerify(sig, m, px))\n        throw new Error('sign: Invalid signature produced');\n    return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n    const sig = ensureBytes('signature', signature, 64);\n    const m = ensureBytes('message', message);\n    const pub = ensureBytes('publicKey', publicKey, 32);\n    try {\n        const P = lift_x(bytesToNumberBE(pub)); // P = lift_x(int(pk)); fail if that fails\n        const r = bytesToNumberBE(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n        if (!fe(r))\n            return false;\n        const s = bytesToNumberBE(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!ge(s))\n            return false;\n        const e = challenge(numTo32b(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n        const R = GmulAdd(P, s, modN(-e)); // R = s⋅G - e⋅P\n        if (!R || !R.hasEvenY() || R.toAffine().x !== r)\n            return false; // -eP == (n-e)P\n        return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n    }\n    catch (error) {\n        return false;\n    }\n}\nexport const schnorr = /* @__PURE__ */ (() => ({\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    utils: {\n        randomPrivateKey: secp256k1.utils.randomPrivateKey,\n        lift_x,\n        pointToBytes,\n        numberToBytesBE,\n        bytesToNumberBE,\n        taggedHash,\n        mod,\n    },\n}))();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [\n    // xNum\n    [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n    ],\n    // xDen\n    [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n    ],\n    // yDen\n    [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fp.create(BigInt('-11')),\n}))();\nconst htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {\n    const { x, y } = mapSWU(Fp.create(scalars[0]));\n    return isoMap(x, y);\n}, {\n    DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n    p: Fp.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\nexport const hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();\n//# sourceMappingURL=secp256k1.js.map","import { secp256k1 } from '@noble/curves/secp256k1';\nimport { hexToBigInt } from '../encoding/fromHex.js';\n/**\n * @description Converts a signature into hex format.\n *\n * @param signature The signature to convert.\n * @returns The signature in hex format.\n *\n * @example\n * serializeSignature({\n *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',\n *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',\n *   yParity: 1\n * })\n * // \"0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c\"\n */\nexport function serializeSignature({ r, s, v, yParity }) {\n    const yParity_ = (() => {\n        if (yParity === 0 || yParity === 1)\n            return yParity;\n        if (v && (v === 27n || v === 28n || v >= 35n))\n            return v % 2n === 0n ? 1 : 0;\n        throw new Error('Invalid `v` or `yParity` value');\n    })();\n    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? '1b' : '1c'}`;\n}\n//# sourceMappingURL=serializeSignature.js.map","import { universalSignatureValidatorAbi } from '../../constants/abis.js';\nimport { universalSignatureValidatorByteCode } from '../../constants/contracts.js';\nimport { CallExecutionError } from '../../errors/contract.js';\nimport { encodeDeployData, } from '../../utils/abi/encodeDeployData.js';\nimport { isBytesEqual, } from '../../utils/data/isBytesEqual.js';\nimport { isHex } from '../../utils/data/isHex.js';\nimport { bytesToHex } from '../../utils/encoding/toHex.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { serializeSignature } from '../../utils/signature/serializeSignature.js';\nimport { call } from './call.js';\n/**\n * Verifies a message hash onchain using ERC-6492.\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyHashParameters}\n * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}\n */\nexport async function verifyHash(client, { address, hash, signature, ...callRequest }) {\n    const signatureHex = (() => {\n        if (isHex(signature))\n            return signature;\n        if (typeof signature === 'object' && 'r' in signature && 's' in signature)\n            return serializeSignature(signature);\n        return bytesToHex(signature);\n    })();\n    try {\n        const { data } = await getAction(client, call, 'call')({\n            data: encodeDeployData({\n                abi: universalSignatureValidatorAbi,\n                args: [address, hash, signatureHex],\n                bytecode: universalSignatureValidatorByteCode,\n            }),\n            ...callRequest,\n        });\n        return isBytesEqual(data ?? '0x0', '0x1');\n    }\n    catch (error) {\n        if (error instanceof CallExecutionError) {\n            // if the execution fails, the signature was not valid and an internal method inside of the validator reverted\n            // this can happen for many reasons, for example if signer can not be recovered from the signature\n            // or if the signature has no valid format\n            return false;\n        }\n        throw error;\n    }\n}\n//# sourceMappingURL=verifyHash.js.map","import { hashMessage } from '../../utils/signature/hashMessage.js';\nimport { verifyHash, } from './verifyHash.js';\n/**\n * Verify that a message was signed by the provided address.\n *\n * Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).\n *\n * - Docs {@link https://viem.sh/docs/actions/public/verifyMessage}\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyMessageParameters}\n * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}\n */\nexport async function verifyMessage(client, { address, message, signature, ...callRequest }) {\n    const hash = hashMessage(message);\n    return verifyHash(client, {\n        address,\n        hash,\n        signature,\n        ...callRequest,\n    });\n}\n//# sourceMappingURL=verifyMessage.js.map","// Implementation forked and adapted from https://github.com/MetaMask/eth-sig-util/blob/main/src/sign-typed-data.ts\nimport { encodeAbiParameters, } from '../abi/encodeAbiParameters.js';\nimport { concat } from '../data/concat.js';\nimport { toHex } from '../encoding/toHex.js';\nimport { keccak256 } from '../hash/keccak256.js';\nimport { getTypesForEIP712Domain, validateTypedData, } from '../typedData.js';\nexport function hashTypedData(parameters) {\n    const { domain = {}, message, primaryType, } = parameters;\n    const types = {\n        EIP712Domain: getTypesForEIP712Domain({ domain }),\n        ...parameters.types,\n    };\n    // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc\n    // as we can't statically check this with TypeScript.\n    validateTypedData({\n        domain,\n        message,\n        primaryType,\n        types,\n    });\n    const parts = ['0x1901'];\n    if (domain)\n        parts.push(hashDomain({\n            domain,\n            types: types,\n        }));\n    if (primaryType !== 'EIP712Domain')\n        parts.push(hashStruct({\n            data: message,\n            primaryType,\n            types: types,\n        }));\n    return keccak256(concat(parts));\n}\nexport function hashDomain({ domain, types, }) {\n    return hashStruct({\n        data: domain,\n        primaryType: 'EIP712Domain',\n        types,\n    });\n}\nfunction hashStruct({ data, primaryType, types, }) {\n    const encoded = encodeData({\n        data,\n        primaryType,\n        types,\n    });\n    return keccak256(encoded);\n}\nfunction encodeData({ data, primaryType, types, }) {\n    const encodedTypes = [{ type: 'bytes32' }];\n    const encodedValues = [hashType({ primaryType, types })];\n    for (const field of types[primaryType]) {\n        const [type, value] = encodeField({\n            types,\n            name: field.name,\n            type: field.type,\n            value: data[field.name],\n        });\n        encodedTypes.push(type);\n        encodedValues.push(value);\n    }\n    return encodeAbiParameters(encodedTypes, encodedValues);\n}\nfunction hashType({ primaryType, types, }) {\n    const encodedHashType = toHex(encodeType({ primaryType, types }));\n    return keccak256(encodedHashType);\n}\nfunction encodeType({ primaryType, types, }) {\n    let result = '';\n    const unsortedDeps = findTypeDependencies({ primaryType, types });\n    unsortedDeps.delete(primaryType);\n    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];\n    for (const type of deps) {\n        result += `${type}(${types[type]\n            .map(({ name, type: t }) => `${t} ${name}`)\n            .join(',')})`;\n    }\n    return result;\n}\nfunction findTypeDependencies({ primaryType: primaryType_, types, }, results = new Set()) {\n    const match = primaryType_.match(/^\\w*/u);\n    const primaryType = match?.[0];\n    if (results.has(primaryType) || types[primaryType] === undefined) {\n        return results;\n    }\n    results.add(primaryType);\n    for (const field of types[primaryType]) {\n        findTypeDependencies({ primaryType: field.type, types }, results);\n    }\n    return results;\n}\nfunction encodeField({ types, name, type, value, }) {\n    if (types[type] !== undefined) {\n        return [\n            { type: 'bytes32' },\n            keccak256(encodeData({ data: value, primaryType: type, types })),\n        ];\n    }\n    if (type === 'bytes') {\n        const prepend = value.length % 2 ? '0' : '';\n        value = `0x${prepend + value.slice(2)}`;\n        return [{ type: 'bytes32' }, keccak256(value)];\n    }\n    if (type === 'string')\n        return [{ type: 'bytes32' }, keccak256(toHex(value))];\n    if (type.lastIndexOf(']') === type.length - 1) {\n        const parsedType = type.slice(0, type.lastIndexOf('['));\n        const typeValuePairs = value.map((item) => encodeField({\n            name,\n            type: parsedType,\n            types,\n            value: item,\n        }));\n        return [\n            { type: 'bytes32' },\n            keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v))),\n        ];\n    }\n    return [{ type }, value];\n}\n//# sourceMappingURL=hashTypedData.js.map","import { hashTypedData, } from '../../utils/signature/hashTypedData.js';\nimport { verifyHash, } from './verifyHash.js';\n/**\n * Verify that typed data was signed by the provided address.\n *\n * - Docs {@link https://viem.sh/docs/actions/public/verifyTypedData}\n *\n * @param client - Client to use.\n * @param parameters - {@link VerifyTypedDataParameters}\n * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}\n */\nexport async function verifyTypedData(client, parameters) {\n    const { address, signature, message, primaryType, types, domain, ...callRequest } = parameters;\n    const hash = hashTypedData({ message, primaryType, types, domain });\n    return verifyHash(client, {\n        address,\n        hash,\n        signature,\n        ...callRequest,\n    });\n}\n//# sourceMappingURL=verifyTypedData.js.map","import { formatBlock } from '../../utils/formatters/block.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { getBlock } from './getBlock.js';\n/**\n * Watches and returns information for incoming blocks.\n *\n * - Docs: https://viem.sh/docs/actions/public/watchBlocks\n * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks/watching-blocks\n * - JSON-RPC Methods:\n *   - When `poll: true`, calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getBlockByNumber) on a polling interval.\n *   - When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `\"newHeads\"` event.\n *\n * @param client - Client to use\n * @param parameters - {@link WatchBlocksParameters}\n * @returns A function that can be invoked to stop watching for new block numbers. {@link WatchBlocksReturnType}\n *\n * @example\n * import { createPublicClient, watchBlocks, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = watchBlocks(client, {\n *   onBlock: (block) => console.log(block),\n * })\n */\nexport function watchBlocks(client, { blockTag = 'latest', emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval, }) {\n    const enablePolling = (() => {\n        if (typeof poll_ !== 'undefined')\n            return poll_;\n        if (client.transport.type === 'webSocket')\n            return false;\n        if (client.transport.type === 'fallback' &&\n            client.transport.transports[0].config.type === 'webSocket')\n            return false;\n        return true;\n    })();\n    const includeTransactions = includeTransactions_ ?? false;\n    let prevBlock;\n    const pollBlocks = () => {\n        const observerId = stringify([\n            'watchBlocks',\n            client.uid,\n            blockTag,\n            emitMissed,\n            emitOnBegin,\n            includeTransactions,\n            pollingInterval,\n        ]);\n        return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {\n            try {\n                const block = await getAction(client, getBlock, 'getBlock')({\n                    blockTag,\n                    includeTransactions,\n                });\n                if (block.number && prevBlock?.number) {\n                    // If the current block number is the same as the previous,\n                    // we can skip.\n                    if (block.number === prevBlock.number)\n                        return;\n                    // If we have missed out on some previous blocks, and the\n                    // `emitMissed` flag is truthy, let's emit those blocks.\n                    if (block.number - prevBlock.number > 1 && emitMissed) {\n                        for (let i = prevBlock?.number + 1n; i < block.number; i++) {\n                            const block = (await getAction(client, getBlock, 'getBlock')({\n                                blockNumber: i,\n                                includeTransactions,\n                            }));\n                            emit.onBlock(block, prevBlock);\n                            prevBlock = block;\n                        }\n                    }\n                }\n                if (\n                // If no previous block exists, emit.\n                !prevBlock?.number ||\n                    // If the block tag is \"pending\" with no block number, emit.\n                    (blockTag === 'pending' && !block?.number) ||\n                    // If the next block number is greater than the previous block number, emit.\n                    // We don't want to emit blocks in the past.\n                    (block.number && block.number > prevBlock.number)) {\n                    emit.onBlock(block, prevBlock);\n                    prevBlock = block;\n                }\n            }\n            catch (err) {\n                emit.onError?.(err);\n            }\n        }, {\n            emitOnBegin,\n            interval: pollingInterval,\n        }));\n    };\n    const subscribeBlocks = () => {\n        let active = true;\n        let unsubscribe = () => (active = false);\n        (async () => {\n            try {\n                const transport = (() => {\n                    if (client.transport.type === 'fallback') {\n                        const transport = client.transport.transports.find((transport) => transport.config.type === 'webSocket');\n                        if (!transport)\n                            return client.transport;\n                        return transport.value;\n                    }\n                    return client.transport;\n                })();\n                const { unsubscribe: unsubscribe_ } = await transport.subscribe({\n                    params: ['newHeads'],\n                    onData(data) {\n                        if (!active)\n                            return;\n                        const format = client.chain?.formatters?.block?.format || formatBlock;\n                        const block = format(data.result);\n                        onBlock(block, prevBlock);\n                        prevBlock = block;\n                    },\n                    onError(error) {\n                        onError?.(error);\n                    },\n                });\n                unsubscribe = unsubscribe_;\n                if (!active)\n                    unsubscribe();\n            }\n            catch (err) {\n                onError?.(err);\n            }\n        })();\n        return () => unsubscribe();\n    };\n    return enablePolling ? pollBlocks() : subscribeBlocks();\n}\n//# sourceMappingURL=watchBlocks.js.map","import { DecodeLogDataMismatch, DecodeLogTopicsMismatch, } from '../../errors/abi.js';\nimport { InvalidInputRpcError } from '../../errors/rpc.js';\nimport { decodeEventLog } from '../../utils/abi/decodeEventLog.js';\nimport { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { formatLog } from '../../utils/formatters/log.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { createContractEventFilter } from './createContractEventFilter.js';\nimport { getBlockNumber } from './getBlockNumber.js';\nimport { getContractEvents, } from './getContractEvents.js';\nimport { getFilterChanges } from './getFilterChanges.js';\nimport { uninstallFilter } from './uninstallFilter.js';\n/**\n * Watches and returns emitted contract event logs.\n *\n * - Docs: https://viem.sh/docs/contract/watchContractEvent\n *\n * This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent#onLogs).\n *\n * `watchContractEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchContractEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.\n *\n * @param client - Client to use\n * @param parameters - {@link WatchContractEventParameters}\n * @returns A function that can be invoked to stop watching for new event logs. {@link WatchContractEventReturnType}\n *\n * @example\n * import { createPublicClient, http, parseAbi } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { watchContractEvent } from 'viem/contract'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = watchContractEvent(client, {\n *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',\n *   abi: parseAbi(['event Transfer(address indexed from, address indexed to, uint256 value)']),\n *   eventName: 'Transfer',\n *   args: { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },\n *   onLogs: (logs) => console.log(logs),\n * })\n */\nexport function watchContractEvent(client, parameters) {\n    const { abi, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_, } = parameters;\n    const enablePolling = (() => {\n        if (typeof poll_ !== 'undefined')\n            return poll_;\n        if (typeof fromBlock === 'bigint')\n            return true;\n        if (client.transport.type === 'webSocket')\n            return false;\n        if (client.transport.type === 'fallback' &&\n            client.transport.transports[0].config.type === 'webSocket')\n            return false;\n        return true;\n    })();\n    const pollContractEvent = () => {\n        const strict = strict_ ?? false;\n        const observerId = stringify([\n            'watchContractEvent',\n            address,\n            args,\n            batch,\n            client.uid,\n            eventName,\n            pollingInterval,\n            strict,\n            fromBlock,\n        ]);\n        return observe(observerId, { onLogs, onError }, (emit) => {\n            let previousBlockNumber;\n            if (fromBlock !== undefined)\n                previousBlockNumber = fromBlock - 1n;\n            let filter;\n            let initialized = false;\n            const unwatch = poll(async () => {\n                if (!initialized) {\n                    try {\n                        filter = (await getAction(client, createContractEventFilter, 'createContractEventFilter')({\n                            abi,\n                            address,\n                            args: args,\n                            eventName: eventName,\n                            strict: strict,\n                            fromBlock,\n                        }));\n                    }\n                    catch { }\n                    initialized = true;\n                    return;\n                }\n                try {\n                    let logs;\n                    if (filter) {\n                        logs = await getAction(client, getFilterChanges, 'getFilterChanges')({ filter });\n                    }\n                    else {\n                        // If the filter doesn't exist, we will fall back to use `getLogs`.\n                        // The fall back exists because some RPC Providers do not support filters.\n                        // Fetch the block number to use for `getLogs`.\n                        const blockNumber = await getAction(client, getBlockNumber, 'getBlockNumber')({});\n                        // If the block number has changed, we will need to fetch the logs.\n                        // If the block number doesn't exist, we are yet to reach the first poll interval,\n                        // so do not emit any logs.\n                        if (previousBlockNumber && previousBlockNumber !== blockNumber) {\n                            logs = await getAction(client, getContractEvents, 'getContractEvents')({\n                                abi,\n                                address,\n                                args,\n                                eventName,\n                                fromBlock: previousBlockNumber + 1n,\n                                toBlock: blockNumber,\n                                strict,\n                            });\n                        }\n                        else {\n                            logs = [];\n                        }\n                        previousBlockNumber = blockNumber;\n                    }\n                    if (logs.length === 0)\n                        return;\n                    if (batch)\n                        emit.onLogs(logs);\n                    else\n                        for (const log of logs)\n                            emit.onLogs([log]);\n                }\n                catch (err) {\n                    // If a filter has been set and gets uninstalled, providers will throw an InvalidInput error.\n                    // Reinitalize the filter when this occurs\n                    if (filter && err instanceof InvalidInputRpcError)\n                        initialized = false;\n                    emit.onError?.(err);\n                }\n            }, {\n                emitOnBegin: true,\n                interval: pollingInterval,\n            });\n            return async () => {\n                if (filter)\n                    await getAction(client, uninstallFilter, 'uninstallFilter')({ filter });\n                unwatch();\n            };\n        });\n    };\n    const subscribeContractEvent = () => {\n        const strict = strict_ ?? false;\n        const observerId = stringify([\n            'watchContractEvent',\n            address,\n            args,\n            batch,\n            client.uid,\n            eventName,\n            pollingInterval,\n            strict,\n        ]);\n        let active = true;\n        let unsubscribe = () => (active = false);\n        return observe(observerId, { onLogs, onError }, (emit) => {\n            ;\n            (async () => {\n                try {\n                    const transport = (() => {\n                        if (client.transport.type === 'fallback') {\n                            const transport = client.transport.transports.find((transport) => transport.config.type === 'webSocket');\n                            if (!transport)\n                                return client.transport;\n                            return transport.value;\n                        }\n                        return client.transport;\n                    })();\n                    const topics = eventName\n                        ? encodeEventTopics({\n                            abi: abi,\n                            eventName: eventName,\n                            args,\n                        })\n                        : [];\n                    const { unsubscribe: unsubscribe_ } = await transport.subscribe({\n                        params: ['logs', { address, topics }],\n                        onData(data) {\n                            if (!active)\n                                return;\n                            const log = data.result;\n                            try {\n                                const { eventName, args } = decodeEventLog({\n                                    abi: abi,\n                                    data: log.data,\n                                    topics: log.topics,\n                                    strict: strict_,\n                                });\n                                const formatted = formatLog(log, {\n                                    args,\n                                    eventName: eventName,\n                                });\n                                emit.onLogs([formatted]);\n                            }\n                            catch (err) {\n                                let eventName;\n                                let isUnnamed;\n                                if (err instanceof DecodeLogDataMismatch ||\n                                    err instanceof DecodeLogTopicsMismatch) {\n                                    // If strict mode is on, and log data/topics do not match event definition, skip.\n                                    if (strict_)\n                                        return;\n                                    eventName = err.abiItem.name;\n                                    isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name));\n                                }\n                                // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).\n                                const formatted = formatLog(log, {\n                                    args: isUnnamed ? [] : {},\n                                    eventName,\n                                });\n                                emit.onLogs([formatted]);\n                            }\n                        },\n                        onError(error) {\n                            emit.onError?.(error);\n                        },\n                    });\n                    unsubscribe = unsubscribe_;\n                    if (!active)\n                        unsubscribe();\n                }\n                catch (err) {\n                    onError?.(err);\n                }\n            })();\n            return () => unsubscribe();\n        });\n    };\n    return enablePolling ? pollContractEvent() : subscribeContractEvent();\n}\n//# sourceMappingURL=watchContractEvent.js.map","import { encodeEventTopics, } from '../../utils/abi/encodeEventTopics.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { DecodeLogDataMismatch, DecodeLogTopicsMismatch, } from '../../errors/abi.js';\nimport { InvalidInputRpcError } from '../../errors/rpc.js';\nimport { decodeEventLog } from '../../utils/abi/decodeEventLog.js';\nimport { formatLog } from '../../utils/formatters/log.js';\nimport { getAction } from '../../utils/getAction.js';\nimport { createEventFilter, } from './createEventFilter.js';\nimport { getBlockNumber } from './getBlockNumber.js';\nimport { getFilterChanges } from './getFilterChanges.js';\nimport { getLogs } from './getLogs.js';\nimport { uninstallFilter } from './uninstallFilter.js';\n/**\n * Watches and returns emitted [Event Logs](https://viem.sh/docs/glossary/terms#event-log).\n *\n * - Docs: https://viem.sh/docs/actions/public/watchEvent\n * - JSON-RPC Methods:\n *   - **RPC Provider supports `eth_newFilter`:**\n *     - Calls [`eth_newFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newfilter) to create a filter (called on initialize).\n *     - On a polling interval, it will call [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges).\n *   - **RPC Provider does not support `eth_newFilter`:**\n *     - Calls [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs) for each block between the polling interval.\n *\n * This Action will batch up all the Event Logs found within the [`pollingInterval`](https://viem.sh/docs/actions/public/watchEvent#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/actions/public/watchEvent#onLogs).\n *\n * `watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/actions/public/createEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.\n *\n * @param client - Client to use\n * @param parameters - {@link WatchEventParameters}\n * @returns A function that can be invoked to stop watching for new Event Logs. {@link WatchEventReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { watchEvent } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = watchEvent(client, {\n *   onLogs: (logs) => console.log(logs),\n * })\n */\nexport function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_, }) {\n    const enablePolling = (() => {\n        if (typeof poll_ !== 'undefined')\n            return poll_;\n        if (typeof fromBlock === 'bigint')\n            return true;\n        if (client.transport.type === 'webSocket')\n            return false;\n        if (client.transport.type === 'fallback' &&\n            client.transport.transports[0].config.type === 'webSocket')\n            return false;\n        return true;\n    })();\n    const strict = strict_ ?? false;\n    const pollEvent = () => {\n        const observerId = stringify([\n            'watchEvent',\n            address,\n            args,\n            batch,\n            client.uid,\n            event,\n            pollingInterval,\n            fromBlock,\n        ]);\n        return observe(observerId, { onLogs, onError }, (emit) => {\n            let previousBlockNumber;\n            if (fromBlock !== undefined)\n                previousBlockNumber = fromBlock - 1n;\n            let filter;\n            let initialized = false;\n            const unwatch = poll(async () => {\n                if (!initialized) {\n                    try {\n                        filter = (await getAction(client, createEventFilter, 'createEventFilter')({\n                            address,\n                            args,\n                            event: event,\n                            events,\n                            strict,\n                            fromBlock,\n                        }));\n                    }\n                    catch { }\n                    initialized = true;\n                    return;\n                }\n                try {\n                    let logs;\n                    if (filter) {\n                        logs = await getAction(client, getFilterChanges, 'getFilterChanges')({ filter });\n                    }\n                    else {\n                        // If the filter doesn't exist, we will fall back to use `getLogs`.\n                        // The fall back exists because some RPC Providers do not support filters.\n                        // Fetch the block number to use for `getLogs`.\n                        const blockNumber = await getAction(client, getBlockNumber, 'getBlockNumber')({});\n                        // If the block number has changed, we will need to fetch the logs.\n                        // If the block number doesn't exist, we are yet to reach the first poll interval,\n                        // so do not emit any logs.\n                        if (previousBlockNumber && previousBlockNumber !== blockNumber) {\n                            logs = await getAction(client, getLogs, 'getLogs')({\n                                address,\n                                args,\n                                event: event,\n                                events,\n                                fromBlock: previousBlockNumber + 1n,\n                                toBlock: blockNumber,\n                            });\n                        }\n                        else {\n                            logs = [];\n                        }\n                        previousBlockNumber = blockNumber;\n                    }\n                    if (logs.length === 0)\n                        return;\n                    if (batch)\n                        emit.onLogs(logs);\n                    else\n                        for (const log of logs)\n                            emit.onLogs([log]);\n                }\n                catch (err) {\n                    // If a filter has been set and gets uninstalled, providers will throw an InvalidInput error.\n                    // Reinitalize the filter when this occurs\n                    if (filter && err instanceof InvalidInputRpcError)\n                        initialized = false;\n                    emit.onError?.(err);\n                }\n            }, {\n                emitOnBegin: true,\n                interval: pollingInterval,\n            });\n            return async () => {\n                if (filter)\n                    await getAction(client, uninstallFilter, 'uninstallFilter')({ filter });\n                unwatch();\n            };\n        });\n    };\n    const subscribeEvent = () => {\n        let active = true;\n        let unsubscribe = () => (active = false);\n        (async () => {\n            try {\n                const transport = (() => {\n                    if (client.transport.type === 'fallback') {\n                        const transport = client.transport.transports.find((transport) => transport.config.type === 'webSocket');\n                        if (!transport)\n                            return client.transport;\n                        return transport.value;\n                    }\n                    return client.transport;\n                })();\n                const events_ = events ?? (event ? [event] : undefined);\n                let topics = [];\n                if (events_) {\n                    topics = [\n                        events_.flatMap((event) => encodeEventTopics({\n                            abi: [event],\n                            eventName: event.name,\n                            args,\n                        })),\n                    ];\n                    if (event)\n                        topics = topics[0];\n                }\n                const { unsubscribe: unsubscribe_ } = await transport.subscribe({\n                    params: ['logs', { address, topics }],\n                    onData(data) {\n                        if (!active)\n                            return;\n                        const log = data.result;\n                        try {\n                            const { eventName, args } = decodeEventLog({\n                                abi: events_ ?? [],\n                                data: log.data,\n                                topics: log.topics,\n                                strict,\n                            });\n                            const formatted = formatLog(log, { args, eventName });\n                            onLogs([formatted]);\n                        }\n                        catch (err) {\n                            let eventName;\n                            let isUnnamed;\n                            if (err instanceof DecodeLogDataMismatch ||\n                                err instanceof DecodeLogTopicsMismatch) {\n                                // If strict mode is on, and log data/topics do not match event definition, skip.\n                                if (strict_)\n                                    return;\n                                eventName = err.abiItem.name;\n                                isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name));\n                            }\n                            // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).\n                            const formatted = formatLog(log, {\n                                args: isUnnamed ? [] : {},\n                                eventName,\n                            });\n                            onLogs([formatted]);\n                        }\n                    },\n                    onError(error) {\n                        onError?.(error);\n                    },\n                });\n                unsubscribe = unsubscribe_;\n                if (!active)\n                    unsubscribe();\n            }\n            catch (err) {\n                onError?.(err);\n            }\n        })();\n        return () => unsubscribe();\n    };\n    return enablePolling ? pollEvent() : subscribeEvent();\n}\n//# sourceMappingURL=watchEvent.js.map","import { getAction } from '../../utils/getAction.js';\nimport { observe } from '../../utils/observe.js';\nimport { poll } from '../../utils/poll.js';\nimport { stringify } from '../../utils/stringify.js';\nimport { createPendingTransactionFilter } from './createPendingTransactionFilter.js';\nimport { getFilterChanges } from './getFilterChanges.js';\nimport { uninstallFilter } from './uninstallFilter.js';\n/**\n * Watches and returns pending transaction hashes.\n *\n * - Docs: https://viem.sh/docs/actions/public/watchPendingTransactions\n * - JSON-RPC Methods:\n *   - When `poll: true`\n *     - Calls [`eth_newPendingTransactionFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newpendingtransactionfilter) to initialize the filter.\n *     - Calls [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getFilterChanges) on a polling interval.\n *   - When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `\"newPendingTransactions\"` event.\n *\n * This Action will batch up all the pending transactions found within the [`pollingInterval`](https://viem.sh/docs/actions/public/watchPendingTransactions#pollinginterval-optional), and invoke them via [`onTransactions`](https://viem.sh/docs/actions/public/watchPendingTransactions#ontransactions).\n *\n * @param client - Client to use\n * @param parameters - {@link WatchPendingTransactionsParameters}\n * @returns A function that can be invoked to stop watching for new pending transaction hashes. {@link WatchPendingTransactionsReturnType}\n *\n * @example\n * import { createPublicClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { watchPendingTransactions } from 'viem/public'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const unwatch = await watchPendingTransactions(client, {\n *   onTransactions: (hashes) => console.log(hashes),\n * })\n */\nexport function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval, }) {\n    const enablePolling = typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket';\n    const pollPendingTransactions = () => {\n        const observerId = stringify([\n            'watchPendingTransactions',\n            client.uid,\n            batch,\n            pollingInterval,\n        ]);\n        return observe(observerId, { onTransactions, onError }, (emit) => {\n            let filter;\n            const unwatch = poll(async () => {\n                try {\n                    if (!filter) {\n                        try {\n                            filter = await getAction(client, createPendingTransactionFilter, 'createPendingTransactionFilter')({});\n                            return;\n                        }\n                        catch (err) {\n                            unwatch();\n                            throw err;\n                        }\n                    }\n                    const hashes = await getAction(client, getFilterChanges, 'getFilterChanges')({ filter });\n                    if (hashes.length === 0)\n                        return;\n                    if (batch)\n                        emit.onTransactions(hashes);\n                    else\n                        for (const hash of hashes)\n                            emit.onTransactions([hash]);\n                }\n                catch (err) {\n                    emit.onError?.(err);\n                }\n            }, {\n                emitOnBegin: true,\n                interval: pollingInterval,\n            });\n            return async () => {\n                if (filter)\n                    await getAction(client, uninstallFilter, 'uninstallFilter')({ filter });\n                unwatch();\n            };\n        });\n    };\n    const subscribePendingTransactions = () => {\n        let active = true;\n        let unsubscribe = () => (active = false);\n        (async () => {\n            try {\n                const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({\n                    params: ['newPendingTransactions'],\n                    onData(data) {\n                        if (!active)\n                            return;\n                        const transaction = data.result;\n                        onTransactions([transaction]);\n                    },\n                    onError(error) {\n                        onError?.(error);\n                    },\n                });\n                unsubscribe = unsubscribe_;\n                if (!active)\n                    unsubscribe();\n            }\n            catch (err) {\n                onError?.(err);\n            }\n        })();\n        return () => unsubscribe();\n    };\n    return enablePolling\n        ? pollPendingTransactions()\n        : subscribePendingTransactions();\n}\n//# sourceMappingURL=watchPendingTransactions.js.map","import { getEnsAddress, } from '../../actions/ens/getEnsAddress.js';\nimport { getEnsAvatar, } from '../../actions/ens/getEnsAvatar.js';\nimport { getEnsName, } from '../../actions/ens/getEnsName.js';\nimport { getEnsResolver, } from '../../actions/ens/getEnsResolver.js';\nimport { getEnsText, } from '../../actions/ens/getEnsText.js';\nimport { call, } from '../../actions/public/call.js';\nimport { createBlockFilter, } from '../../actions/public/createBlockFilter.js';\nimport { createContractEventFilter, } from '../../actions/public/createContractEventFilter.js';\nimport { createEventFilter, } from '../../actions/public/createEventFilter.js';\nimport { createPendingTransactionFilter, } from '../../actions/public/createPendingTransactionFilter.js';\nimport { estimateContractGas, } from '../../actions/public/estimateContractGas.js';\nimport { estimateFeesPerGas, } from '../../actions/public/estimateFeesPerGas.js';\nimport { estimateGas, } from '../../actions/public/estimateGas.js';\nimport { estimateMaxPriorityFeePerGas, } from '../../actions/public/estimateMaxPriorityFeePerGas.js';\nimport { getBalance, } from '../../actions/public/getBalance.js';\nimport { getBlobBaseFee, } from '../../actions/public/getBlobBaseFee.js';\nimport { getBlock, } from '../../actions/public/getBlock.js';\nimport { getBlockNumber, } from '../../actions/public/getBlockNumber.js';\nimport { getBlockTransactionCount, } from '../../actions/public/getBlockTransactionCount.js';\nimport { getBytecode, } from '../../actions/public/getBytecode.js';\nimport { getChainId, } from '../../actions/public/getChainId.js';\nimport { getContractEvents, } from '../../actions/public/getContractEvents.js';\nimport { getFeeHistory, } from '../../actions/public/getFeeHistory.js';\nimport { getFilterChanges, } from '../../actions/public/getFilterChanges.js';\nimport { getFilterLogs, } from '../../actions/public/getFilterLogs.js';\nimport { getGasPrice, } from '../../actions/public/getGasPrice.js';\nimport { getLogs, } from '../../actions/public/getLogs.js';\nimport { getProof, } from '../../actions/public/getProof.js';\nimport { getStorageAt, } from '../../actions/public/getStorageAt.js';\nimport { getTransaction, } from '../../actions/public/getTransaction.js';\nimport { getTransactionConfirmations, } from '../../actions/public/getTransactionConfirmations.js';\nimport { getTransactionCount, } from '../../actions/public/getTransactionCount.js';\nimport { getTransactionReceipt, } from '../../actions/public/getTransactionReceipt.js';\nimport { multicall, } from '../../actions/public/multicall.js';\nimport { readContract, } from '../../actions/public/readContract.js';\nimport { simulateContract, } from '../../actions/public/simulateContract.js';\nimport { uninstallFilter, } from '../../actions/public/uninstallFilter.js';\nimport { verifyMessage, } from '../../actions/public/verifyMessage.js';\nimport { verifyTypedData, } from '../../actions/public/verifyTypedData.js';\nimport { waitForTransactionReceipt, } from '../../actions/public/waitForTransactionReceipt.js';\nimport { watchBlockNumber, } from '../../actions/public/watchBlockNumber.js';\nimport { watchBlocks, } from '../../actions/public/watchBlocks.js';\nimport { watchContractEvent, } from '../../actions/public/watchContractEvent.js';\nimport { watchEvent, } from '../../actions/public/watchEvent.js';\nimport { watchPendingTransactions, } from '../../actions/public/watchPendingTransactions.js';\nimport { prepareTransactionRequest, } from '../../actions/wallet/prepareTransactionRequest.js';\nimport { sendRawTransaction, } from '../../actions/wallet/sendRawTransaction.js';\nexport function publicActions(client) {\n    return {\n        call: (args) => call(client, args),\n        createBlockFilter: () => createBlockFilter(client),\n        createContractEventFilter: (args) => createContractEventFilter(client, args),\n        createEventFilter: (args) => createEventFilter(client, args),\n        createPendingTransactionFilter: () => createPendingTransactionFilter(client),\n        estimateContractGas: (args) => estimateContractGas(client, args),\n        estimateGas: (args) => estimateGas(client, args),\n        getBalance: (args) => getBalance(client, args),\n        getBlobBaseFee: () => getBlobBaseFee(client),\n        getBlock: (args) => getBlock(client, args),\n        getBlockNumber: (args) => getBlockNumber(client, args),\n        getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),\n        getBytecode: (args) => getBytecode(client, args),\n        getChainId: () => getChainId(client),\n        getContractEvents: (args) => getContractEvents(client, args),\n        getEnsAddress: (args) => getEnsAddress(client, args),\n        getEnsAvatar: (args) => getEnsAvatar(client, args),\n        getEnsName: (args) => getEnsName(client, args),\n        getEnsResolver: (args) => getEnsResolver(client, args),\n        getEnsText: (args) => getEnsText(client, args),\n        getFeeHistory: (args) => getFeeHistory(client, args),\n        estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),\n        getFilterChanges: (args) => getFilterChanges(client, args),\n        getFilterLogs: (args) => getFilterLogs(client, args),\n        getGasPrice: () => getGasPrice(client),\n        getLogs: (args) => getLogs(client, args),\n        getProof: (args) => getProof(client, args),\n        estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),\n        getStorageAt: (args) => getStorageAt(client, args),\n        getTransaction: (args) => getTransaction(client, args),\n        getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),\n        getTransactionCount: (args) => getTransactionCount(client, args),\n        getTransactionReceipt: (args) => getTransactionReceipt(client, args),\n        multicall: (args) => multicall(client, args),\n        prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),\n        readContract: (args) => readContract(client, args),\n        sendRawTransaction: (args) => sendRawTransaction(client, args),\n        simulateContract: (args) => simulateContract(client, args),\n        verifyMessage: (args) => verifyMessage(client, args),\n        verifyTypedData: (args) => verifyTypedData(client, args),\n        uninstallFilter: (args) => uninstallFilter(client, args),\n        waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),\n        watchBlocks: (args) => watchBlocks(client, args),\n        watchBlockNumber: (args) => watchBlockNumber(client, args),\n        watchContractEvent: (args) => watchContractEvent(client, args),\n        watchEvent: (args) => watchEvent(client, args),\n        watchPendingTransactions: (args) => watchPendingTransactions(client, args),\n    };\n}\n//# sourceMappingURL=public.js.map","import { AbiConstructorNotFoundError, AbiConstructorParamsNotFoundError, } from '../../errors/abi.js';\nimport { concatHex } from '../data/concat.js';\nimport { encodeAbiParameters, } from './encodeAbiParameters.js';\nconst docsPath = '/docs/contract/encodeDeployData';\nexport function encodeDeployData(parameters) {\n    const { abi, args, bytecode } = parameters;\n    if (!args || args.length === 0)\n        return bytecode;\n    const description = abi.find((x) => 'type' in x && x.type === 'constructor');\n    if (!description)\n        throw new AbiConstructorNotFoundError({ docsPath });\n    if (!('inputs' in description))\n        throw new AbiConstructorParamsNotFoundError({ docsPath });\n    if (!description.inputs || description.inputs.length === 0)\n        throw new AbiConstructorParamsNotFoundError({ docsPath });\n    const data = encodeAbiParameters(description.inputs, args);\n    return concatHex([bytecode, data]);\n}\n//# sourceMappingURL=encodeDeployData.js.map","export const arrayRegex = /^(.*)\\[([0-9]*)\\]$/;\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)?$/;\n//# sourceMappingURL=regex.js.map","import { BytesSizeMismatchError } from '../errors/abi.js';\nimport { InvalidAddressError } from '../errors/address.js';\nimport { isAddress } from './address/isAddress.js';\nimport { size } from './data/size.js';\nimport { numberToHex } from './encoding/toHex.js';\nimport { bytesRegex, integerRegex } from './regex.js';\nimport { hashDomain, } from './signature/hashTypedData.js';\nexport function validateTypedData(parameters) {\n    const { domain, message, primaryType, types } = parameters;\n    const validateData = (struct, data) => {\n        for (const param of struct) {\n            const { name, type } = param;\n            const value = data[name];\n            const integerMatch = type.match(integerRegex);\n            if (integerMatch &&\n                (typeof value === 'number' || typeof value === 'bigint')) {\n                const [_type, base, size_] = integerMatch;\n                // If number cannot be cast to a sized hex value, it is out of range\n                // and will throw.\n                numberToHex(value, {\n                    signed: base === 'int',\n                    size: Number.parseInt(size_) / 8,\n                });\n            }\n            if (type === 'address' && typeof value === 'string' && !isAddress(value))\n                throw new InvalidAddressError({ address: value });\n            const bytesMatch = type.match(bytesRegex);\n            if (bytesMatch) {\n                const [_type, size_] = bytesMatch;\n                if (size_ && size(value) !== Number.parseInt(size_))\n                    throw new BytesSizeMismatchError({\n                        expectedSize: Number.parseInt(size_),\n                        givenSize: size(value),\n                    });\n            }\n            const struct = types[type];\n            if (struct)\n                validateData(struct, value);\n        }\n    };\n    // Validate domain types.\n    if (types.EIP712Domain && domain)\n        validateData(types.EIP712Domain, domain);\n    if (primaryType !== 'EIP712Domain') {\n        // Validate message types.\n        const type = types[primaryType];\n        validateData(type, message);\n    }\n}\nexport function getTypesForEIP712Domain({ domain, }) {\n    return [\n        typeof domain?.name === 'string' && { name: 'name', type: 'string' },\n        domain?.version && { name: 'version', type: 'string' },\n        typeof domain?.chainId === 'number' && {\n            name: 'chainId',\n            type: 'uint256',\n        },\n        domain?.verifyingContract && {\n            name: 'verifyingContract',\n            type: 'address',\n        },\n        domain?.salt && { name: 'salt', type: 'bytes32' },\n    ].filter(Boolean);\n}\nexport function domainSeparator({ domain }) {\n    return hashDomain({\n        domain,\n        types: {\n            EIP712Domain: getTypesForEIP712Domain({ domain }),\n        },\n    });\n}\n//# sourceMappingURL=typedData.js.map"],"names":["eq","__webpack_require__","isArrayLike","isIndex","isObject","module","exports","value","index","object","type","length","toNumber","INFINITY","sign","spanFn","span","_chakra_ui_breakpoint_utils__WEBPACK_IMPORTED_MODULE_1__","XQ","GridItem","_chakra_ui_system__WEBPACK_IMPORTED_MODULE_2__","G","props","ref","area","colSpan","colStart","colEnd","rowEnd","rowSpan","rowStart","rest","styles","_chakra_ui_object_utils__WEBPACK_IMPORTED_MODULE_3__","o","gridArea","gridColumn","gridRow","gridColumnStart","gridColumnEnd","gridRowStart","gridRowEnd","react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__","jsx","_chakra_ui_system__WEBPACK_IMPORTED_MODULE_4__","m","div","__css","displayName","Show","children","ssr","query","_chunk_R3K6W4OF_mjs__WEBPACK_IMPORTED_MODULE_1__","a","_chunk_DZU5YH7Z_mjs__WEBPACK_IMPORTED_MODULE_2__","E","breakpoint","getEnsResolver","client","blockNumber","blockTag","name","universalResolverAddress","universalResolverAddress_","chain","getChainContractAddress","L","contract","resolverAddress","getAction","s","readContract","address","abi","inputs","outputs","stateMutability","functionName","args","toHex","NC","packetToBytes","T","createFilterRequestScope","method","requestMap","transport","onResponse","method_","response","id","status","request","createBlockFilter","getRequest","FilterTypeNotSupportedError","base","constructor","Object","defineProperty","enumerable","configurable","writable","docsPath","encodeEventTopics","parameters","eventName","abiItem","item","getAbiItem","mE","errors_abi","mv","undefined","definition","formatAbiItem","t","signature","toEventSelector","n","topics","indexedInputs","filter","param","indexed","args_","Array","isArray","values","map","x","i","_","j","encodeArg","keccak256","w","toBytes","O0","match","encodeAbiParameters","createContractEventFilter","fromBlock","strict","toBlock","params","eC","Boolean","createEventFilter","event","events","events_","flatMap","createPendingTransactionFilter","estimateContractGas","data","encodeFunctionData","R","estimateGas","Q","to","error","account","parseAccount","getContractError","S","sender","getBlobBaseFee","BigInt","getBlockTransactionCount","blockHash","count","blockNumberHex","fromHex","ly","getBytecode","hex","decodeEventLog_docsPath","decodeEventLog","strict_","argTopics","FM","find","lC","isUnnamed","some","topic","Gy","decodeTopic","decodedArg","decodeAbiParameters","r","nonIndexedInputs","decodedData","err","xB","cursor","lQ","SM","size","d","parseEventLogs","logs","log","includes","getLogs","formattedLogs","formatters_log","U","getContractEvents","getFeeHistory","blockCount","rewardPercentiles","feeHistory","baseFeePerGas","gasUsedRatio","oldestBlock","reward","getFilterChanges","_client","getFilterLogs","getProof","blockTag_","storageKeys","proof","balance","nonce","storageProof","getStorageAt","slot","getTransactionConfirmations","hash","transactionReceipt","transaction","Promise","all","getBlockNumber","z","getTransaction","f","transactionBlockNumber","uninstallFilter","_1n","_2n","u8a","Uint8Array","hexes","from","toString","padStart","bytesToHex","bytes","hexToNumber","hexToBytes","len","array","byte","Number","parseInt","slice","isNaN","utils_bytesToNumberBE","utils_bytesToNumberLE","reverse","utils_numberToBytesBE","numberToBytesLE","utils_ensureBytes","title","expectedLength","res","e","utils_concatBytes","arrays","reduce","sum","pad","forEach","set","equalBytes","b1","b2","bitMask","u8n","u8fr","arr","createHmacDrbg","hashLen","qByteLen","hmacFn","v","k","reset","fill","h","b","reseed","seed","gen","out","sl","push","pred","validatorFns","bigint","val","function","boolean","string","stringOrUint8Array","isSafeInteger","field","Fp","isValid","outputLen","validateObject","validators","optValidators","checkField","fieldName","isOptional","checkVal","String","entries","modular_0n","modular_1n","modular_2n","_3n","_4n","_5n","_8n","modular_mod","result","pow2","power","modulo","invert","number","y","u","q","gcd","FIELD_FIELDS","nLength","nBitLength","_nBitLength","nByteLength","Math","ceil","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","HMAC","utils","kb","_key","finished","destroyed","_assert","vp","key","iHash","create","update","blockLen","digest","oHash","buf","Gg","digestInto","aI","destroy","_cloneInto","getPrototypeOf","hmac","message","curve_0n","curve_1n","validateBasic","curve","ORDER","MASK","BYTES","BITS","Gx","freeze","p","bytesToNumberBE","b2n","h2b","utils_namespaceObject","DER","Err","Error","_parseInt","subarray","l","toSig","sBytes","rBytesLeft","hexFromSig","sig","num","shl","rhl","rl","weierstrass_0n","weierstrass_1n","weierstrass_3n","secp256k1P","secp256k1N","secp256k1_1n","secp256k1_2n","divNearest","Field","bitLen","isLE","redef","sqrtP","FpSqrt","P","p1div4","root","pow","eql","sqr","c1","n2","mul","nv","sub","ONE","tonelliShanks","Z","legendreC","Q1div2","neg","g","ZERO","t2","ge","is0","isOdd","lhs","rhs","add","FpPow","sqrN","addN","subN","mulN","inv","sqrt","invertBatch","FpInvertBatch","nums","tmp","lastMultiplied","acc","inverted","reduceRight","lst","cmov","c","fromBytes","_6n","_11n","_22n","_23n","_44n","_88n","b3","b6","b9","b11","b22","b44","b88","b176","b220","b223","t1","secp256k1","createCurve","curveDef","defHash","weierstrass","CURVE","validateOpts","opts","randomBytes","bits2int","bits2int_modN","lowS","CURVE_ORDER","compressedLen","uncompressedLen","modN","ProjectivePoint","Point","normPrivateKeyToScalar","weierstrassEquation","isWithinCurveOrder","weierstrassPoints","validatePointOpts","allowedPrivateKeyLengths","wrapPrivateKey","isTorsionFree","clearCofactor","allowInfinityPoint","endo","beta","splitScalar","_c","point","_isCompressed","toAffine","tail","x2","x3","assertGE","lengths","pointPrecomputes","Map","assertPrjPoint","other","px","py","pz","fromAffine","normalizeZ","points","toInv","assertValidity","fromPrivateKey","privateKey","BASE","multiply","_setWindowSize","windowSize","_WINDOW_SIZE","delete","left","right","hasEvenY","equals","X1","Y1","Z1","X2","Y2","Z2","U1","U2","negate","double","X3","Y3","Z3","t0","t3","t4","t5","subtract","wNAF","wnaf","wNAFCached","comp","multiplyUnsafe","I","unsafeLadder","k1neg","k1","k2neg","k2","k1p","k2p","scalar","fake","f1p","f2p","constTimeNegate","multiplyAndAddUnsafe","iz","ax","ay","zz","cofactor","toRawBytes","isCompressed","_bits","bits","condition","windows","W","elm","precomputeWindow","window","precomputes","mask","maxNumber","shiftBy","offset","wbits","offset2","abs","cond1","cond2","precomputesMap","transform","get","cat","head","y2","numToNByteStr","slcNum","Signature","recovery","fromCompact","fromDER","addRecoveryBit","recoverPublicKey","msgHash","rec","radj","prefix","ir","u1","u2","hasHighS","normalizeS","toDERRawBytes","toDERHex","toCompactRawBytes","toCompactHex","isProbPub","str","delta","ORDER_MASK","int2octets","defaultSigOpts","prehash","defaultVerOpts","getPublicKey","getSharedSecret","privateA","publicB","privKey","k2sig","prepSig","extraEntropy","ent","h1int","seedArgs","kBytes","ik","normS","isBiggerThanHalfOrder","drbg","C","verify","publicKey","_sig","sg","derError","is","isValidPrivateKey","randomPrivateKey","mapHashToField","fieldLen","minLen","reduced","precompute","msgs","eV","O6","a1","a2","POW_2_128","c2","esm_sha256","J","verifyHash","callRequest","signatureHex","isHex","serializeSignature","yParity","yParity_","y_","ci","call","RE","encodeDeployData","abis","$o","bytecode","isBytesEqual","a_","b_","cg","verifyMessage","hashMessage","to_","messageBytes","qX","raw","prefixBytes","concat","zo","hashStruct","primaryType","types","encoded","encodeData","encodedTypes","encodedValues","hashType","encodedHashType","encodeType","unsortedDeps","findTypeDependencies","primaryType_","results","Set","has","sort","join","encodeField","prepend","lastIndexOf","parsedType","typeValuePairs","verifyTypedData","domain","hashTypedData","EIP712Domain","typedData","cj","iC","parts","hashDomain","publicActions","getBalance","getBlock","getChainId","getEnsAddress","O","getEnsAvatar","getEnsName","getEnsText","estimateFeesPerGas","X","getGasPrice","estimateMaxPriorityFeePerGas","getTransactionCount","K","getTransactionReceipt","multicall","A","prepareTransactionRequest","sendRawTransaction","simulateContract","waitForTransactionReceipt","watchBlocks","emitMissed","emitOnBegin","onBlock","onError","includeTransactions","includeTransactions_","poll","poll_","pollingInterval","prevBlock","active","unsubscribe","enablePolling","transports","config","pollBlocks","observerId","stringify","uid","observe","N7","$","block","emit","interval","unsubscribe_","subscribe","onData","format","formatters","formatters_block","watchBlockNumber","watchContractEvent","batch","onLogs","pollContractEvent","previousBlockNumber","initialized","unwatch","rpc","yR","subscribeContractEvent","formatted","watchEvent","pollEvent","watchPendingTransactions","onTransactions","pollPendingTransactions","hashes","description","_errors_abi_js__WEBPACK_IMPORTED_MODULE_0__","fM","cO","_encodeAbiParameters_js__WEBPACK_IMPORTED_MODULE_1__","_data_concat_js__WEBPACK_IMPORTED_MODULE_2__","bytesRegex","integerRegex","validateTypedData","validateData","struct","integerMatch","_type","size_","signed","isAddress","bytesMatch","KY","expectedSize","givenSize","getTypesForEIP712Domain","version","chainId","verifyingContract","salt"],"sourceRoot":""}