{"version":3,"file":"static/chunks/7417-3e84cadf08beb687.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@moonbeam-network/xcm-sdk/build/index.mjs","webpack://_N_E/../../../actions/public/multicall.ts","webpack://_N_E/../../../actions/public/readContract.ts","webpack://_N_E/../../../utils/ens/errors.ts","webpack://_N_E/../../../utils/ens/encodedLabelToLabelhash.ts","webpack://_N_E/../../../utils/ens/namehash.ts","webpack://_N_E/../../../utils/ens/encodeLabelhash.ts","webpack://_N_E/../../../utils/ens/labelhash.ts","webpack://_N_E/../../../utils/ens/packetToBytes.ts","webpack://_N_E/../../../actions/ens/getEnsAddress.ts","webpack://_N_E/../../errors/ens.ts","webpack://_N_E/../../../../utils/ens/avatar/utils.ts","webpack://_N_E/../../../../utils/ens/avatar/parseAvatarRecord.ts","webpack://_N_E/../../../actions/ens/getEnsText.ts","webpack://_N_E/../../../actions/ens/getEnsAvatar.ts","webpack://_N_E/../../../actions/ens/getEnsName.ts","webpack://_N_E/../../../actions/ens/getEnsResolver.ts","webpack://_N_E/../../../actions/public/createAccessList.ts","webpack://_N_E/../../../utils/filters/createFilterRequestScope.ts","webpack://_N_E/../../../actions/public/createBlockFilter.ts","webpack://_N_E/../../errors/log.ts","webpack://_N_E/../../../utils/abi/encodeEventTopics.ts","webpack://_N_E/../../../actions/public/createContractEventFilter.ts","webpack://_N_E/../../../actions/public/createEventFilter.ts","webpack://_N_E/../../../actions/public/createPendingTransactionFilter.ts","webpack://_N_E/../../../actions/public/estimateContractGas.ts","webpack://_N_E/../../../actions/public/getBlobBaseFee.ts","webpack://_N_E/../../../actions/public/getBlockTransactionCount.ts","webpack://_N_E/../../../actions/public/getCode.ts","webpack://_N_E/../../../utils/abi/decodeEventLog.ts","webpack://_N_E/../../../utils/abi/parseEventLogs.ts","webpack://_N_E/../../../actions/public/getLogs.ts","webpack://_N_E/../../../actions/public/getContractEvents.ts","webpack://_N_E/../../errors/eip712.ts","webpack://_N_E/../../../actions/public/getEip712Domain.ts","webpack://_N_E/../../../utils/formatters/feeHistory.ts","webpack://_N_E/../../../actions/public/getFeeHistory.ts","webpack://_N_E/../../../actions/public/getFilterChanges.ts","webpack://_N_E/../../../actions/public/getFilterLogs.ts","webpack://_N_E/../../../utils/formatters/proof.ts","webpack://_N_E/../../../actions/public/getProof.ts","webpack://_N_E/../../../actions/public/getStorageAt.ts","webpack://_N_E/../../../actions/public/getTransactionConfirmations.ts","webpack://_N_E/./node_modules/ox/_esm/core/version.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/errors.js","webpack://_N_E/./node_modules/ox/_esm/core/Errors.js","webpack://_N_E/./node_modules/ox/_esm/core/Json.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/hex.js","webpack://_N_E/./node_modules/ox/_esm/core/Hex.js","webpack://_N_E/./node_modules/ox/_esm/core/Withdrawal.js","webpack://_N_E/./node_modules/ox/_esm/core/BlockOverrides.js","webpack://_N_E/../../../actions/public/simulateBlocks.ts","webpack://_N_E/./node_modules/abitype/dist/esm/human-readable/parseAbiItem.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/bytes.js","webpack://_N_E/./node_modules/ox/_esm/core/Bytes.js","webpack://_N_E/./node_modules/ox/_esm/core/Hash.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/lru.js","webpack://_N_E/./node_modules/ox/_esm/core/Caches.js","webpack://_N_E/./node_modules/ox/_esm/core/Address.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/abiItem.js","webpack://_N_E/./node_modules/ox/_esm/core/AbiItem.js","webpack://_N_E/./node_modules/ox/_esm/core/Solidity.js","webpack://_N_E/./node_modules/ox/_esm/core/internal/abiParameters.js","webpack://_N_E/./node_modules/ox/_esm/core/AbiParameters.js","webpack://_N_E/./node_modules/ox/_esm/core/AbiConstructor.js","webpack://_N_E/./node_modules/ox/_esm/core/AbiFunction.js","webpack://_N_E/../../constants/address.ts","webpack://_N_E/../../../actions/public/simulateCalls.ts","webpack://_N_E/../../../actions/public/simulateContract.ts","webpack://_N_E/../../../actions/public/uninstallFilter.ts","webpack://_N_E/../../constants/strings.ts","webpack://_N_E/../../../utils/signature/toPrefixedMessage.ts","webpack://_N_E/../../../utils/signature/hashMessage.ts","webpack://_N_E/../../constants/bytes.ts","webpack://_N_E/../../../utils/signature/isErc6492Signature.ts","webpack://_N_E/../../../utils/signature/serializeErc6492Signature.ts","webpack://_N_E/../../../utils/signature/serializeSignature.ts","webpack://_N_E/../../../actions/public/verifyHash.ts","webpack://_N_E/../../../actions/public/verifyMessage.ts","webpack://_N_E/../../../utils/signature/hashTypedData.ts","webpack://_N_E/../../../actions/public/verifyTypedData.ts","webpack://_N_E/../../../actions/public/watchBlocks.ts","webpack://_N_E/../../../actions/public/watchContractEvent.ts","webpack://_N_E/../../../actions/public/watchEvent.ts","webpack://_N_E/../../../actions/public/watchPendingTransactions.ts","webpack://_N_E/../../../utils/siwe/parseSiweMessage.ts","webpack://_N_E/../../../utils/siwe/validateSiweMessage.ts","webpack://_N_E/../../../actions/siwe/verifySiweMessage.ts","webpack://_N_E/../../../clients/decorators/public.ts","webpack://_N_E/../../clients/createPublicClient.ts","webpack://_N_E/../../../utils/address/isAddressEqual.ts","webpack://_N_E/../../errors/typedData.ts","webpack://_N_E/../../utils/typedData.ts"],"sourcesContent":["// src/services/polkadot/PolkadotService.ts\nimport \"@polkadot/api-augment\";\nimport { AssetAmount } from \"@moonbeam-network/xcm-types\";\nimport { getPolkadotApi } from \"@moonbeam-network/xcm-utils\";\nvar PolkadotService = class _PolkadotService {\n  api;\n  chain;\n  constructor(api, chain) {\n    this.api = api;\n    this.chain = chain;\n  }\n  static async create(chain) {\n    return new _PolkadotService(await getPolkadotApi(chain.ws), chain);\n  }\n  static async createMulti(chains) {\n    return Promise.all(\n      chains.map((chain) => _PolkadotService.create(chain))\n    );\n  }\n  get decimals() {\n    return this.api.registry.chainDecimals.at(0) || 12;\n  }\n  get existentialDeposit() {\n    const existentialDeposit = this.api.consts.balances?.existentialDeposit;\n    const eqExistentialDeposit = this.api.consts.eqBalances?.existentialDeposit;\n    const amount = existentialDeposit?.toBigInt() || eqExistentialDeposit?.toBigInt() || 0n;\n    return AssetAmount.fromChainAsset(this.chain.nativeAsset, { amount });\n  }\n  async query(config) {\n    const response = await this.api.query[config.module][config.func](\n      ...config.args\n    );\n    return config.transform(response);\n  }\n  getExtrinsic(config) {\n    const fn = this.api.tx[config.module][config.func];\n    const args = config.getArgs(fn);\n    return fn(...args);\n  }\n  getExtrinsicCallHash(config) {\n    return this.getExtrinsic(config).method.toHex();\n  }\n  async getPaymentInfo(account, config) {\n    const extrinsic = this.getExtrinsic(config);\n    return extrinsic.paymentInfo(account, { nonce: -1 });\n  }\n  async getFee(account, config) {\n    const info = await this.getPaymentInfo(account, config);\n    return info.partialFee.toBigInt();\n  }\n  async transfer(account, config, signer, statusCallback) {\n    const extrinsic = this.getExtrinsic(config);\n    const isSigner = this.#isSigner(signer);\n    const signOptions = {\n      nonce: -1,\n      signer: isSigner ? signer : void 0,\n      withSignedTransaction: true\n    };\n    const hash = await new Promise((resolve, reject) => {\n      extrinsic.signAndSend(isSigner ? account : signer, signOptions, (result) => {\n        if (result.isError || result.dispatchError) {\n          reject(\n            new Error(\n              result.dispatchError?.toString() || \"Transaction failed\"\n            )\n          );\n        }\n        if (result.txHash) {\n          resolve(result.txHash.toString());\n        }\n        statusCallback?.(result);\n      }).catch(reject);\n    });\n    return hash;\n  }\n  #isSigner(signer) {\n    return \"signPayload\" in signer;\n  }\n};\n\n// src/getTransferData/getTransferData.utils.ts\nimport {\n  ContractConfig,\n  EvmQueryConfig,\n  SubstrateQueryConfig\n} from \"@moonbeam-network/xcm-builder\";\nimport {\n  AssetAmount as AssetAmount2,\n  EvmChain,\n  EvmParachain,\n  Parachain\n} from \"@moonbeam-network/xcm-types\";\nimport { convertDecimals, toBigInt } from \"@moonbeam-network/xcm-utils\";\nimport Big from \"big.js\";\n\n// src/services/evm/EvmService.ts\nimport {\n  http,\n  createPublicClient\n} from \"viem\";\nvar EvmService = class _EvmService {\n  chain;\n  client;\n  static create(chain) {\n    return new _EvmService(chain);\n  }\n  constructor(chain) {\n    this.chain = chain;\n    this.client = createPublicClient({\n      chain: chain.getViemChain(),\n      transport: http()\n    });\n  }\n  async query(query) {\n    return this.client[query.func](...query.args);\n  }\n  async getFee(address, contract) {\n    const gas = await this.client.estimateContractGas({\n      abi: contract.abi,\n      account: address,\n      address: contract.address,\n      args: contract.args,\n      functionName: contract.func\n    });\n    const gasPrice = await this.client.getGasPrice();\n    return gas * gasPrice;\n  }\n  async getBalance(address, contract) {\n    const balance = await this.client.readContract({\n      abi: contract.abi,\n      address: contract.address,\n      args: [address],\n      functionName: \"balanceOf\"\n    });\n    if (typeof balance !== \"bigint\") {\n      throw new Error(\n        `Could not get balance on ${this.chain.name} for ${address} from contract ${contract.address}`\n      );\n    }\n    return balance;\n  }\n  async transfer(signer, contract) {\n    const { request } = await this.client.simulateContract({\n      abi: contract.abi,\n      account: signer.account,\n      address: contract.address,\n      args: contract.args,\n      functionName: contract.func\n    });\n    const hash = await signer.writeContract(request);\n    return hash;\n  }\n};\n\n// src/getTransferData/getTransferData.utils.ts\nasync function getBalance({\n  address,\n  asset,\n  builder,\n  chain\n}) {\n  const config = builder.build({\n    address,\n    asset\n  });\n  const amount = AssetAmount2.fromChainAsset(asset, { amount: 0n });\n  if (SubstrateQueryConfig.is(config) && EvmParachain.isAnyParachain(chain)) {\n    const polkadot = await PolkadotService.create(chain);\n    const balance = await polkadot.query(config);\n    const converted = chain.usesChainDecimals ? convertDecimals(balance, polkadot.decimals, asset.decimals) : balance;\n    return amount.copyWith({ amount: converted });\n  }\n  if (EvmChain.is(chain) || EvmParachain.is(chain)) {\n    const evm = EvmService.create(chain);\n    if (ContractConfig.is(config)) {\n      const balance = await evm.getBalance(address, config);\n      return amount.copyWith({ amount: balance });\n    }\n    if (EvmQueryConfig.is(config)) {\n      const balance = await evm.query(config);\n      return amount.copyWith({ amount: balance });\n    }\n  }\n  throw new Error(\n    `Can't get balance for ${address} on chain ${chain.name} and asset ${asset.symbol}`\n  );\n}\nasync function getAssetMin({\n  asset,\n  builder,\n  chain\n}) {\n  const zero = AssetAmount2.fromChainAsset(chain.getChainAsset(asset), {\n    amount: 0n\n  });\n  if (builder && EvmParachain.isAnyParachain(chain)) {\n    const polkadot = await PolkadotService.create(chain);\n    const min = await polkadot.query(\n      builder.build({ asset: zero.getMinAssetId(), address: zero.address })\n    );\n    return zero.copyWith({ amount: min });\n  }\n  if (zero.min) {\n    return zero.copyWith({ amount: zero.min });\n  }\n  return zero;\n}\nfunction getMin({\n  balance,\n  existentialDeposit,\n  fee,\n  min\n}) {\n  const result = Big(0).plus(balance.isSame(fee) ? fee.toBig() : Big(0)).plus(\n    existentialDeposit && balance.isSame(existentialDeposit) && balance.toBig().lt(existentialDeposit.toBig()) ? existentialDeposit.toBig() : Big(0)\n  ).plus(balance.toBig().lt(min.toBig()) ? min.toBig() : Big(0));\n  return balance.copyWith({\n    amount: BigInt(result.toFixed())\n  });\n}\nfunction getMax({\n  balance,\n  existentialDeposit,\n  fee,\n  min\n}) {\n  const result = balance.toBig().minus(min.toBig()).minus(\n    existentialDeposit && balance.isSame(existentialDeposit) ? existentialDeposit.toBig() : Big(0)\n  ).minus(balance.isSame(fee) ? fee.toBig() : Big(0));\n  return balance.copyWith({\n    amount: result.lt(0) ? 0n : BigInt(result.toFixed())\n  });\n}\nasync function getDestinationFee({\n  address,\n  asset,\n  destination,\n  fee,\n  feeAsset,\n  source\n}) {\n  const zero = AssetAmount2.fromChainAsset(destination.getChainAsset(feeAsset), {\n    amount: 0n\n  });\n  if (typeof fee === \"number\") {\n    return zero.copyWith({\n      amount: fee\n    });\n  }\n  if (EvmParachain.isAnyParachain(destination)) {\n    const polkadot = await PolkadotService.create(destination);\n    const cfg = fee.build({\n      address,\n      api: polkadot.api,\n      asset: destination.getChainAsset(asset),\n      destination,\n      feeAsset: destination.getChainAsset(feeAsset),\n      source\n    });\n    return zero.copyWith({\n      amount: await cfg.call()\n    });\n  }\n  return zero;\n}\nfunction convertToChainDecimals({\n  asset,\n  target\n}) {\n  return AssetAmount2.fromChainAsset(target, {\n    amount: asset.convertDecimals(target.decimals).amount\n  });\n}\nasync function getExistentialDeposit(chain) {\n  if (EvmParachain.isAnyParachain(chain)) {\n    const polkadot = await PolkadotService.create(chain);\n    return polkadot.existentialDeposit;\n  }\n  return void 0;\n}\nasync function getDestinationFeeBalance({\n  balance,\n  feeBalance,\n  route,\n  sourceAddress\n}) {\n  if (route.destination.fee.asset.isEqual(balance)) {\n    return balance;\n  }\n  if (route.destination.fee.asset.isEqual(feeBalance)) {\n    return feeBalance;\n  }\n  if (!route.source.destinationFee?.balance) {\n    throw new Error(\n      \"BalanceBuilder must be defined for source.destinationFee.balance for AssetRoute\"\n    );\n  }\n  return getBalance({\n    address: sourceAddress,\n    asset: route.getDestinationFeeAssetOnSource(),\n    builder: route.source.destinationFee?.balance,\n    chain: route.source.chain\n  });\n}\nasync function getExtrinsicFee({\n  address,\n  balance,\n  chain,\n  extrinsic,\n  feeBalance,\n  feeConfig\n}) {\n  try {\n    const polkadot = await PolkadotService.create(chain);\n    const fee = await polkadot.getFee(address, extrinsic);\n    const extra = feeConfig?.extra ? toBigInt(feeConfig.extra, feeBalance.decimals) : 0n;\n    const totalFee = fee + extra;\n    const converted = chain.usesChainDecimals ? convertDecimals(totalFee, polkadot.decimals, feeBalance.decimals) : totalFee;\n    return feeBalance.copyWith({ amount: converted });\n  } catch (error) {\n    if (balance.amount) {\n      throw error;\n    }\n    return feeBalance.copyWith({ amount: 0n });\n  }\n}\nasync function getContractFee({\n  address,\n  balance,\n  chain,\n  contract,\n  destinationFee,\n  feeBalance,\n  feeConfig\n}) {\n  try {\n    if (balance.amount === 0n) {\n      return feeBalance.copyWith({ amount: 0n });\n    }\n    const evm = EvmService.create(chain);\n    const fee = await evm.getFee(address, contract);\n    const extra = feeConfig?.extra ? toBigInt(feeConfig.extra, feeBalance.decimals) : 0n;\n    return feeBalance.copyWith({ amount: fee + extra });\n  } catch (error) {\n    throw new Error(\n      `Can't get a fee, make sure you have ${destinationFee.toDecimal()} ${destinationFee.getSymbol()} in your source balance, needed for destination fees`,\n      { cause: error }\n    );\n  }\n}\nfunction validateSovereignAccountBalances({\n  amount,\n  sourceData,\n  destinationData\n}) {\n  if (!Parachain.is(destinationData.chain) || !destinationData.chain.checkSovereignAccountBalances || !destinationData.sovereignAccountBalances) {\n    return;\n  }\n  const { feeAssetBalance, transferAssetBalance } = destinationData.sovereignAccountBalances;\n  if (amount > transferAssetBalance) {\n    throw new Error(\n      `${sourceData.chain.name} Sovereign account in ${destinationData.chain.name} does not have enough balance for this transaction`\n    );\n  }\n  if (feeAssetBalance && sourceData.destinationFee.amount > feeAssetBalance) {\n    throw new Error(\n      `${sourceData.chain.name} Sovereign account in ${destinationData.chain.name} does not have enough balance to pay for fees for this transaction`\n    );\n  }\n}\n\n// src/getTransferData/getSourceData.ts\nasync function getSourceData({\n  route,\n  destinationAddress,\n  destinationFee,\n  sourceAddress\n}) {\n  const source = route.source.chain;\n  const destination = route.destination.chain;\n  const [sourcePolkadot, destinationPolkadot] = await PolkadotService.createMulti([source, destination]);\n  const asset = source.getChainAsset(route.source.asset);\n  const feeAsset = route.source.fee ? source.getChainAsset(route.source.fee.asset) : asset;\n  const balance = await getBalance({\n    address: sourceAddress,\n    asset,\n    builder: route.source.balance,\n    chain: source\n  });\n  const feeBalance = route.source.fee ? await getBalance({\n    address: sourceAddress,\n    asset: feeAsset,\n    builder: route.source.fee.balance,\n    chain: source\n  }) : balance;\n  const destinationFeeBalance = await getDestinationFeeBalance({\n    balance,\n    feeBalance,\n    route,\n    sourceAddress\n  });\n  const existentialDeposit = await getExistentialDeposit(source);\n  const min = await getAssetMin({\n    asset,\n    builder: route.source.min,\n    chain: source\n  });\n  const extrinsic = route.extrinsic?.build({\n    asset: balance,\n    destination: route.destination.chain,\n    destinationAddress,\n    destinationApi: destinationPolkadot.api,\n    fee: destinationFee,\n    source,\n    sourceAddress,\n    sourceApi: sourcePolkadot.api\n  });\n  const contract = route.contract?.build({\n    asset: balance,\n    destination: route.destination.chain,\n    destinationAddress,\n    destinationApi: destinationPolkadot.api,\n    fee: destinationFee,\n    source,\n    sourceAddress,\n    sourceApi: sourcePolkadot.api\n  });\n  const fee = await getFee({\n    balance,\n    chain: source,\n    contract,\n    destinationFee,\n    extrinsic,\n    feeBalance,\n    feeConfig: route.source.fee,\n    sourceAddress\n  });\n  const max = getMax({\n    balance,\n    existentialDeposit,\n    fee,\n    min\n  });\n  return {\n    balance,\n    chain: source,\n    destinationFee,\n    destinationFeeBalance,\n    existentialDeposit,\n    fee,\n    feeBalance,\n    max,\n    min\n  };\n}\nasync function getFee({\n  balance,\n  feeBalance,\n  chain,\n  contract,\n  destinationFee,\n  extrinsic,\n  feeConfig,\n  sourceAddress\n}) {\n  if (!contract && !extrinsic) {\n    throw new Error(\"Either contract or extrinsic must be provided\");\n  }\n  if (contract) {\n    return getContractFee({\n      address: sourceAddress,\n      balance,\n      chain,\n      contract,\n      destinationFee,\n      feeBalance,\n      feeConfig\n    });\n  }\n  return getExtrinsicFee({\n    address: sourceAddress,\n    balance,\n    chain,\n    extrinsic,\n    feeBalance,\n    feeConfig\n  });\n}\nasync function getAssetsBalances({\n  address,\n  chain,\n  routes\n}) {\n  const uniqueRoutes = routes.reduce((acc, route) => {\n    if (!acc.some((a) => a.source.asset.isEqual(route.source.asset))) {\n      return [route, ...acc];\n    }\n    return acc;\n  }, []);\n  const balances = await Promise.all(\n    uniqueRoutes.map(\n      async (route) => getBalance({\n        address,\n        asset: chain.getChainAsset(route.source.asset),\n        builder: route.source.balance,\n        chain\n      })\n    )\n  );\n  return balances;\n}\n\n// src/getTransferData/getDestinationData.ts\nimport { Parachain as Parachain2 } from \"@moonbeam-network/xcm-types\";\nimport { getSovereignAccountAddresses } from \"@moonbeam-network/xcm-utils\";\nasync function getDestinationData({\n  route,\n  destinationAddress\n}) {\n  const destination = route.destination.chain;\n  const asset = destination.getChainAsset(route.destination.asset);\n  const balance = await getBalance({\n    address: destinationAddress,\n    asset,\n    builder: route.destination.balance,\n    chain: destination\n  });\n  const min = await getAssetMin({\n    asset,\n    builder: route.destination.min,\n    chain: destination\n  });\n  const fee = await getDestinationFee({\n    address: destinationAddress,\n    feeAsset: route.destination.fee.asset,\n    destination,\n    fee: route.destination.fee.amount,\n    source: route.source.chain,\n    asset: route.source.asset\n  });\n  const existentialDeposit = await getExistentialDeposit(destination);\n  return {\n    chain: destination,\n    balance,\n    existentialDeposit,\n    fee,\n    min,\n    sovereignAccountBalances: await getSovereignAccountBalances({\n      source: route.source,\n      destination: route.destination\n    })\n  };\n}\nasync function getSovereignAccountBalances({\n  destination,\n  source\n}) {\n  if (!Parachain2.is(source.chain) || !Parachain2.is(destination.chain) || !destination.chain.checkSovereignAccountBalances) {\n    return void 0;\n  }\n  const sovereignAccountAddresses = getSovereignAccountAddresses(\n    source.chain.parachainId\n  );\n  const destinationFeeAssetBalance = destination.fee.balance;\n  const sovereignAccountAddress = destination.chain.isRelay ? sovereignAccountAddresses.relay : sovereignAccountAddresses.generic;\n  const sovereignAccountBalance = await getBalance({\n    address: sovereignAccountAddress,\n    asset: destination.chain.getChainAsset(destination.asset),\n    builder: destination.balance,\n    chain: destination.chain\n  });\n  const sovereignAccountFeeAssetBalance = destinationFeeAssetBalance ? await getBalance({\n    address: sovereignAccountAddress,\n    asset: destination.chain.getChainAsset(destination.fee.asset),\n    builder: destinationFeeAssetBalance,\n    chain: destination.chain\n  }) : void 0;\n  return {\n    feeAssetBalance: sovereignAccountFeeAssetBalance?.amount,\n    transferAssetBalance: sovereignAccountBalance.amount\n  };\n}\n\n// src/sdk.ts\nimport { ConfigService, xcmRoutesMap } from \"@moonbeam-network/xcm-config\";\nimport {\n  EvmParachain as EvmParachain2\n} from \"@moonbeam-network/xcm-types\";\n\n// src/getTransferData/getTransferData.ts\nimport {\n  AssetAmount as AssetAmount3\n} from \"@moonbeam-network/xcm-types\";\nimport { toBigInt as toBigInt2 } from \"@moonbeam-network/xcm-utils\";\nimport Big2 from \"big.js\";\nasync function getTransferData({\n  route,\n  sourceAddress,\n  destinationAddress\n}) {\n  const destinationData = await getDestinationData({\n    route,\n    destinationAddress\n  });\n  const destinationFee = convertToChainDecimals({\n    asset: destinationData.fee,\n    target: route.getDestinationFeeAssetOnSource()\n  });\n  const sourceData = await getSourceData({\n    route,\n    destinationAddress,\n    destinationFee,\n    sourceAddress\n  });\n  return {\n    destination: destinationData,\n    getEstimate(amount) {\n      const bigAmount = Big2(\n        toBigInt2(amount, sourceData.balance.decimals).toString()\n      );\n      const result = bigAmount.minus(\n        sourceData.balance.isSame(destinationFee) ? destinationFee.toBig() : Big2(0)\n      );\n      return sourceData.balance.copyWith({\n        amount: result.lt(0) ? 0n : BigInt(result.toFixed())\n      });\n    },\n    max: sourceData.max,\n    min: getMin(destinationData),\n    source: sourceData,\n    async transfer(amount, { evmSigner, polkadotSigner }) {\n      const source = route.source.chain;\n      const destination = route.destination.chain;\n      const bigintAmount = toBigInt2(amount, sourceData.balance.decimals);\n      validateSovereignAccountBalances({\n        amount: bigintAmount,\n        destinationData,\n        sourceData\n      });\n      const asset = AssetAmount3.fromChainAsset(\n        route.source.chain.getChainAsset(route.source.asset),\n        { amount: bigintAmount }\n      );\n      const [sourcePolkadot, destinationPolkadot] = await PolkadotService.createMulti([source, destination]);\n      const contract = route.contract?.build({\n        asset,\n        destination,\n        destinationAddress,\n        destinationApi: destinationPolkadot.api,\n        fee: destinationFee,\n        source,\n        sourceAddress,\n        sourceApi: sourcePolkadot.api\n      });\n      const extrinsic = route.extrinsic?.build({\n        asset,\n        destination,\n        destinationAddress,\n        destinationApi: destinationPolkadot.api,\n        fee: destinationFee,\n        source,\n        sourceAddress,\n        sourceApi: sourcePolkadot.api\n      });\n      if (contract) {\n        if (!evmSigner) {\n          throw new Error(\"EVM Signer must be provided\");\n        }\n        const evm = EvmService.create(source);\n        return evm.transfer(evmSigner, contract);\n      }\n      if (extrinsic) {\n        if (!polkadotSigner) {\n          throw new Error(\"Polkadot signer must be provided\");\n        }\n        return sourcePolkadot.transfer(\n          sourceAddress,\n          extrinsic,\n          polkadotSigner\n        );\n      }\n      throw new Error(\"Either contract or extrinsic must be provided\");\n    }\n  };\n}\n\n// src/sdk.ts\nvar DEFAULT_SERVICE = new ConfigService({ routes: xcmRoutesMap });\nfunction Sdk({ configService, ecosystem } = {}) {\n  const service = configService ?? DEFAULT_SERVICE;\n  const assets = service.getEcosystemAssets(ecosystem);\n  return {\n    assets,\n    setAsset(asset) {\n      const sources = service.getSourceChains({ asset, ecosystem });\n      return {\n        sources,\n        setSource(source) {\n          const destinations = service.getDestinationChains({\n            asset,\n            source\n          });\n          return {\n            destinations,\n            setDestination(destination) {\n              const route = service.getAssetRoute({\n                asset,\n                source,\n                destination\n              });\n              return {\n                setAddresses({\n                  sourceAddress,\n                  destinationAddress\n                }) {\n                  const sourceChain = service.getChain(source);\n                  if (!EvmParachain2.isAnyParachain(sourceChain)) {\n                    throw new Error(\n                      \"Source chain should be a Parachain or EvmParachain\"\n                    );\n                  }\n                  if (!EvmParachain2.isAnyParachain(route.destination.chain)) {\n                    throw new Error(\n                      \"Destination chain should be a Parachain or EvmParachain\"\n                    );\n                  }\n                  return getTransferData({\n                    route,\n                    sourceAddress,\n                    destinationAddress\n                  });\n                }\n              };\n            }\n          };\n        }\n      };\n    }\n  };\n}\nasync function getParachainBalances(chain, address, service = DEFAULT_SERVICE) {\n  const routes = service.getChainRoutes(chain).getRoutes();\n  const balances = await getAssetsBalances({\n    chain,\n    routes,\n    address\n  });\n  return balances;\n}\nexport {\n  EvmService,\n  PolkadotService,\n  Sdk,\n  convertToChainDecimals,\n  getAssetMin,\n  getAssetsBalances,\n  getBalance,\n  getContractFee,\n  getDestinationData,\n  getDestinationFee,\n  getDestinationFeeBalance,\n  getExistentialDeposit,\n  getExtrinsicFee,\n  getFee,\n  getMax,\n  getMin,\n  getParachainBalances,\n  getSourceData,\n  validateSovereignAccountBalances\n};\n//# sourceMappingURL=index.mjs.map",null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"/** @internal */\nexport const version = '0.1.1';\n//# sourceMappingURL=version.js.map","import { version } from '../version.js';\n/** @internal */\nexport function getUrl(url) {\n    return url;\n}\n/** @internal */\nexport function getVersion() {\n    return version;\n}\n/** @internal */\nexport function prettyPrint(args) {\n    if (!args)\n        return '';\n    const entries = Object.entries(args)\n        .map(([key, value]) => {\n        if (value === undefined || value === false)\n            return null;\n        return [key, value];\n    })\n        .filter(Boolean);\n    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);\n    return entries\n        .map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`)\n        .join('\\n');\n}\n//# sourceMappingURL=errors.js.map","import { getVersion } from './internal/errors.js';\n/**\n * Base error class inherited by all errors thrown by ox.\n *\n * @example\n * ```ts\n * import { Errors } from 'ox'\n * throw new Errors.BaseError('An error occurred')\n * ```\n */\nexport class BaseError extends Error {\n    constructor(shortMessage, options = {}) {\n        const details = (() => {\n            if (options.cause instanceof BaseError) {\n                if (options.cause.details)\n                    return options.cause.details;\n                if (options.cause.shortMessage)\n                    return options.cause.shortMessage;\n            }\n            if (options.cause?.message)\n                return options.cause.message;\n            return options.details;\n        })();\n        const docsPath = (() => {\n            if (options.cause instanceof BaseError)\n                return options.cause.docsPath || options.docsPath;\n            return options.docsPath;\n        })();\n        const docsBaseUrl = 'https://oxlib.sh';\n        const docs = `${docsBaseUrl}${docsPath ?? ''}`;\n        const message = [\n            shortMessage || 'An error occurred.',\n            ...(options.metaMessages ? ['', ...options.metaMessages] : []),\n            ...(details || docsPath\n                ? [\n                    '',\n                    details ? `Details: ${details}` : undefined,\n                    docsPath ? `See: ${docs}` : undefined,\n                ]\n                : []),\n        ]\n            .filter((x) => typeof x === 'string')\n            .join('\\n');\n        super(message, options.cause ? { cause: options.cause } : undefined);\n        Object.defineProperty(this, \"details\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"docs\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"docsPath\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"shortMessage\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"cause\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'BaseError'\n        });\n        Object.defineProperty(this, \"version\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: `ox@${getVersion()}`\n        });\n        this.cause = options.cause;\n        this.details = details;\n        this.docs = docs;\n        this.docsPath = docsPath;\n        this.shortMessage = shortMessage;\n    }\n    walk(fn) {\n        return walk(this, fn);\n    }\n}\n/** @internal */\nfunction walk(err, fn) {\n    if (fn?.(err))\n        return err;\n    if (err && typeof err === 'object' && 'cause' in err && err.cause)\n        return walk(err.cause, fn);\n    return fn ? null : err;\n}\n//# sourceMappingURL=Errors.js.map","const bigIntSuffix = '#__bigint';\n/**\n * Parses a JSON string, with support for `bigint`.\n *\n * @example\n * ```ts twoslash\n * import { Json } from 'ox'\n *\n * const json = Json.parse('{\"foo\":\"bar\",\"baz\":\"69420694206942069420694206942069420694206942069420#__bigint\"}')\n * // @log: {\n * // @log:   foo: 'bar',\n * // @log:   baz: 69420694206942069420694206942069420694206942069420n\n * // @log: }\n * ```\n *\n * @param string - The value to parse.\n * @param reviver - A function that transforms the results.\n * @returns The parsed value.\n */\nexport function parse(string, reviver) {\n    return JSON.parse(string, (key, value_) => {\n        const value = value_;\n        if (typeof value === 'string' && value.endsWith(bigIntSuffix))\n            return BigInt(value.slice(0, -bigIntSuffix.length));\n        return typeof reviver === 'function' ? reviver(key, value) : value;\n    });\n}\n/**\n * Stringifies a value to its JSON representation, with support for `bigint`.\n *\n * @example\n * ```ts twoslash\n * import { Json } from 'ox'\n *\n * const json = Json.stringify({\n *   foo: 'bar',\n *   baz: 69420694206942069420694206942069420694206942069420n,\n * })\n * // @log: '{\"foo\":\"bar\",\"baz\":\"69420694206942069420694206942069420694206942069420#__bigint\"}'\n * ```\n *\n * @param value - The value to stringify.\n * @param replacer - A function that transforms the results. It is passed the key and value of the property, and must return the value to be used in the JSON string. If this function returns `undefined`, the property is not included in the resulting JSON string.\n * @param space - A string or number that determines the indentation of the JSON string. If it is a number, it indicates the number of spaces to use as indentation; if it is a string (e.g. `'\\t'`), it uses the string as the indentation character.\n * @returns The JSON string.\n */\nexport function stringify(value, replacer, space) {\n    return JSON.stringify(value, (key, value) => {\n        if (typeof replacer === 'function')\n            return replacer(key, value);\n        if (typeof value === 'bigint')\n            return value.toString() + bigIntSuffix;\n        return value;\n    }, space);\n}\n//# sourceMappingURL=Json.js.map","import * as Hex from '../Hex.js';\n/** @internal */\nexport function assertSize(hex, size_) {\n    if (Hex.size(hex) > size_)\n        throw new Hex.SizeOverflowError({\n            givenSize: Hex.size(hex),\n            maxSize: size_,\n        });\n}\n/** @internal */\nexport function assertStartOffset(value, start) {\n    if (typeof start === 'number' && start > 0 && start > Hex.size(value) - 1)\n        throw new Hex.SliceOffsetOutOfBoundsError({\n            offset: start,\n            position: 'start',\n            size: Hex.size(value),\n        });\n}\n/** @internal */\nexport function assertEndOffset(value, start, end) {\n    if (typeof start === 'number' &&\n        typeof end === 'number' &&\n        Hex.size(value) !== end - start) {\n        throw new Hex.SliceOffsetOutOfBoundsError({\n            offset: end,\n            position: 'end',\n            size: Hex.size(value),\n        });\n    }\n}\n/** @internal */\nexport function pad(hex_, options = {}) {\n    const { dir, size = 32 } = options;\n    if (size === 0)\n        return hex_;\n    const hex = hex_.replace('0x', '');\n    if (hex.length > size * 2)\n        throw new Hex.SizeExceedsPaddingSizeError({\n            size: Math.ceil(hex.length / 2),\n            targetSize: size,\n            type: 'Hex',\n        });\n    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;\n}\n/** @internal */\nexport function trim(value, options = {}) {\n    const { dir = 'left' } = options;\n    let data = value.replace('0x', '');\n    let sliceLength = 0;\n    for (let i = 0; i < data.length - 1; i++) {\n        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')\n            sliceLength++;\n        else\n            break;\n    }\n    data =\n        dir === 'left'\n            ? data.slice(sliceLength)\n            : data.slice(0, data.length - sliceLength);\n    if (data === '0')\n        return '0x';\n    if (dir === 'right' && data.length % 2 === 1)\n        return `0x${data}0`;\n    return `0x${data}`;\n}\n//# sourceMappingURL=hex.js.map","import { equalBytes } from '@noble/curves/abstract/utils';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Json from './Json.js';\nimport * as internal_bytes from './internal/bytes.js';\nimport * as internal from './internal/hex.js';\nconst encoder = /*#__PURE__*/ new TextEncoder();\nconst hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));\n/**\n * Asserts if the given value is {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert('abc')\n * // @error: InvalidHexValueTypeError:\n * // @error: Value `\"abc\"` of type `string` is an invalid hex type.\n * // @error: Hex types must be represented as `\"0x\\${string}\"`.\n * ```\n *\n * @param value - The value to assert.\n * @param options - Options.\n */\nexport function assert(value, options = {}) {\n    const { strict = false } = options;\n    if (!value)\n        throw new InvalidHexTypeError(value);\n    if (typeof value !== 'string')\n        throw new InvalidHexTypeError(value);\n    if (strict) {\n        if (!/^0x[0-9a-fA-F]*$/.test(value))\n            throw new InvalidHexValueError(value);\n    }\n    if (!value.startsWith('0x'))\n        throw new InvalidHexValueError(value);\n}\n/**\n * Concatenates two or more {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.concat('0x123', '0x456')\n * // @log: '0x123456'\n * ```\n *\n * @param values - The {@link ox#Hex.Hex} values to concatenate.\n * @returns The concatenated {@link ox#Hex.Hex} value.\n */\nexport function concat(...values) {\n    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;\n}\n/**\n * Instantiates a {@link ox#Hex.Hex} value from a hex string or {@link ox#Bytes.Bytes} value.\n *\n * :::tip\n *\n * To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:\n *\n * - `Hex.fromBoolean`\n *\n * - `Hex.fromString`\n *\n * - `Hex.fromNumber`\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.from('0x48656c6c6f20576f726c6421')\n * // @log: '0x48656c6c6f20576f726c6421'\n *\n * Hex.from(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // @log: '0x48656c6c6f20576f726c6421'\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} value to encode.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function from(value) {\n    if (value instanceof Uint8Array)\n        return fromBytes(value);\n    if (Array.isArray(value))\n        return fromBytes(new Uint8Array(value));\n    return value;\n}\n/**\n * Encodes a boolean into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromBoolean(true)\n * // @log: '0x1'\n *\n * Hex.fromBoolean(false)\n * // @log: '0x0'\n *\n * Hex.fromBoolean(true, { size: 32 })\n * // @log: '0x0000000000000000000000000000000000000000000000000000000000000001'\n * ```\n *\n * @param value - The boolean value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromBoolean(value, options = {}) {\n    const hex = `0x${Number(value)}`;\n    if (typeof options.size === 'number') {\n        internal.assertSize(hex, options.size);\n        return padLeft(hex, options.size);\n    }\n    return hex;\n}\n/**\n * Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.fromBytes(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // @log: '0x48656c6c6f20576f726c6421'\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromBytes(value, options = {}) {\n    let string = '';\n    for (let i = 0; i < value.length; i++)\n        string += hexes[value[i]];\n    const hex = `0x${string}`;\n    if (typeof options.size === 'number') {\n        internal.assertSize(hex, options.size);\n        return padRight(hex, options.size);\n    }\n    return hex;\n}\n/**\n * Encodes a number or bigint into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromNumber(420)\n * // @log: '0x1a4'\n *\n * Hex.fromNumber(420, { size: 32 })\n * // @log: '0x00000000000000000000000000000000000000000000000000000000000001a4'\n * ```\n *\n * @param value - The number or bigint value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromNumber(value, options = {}) {\n    const { signed, size } = options;\n    const value_ = BigInt(value);\n    let maxValue;\n    if (size) {\n        if (signed)\n            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;\n        else\n            maxValue = 2n ** (BigInt(size) * 8n) - 1n;\n    }\n    else if (typeof value === 'number') {\n        maxValue = BigInt(Number.MAX_SAFE_INTEGER);\n    }\n    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;\n    if ((maxValue && value_ > maxValue) || value_ < minValue) {\n        const suffix = typeof value === 'bigint' ? 'n' : '';\n        throw new IntegerOutOfRangeError({\n            max: maxValue ? `${maxValue}${suffix}` : undefined,\n            min: `${minValue}${suffix}`,\n            signed,\n            size,\n            value: `${value}${suffix}`,\n        });\n    }\n    const stringValue = (signed && value_ < 0 ? (1n << BigInt(size * 8)) + BigInt(value_) : value_).toString(16);\n    const hex = `0x${stringValue}`;\n    if (size)\n        return padLeft(hex, size);\n    return hex;\n}\n/**\n * Encodes a string into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n * Hex.fromString('Hello World!')\n * // '0x48656c6c6f20576f726c6421'\n *\n * Hex.fromString('Hello World!', { size: 32 })\n * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'\n * ```\n *\n * @param value - The string value to encode.\n * @param options - Options.\n * @returns The encoded {@link ox#Hex.Hex} value.\n */\nexport function fromString(value, options = {}) {\n    return fromBytes(encoder.encode(value), options);\n}\n/**\n * Checks if two {@link ox#Hex.Hex} values are equal.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.isEqual('0xdeadbeef', '0xdeadbeef')\n * // @log: true\n *\n * Hex.isEqual('0xda', '0xba')\n * // @log: false\n * ```\n *\n * @param hexA - The first {@link ox#Hex.Hex} value.\n * @param hexB - The second {@link ox#Hex.Hex} value.\n * @returns `true` if the two {@link ox#Hex.Hex} values are equal, `false` otherwise.\n */\nexport function isEqual(hexA, hexB) {\n    return equalBytes(Bytes.fromHex(hexA), Bytes.fromHex(hexB));\n}\n/**\n * Pads a {@link ox#Hex.Hex} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.padLeft('0x1234', 4)\n * // @log: '0x00001234'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to pad.\n * @param size - The size (in bytes) of the output hex value.\n * @returns The padded {@link ox#Hex.Hex} value.\n */\nexport function padLeft(value, size) {\n    return internal.pad(value, { dir: 'left', size });\n}\n/**\n * Pads a {@link ox#Hex.Hex} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts\n * import { Hex } from 'ox'\n *\n * Hex.padRight('0x1234', 4)\n * // @log: '0x12340000'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to pad.\n * @param size - The size (in bytes) of the output hex value.\n * @returns The padded {@link ox#Hex.Hex} value.\n */\nexport function padRight(value, size) {\n    return internal.pad(value, { dir: 'right', size });\n}\n/**\n * Generates a random {@link ox#Hex.Hex} value of the specified length.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * const hex = Hex.random(32)\n * // @log: '0x...'\n * ```\n *\n * @returns Random {@link ox#Hex.Hex} value.\n */\nexport function random(length) {\n    return fromBytes(Bytes.random(length));\n}\n/**\n * Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.slice('0x0123456789', 1, 4)\n * // @log: '0x234567'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to slice.\n * @param start - The start offset (in bytes).\n * @param end - The end offset (in bytes).\n * @param options - Options.\n * @returns The sliced {@link ox#Hex.Hex} value.\n */\nexport function slice(value, start, end, options = {}) {\n    const { strict } = options;\n    internal.assertStartOffset(value, start);\n    const value_ = `0x${value\n        .replace('0x', '')\n        .slice((start ?? 0) * 2, (end ?? value.length) * 2)}`;\n    if (strict)\n        internal.assertEndOffset(value_, start, end);\n    return value_;\n}\n/**\n * Retrieves the size of a {@link ox#Hex.Hex} value (in bytes).\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.size('0xdeadbeef')\n * // @log: 4\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to get the size of.\n * @returns The size of the {@link ox#Hex.Hex} value (in bytes).\n */\nexport function size(value) {\n    return Math.ceil((value.length - 2) / 2);\n}\n/**\n * Trims leading zeros from a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.trimLeft('0x00000000deadbeef')\n * // @log: '0xdeadbeef'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to trim.\n * @returns The trimmed {@link ox#Hex.Hex} value.\n */\nexport function trimLeft(value) {\n    return internal.trim(value, { dir: 'left' });\n}\n/**\n * Trims trailing zeros from a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.trimRight('0xdeadbeef00000000')\n * // @log: '0xdeadbeef'\n * ```\n *\n * @param value - The {@link ox#Hex.Hex} value to trim.\n * @returns The trimmed {@link ox#Hex.Hex} value.\n */\nexport function trimRight(value) {\n    return internal.trim(value, { dir: 'right' });\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a BigInt.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBigInt('0x1a4')\n * // @log: 420n\n *\n * Hex.toBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // @log: 420n\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded BigInt.\n */\nexport function toBigInt(hex, options = {}) {\n    const { signed } = options;\n    if (options.size)\n        internal.assertSize(hex, options.size);\n    const value = BigInt(hex);\n    if (!signed)\n        return value;\n    const size = (hex.length - 2) / 2;\n    const max_unsigned = (1n << (BigInt(size) * 8n)) - 1n;\n    const max_signed = max_unsigned >> 1n;\n    if (value <= max_signed)\n        return value;\n    return value - max_unsigned - 1n;\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a boolean.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBoolean('0x01')\n * // @log: true\n *\n * Hex.toBoolean('0x0000000000000000000000000000000000000000000000000000000000000001', { size: 32 })\n * // @log: true\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded boolean.\n */\nexport function toBoolean(hex, options = {}) {\n    if (options.size)\n        internal.assertSize(hex, options.size);\n    const hex_ = trimLeft(hex);\n    if (hex_ === '0x')\n        return false;\n    if (hex_ === '0x1')\n        return true;\n    throw new InvalidHexBooleanError(hex);\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * const data = Hex.toBytes('0x48656c6c6f20776f726c6421')\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded {@link ox#Bytes.Bytes}.\n */\nexport function toBytes(hex, options = {}) {\n    return Bytes.fromHex(hex, options);\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a number.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toNumber('0x1a4')\n * // @log: 420\n *\n * Hex.toNumber('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })\n * // @log: 420\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded number.\n */\nexport function toNumber(hex, options = {}) {\n    const { signed, size } = options;\n    if (!signed && !size)\n        return Number(hex);\n    return Number(toBigInt(hex, options));\n}\n/**\n * Decodes a {@link ox#Hex.Hex} value into a string.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toString('0x48656c6c6f20576f726c6421')\n * // @log: 'Hello world!'\n *\n * Hex.toString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {\n *  size: 32,\n * })\n * // @log: 'Hello world'\n * ```\n *\n * @param hex - The {@link ox#Hex.Hex} value to decode.\n * @param options - Options.\n * @returns The decoded string.\n */\nexport function toString(hex, options = {}) {\n    const { size } = options;\n    let bytes = Bytes.fromHex(hex);\n    if (size) {\n        internal_bytes.assertSize(bytes, size);\n        bytes = Bytes.trimRight(bytes);\n    }\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Checks if the given value is {@link ox#Hex.Hex}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes, Hex } from 'ox'\n *\n * Hex.validate('0xdeadbeef')\n * // @log: true\n *\n * Hex.validate(Bytes.from([1, 2, 3]))\n * // @log: false\n * ```\n *\n * @param value - The value to check.\n * @param options - Options.\n * @returns `true` if the value is a {@link ox#Hex.Hex}, `false` otherwise.\n */\nexport function validate(value, options = {}) {\n    const { strict = false } = options;\n    try {\n        assert(value, { strict });\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Thrown when the provided integer is out of range, and cannot be represented as a hex value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromNumber(420182738912731283712937129)\n * // @error: Hex.IntegerOutOfRangeError: Number \\`4.2018273891273126e+26\\` is not in safe unsigned integer range (`0` to `9007199254740991`)\n * ```\n */\nexport class IntegerOutOfRangeError extends Errors.BaseError {\n    constructor({ max, min, signed, size, value, }) {\n        super(`Number \\`${value}\\` is not in safe${size ? ` ${size * 8}-bit` : ''}${signed ? ' signed' : ' unsigned'} integer range ${max ? `(\\`${min}\\` to \\`${max}\\`)` : `(above \\`${min}\\`)`}`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.IntegerOutOfRangeError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value cannot be represented as a boolean.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.toBoolean('0xa')\n * // @error: Hex.InvalidHexBooleanError: Hex value `\"0xa\"` is not a valid boolean.\n * // @error: The hex value must be `\"0x0\"` (false) or `\"0x1\"` (true).\n * ```\n */\nexport class InvalidHexBooleanError extends Errors.BaseError {\n    constructor(hex) {\n        super(`Hex value \\`\"${hex}\"\\` is not a valid boolean.`, {\n            metaMessages: [\n                'The hex value must be `\"0x0\"` (false) or `\"0x1\"` (true).',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexBooleanError'\n        });\n    }\n}\n/**\n * Thrown when the provided value is not a valid hex type.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert(1)\n * // @error: Hex.InvalidHexTypeError: Value `1` of type `number` is an invalid hex type.\n * ```\n */\nexport class InvalidHexTypeError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${typeof value === 'object' ? Json.stringify(value) : value}\\` of type \\`${typeof value}\\` is an invalid hex type.`, {\n            metaMessages: ['Hex types must be represented as `\"0x${string}\"`.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexTypeError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.assert('0x0123456789abcdefg')\n * // @error: Hex.InvalidHexValueError: Value `0x0123456789abcdefg` is an invalid hex value.\n * // @error: Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F).\n * ```\n */\nexport class InvalidHexValueError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${value}\\` is an invalid hex value.`, {\n            metaMessages: [\n                'Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F).',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidHexValueError'\n        });\n    }\n}\n/**\n * Thrown when the provided hex value is an odd length.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.fromHex('0xabcde')\n * // @error: Hex.InvalidLengthError: Hex value `\"0xabcde\"` is an odd length (5 nibbles).\n * ```\n */\nexport class InvalidLengthError extends Errors.BaseError {\n    constructor(value) {\n        super(`Hex value \\`\"${value}\"\\` is an odd length (${value.length - 2} nibbles).`, {\n            metaMessages: ['It must be an even length.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.InvalidLengthError'\n        });\n    }\n}\n/**\n * Thrown when the size of the value exceeds the expected max size.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.fromString('Hello World!', { size: 8 })\n * // @error: Hex.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.\n * ```\n */\nexport class SizeOverflowError extends Errors.BaseError {\n    constructor({ givenSize, maxSize }) {\n        super(`Size cannot exceed \\`${maxSize}\\` bytes. Given size: \\`${givenSize}\\` bytes.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SizeOverflowError'\n        });\n    }\n}\n/**\n * Thrown when the slice offset exceeds the bounds of the value.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.slice('0x0123456789', 6)\n * // @error: Hex.SliceOffsetOutOfBoundsError: Slice starting at offset `6` is out-of-bounds (size: `5`).\n * ```\n */\nexport class SliceOffsetOutOfBoundsError extends Errors.BaseError {\n    constructor({ offset, position, size, }) {\n        super(`Slice ${position === 'start' ? 'starting' : 'ending'} at offset \\`${offset}\\` is out-of-bounds (size: \\`${size}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SliceOffsetOutOfBoundsError'\n        });\n    }\n}\n/**\n * Thrown when the size of the value exceeds the pad size.\n *\n * @example\n * ```ts twoslash\n * import { Hex } from 'ox'\n *\n * Hex.padLeft('0x1a4e12a45a21323123aaa87a897a897a898a6567a578a867a98778a667a85a875a87a6a787a65a675a6a9', 32)\n * // @error: Hex.SizeExceedsPaddingSizeError: Hex size (`43`) exceeds padding size (`32`).\n * ```\n */\nexport class SizeExceedsPaddingSizeError extends Errors.BaseError {\n    constructor({ size, targetSize, type, }) {\n        super(`${type.charAt(0).toUpperCase()}${type\n            .slice(1)\n            .toLowerCase()} size (\\`${size}\\`) exceeds padding size (\\`${targetSize}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Hex.SizeExceedsPaddingSizeError'\n        });\n    }\n}\n//# sourceMappingURL=Hex.js.map","import * as Hex from './Hex.js';\n/**\n * Converts a {@link ox#Withdrawal.Rpc} to an {@link ox#Withdrawal.Withdrawal}.\n *\n * @example\n * ```ts twoslash\n * import { Withdrawal } from 'ox'\n *\n * const withdrawal = Withdrawal.fromRpc({\n *   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n *   amount: '0x620323',\n *   index: '0x0',\n *   validatorIndex: '0x1',\n * })\n * // @log: {\n * // @log:   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n * // @log:   amount: 6423331n,\n * // @log:   index: 0,\n * // @log:   validatorIndex: 1\n * // @log: }\n * ```\n *\n * @param withdrawal - The RPC withdrawal to convert.\n * @returns An instantiated {@link ox#Withdrawal.Withdrawal}.\n */\nexport function fromRpc(withdrawal) {\n    return {\n        ...withdrawal,\n        amount: BigInt(withdrawal.amount),\n        index: Number(withdrawal.index),\n        validatorIndex: Number(withdrawal.validatorIndex),\n    };\n}\n/**\n * Converts a {@link ox#Withdrawal.Withdrawal} to an {@link ox#Withdrawal.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { Withdrawal } from 'ox'\n *\n * const withdrawal = Withdrawal.toRpc({\n *   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n *   amount: 6423331n,\n *   index: 0,\n *   validatorIndex: 1,\n * })\n * // @log: {\n * // @log:   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',\n * // @log:   amount: '0x620323',\n * // @log:   index: '0x0',\n * // @log:   validatorIndex: '0x1',\n * // @log: }\n * ```\n *\n * @param withdrawal - The Withdrawal to convert.\n * @returns An RPC Withdrawal.\n */\nexport function toRpc(withdrawal) {\n    return {\n        address: withdrawal.address,\n        amount: Hex.fromNumber(withdrawal.amount),\n        index: Hex.fromNumber(withdrawal.index),\n        validatorIndex: Hex.fromNumber(withdrawal.validatorIndex),\n    };\n}\n//# sourceMappingURL=Withdrawal.js.map","import * as Hex from './Hex.js';\nimport * as Withdrawal from './Withdrawal.js';\n/**\n * Converts an {@link ox#BlockOverrides.Rpc} to an {@link ox#BlockOverrides.BlockOverrides}.\n *\n * @example\n * ```ts twoslash\n * import { BlockOverrides } from 'ox'\n *\n * const blockOverrides = BlockOverrides.fromRpc({\n *   baseFeePerGas: '0x1',\n *   blobBaseFee: '0x2',\n *   feeRecipient: '0x0000000000000000000000000000000000000000',\n *   gasLimit: '0x4',\n *   number: '0x5',\n *   prevRandao: '0x6',\n *   time: '0x1234567890',\n *   withdrawals: [\n *     {\n *       address: '0x0000000000000000000000000000000000000000',\n *       amount: '0x1',\n *       index: '0x0',\n *       validatorIndex: '0x1',\n *     },\n *   ],\n * })\n * ```\n *\n * @param rpcBlockOverrides - The RPC block overrides to convert.\n * @returns An instantiated {@link ox#BlockOverrides.BlockOverrides}.\n */\nexport function fromRpc(rpcBlockOverrides) {\n    return {\n        ...(rpcBlockOverrides.baseFeePerGas && {\n            baseFeePerGas: BigInt(rpcBlockOverrides.baseFeePerGas),\n        }),\n        ...(rpcBlockOverrides.blobBaseFee && {\n            blobBaseFee: BigInt(rpcBlockOverrides.blobBaseFee),\n        }),\n        ...(rpcBlockOverrides.feeRecipient && {\n            feeRecipient: rpcBlockOverrides.feeRecipient,\n        }),\n        ...(rpcBlockOverrides.gasLimit && {\n            gasLimit: BigInt(rpcBlockOverrides.gasLimit),\n        }),\n        ...(rpcBlockOverrides.number && {\n            number: BigInt(rpcBlockOverrides.number),\n        }),\n        ...(rpcBlockOverrides.prevRandao && {\n            prevRandao: BigInt(rpcBlockOverrides.prevRandao),\n        }),\n        ...(rpcBlockOverrides.time && {\n            time: BigInt(rpcBlockOverrides.time),\n        }),\n        ...(rpcBlockOverrides.withdrawals && {\n            withdrawals: rpcBlockOverrides.withdrawals.map(Withdrawal.fromRpc),\n        }),\n    };\n}\n/**\n * Converts an {@link ox#BlockOverrides.BlockOverrides} to an {@link ox#BlockOverrides.Rpc}.\n *\n * @example\n * ```ts twoslash\n * import { BlockOverrides } from 'ox'\n *\n * const blockOverrides = BlockOverrides.toRpc({\n *   baseFeePerGas: 1n,\n *   blobBaseFee: 2n,\n *   feeRecipient: '0x0000000000000000000000000000000000000000',\n *   gasLimit: 4n,\n *   number: 5n,\n *   prevRandao: 6n,\n *   time: 78187493520n,\n *   withdrawals: [\n *     {\n *       address: '0x0000000000000000000000000000000000000000',\n *       amount: 1n,\n *       index: 0,\n *       validatorIndex: 1,\n *     },\n *   ],\n * })\n * ```\n *\n * @param blockOverrides - The block overrides to convert.\n * @returns An instantiated {@link ox#BlockOverrides.Rpc}.\n */\nexport function toRpc(blockOverrides) {\n    return {\n        ...(typeof blockOverrides.baseFeePerGas === 'bigint' && {\n            baseFeePerGas: Hex.fromNumber(blockOverrides.baseFeePerGas),\n        }),\n        ...(typeof blockOverrides.blobBaseFee === 'bigint' && {\n            blobBaseFee: Hex.fromNumber(blockOverrides.blobBaseFee),\n        }),\n        ...(typeof blockOverrides.feeRecipient === 'string' && {\n            feeRecipient: blockOverrides.feeRecipient,\n        }),\n        ...(typeof blockOverrides.gasLimit === 'bigint' && {\n            gasLimit: Hex.fromNumber(blockOverrides.gasLimit),\n        }),\n        ...(typeof blockOverrides.number === 'bigint' && {\n            number: Hex.fromNumber(blockOverrides.number),\n        }),\n        ...(typeof blockOverrides.prevRandao === 'bigint' && {\n            prevRandao: Hex.fromNumber(blockOverrides.prevRandao),\n        }),\n        ...(typeof blockOverrides.time === 'bigint' && {\n            time: Hex.fromNumber(blockOverrides.time),\n        }),\n        ...(blockOverrides.withdrawals && {\n            withdrawals: blockOverrides.withdrawals.map(Withdrawal.toRpc),\n        }),\n    };\n}\n//# sourceMappingURL=BlockOverrides.js.map",null,"import { InvalidAbiItemError } from './errors/abiItem.js';\nimport { isStructSignature } from './runtime/signatures.js';\nimport { parseStructs } from './runtime/structs.js';\nimport { parseSignature } from './runtime/utils.js';\n/**\n * Parses human-readable ABI item (e.g. error, event, function) into {@link Abi} item\n *\n * @param signature - Human-readable ABI item\n * @returns Parsed {@link Abi} item\n *\n * @example\n * const abiItem = parseAbiItem('function balanceOf(address owner) view returns (uint256)')\n * //    ^? const abiItem: { name: \"balanceOf\"; type: \"function\"; stateMutability: \"view\";...\n *\n * @example\n * const abiItem = parseAbiItem([\n *   //  ^? const abiItem: { name: \"foo\"; type: \"function\"; stateMutability: \"view\"; inputs:...\n *   'function foo(Baz bar) view returns (string)',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiItem(signature) {\n    let abiItem;\n    if (typeof signature === 'string')\n        abiItem = parseSignature(signature);\n    else {\n        const structs = parseStructs(signature);\n        const length = signature.length;\n        for (let i = 0; i < length; i++) {\n            const signature_ = signature[i];\n            if (isStructSignature(signature_))\n                continue;\n            abiItem = parseSignature(signature_, structs);\n            break;\n        }\n    }\n    if (!abiItem)\n        throw new InvalidAbiItemError({ signature });\n    return abiItem;\n}\n//# sourceMappingURL=parseAbiItem.js.map","import * as Bytes from '../Bytes.js';\n/** @internal */\nexport function assertSize(bytes, size_) {\n    if (Bytes.size(bytes) > size_)\n        throw new Bytes.SizeOverflowError({\n            givenSize: Bytes.size(bytes),\n            maxSize: size_,\n        });\n}\n/** @internal */\nexport function assertStartOffset(value, start) {\n    if (typeof start === 'number' && start > 0 && start > Bytes.size(value) - 1)\n        throw new Bytes.SliceOffsetOutOfBoundsError({\n            offset: start,\n            position: 'start',\n            size: Bytes.size(value),\n        });\n}\n/** @internal */\nexport function assertEndOffset(value, start, end) {\n    if (typeof start === 'number' &&\n        typeof end === 'number' &&\n        Bytes.size(value) !== end - start) {\n        throw new Bytes.SliceOffsetOutOfBoundsError({\n            offset: end,\n            position: 'end',\n            size: Bytes.size(value),\n        });\n    }\n}\n/** @internal */\nexport const charCodeMap = {\n    zero: 48,\n    nine: 57,\n    A: 65,\n    F: 70,\n    a: 97,\n    f: 102,\n};\n/** @internal */\nexport function charCodeToBase16(char) {\n    if (char >= charCodeMap.zero && char <= charCodeMap.nine)\n        return char - charCodeMap.zero;\n    if (char >= charCodeMap.A && char <= charCodeMap.F)\n        return char - (charCodeMap.A - 10);\n    if (char >= charCodeMap.a && char <= charCodeMap.f)\n        return char - (charCodeMap.a - 10);\n    return undefined;\n}\n/** @internal */\nexport function pad(bytes, options = {}) {\n    const { dir, size = 32 } = options;\n    if (size === 0)\n        return bytes;\n    if (bytes.length > size)\n        throw new Bytes.SizeExceedsPaddingSizeError({\n            size: bytes.length,\n            targetSize: size,\n            type: 'Bytes',\n        });\n    const paddedBytes = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n        const padEnd = dir === 'right';\n        paddedBytes[padEnd ? i : size - i - 1] =\n            bytes[padEnd ? i : bytes.length - i - 1];\n    }\n    return paddedBytes;\n}\n/** @internal */\nexport function trim(value, options = {}) {\n    const { dir = 'left' } = options;\n    let data = value;\n    let sliceLength = 0;\n    for (let i = 0; i < data.length - 1; i++) {\n        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')\n            sliceLength++;\n        else\n            break;\n    }\n    data =\n        dir === 'left'\n            ? data.slice(sliceLength)\n            : data.slice(0, data.length - sliceLength);\n    return data;\n}\n//# sourceMappingURL=bytes.js.map","import { equalBytes } from '@noble/curves/abstract/utils';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Json from './Json.js';\nimport * as internal from './internal/bytes.js';\nimport * as internal_hex from './internal/hex.js';\nconst decoder = /*#__PURE__*/ new TextDecoder();\nconst encoder = /*#__PURE__*/ new TextEncoder();\n/**\n * Asserts if the given value is {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.assert('abc')\n * // @error: Bytes.InvalidBytesTypeError:\n * // @error: Value `\"abc\"` of type `string` is an invalid Bytes value.\n * // @error: Bytes values must be of type `Uint8Array`.\n * ```\n *\n * @param value - Value to assert.\n */\nexport function assert(value) {\n    if (value instanceof Uint8Array)\n        return;\n    if (!value)\n        throw new InvalidBytesTypeError(value);\n    if (typeof value !== 'object')\n        throw new InvalidBytesTypeError(value);\n    if (!('BYTES_PER_ELEMENT' in value))\n        throw new InvalidBytesTypeError(value);\n    if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== 'Uint8Array')\n        throw new InvalidBytesTypeError(value);\n}\n/**\n * Concatenates two or more {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const bytes = Bytes.concat(\n *   Bytes.from([1]),\n *   Bytes.from([69]),\n *   Bytes.from([420, 69]),\n * )\n * // @log: Uint8Array [ 1, 69, 420, 69 ]\n * ```\n *\n * @param values - Values to concatenate.\n * @returns Concatenated {@link ox#Bytes.Bytes}.\n */\nexport function concat(...values) {\n    let length = 0;\n    for (const arr of values) {\n        length += arr.length;\n    }\n    const result = new Uint8Array(length);\n    for (let i = 0, index = 0; i < values.length; i++) {\n        const arr = values[i];\n        result.set(arr, index);\n        index += arr.length;\n    }\n    return result;\n}\n/**\n * Instantiates a {@link ox#Bytes.Bytes} value from a `Uint8Array`, a hex string, or an array of unsigned 8-bit integers.\n *\n * :::tip\n *\n * To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:\n *\n * - `Bytes.fromBoolean`\n *\n * - `Bytes.fromString`\n *\n * - `Bytes.fromNumber`\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.from([255, 124, 5, 4])\n * // @log: Uint8Array([255, 124, 5, 4])\n *\n * const data = Bytes.from('0xdeadbeef')\n * // @log: Uint8Array([222, 173, 190, 239])\n * ```\n *\n * @param value - Value to convert.\n * @returns A {@link ox#Bytes.Bytes} instance.\n */\nexport function from(value) {\n    if (value instanceof Uint8Array)\n        return value;\n    if (typeof value === 'string')\n        return fromHex(value);\n    return fromArray(value);\n}\n/**\n * Converts an array of unsigned 8-bit integers into {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromArray([255, 124, 5, 4])\n * // @log: Uint8Array([255, 124, 5, 4])\n * ```\n *\n * @param value - Value to convert.\n * @returns A {@link ox#Bytes.Bytes} instance.\n */\nexport function fromArray(value) {\n    return value instanceof Uint8Array ? value : new Uint8Array(value);\n}\n/**\n * Encodes a boolean value into {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromBoolean(true)\n * // @log: Uint8Array([1])\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromBoolean(true, { size: 32 })\n * // @log: Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])\n * ```\n *\n * @param value - Boolean value to encode.\n * @param options - Encoding options.\n * @returns Encoded {@link ox#Bytes.Bytes}.\n */\nexport function fromBoolean(value, options = {}) {\n    const { size } = options;\n    const bytes = new Uint8Array(1);\n    bytes[0] = Number(value);\n    if (typeof size === 'number') {\n        internal.assertSize(bytes, size);\n        return padLeft(bytes, size);\n    }\n    return bytes;\n}\n/**\n * Encodes a {@link ox#Hex.Hex} value into {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromHex('0x48656c6c6f20776f726c6421')\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromHex('0x48656c6c6f20776f726c6421', { size: 32 })\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n * ```\n *\n * @param value - {@link ox#Hex.Hex} value to encode.\n * @param options - Encoding options.\n * @returns Encoded {@link ox#Bytes.Bytes}.\n */\nexport function fromHex(value, options = {}) {\n    const { size } = options;\n    let hex = value;\n    if (size) {\n        internal_hex.assertSize(value, size);\n        hex = Hex.padRight(value, size);\n    }\n    let hexString = hex.slice(2);\n    if (hexString.length % 2)\n        hexString = `0${hexString}`;\n    const length = hexString.length / 2;\n    const bytes = new Uint8Array(length);\n    for (let index = 0, j = 0; index < length; index++) {\n        const nibbleLeft = internal.charCodeToBase16(hexString.charCodeAt(j++));\n        const nibbleRight = internal.charCodeToBase16(hexString.charCodeAt(j++));\n        if (nibbleLeft === undefined || nibbleRight === undefined) {\n            throw new Errors.BaseError(`Invalid byte sequence (\"${hexString[j - 2]}${hexString[j - 1]}\" in \"${hexString}\").`);\n        }\n        bytes[index] = nibbleLeft * 16 + nibbleRight;\n    }\n    return bytes;\n}\n/**\n * Encodes a number value into {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromNumber(420)\n * // @log: Uint8Array([1, 164])\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromNumber(420, { size: 4 })\n * // @log: Uint8Array([0, 0, 1, 164])\n * ```\n *\n * @param value - Number value to encode.\n * @param options - Encoding options.\n * @returns Encoded {@link ox#Bytes.Bytes}.\n */\nexport function fromNumber(value, options) {\n    const hex = Hex.fromNumber(value, options);\n    return fromHex(hex);\n}\n/**\n * Encodes a string into {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromString('Hello world!')\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.fromString('Hello world!', { size: 32 })\n * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n * ```\n *\n * @param value - String to encode.\n * @param options - Encoding options.\n * @returns Encoded {@link ox#Bytes.Bytes}.\n */\nexport function fromString(value, options = {}) {\n    const { size } = options;\n    const bytes = encoder.encode(value);\n    if (typeof size === 'number') {\n        internal.assertSize(bytes, size);\n        return padRight(bytes, size);\n    }\n    return bytes;\n}\n/**\n * Checks if two {@link ox#Bytes.Bytes} values are equal.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.isEqual(Bytes.from([1]), Bytes.from([1]))\n * // @log: true\n *\n * Bytes.isEqual(Bytes.from([1]), Bytes.from([2]))\n * // @log: false\n * ```\n *\n * @param bytesA - First {@link ox#Bytes.Bytes} value.\n * @param bytesB - Second {@link ox#Bytes.Bytes} value.\n * @returns `true` if the two values are equal, otherwise `false`.\n */\nexport function isEqual(bytesA, bytesB) {\n    return equalBytes(bytesA, bytesB);\n}\n/**\n * Pads a {@link ox#Bytes.Bytes} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.padLeft(Bytes.from([1]), 4)\n * // @log: Uint8Array([0, 0, 0, 1])\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} value to pad.\n * @param size - Size to pad the {@link ox#Bytes.Bytes} value to.\n * @returns Padded {@link ox#Bytes.Bytes} value.\n */\nexport function padLeft(value, size) {\n    return internal.pad(value, { dir: 'left', size });\n}\n/**\n * Pads a {@link ox#Bytes.Bytes} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.padRight(Bytes.from([1]), 4)\n * // @log: Uint8Array([1, 0, 0, 0])\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} value to pad.\n * @param size - Size to pad the {@link ox#Bytes.Bytes} value to.\n * @returns Padded {@link ox#Bytes.Bytes} value.\n */\nexport function padRight(value, size) {\n    return internal.pad(value, { dir: 'right', size });\n}\n/**\n * Generates random {@link ox#Bytes.Bytes} of the specified length.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const bytes = Bytes.random(32)\n * // @log: Uint8Array([... x32])\n * ```\n *\n * @param length - Length of the random {@link ox#Bytes.Bytes} to generate.\n * @returns Random {@link ox#Bytes.Bytes} of the specified length.\n */\nexport function random(length) {\n    return crypto.getRandomValues(new Uint8Array(length));\n}\n/**\n * Retrieves the size of a {@link ox#Bytes.Bytes} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.size(Bytes.from([1, 2, 3, 4]))\n * // @log: 4\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} value.\n * @returns Size of the {@link ox#Bytes.Bytes} value.\n */\nexport function size(value) {\n    return value.length;\n}\n/**\n * Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.slice(\n *   Bytes.from([1, 2, 3, 4, 5, 6, 7, 8, 9]),\n *   1,\n *   4,\n * )\n * // @log: Uint8Array([2, 3, 4])\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} value.\n * @param start - Start offset.\n * @param end - End offset.\n * @param options - Slice options.\n * @returns Sliced {@link ox#Bytes.Bytes} value.\n */\nexport function slice(value, start, end, options = {}) {\n    const { strict } = options;\n    internal.assertStartOffset(value, start);\n    const value_ = value.slice(start, end);\n    if (strict)\n        internal.assertEndOffset(value_, start, end);\n    return value_;\n}\n/**\n * Decodes a {@link ox#Bytes.Bytes} into a bigint.\n *\n * @example\n * ```ts\n * import { Bytes } from 'ox'\n *\n * Bytes.toBigInt(Bytes.from([1, 164]))\n * // @log: 420n\n * ```\n *\n * @param bytes - The {@link ox#Bytes.Bytes} to decode.\n * @param options - Decoding options.\n * @returns Decoded bigint.\n */\nexport function toBigInt(bytes, options = {}) {\n    const { size } = options;\n    if (typeof size !== 'undefined')\n        internal.assertSize(bytes, size);\n    const hex = Hex.fromBytes(bytes, options);\n    return Hex.toBigInt(hex, options);\n}\n/**\n * Decodes a {@link ox#Bytes.Bytes} into a boolean.\n *\n * @example\n * ```ts\n * import { Bytes } from 'ox'\n *\n * Bytes.toBoolean(Bytes.from([1]))\n * // @log: true\n * ```\n *\n * @param bytes - The {@link ox#Bytes.Bytes} to decode.\n * @param options - Decoding options.\n * @returns Decoded boolean.\n */\nexport function toBoolean(bytes, options = {}) {\n    const { size } = options;\n    let bytes_ = bytes;\n    if (typeof size !== 'undefined') {\n        internal.assertSize(bytes_, size);\n        bytes_ = trimLeft(bytes_);\n    }\n    if (bytes_.length > 1 || bytes_[0] > 1)\n        throw new InvalidBytesBooleanError(bytes_);\n    return Boolean(bytes_[0]);\n}\n/**\n * Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.toHex(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // '0x48656c6c6f20576f726c6421'\n * ```\n *\n * @param value - The {@link ox#Bytes.Bytes} to decode.\n * @param options - Options.\n * @returns Decoded {@link ox#Hex.Hex} value.\n */\nexport function toHex(value, options = {}) {\n    return Hex.fromBytes(value, options);\n}\n/**\n * Decodes a {@link ox#Bytes.Bytes} into a number.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.toNumber(Bytes.from([1, 164]))\n * // @log: 420\n * ```\n */\nexport function toNumber(bytes, options = {}) {\n    const { size } = options;\n    if (typeof size !== 'undefined')\n        internal.assertSize(bytes, size);\n    const hex = Hex.fromBytes(bytes, options);\n    return Hex.toNumber(hex, options);\n}\n/**\n * Decodes a {@link ox#Bytes.Bytes} into a string.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * const data = Bytes.toString(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))\n * // @log: 'Hello world'\n * ```\n *\n * @param bytes - The {@link ox#Bytes.Bytes} to decode.\n * @param options - Options.\n * @returns Decoded string.\n */\nexport function toString(bytes, options = {}) {\n    const { size } = options;\n    let bytes_ = bytes;\n    if (typeof size !== 'undefined') {\n        internal.assertSize(bytes_, size);\n        bytes_ = trimRight(bytes_);\n    }\n    return decoder.decode(bytes_);\n}\n/**\n * Trims leading zeros from a {@link ox#Bytes.Bytes} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.trimLeft(Bytes.from([0, 0, 0, 0, 1, 2, 3]))\n * // @log: Uint8Array([1, 2, 3])\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} value.\n * @returns Trimmed {@link ox#Bytes.Bytes} value.\n */\nexport function trimLeft(value) {\n    return internal.trim(value, { dir: 'left' });\n}\n/**\n * Trims trailing zeros from a {@link ox#Bytes.Bytes} value.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.trimRight(Bytes.from([1, 2, 3, 0, 0, 0, 0]))\n * // @log: Uint8Array([1, 2, 3])\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} value.\n * @returns Trimmed {@link ox#Bytes.Bytes} value.\n */\nexport function trimRight(value) {\n    return internal.trim(value, { dir: 'right' });\n}\n/**\n * Checks if the given value is {@link ox#Bytes.Bytes}.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.validate('0x')\n * // @log: false\n *\n * Bytes.validate(Bytes.from([1, 2, 3]))\n * // @log: true\n * ```\n *\n * @param value - Value to check.\n * @returns `true` if the value is {@link ox#Bytes.Bytes}, otherwise `false`.\n */\nexport function validate(value) {\n    try {\n        assert(value);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Thrown when the bytes value cannot be represented as a boolean.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.toBoolean(Bytes.from([5]))\n * // @error: Bytes.InvalidBytesBooleanError: Bytes value `[5]` is not a valid boolean.\n * // @error: The bytes array must contain a single byte of either a `0` or `1` value.\n * ```\n */\nexport class InvalidBytesBooleanError extends Errors.BaseError {\n    constructor(bytes) {\n        super(`Bytes value \\`${bytes}\\` is not a valid boolean.`, {\n            metaMessages: [\n                'The bytes array must contain a single byte of either a `0` or `1` value.',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Bytes.InvalidBytesBooleanError'\n        });\n    }\n}\n/**\n * Thrown when a value cannot be converted to bytes.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Bytes } from 'ox'\n *\n * Bytes.from('foo')\n * // @error: Bytes.InvalidBytesTypeError: Value `foo` of type `string` is an invalid Bytes value.\n * ```\n */\nexport class InvalidBytesTypeError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${typeof value === 'object' ? Json.stringify(value) : value}\\` of type \\`${typeof value}\\` is an invalid Bytes value.`, {\n            metaMessages: ['Bytes values must be of type `Bytes`.'],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Bytes.InvalidBytesTypeError'\n        });\n    }\n}\n/**\n * Thrown when a size exceeds the maximum allowed size.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.fromString('Hello World!', { size: 8 })\n * // @error: Bytes.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.\n * ```\n */\nexport class SizeOverflowError extends Errors.BaseError {\n    constructor({ givenSize, maxSize }) {\n        super(`Size cannot exceed \\`${maxSize}\\` bytes. Given size: \\`${givenSize}\\` bytes.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Bytes.SizeOverflowError'\n        });\n    }\n}\n/**\n * Thrown when a slice offset is out-of-bounds.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.slice(Bytes.from([1, 2, 3]), 4)\n * // @error: Bytes.SliceOffsetOutOfBoundsError: Slice starting at offset `4` is out-of-bounds (size: `3`).\n * ```\n */\nexport class SliceOffsetOutOfBoundsError extends Errors.BaseError {\n    constructor({ offset, position, size, }) {\n        super(`Slice ${position === 'start' ? 'starting' : 'ending'} at offset \\`${offset}\\` is out-of-bounds (size: \\`${size}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Bytes.SliceOffsetOutOfBoundsError'\n        });\n    }\n}\n/**\n * Thrown when a the padding size exceeds the maximum allowed size.\n *\n * @example\n * ```ts twoslash\n * import { Bytes } from 'ox'\n *\n * Bytes.padLeft(Bytes.fromString('Hello World!'), 8)\n * // @error: [Bytes.SizeExceedsPaddingSizeError: Bytes size (`12`) exceeds padding size (`8`).\n * ```\n */\nexport class SizeExceedsPaddingSizeError extends Errors.BaseError {\n    constructor({ size, targetSize, type, }) {\n        super(`${type.charAt(0).toUpperCase()}${type\n            .slice(1)\n            .toLowerCase()} size (\\`${size}\\`) exceeds padding size (\\`${targetSize}\\`).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Bytes.SizeExceedsPaddingSizeError'\n        });\n    }\n}\n//# sourceMappingURL=Bytes.js.map","import { ripemd160 as noble_ripemd160 } from '@noble/hashes/ripemd160';\nimport { keccak_256 as noble_keccak256 } from '@noble/hashes/sha3';\nimport { sha256 as noble_sha256 } from '@noble/hashes/sha256';\nimport * as Bytes from './Bytes.js';\nimport * as Hex from './Hex.js';\n/**\n * Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.keccak256('0xdeadbeef')\n * // @log: '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'\n * ```\n *\n * @example\n * ### Calculate Hash of a String\n *\n * ```ts twoslash\n * import { Hash, Hex } from 'ox'\n *\n * Hash.keccak256(Hex.fromString('hello world'))\n * // @log: '0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0'\n * ```\n *\n * @example\n * ### Configure Return Type\n *\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.keccak256('0xdeadbeef', { as: 'Bytes' })\n * // @log: Uint8Array [...]\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Keccak256 hash.\n */\nexport function keccak256(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_keccak256(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Calculates the [Ripemd160](https://en.wikipedia.org/wiki/RIPEMD) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `ripemd160` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.ripemd160('0xdeadbeef')\n * // '0x226821c2f5423e11fe9af68bd285c249db2e4b5a'\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Ripemd160 hash.\n */\nexport function ripemd160(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_ripemd160(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Calculates the [Sha256](https://en.wikipedia.org/wiki/SHA-256) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n *\n * This function is a re-export of `sha256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.sha256('0xdeadbeef')\n * // '0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953'\n * ```\n *\n * @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.\n * @param options - Options.\n * @returns Sha256 hash.\n */\nexport function sha256(value, options = {}) {\n    const { as = typeof value === 'string' ? 'Hex' : 'Bytes' } = options;\n    const bytes = noble_sha256(Bytes.from(value));\n    if (as === 'Bytes')\n        return bytes;\n    return Hex.fromBytes(bytes);\n}\n/**\n * Checks if a string is a valid hash value.\n *\n * @example\n * ```ts twoslash\n * import { Hash } from 'ox'\n *\n * Hash.validate('0x')\n * // @log: false\n *\n * Hash.validate('0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0')\n * // @log: true\n * ```\n *\n * @param value - Value to check.\n * @returns Whether the value is a valid hash.\n */\nexport function validate(value) {\n    return Hex.validate(value) && Hex.size(value) === 32;\n}\n//# sourceMappingURL=Hash.js.map","/**\n * @internal\n *\n * Map with a LRU (Least recently used) policy.\n * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\n */\nexport class LruMap extends Map {\n    constructor(size) {\n        super();\n        Object.defineProperty(this, \"maxSize\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        this.maxSize = size;\n    }\n    get(key) {\n        const value = super.get(key);\n        if (super.has(key) && value !== undefined) {\n            this.delete(key);\n            super.set(key, value);\n        }\n        return value;\n    }\n    set(key, value) {\n        super.set(key, value);\n        if (this.maxSize && this.size > this.maxSize) {\n            const firstKey = this.keys().next().value;\n            if (firstKey)\n                this.delete(firstKey);\n        }\n        return this;\n    }\n}\n//# sourceMappingURL=lru.js.map","import { LruMap } from './internal/lru.js';\nconst caches = {\n    checksum: /*#__PURE__*/ new LruMap(8192),\n};\nexport const checksum = caches.checksum;\n/**\n * Clears all global caches.\n *\n * @example\n * ```ts\n * import { Caches } from 'ox'\n * Caches.clear()\n * ```\n */\nexport function clear() {\n    for (const cache of Object.values(caches))\n        cache.clear();\n}\n//# sourceMappingURL=Caches.js.map","import * as Bytes from './Bytes.js';\nimport * as Caches from './Caches.js';\nimport * as Errors from './Errors.js';\nimport * as Hash from './Hash.js';\nimport * as PublicKey from './PublicKey.js';\nconst addressRegex = /*#__PURE__*/ /^0x[a-fA-F0-9]{40}$/;\n/**\n * Asserts that the given value is a valid {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.assert('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.assert('0xdeadbeef')\n * // @error: InvalidAddressError: Address \"0xdeadbeef\" is invalid.\n * ```\n *\n * @param value - Value to assert if it is a valid address.\n * @param options - Assertion options.\n */\nexport function assert(value, options = {}) {\n    const { strict = true } = options;\n    if (!addressRegex.test(value))\n        throw new InvalidAddressError({\n            address: value,\n            cause: new InvalidInputError(),\n        });\n    if (strict) {\n        if (value.toLowerCase() === value)\n            return;\n        if (checksum(value) !== value)\n            throw new InvalidAddressError({\n                address: value,\n                cause: new InvalidChecksumError(),\n            });\n    }\n}\n/**\n * Computes the checksum address for the given {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.checksum('0xa0cf798816d4b9b9866b5330eea46a18382f251e')\n * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * ```\n *\n * @param address - The address to compute the checksum for.\n * @returns The checksummed address.\n */\nexport function checksum(address) {\n    if (Caches.checksum.has(address))\n        return Caches.checksum.get(address);\n    assert(address, { strict: false });\n    const hexAddress = address.substring(2).toLowerCase();\n    const hash = Hash.keccak256(Bytes.fromString(hexAddress), { as: 'Bytes' });\n    const characters = hexAddress.split('');\n    for (let i = 0; i < 40; i += 2) {\n        if (hash[i >> 1] >> 4 >= 8 && characters[i]) {\n            characters[i] = characters[i].toUpperCase();\n        }\n        if ((hash[i >> 1] & 0x0f) >= 8 && characters[i + 1]) {\n            characters[i + 1] = characters[i + 1].toUpperCase();\n        }\n    }\n    const result = `0x${characters.join('')}`;\n    Caches.checksum.set(address, result);\n    return result;\n}\n/**\n * Converts a stringified address to a typed (checksummed) {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e')\n * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e', {\n *   checksum: false\n * })\n * // @log: '0xa0cf798816d4b9b9866b5330eea46a18382f251e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('hello')\n * // @error: InvalidAddressError: Address \"0xa\" is invalid.\n * ```\n *\n * @param address - An address string to convert to a typed Address.\n * @param options - Conversion options.\n * @returns The typed Address.\n */\nexport function from(address, options = {}) {\n    const { checksum: checksumVal = false } = options;\n    assert(address);\n    if (checksumVal)\n        return checksum(address);\n    return address;\n}\n/**\n * Converts an ECDSA public key to an {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address, PublicKey } from 'ox'\n *\n * const publicKey = PublicKey.from(\n *   '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',\n * )\n * const address = Address.fromPublicKey(publicKey)\n * // @log: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'\n * ```\n *\n * @param publicKey - The ECDSA public key to convert to an {@link ox#Address.Address}.\n * @param options - Conversion options.\n * @returns The {@link ox#Address.Address} corresponding to the public key.\n */\nexport function fromPublicKey(publicKey, options = {}) {\n    const address = Hash.keccak256(`0x${PublicKey.toHex(publicKey).slice(4)}`).substring(26);\n    return from(`0x${address}`, options);\n}\n/**\n * Checks if two {@link ox#Address.Address} are equal.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.isEqual(\n *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',\n *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'\n * )\n * // @log: true\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.isEqual(\n *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',\n *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251f'\n * )\n * // @log: false\n * ```\n *\n * @param addressA - The first address to compare.\n * @param addressB - The second address to compare.\n * @returns Whether the addresses are equal.\n */\nexport function isEqual(addressA, addressB) {\n    assert(addressA, { strict: false });\n    assert(addressB, { strict: false });\n    return addressA.toLowerCase() === addressB.toLowerCase();\n}\n/**\n * Checks if the given address is a valid {@link ox#Address.Address}.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.validate('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')\n * // @log: true\n * ```\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.validate('0xdeadbeef')\n * // @log: false\n * ```\n *\n * @param address - Value to check if it is a valid address.\n * @param options - Check options.\n * @returns Whether the address is a valid address.\n */\nexport function validate(address, options = {}) {\n    const { strict = true } = options ?? {};\n    try {\n        assert(address, { strict });\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n/**\n * Thrown when an address is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Address } from 'ox'\n *\n * Address.from('0x123')\n * // @error: Address.InvalidAddressError: Address `0x123` is invalid.\n * ```\n */\nexport class InvalidAddressError extends Errors.BaseError {\n    constructor({ address, cause }) {\n        super(`Address \"${address}\" is invalid.`, {\n            cause,\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidAddressError'\n        });\n    }\n}\n/** Thrown when an address is not a 20 byte (40 hexadecimal character) value. */\nexport class InvalidInputError extends Errors.BaseError {\n    constructor() {\n        super('Address is not a 20 byte (40 hexadecimal character) value.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidInputError'\n        });\n    }\n}\n/** Thrown when an address does not match its checksum counterpart. */\nexport class InvalidChecksumError extends Errors.BaseError {\n    constructor() {\n        super('Address does not match its checksum counterpart.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'Address.InvalidChecksumError'\n        });\n    }\n}\n//# sourceMappingURL=Address.js.map","import * as Address from '../Address.js';\nimport * as Errors from '../Errors.js';\n/** @internal */\nexport function normalizeSignature(signature) {\n    let active = true;\n    let current = '';\n    let level = 0;\n    let result = '';\n    let valid = false;\n    for (let i = 0; i < signature.length; i++) {\n        const char = signature[i];\n        // If the character is a separator, we want to reactivate.\n        if (['(', ')', ','].includes(char))\n            active = true;\n        // If the character is a \"level\" token, we want to increment/decrement.\n        if (char === '(')\n            level++;\n        if (char === ')')\n            level--;\n        // If we aren't active, we don't want to mutate the result.\n        if (!active)\n            continue;\n        // If level === 0, we are at the definition level.\n        if (level === 0) {\n            if (char === ' ' && ['event', 'function', 'error', ''].includes(result))\n                result = '';\n            else {\n                result += char;\n                // If we are at the end of the definition, we must be finished.\n                if (char === ')') {\n                    valid = true;\n                    break;\n                }\n            }\n            continue;\n        }\n        // Ignore spaces\n        if (char === ' ') {\n            // If the previous character is a separator, and the current section isn't empty, we want to deactivate.\n            if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {\n                current = '';\n                active = false;\n            }\n            continue;\n        }\n        result += char;\n        current += char;\n    }\n    if (!valid)\n        throw new Errors.BaseError('Unable to normalize signature.');\n    return result;\n}\n/** @internal */\nexport function isArgOfType(arg, abiParameter) {\n    const argType = typeof arg;\n    const abiParameterType = abiParameter.type;\n    switch (abiParameterType) {\n        case 'address':\n            return Address.validate(arg, { strict: false });\n        case 'bool':\n            return argType === 'boolean';\n        case 'function':\n            return argType === 'string';\n        case 'string':\n            return argType === 'string';\n        default: {\n            if (abiParameterType === 'tuple' && 'components' in abiParameter)\n                return Object.values(abiParameter.components).every((component, index) => {\n                    return isArgOfType(Object.values(arg)[index], component);\n                });\n            // `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`\n            // https://regexr.com/6v8hp\n            if (/^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)?$/.test(abiParameterType))\n                return argType === 'number' || argType === 'bigint';\n            // `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`\n            // https://regexr.com/6va55\n            if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))\n                return argType === 'string' || arg instanceof Uint8Array;\n            // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays\n            // https://regexr.com/6va6i\n            if (/[a-z]+[1-9]{0,3}(\\[[0-9]{0,}\\])+$/.test(abiParameterType)) {\n                return (Array.isArray(arg) &&\n                    arg.every((x) => isArgOfType(x, {\n                        ...abiParameter,\n                        // Pop off `[]` or `[M]` from end of type\n                        type: abiParameterType.replace(/(\\[[0-9]{0,}\\])$/, ''),\n                    })));\n            }\n            return false;\n        }\n    }\n}\n/** @internal */\nexport function getAmbiguousTypes(sourceParameters, targetParameters, args) {\n    for (const parameterIndex in sourceParameters) {\n        const sourceParameter = sourceParameters[parameterIndex];\n        const targetParameter = targetParameters[parameterIndex];\n        if (sourceParameter.type === 'tuple' &&\n            targetParameter.type === 'tuple' &&\n            'components' in sourceParameter &&\n            'components' in targetParameter)\n            return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);\n        const types = [sourceParameter.type, targetParameter.type];\n        const ambiguous = (() => {\n            if (types.includes('address') && types.includes('bytes20'))\n                return true;\n            if (types.includes('address') && types.includes('string'))\n                return Address.validate(args[parameterIndex], {\n                    strict: false,\n                });\n            if (types.includes('address') && types.includes('bytes'))\n                return Address.validate(args[parameterIndex], {\n                    strict: false,\n                });\n            return false;\n        })();\n        if (ambiguous)\n            return types;\n    }\n    return;\n}\n//# sourceMappingURL=abiItem.js.map","import * as abitype from 'abitype';\nimport * as Errors from './Errors.js';\nimport * as Hash from './Hash.js';\nimport * as Hex from './Hex.js';\nimport * as internal from './internal/abiItem.js';\n/**\n * Formats an {@link ox#AbiItem.AbiItem} into a **Human Readable ABI Item**.\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const formatted = AbiItem.format({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param abiItem - The ABI Item to format.\n * @returns The formatted ABI Item  .\n */\nexport function format(abiItem) {\n    return abitype.formatAbiItem(abiItem);\n}\n/**\n * Parses an arbitrary **JSON ABI Item** or **Human Readable ABI Item** into a typed {@link ox#AbiItem.AbiItem}.\n *\n * @example\n * ### JSON ABIs\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable ABIs\n *\n * A Human Readable ABI can be parsed into a typed ABI object:\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from(\n *   'function approve(address spender, uint256 amount) returns (bool)' // [!code hl]\n * )\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const abiItem = AbiItem.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'function approve(Foo foo) returns (bool)',\n * ])\n *\n * abiItem\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param abiItem - The ABI Item to parse.\n * @returns The typed ABI Item.\n */\nexport function from(abiItem, options = {}) {\n    const { prepare = true } = options;\n    const item = (() => {\n        if (Array.isArray(abiItem))\n            return abitype.parseAbiItem(abiItem);\n        if (typeof abiItem === 'string')\n            return abitype.parseAbiItem(abiItem);\n        return abiItem;\n    })();\n    return {\n        ...item,\n        ...(prepare ? { hash: getSignatureHash(item) } : {}),\n    };\n}\n/**\n * Extracts an {@link ox#AbiItem.AbiItem} from an {@link ox#Abi.Abi} given a name and optional arguments.\n *\n * @example\n * ABI Items can be extracted by their name using the `name` option:\n *\n * ```ts twoslash\n * import { Abi, AbiItem } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n *\n * const item = AbiItem.fromAbi(abi, 'Transfer') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Extracting by Selector\n *\n * ABI Items can be extract by their selector when {@link ox#Hex.Hex} is provided to `name`.\n *\n * ```ts twoslash\n * import { Abi, AbiItem } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n * const item = AbiItem.fromAbi(abi, '0x095ea7b3') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * :::note\n *\n * Extracting via a hex selector is useful when extracting an ABI Item from an `eth_call` RPC response,\n * a Transaction `input`, or from Event Log `topics`.\n *\n * :::\n *\n * @param abi - The ABI to extract from.\n * @param name - The name (or selector) of the ABI item to extract.\n * @param options - Extraction options.\n * @returns The ABI item.\n */\nexport function fromAbi(abi, name, options) {\n    const { args = [], prepare = true } = (options ??\n        {});\n    const isSelector = Hex.validate(name, { strict: false });\n    const abiItems = abi.filter((abiItem) => {\n        if (isSelector) {\n            if (abiItem.type === 'function' || abiItem.type === 'error')\n                return getSelector(abiItem) === Hex.slice(name, 0, 4);\n            if (abiItem.type === 'event')\n                return getSignatureHash(abiItem) === name;\n            return false;\n        }\n        return 'name' in abiItem && abiItem.name === name;\n    });\n    if (abiItems.length === 0)\n        throw new NotFoundError({ name: name });\n    if (abiItems.length === 1)\n        return {\n            ...abiItems[0],\n            ...(prepare ? { hash: getSignatureHash(abiItems[0]) } : {}),\n        };\n    let matchedAbiItem = undefined;\n    for (const abiItem of abiItems) {\n        if (!('inputs' in abiItem))\n            continue;\n        if (!args || args.length === 0) {\n            if (!abiItem.inputs || abiItem.inputs.length === 0)\n                return {\n                    ...abiItem,\n                    ...(prepare ? { hash: getSignatureHash(abiItem) } : {}),\n                };\n            continue;\n        }\n        if (!abiItem.inputs)\n            continue;\n        if (abiItem.inputs.length === 0)\n            continue;\n        if (abiItem.inputs.length !== args.length)\n            continue;\n        const matched = args.every((arg, index) => {\n            const abiParameter = 'inputs' in abiItem && abiItem.inputs[index];\n            if (!abiParameter)\n                return false;\n            return internal.isArgOfType(arg, abiParameter);\n        });\n        if (matched) {\n            // Check for ambiguity against already matched parameters (e.g. `address` vs `bytes20`).\n            if (matchedAbiItem &&\n                'inputs' in matchedAbiItem &&\n                matchedAbiItem.inputs) {\n                const ambiguousTypes = internal.getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);\n                if (ambiguousTypes)\n                    throw new AmbiguityError({\n                        abiItem,\n                        type: ambiguousTypes[0],\n                    }, {\n                        abiItem: matchedAbiItem,\n                        type: ambiguousTypes[1],\n                    });\n            }\n            matchedAbiItem = abiItem;\n        }\n    }\n    const abiItem = (() => {\n        if (matchedAbiItem)\n            return matchedAbiItem;\n        const [abiItem, ...overloads] = abiItems;\n        return { ...abiItem, overloads };\n    })();\n    if (!abiItem)\n        throw new NotFoundError({ name: name });\n    return {\n        ...abiItem,\n        ...(prepare ? { hash: getSignatureHash(abiItem) } : {}),\n    };\n}\n/**\n * Computes the [4-byte selector](https://solidity-by-example.org/function-selector/) for an {@link ox#AbiItem.AbiItem}.\n *\n * Useful for computing function selectors for calldata.\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const selector = AbiItem.getSelector('function ownerOf(uint256 tokenId)')\n * // @log: '0x6352211e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const selector = AbiItem.getSelector({\n *   inputs: [{ type: 'uint256' }],\n *   name: 'ownerOf',\n *   outputs: [],\n *   stateMutability: 'view',\n *   type: 'function'\n * })\n * // @log: '0x6352211e'\n * ```\n *\n * @param abiItem - The ABI item to compute the selector for. Can be a signature or an ABI item for an error, event, function, etc.\n * @returns The first 4 bytes of the {@link ox#Hash.(keccak256:function)} hash of the function signature.\n */\nexport function getSelector(abiItem) {\n    return Hex.slice(getSignatureHash(abiItem), 0, 4);\n}\n/**\n * Computes the stringified signature for a given {@link ox#AbiItem.AbiItem}.\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const signature = AbiItem.getSignature('function ownerOf(uint256 tokenId)')\n * // @log: 'ownerOf(uint256)'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const signature = AbiItem.getSignature({\n *   name: 'ownerOf',\n *   type: 'function',\n *   inputs: [{ name: 'tokenId', type: 'uint256' }],\n *   outputs: [],\n *   stateMutability: 'view',\n * })\n * // @log: 'ownerOf(uint256)'\n * ```\n *\n * @param abiItem - The ABI Item to compute the signature for.\n * @returns The stringified signature of the ABI Item.\n */\nexport function getSignature(abiItem) {\n    const signature = (() => {\n        if (typeof abiItem === 'string')\n            return abiItem;\n        return abitype.formatAbiItem(abiItem);\n    })();\n    return internal.normalizeSignature(signature);\n}\n/**\n * Computes the signature hash for an {@link ox#AbiItem.AbiItem}.\n *\n * Useful for computing Event Topic values.\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const hash = AbiItem.getSignatureHash('event Transfer(address indexed from, address indexed to, uint256 amount)')\n * // @log: '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { AbiItem } from 'ox'\n *\n * const hash = AbiItem.getSignatureHash({\n *   name: 'Transfer',\n *   type: 'event',\n *   inputs: [\n *     { name: 'from', type: 'address', indexed: true },\n *     { name: 'to', type: 'address', indexed: true },\n *     { name: 'amount', type: 'uint256', indexed: false },\n *   ],\n * })\n * // @log: '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'\n * ```\n *\n * @param abiItem - The ABI Item to compute the signature hash for.\n * @returns The {@link ox#Hash.(keccak256:function)} hash of the ABI item's signature.\n */\nexport function getSignatureHash(abiItem) {\n    if (typeof abiItem !== 'string' && 'hash' in abiItem && abiItem.hash)\n        return abiItem.hash;\n    return Hash.keccak256(Hex.fromString(getSignature(abiItem)));\n}\n/**\n * Throws when ambiguous types are found on overloaded ABI items.\n *\n * @example\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from(['function foo(address)', 'function foo(bytes20)'])\n * AbiFunction.fromAbi(foo, 'foo', {\n *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n * })\n * // @error: AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.\n * // @error: `bytes20` in `foo(bytes20)`, and\n * // @error: `address` in `foo(address)`\n * // @error: These types encode differently and cannot be distinguished at runtime.\n * // @error: Remove one of the ambiguous items in the ABI.\n * ```\n *\n * ### Solution\n *\n * Remove one of the ambiguous types from the ABI.\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function foo(bytes20)' // [!code --]\n * ])\n * AbiFunction.fromAbi(foo, 'foo', {\n *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],\n * })\n * // @error: AbiItem.AmbiguityError: Found ambiguous types in overloaded ABI Items.\n * // @error: `bytes20` in `foo(bytes20)`, and\n * // @error: `address` in `foo(address)`\n * // @error: These types encode differently and cannot be distinguished at runtime.\n * // @error: Remove one of the ambiguous items in the ABI.\n * ```\n */\nexport class AmbiguityError extends Errors.BaseError {\n    constructor(x, y) {\n        super('Found ambiguous types in overloaded ABI Items.', {\n            metaMessages: [\n                // TODO: abitype to add support for signature-formatted ABI items.\n                `\\`${x.type}\\` in \\`${internal.normalizeSignature(abitype.formatAbiItem(x.abiItem))}\\`, and`,\n                `\\`${y.type}\\` in \\`${internal.normalizeSignature(abitype.formatAbiItem(y.abiItem))}\\``,\n                '',\n                'These types encode differently and cannot be distinguished at runtime.',\n                'Remove one of the ambiguous items in the ABI.',\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.AmbiguityError'\n        });\n    }\n}\n/**\n * Throws when an ABI item is not found in the ABI.\n *\n * @example\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, 'baz')\n * // @error: AbiItem.NotFoundError: ABI function with name \"baz\" not found.\n * ```\n *\n * ### Solution\n *\n * Ensure the ABI item exists on the ABI.\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)',\n *   'function baz(bool)' // [!code ++]\n * ])\n * AbiFunction.fromAbi(foo, 'baz')\n * ```\n */\nexport class NotFoundError extends Errors.BaseError {\n    constructor({ name, data, type = 'item', }) {\n        const selector = (() => {\n            if (name)\n                return ` with name \"${name}\"`;\n            if (data)\n                return ` with data \"${data}\"`;\n            return '';\n        })();\n        super(`ABI ${type}${selector} not found.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.NotFoundError'\n        });\n    }\n}\n/**\n * Throws when the selector size is invalid.\n *\n * @example\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, '0xaaa')\n * // @error: AbiItem.InvalidSelectorSizeError: Selector size is invalid. Expected 4 bytes. Received 2 bytes (\"0xaaa\").\n * ```\n *\n * ### Solution\n *\n * Ensure the selector size is 4 bytes.\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const foo = Abi.from([\n *   'function foo(address)',\n *   'function bar(uint)'\n * ])\n * AbiFunction.fromAbi(foo, '0x7af82b1a')\n * ```\n */\nexport class InvalidSelectorSizeError extends Errors.BaseError {\n    constructor({ data }) {\n        super(`Selector size is invalid. Expected 4 bytes. Received ${Hex.size(data)} bytes (\"${data}\").`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiItem.InvalidSelectorSizeError'\n        });\n    }\n}\n//# sourceMappingURL=AbiItem.js.map","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)?$/;\nexport const maxInt8 = 2n ** (8n - 1n) - 1n;\nexport const maxInt16 = 2n ** (16n - 1n) - 1n;\nexport const maxInt24 = 2n ** (24n - 1n) - 1n;\nexport const maxInt32 = 2n ** (32n - 1n) - 1n;\nexport const maxInt40 = 2n ** (40n - 1n) - 1n;\nexport const maxInt48 = 2n ** (48n - 1n) - 1n;\nexport const maxInt56 = 2n ** (56n - 1n) - 1n;\nexport const maxInt64 = 2n ** (64n - 1n) - 1n;\nexport const maxInt72 = 2n ** (72n - 1n) - 1n;\nexport const maxInt80 = 2n ** (80n - 1n) - 1n;\nexport const maxInt88 = 2n ** (88n - 1n) - 1n;\nexport const maxInt96 = 2n ** (96n - 1n) - 1n;\nexport const maxInt104 = 2n ** (104n - 1n) - 1n;\nexport const maxInt112 = 2n ** (112n - 1n) - 1n;\nexport const maxInt120 = 2n ** (120n - 1n) - 1n;\nexport const maxInt128 = 2n ** (128n - 1n) - 1n;\nexport const maxInt136 = 2n ** (136n - 1n) - 1n;\nexport const maxInt144 = 2n ** (144n - 1n) - 1n;\nexport const maxInt152 = 2n ** (152n - 1n) - 1n;\nexport const maxInt160 = 2n ** (160n - 1n) - 1n;\nexport const maxInt168 = 2n ** (168n - 1n) - 1n;\nexport const maxInt176 = 2n ** (176n - 1n) - 1n;\nexport const maxInt184 = 2n ** (184n - 1n) - 1n;\nexport const maxInt192 = 2n ** (192n - 1n) - 1n;\nexport const maxInt200 = 2n ** (200n - 1n) - 1n;\nexport const maxInt208 = 2n ** (208n - 1n) - 1n;\nexport const maxInt216 = 2n ** (216n - 1n) - 1n;\nexport const maxInt224 = 2n ** (224n - 1n) - 1n;\nexport const maxInt232 = 2n ** (232n - 1n) - 1n;\nexport const maxInt240 = 2n ** (240n - 1n) - 1n;\nexport const maxInt248 = 2n ** (248n - 1n) - 1n;\nexport const maxInt256 = 2n ** (256n - 1n) - 1n;\nexport const minInt8 = -(2n ** (8n - 1n));\nexport const minInt16 = -(2n ** (16n - 1n));\nexport const minInt24 = -(2n ** (24n - 1n));\nexport const minInt32 = -(2n ** (32n - 1n));\nexport const minInt40 = -(2n ** (40n - 1n));\nexport const minInt48 = -(2n ** (48n - 1n));\nexport const minInt56 = -(2n ** (56n - 1n));\nexport const minInt64 = -(2n ** (64n - 1n));\nexport const minInt72 = -(2n ** (72n - 1n));\nexport const minInt80 = -(2n ** (80n - 1n));\nexport const minInt88 = -(2n ** (88n - 1n));\nexport const minInt96 = -(2n ** (96n - 1n));\nexport const minInt104 = -(2n ** (104n - 1n));\nexport const minInt112 = -(2n ** (112n - 1n));\nexport const minInt120 = -(2n ** (120n - 1n));\nexport const minInt128 = -(2n ** (128n - 1n));\nexport const minInt136 = -(2n ** (136n - 1n));\nexport const minInt144 = -(2n ** (144n - 1n));\nexport const minInt152 = -(2n ** (152n - 1n));\nexport const minInt160 = -(2n ** (160n - 1n));\nexport const minInt168 = -(2n ** (168n - 1n));\nexport const minInt176 = -(2n ** (176n - 1n));\nexport const minInt184 = -(2n ** (184n - 1n));\nexport const minInt192 = -(2n ** (192n - 1n));\nexport const minInt200 = -(2n ** (200n - 1n));\nexport const minInt208 = -(2n ** (208n - 1n));\nexport const minInt216 = -(2n ** (216n - 1n));\nexport const minInt224 = -(2n ** (224n - 1n));\nexport const minInt232 = -(2n ** (232n - 1n));\nexport const minInt240 = -(2n ** (240n - 1n));\nexport const minInt248 = -(2n ** (248n - 1n));\nexport const minInt256 = -(2n ** (256n - 1n));\nexport const maxUint8 = 2n ** 8n - 1n;\nexport const maxUint16 = 2n ** 16n - 1n;\nexport const maxUint24 = 2n ** 24n - 1n;\nexport const maxUint32 = 2n ** 32n - 1n;\nexport const maxUint40 = 2n ** 40n - 1n;\nexport const maxUint48 = 2n ** 48n - 1n;\nexport const maxUint56 = 2n ** 56n - 1n;\nexport const maxUint64 = 2n ** 64n - 1n;\nexport const maxUint72 = 2n ** 72n - 1n;\nexport const maxUint80 = 2n ** 80n - 1n;\nexport const maxUint88 = 2n ** 88n - 1n;\nexport const maxUint96 = 2n ** 96n - 1n;\nexport const maxUint104 = 2n ** 104n - 1n;\nexport const maxUint112 = 2n ** 112n - 1n;\nexport const maxUint120 = 2n ** 120n - 1n;\nexport const maxUint128 = 2n ** 128n - 1n;\nexport const maxUint136 = 2n ** 136n - 1n;\nexport const maxUint144 = 2n ** 144n - 1n;\nexport const maxUint152 = 2n ** 152n - 1n;\nexport const maxUint160 = 2n ** 160n - 1n;\nexport const maxUint168 = 2n ** 168n - 1n;\nexport const maxUint176 = 2n ** 176n - 1n;\nexport const maxUint184 = 2n ** 184n - 1n;\nexport const maxUint192 = 2n ** 192n - 1n;\nexport const maxUint200 = 2n ** 200n - 1n;\nexport const maxUint208 = 2n ** 208n - 1n;\nexport const maxUint216 = 2n ** 216n - 1n;\nexport const maxUint224 = 2n ** 224n - 1n;\nexport const maxUint232 = 2n ** 232n - 1n;\nexport const maxUint240 = 2n ** 240n - 1n;\nexport const maxUint248 = 2n ** 248n - 1n;\nexport const maxUint256 = 2n ** 256n - 1n;\n//# sourceMappingURL=Solidity.js.map","import * as AbiParameters from '../AbiParameters.js';\nimport * as Address from '../Address.js';\nimport * as Bytes from '../Bytes.js';\nimport * as Errors from '../Errors.js';\nimport * as Hex from '../Hex.js';\nimport { integerRegex } from '../Solidity.js';\n/** @internal */\nexport function decodeParameter(cursor, param, options) {\n    const { checksumAddress, staticPosition } = options;\n    const arrayComponents = getArrayComponents(param.type);\n    if (arrayComponents) {\n        const [length, type] = arrayComponents;\n        return decodeArray(cursor, { ...param, type }, { checksumAddress, length, staticPosition });\n    }\n    if (param.type === 'tuple')\n        return decodeTuple(cursor, param, {\n            checksumAddress,\n            staticPosition,\n        });\n    if (param.type === 'address')\n        return decodeAddress(cursor, { checksum: checksumAddress });\n    if (param.type === 'bool')\n        return decodeBool(cursor);\n    if (param.type.startsWith('bytes'))\n        return decodeBytes(cursor, param, { staticPosition });\n    if (param.type.startsWith('uint') || param.type.startsWith('int'))\n        return decodeNumber(cursor, param);\n    if (param.type === 'string')\n        return decodeString(cursor, { staticPosition });\n    throw new AbiParameters.InvalidTypeError(param.type);\n}\nconst sizeOfLength = 32;\nconst sizeOfOffset = 32;\n/** @internal */\nexport function decodeAddress(cursor, options = {}) {\n    const { checksum = false } = options;\n    const value = cursor.readBytes(32);\n    const wrap = (address) => checksum ? Address.checksum(address) : address;\n    return [wrap(Hex.fromBytes(Bytes.slice(value, -20))), 32];\n}\n/** @internal */\nexport function decodeArray(cursor, param, options) {\n    const { checksumAddress, length, staticPosition } = options;\n    // If the length of the array is not known in advance (dynamic array),\n    // this means we will need to wonder off to the pointer and decode.\n    if (!length) {\n        // Dealing with a dynamic type, so get the offset of the array data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of current slot + offset.\n        const start = staticPosition + offset;\n        const startOfData = start + sizeOfLength;\n        // Get the length of the array from the offset.\n        cursor.setPosition(start);\n        const length = Bytes.toNumber(cursor.readBytes(sizeOfLength));\n        // Check if the array has any dynamic children.\n        const dynamicChild = hasDynamicChild(param);\n        let consumed = 0;\n        const value = [];\n        for (let i = 0; i < length; ++i) {\n            // If any of the children is dynamic, then all elements will be offset pointer, thus size of one slot (32 bytes).\n            // Otherwise, elements will be the size of their encoding (consumed bytes).\n            cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed));\n            const [data, consumed_] = decodeParameter(cursor, param, {\n                checksumAddress,\n                staticPosition: startOfData,\n            });\n            consumed += consumed_;\n            value.push(data);\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the length of the array is known in advance,\n    // and the length of an element deeply nested in the array is not known,\n    // we need to decode the offset of the array data.\n    if (hasDynamicChild(param)) {\n        // Dealing with dynamic types, so get the offset of the array data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of current slot + offset.\n        const start = staticPosition + offset;\n        const value = [];\n        for (let i = 0; i < length; ++i) {\n            // Move cursor along to the next slot (next offset pointer).\n            cursor.setPosition(start + i * 32);\n            const [data] = decodeParameter(cursor, param, {\n                checksumAddress,\n                staticPosition: start,\n            });\n            value.push(data);\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the length of the array is known in advance and the array is deeply static,\n    // then we can just decode each element in sequence.\n    let consumed = 0;\n    const value = [];\n    for (let i = 0; i < length; ++i) {\n        const [data, consumed_] = decodeParameter(cursor, param, {\n            checksumAddress,\n            staticPosition: staticPosition + consumed,\n        });\n        consumed += consumed_;\n        value.push(data);\n    }\n    return [value, consumed];\n}\n/** @internal */\nexport function decodeBool(cursor) {\n    return [Bytes.toBoolean(cursor.readBytes(32), { size: 32 }), 32];\n}\n/** @internal */\nexport function decodeBytes(cursor, param, { staticPosition }) {\n    const [_, size] = param.type.split('bytes');\n    if (!size) {\n        // Dealing with dynamic types, so get the offset of the bytes data.\n        const offset = Bytes.toNumber(cursor.readBytes(32));\n        // Set position of the cursor to start of bytes data.\n        cursor.setPosition(staticPosition + offset);\n        const length = Bytes.toNumber(cursor.readBytes(32));\n        // If there is no length, we have zero data.\n        if (length === 0) {\n            // As we have gone wondering, restore to the original position + next slot.\n            cursor.setPosition(staticPosition + 32);\n            return ['0x', 32];\n        }\n        const data = cursor.readBytes(length);\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [Hex.fromBytes(data), 32];\n    }\n    const value = Hex.fromBytes(cursor.readBytes(Number.parseInt(size), 32));\n    return [value, 32];\n}\n/** @internal */\nexport function decodeNumber(cursor, param) {\n    const signed = param.type.startsWith('int');\n    const size = Number.parseInt(param.type.split('int')[1] || '256');\n    const value = cursor.readBytes(32);\n    return [\n        size > 48\n            ? Bytes.toBigInt(value, { signed })\n            : Bytes.toNumber(value, { signed }),\n        32,\n    ];\n}\n/** @internal */\nexport function decodeTuple(cursor, param, options) {\n    const { checksumAddress, staticPosition } = options;\n    // Tuples can have unnamed components (i.e. they are arrays), so we must\n    // determine whether the tuple is named or unnamed. In the case of a named\n    // tuple, the value will be an object where each property is the name of the\n    // component. In the case of an unnamed tuple, the value will be an array.\n    const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);\n    // Initialize the value to an object or an array, depending on whether the\n    // tuple is named or unnamed.\n    const value = hasUnnamedChild ? [] : {};\n    let consumed = 0;\n    // If the tuple has a dynamic child, we must first decode the offset to the\n    // tuple data.\n    if (hasDynamicChild(param)) {\n        // Dealing with dynamic types, so get the offset of the tuple data.\n        const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset));\n        // Start is the static position of referencing slot + offset.\n        const start = staticPosition + offset;\n        for (let i = 0; i < param.components.length; ++i) {\n            const component = param.components[i];\n            cursor.setPosition(start + consumed);\n            const [data, consumed_] = decodeParameter(cursor, component, {\n                checksumAddress,\n                staticPosition: start,\n            });\n            consumed += consumed_;\n            value[hasUnnamedChild ? i : component?.name] = data;\n        }\n        // As we have gone wondering, restore to the original position + next slot.\n        cursor.setPosition(staticPosition + 32);\n        return [value, 32];\n    }\n    // If the tuple has static children, we can just decode each component\n    // in sequence.\n    for (let i = 0; i < param.components.length; ++i) {\n        const component = param.components[i];\n        const [data, consumed_] = decodeParameter(cursor, component, {\n            checksumAddress,\n            staticPosition,\n        });\n        value[hasUnnamedChild ? i : component?.name] = data;\n        consumed += consumed_;\n    }\n    return [value, consumed];\n}\n/** @internal */\nexport function decodeString(cursor, { staticPosition }) {\n    // Get offset to start of string data.\n    const offset = Bytes.toNumber(cursor.readBytes(32));\n    // Start is the static position of current slot + offset.\n    const start = staticPosition + offset;\n    cursor.setPosition(start);\n    const length = Bytes.toNumber(cursor.readBytes(32));\n    // If there is no length, we have zero data (empty string).\n    if (length === 0) {\n        cursor.setPosition(staticPosition + 32);\n        return ['', 32];\n    }\n    const data = cursor.readBytes(length, 32);\n    const value = Bytes.toString(Bytes.trimLeft(data));\n    // As we have gone wondering, restore to the original position + next slot.\n    cursor.setPosition(staticPosition + 32);\n    return [value, 32];\n}\n/** @internal */\nexport function prepareParameters({ checksumAddress, parameters, values, }) {\n    const preparedParameters = [];\n    for (let i = 0; i < parameters.length; i++) {\n        preparedParameters.push(prepareParameter({\n            checksumAddress,\n            parameter: parameters[i],\n            value: values[i],\n        }));\n    }\n    return preparedParameters;\n}\n/** @internal */\nexport function prepareParameter({ checksumAddress = false, parameter: parameter_, value, }) {\n    const parameter = parameter_;\n    const arrayComponents = getArrayComponents(parameter.type);\n    if (arrayComponents) {\n        const [length, type] = arrayComponents;\n        return encodeArray(value, {\n            checksumAddress,\n            length,\n            parameter: {\n                ...parameter,\n                type,\n            },\n        });\n    }\n    if (parameter.type === 'tuple') {\n        return encodeTuple(value, {\n            checksumAddress,\n            parameter: parameter,\n        });\n    }\n    if (parameter.type === 'address') {\n        return encodeAddress(value, {\n            checksum: checksumAddress,\n        });\n    }\n    if (parameter.type === 'bool') {\n        return encodeBoolean(value);\n    }\n    if (parameter.type.startsWith('uint') || parameter.type.startsWith('int')) {\n        const signed = parameter.type.startsWith('int');\n        const [, , size = '256'] = integerRegex.exec(parameter.type) ?? [];\n        return encodeNumber(value, {\n            signed,\n            size: Number(size),\n        });\n    }\n    if (parameter.type.startsWith('bytes')) {\n        return encodeBytes(value, { type: parameter.type });\n    }\n    if (parameter.type === 'string') {\n        return encodeString(value);\n    }\n    throw new AbiParameters.InvalidTypeError(parameter.type);\n}\n/** @internal */\nexport function encode(preparedParameters) {\n    // 1. Compute the size of the static part of the parameters.\n    let staticSize = 0;\n    for (let i = 0; i < preparedParameters.length; i++) {\n        const { dynamic, encoded } = preparedParameters[i];\n        if (dynamic)\n            staticSize += 32;\n        else\n            staticSize += Hex.size(encoded);\n    }\n    // 2. Split the parameters into static and dynamic parts.\n    const staticParameters = [];\n    const dynamicParameters = [];\n    let dynamicSize = 0;\n    for (let i = 0; i < preparedParameters.length; i++) {\n        const { dynamic, encoded } = preparedParameters[i];\n        if (dynamic) {\n            staticParameters.push(Hex.fromNumber(staticSize + dynamicSize, { size: 32 }));\n            dynamicParameters.push(encoded);\n            dynamicSize += Hex.size(encoded);\n        }\n        else {\n            staticParameters.push(encoded);\n        }\n    }\n    // 3. Concatenate static and dynamic parts.\n    return Hex.concat(...staticParameters, ...dynamicParameters);\n}\n/** @internal */\nexport function encodeAddress(value, options) {\n    const { checksum = false } = options;\n    Address.assert(value, { strict: checksum });\n    return {\n        dynamic: false,\n        encoded: Hex.padLeft(value.toLowerCase()),\n    };\n}\n/** @internal */\nexport function encodeArray(value, options) {\n    const { checksumAddress, length, parameter } = options;\n    const dynamic = length === null;\n    if (!Array.isArray(value))\n        throw new AbiParameters.InvalidArrayError(value);\n    if (!dynamic && value.length !== length)\n        throw new AbiParameters.ArrayLengthMismatchError({\n            expectedLength: length,\n            givenLength: value.length,\n            type: `${parameter.type}[${length}]`,\n        });\n    let dynamicChild = false;\n    const preparedParameters = [];\n    for (let i = 0; i < value.length; i++) {\n        const preparedParam = prepareParameter({\n            checksumAddress,\n            parameter,\n            value: value[i],\n        });\n        if (preparedParam.dynamic)\n            dynamicChild = true;\n        preparedParameters.push(preparedParam);\n    }\n    if (dynamic || dynamicChild) {\n        const data = encode(preparedParameters);\n        if (dynamic) {\n            const length = Hex.fromNumber(preparedParameters.length, { size: 32 });\n            return {\n                dynamic: true,\n                encoded: preparedParameters.length > 0 ? Hex.concat(length, data) : length,\n            };\n        }\n        if (dynamicChild)\n            return { dynamic: true, encoded: data };\n    }\n    return {\n        dynamic: false,\n        encoded: Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),\n    };\n}\n/** @internal */\nexport function encodeBytes(value, { type }) {\n    const [, parametersize] = type.split('bytes');\n    const bytesSize = Hex.size(value);\n    if (!parametersize) {\n        let value_ = value;\n        // If the size is not divisible by 32 bytes, pad the end\n        // with empty bytes to the ceiling 32 bytes.\n        if (bytesSize % 32 !== 0)\n            value_ = Hex.padRight(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);\n        return {\n            dynamic: true,\n            encoded: Hex.concat(Hex.padLeft(Hex.fromNumber(bytesSize, { size: 32 })), value_),\n        };\n    }\n    if (bytesSize !== Number.parseInt(parametersize))\n        throw new AbiParameters.BytesSizeMismatchError({\n            expectedSize: Number.parseInt(parametersize),\n            value,\n        });\n    return { dynamic: false, encoded: Hex.padRight(value) };\n}\n/** @internal */\nexport function encodeBoolean(value) {\n    if (typeof value !== 'boolean')\n        throw new Errors.BaseError(`Invalid boolean value: \"${value}\" (type: ${typeof value}). Expected: \\`true\\` or \\`false\\`.`);\n    return { dynamic: false, encoded: Hex.padLeft(Hex.fromBoolean(value)) };\n}\n/** @internal */\nexport function encodeNumber(value, { signed, size }) {\n    if (typeof size === 'number') {\n        const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;\n        const min = signed ? -max - 1n : 0n;\n        if (value > max || value < min)\n            throw new Hex.IntegerOutOfRangeError({\n                max: max.toString(),\n                min: min.toString(),\n                signed,\n                size: size / 8,\n                value: value.toString(),\n            });\n    }\n    return {\n        dynamic: false,\n        encoded: Hex.fromNumber(value, {\n            size: 32,\n            signed,\n        }),\n    };\n}\n/** @internal */\nexport function encodeString(value) {\n    const hexValue = Hex.fromString(value);\n    const partsLength = Math.ceil(Hex.size(hexValue) / 32);\n    const parts = [];\n    for (let i = 0; i < partsLength; i++) {\n        parts.push(Hex.padRight(Hex.slice(hexValue, i * 32, (i + 1) * 32)));\n    }\n    return {\n        dynamic: true,\n        encoded: Hex.concat(Hex.padRight(Hex.fromNumber(Hex.size(hexValue), { size: 32 })), ...parts),\n    };\n}\n/** @internal */\nexport function encodeTuple(value, options) {\n    const { checksumAddress, parameter } = options;\n    let dynamic = false;\n    const preparedParameters = [];\n    for (let i = 0; i < parameter.components.length; i++) {\n        const param_ = parameter.components[i];\n        const index = Array.isArray(value) ? i : param_.name;\n        const preparedParam = prepareParameter({\n            checksumAddress,\n            parameter: param_,\n            value: value[index],\n        });\n        preparedParameters.push(preparedParam);\n        if (preparedParam.dynamic)\n            dynamic = true;\n    }\n    return {\n        dynamic,\n        encoded: dynamic\n            ? encode(preparedParameters)\n            : Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),\n    };\n}\n/** @internal */\nexport function getArrayComponents(type) {\n    const matches = type.match(/^(.*)\\[(\\d+)?\\]$/);\n    return matches\n        ? // Return `null` if the array is dynamic.\n            [matches[2] ? Number(matches[2]) : null, matches[1]]\n        : undefined;\n}\n/** @internal */\nexport function hasDynamicChild(param) {\n    const { type } = param;\n    if (type === 'string')\n        return true;\n    if (type === 'bytes')\n        return true;\n    if (type.endsWith('[]'))\n        return true;\n    if (type === 'tuple')\n        return param.components?.some(hasDynamicChild);\n    const arrayComponents = getArrayComponents(param.type);\n    if (arrayComponents &&\n        hasDynamicChild({\n            ...param,\n            type: arrayComponents[1],\n        }))\n        return true;\n    return false;\n}\n//# sourceMappingURL=abiParameters.js.map","import * as abitype from 'abitype';\nimport * as Address from './Address.js';\nimport * as Bytes from './Bytes.js';\nimport * as Errors from './Errors.js';\nimport * as Hex from './Hex.js';\nimport * as Solidity from './Solidity.js';\nimport * as internal from './internal/abiParameters.js';\nimport * as Cursor from './internal/cursor.js';\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function decode(parameters, data, options = {}) {\n    const { as = 'Array', checksumAddress = false } = options;\n    const bytes = typeof data === 'string' ? Bytes.fromHex(data) : data;\n    const cursor = Cursor.create(bytes);\n    if (Bytes.size(bytes) === 0 && parameters.length > 0)\n        throw new ZeroDataError();\n    if (Bytes.size(bytes) && Bytes.size(bytes) < 32)\n        throw new DataSizeTooSmallError({\n            data: typeof data === 'string' ? data : Hex.fromBytes(data),\n            parameters: parameters,\n            size: Bytes.size(bytes),\n        });\n    let consumed = 0;\n    const values = as === 'Array' ? [] : {};\n    for (let i = 0; i < parameters.length; ++i) {\n        const param = parameters[i];\n        cursor.setPosition(consumed);\n        const [data, consumed_] = internal.decodeParameter(cursor, param, {\n            checksumAddress,\n            staticPosition: 0,\n        });\n        consumed += consumed_;\n        if (as === 'Array')\n            values.push(data);\n        else\n            values[param.name ?? i] = data;\n    }\n    return values;\n}\n/**\n * Encodes primitive values into ABI encoded data as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec).\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const data = AbiParameters.encode(\n *   AbiParameters.from(['string', 'uint', 'bool']),\n *   ['wagmi', 420n, true],\n * )\n * ```\n *\n * @example\n * ### JSON Parameters\n *\n * Specify **JSON ABI** Parameters as schema:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const data = AbiParameters.encode(\n *   [\n *     { type: 'string', name: 'name' },\n *     { type: 'uint', name: 'age' },\n *     { type: 'bool', name: 'isOwner' },\n *   ],\n *   ['wagmi', 420n, true],\n * )\n * ```\n *\n * @param parameters - The set of ABI parameters to encode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).\n * @param values - The set of primitive values that correspond to the ABI types defined in `parameters`.\n * @returns ABI encoded data.\n */\nexport function encode(parameters, values, options) {\n    const { checksumAddress = false } = options ?? {};\n    if (parameters.length !== values.length)\n        throw new LengthMismatchError({\n            expectedLength: parameters.length,\n            givenLength: values.length,\n        });\n    // Prepare the parameters to determine dynamic types to encode.\n    const preparedParameters = internal.prepareParameters({\n        checksumAddress,\n        parameters: parameters,\n        values: values,\n    });\n    const data = internal.encode(preparedParameters);\n    if (data.length === 0)\n        return '0x';\n    return data;\n}\n/**\n * Encodes an array of primitive values to a [packed ABI encoding](https://docs.soliditylang.org/en/latest/abi-spec.html#non-standard-packed-mode).\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const encoded = AbiParameters.encodePacked(\n *   ['address', 'string'],\n *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 'hello world'],\n * )\n * // @log: '0xd8da6bf26964af9d7eed9e03e53415d37aa9604568656c6c6f20776f726c64'\n * ```\n *\n * @param types - Set of ABI types to pack encode.\n * @param values - The set of primitive values that correspond to the ABI types defined in `types`.\n * @returns The encoded packed data.\n */\nexport function encodePacked(types, values) {\n    if (types.length !== values.length)\n        throw new LengthMismatchError({\n            expectedLength: types.length,\n            givenLength: values.length,\n        });\n    const data = [];\n    for (let i = 0; i < types.length; i++) {\n        const type = types[i];\n        const value = values[i];\n        data.push(encodePacked.encode(type, value));\n    }\n    return Hex.concat(...data);\n}\n(function (encodePacked) {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    function encode(type, value, isArray = false) {\n        if (type === 'address') {\n            const address = value;\n            Address.assert(address);\n            return Hex.padLeft(address.toLowerCase(), isArray ? 32 : 0);\n        }\n        if (type === 'string')\n            return Hex.fromString(value);\n        if (type === 'bytes')\n            return value;\n        if (type === 'bool')\n            return Hex.padLeft(Hex.fromBoolean(value), isArray ? 32 : 1);\n        const intMatch = type.match(Solidity.integerRegex);\n        if (intMatch) {\n            const [_type, baseType, bits = '256'] = intMatch;\n            const size = Number.parseInt(bits) / 8;\n            return Hex.fromNumber(value, {\n                size: isArray ? 32 : size,\n                signed: baseType === 'int',\n            });\n        }\n        const bytesMatch = type.match(Solidity.bytesRegex);\n        if (bytesMatch) {\n            const [_type, size] = bytesMatch;\n            if (Number.parseInt(size) !== (value.length - 2) / 2)\n                throw new BytesSizeMismatchError({\n                    expectedSize: Number.parseInt(size),\n                    value: value,\n                });\n            return Hex.padRight(value, isArray ? 32 : 0);\n        }\n        const arrayMatch = type.match(Solidity.arrayRegex);\n        if (arrayMatch && Array.isArray(value)) {\n            const [_type, childType] = arrayMatch;\n            const data = [];\n            for (let i = 0; i < value.length; i++) {\n                data.push(encode(childType, value[i], true));\n            }\n            if (data.length === 0)\n                return '0x';\n            return Hex.concat(...data);\n        }\n        throw new InvalidTypeError(type);\n    }\n    encodePacked.encode = encode;\n})(encodePacked || (encodePacked = {}));\n/**\n * Formats {@link ox#AbiParameters.AbiParameters} into **Human Readable ABI Parameters**.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const formatted = AbiParameters.format([\n *   {\n *     name: 'spender',\n *     type: 'address',\n *   },\n *   {\n *     name: 'amount',\n *     type: 'uint256',\n *   },\n * ])\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param parameters - The ABI Parameters to format.\n * @returns The formatted ABI Parameters  .\n */\nexport function format(parameters) {\n    return abitype.formatAbiParameters(parameters);\n}\n/**\n * Parses arbitrary **JSON ABI Parameters** or **Human Readable ABI Parameters** into typed {@link ox#AbiParameters.AbiParameters}.\n *\n * @example\n * ### JSON Parameters\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from([\n *   {\n *     name: 'spender',\n *     type: 'address',\n *   },\n *   {\n *     name: 'amount',\n *     type: 'uint256',\n *   },\n * ])\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable Parameters\n *\n * Human Readable ABI Parameters can be parsed into a typed {@link ox#AbiParameters.AbiParameters}:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from('address spender, uint256 amount')\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * const parameters = AbiParameters.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'Foo foo, address bar',\n * ])\n *\n * parameters\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param parameters - The ABI Parameters to parse.\n * @returns The typed ABI Parameters.\n */\nexport function from(parameters) {\n    if (Array.isArray(parameters) && typeof parameters[0] === 'string')\n        return abitype.parseAbiParameters(parameters);\n    if (typeof parameters === 'string')\n        return abitype.parseAbiParameters(parameters);\n    return parameters;\n}\n/**\n * Throws when the data size is too small for the given parameters.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x010f')\n * //                                             ↑ ❌ 2 bytes\n * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.\n * // @error: Params: (uint256)\n * // @error: Data:   0x010f (2 bytes)\n * ```\n *\n * ### Solution\n *\n * Pass a valid data size.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                                             ↑ ✅ 32 bytes\n * ```\n */\nexport class DataSizeTooSmallError extends Errors.BaseError {\n    constructor({ data, parameters, size, }) {\n        super(`Data size of ${size} bytes is too small for given parameters.`, {\n            metaMessages: [\n                `Params: (${abitype.formatAbiParameters(parameters)})`,\n                `Data:   ${data} (${size} bytes)`,\n            ],\n        });\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.DataSizeTooSmallError'\n        });\n    }\n}\n/**\n * Throws when zero data is provided, but data is expected.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x')\n * //                                           ↑ ❌ zero data\n * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.\n * // @error: Params: (uint256)\n * // @error: Data:   0x010f (2 bytes)\n * ```\n *\n * ### Solution\n *\n * Pass valid data.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                                             ↑ ✅ 32 bytes\n * ```\n */\nexport class ZeroDataError extends Errors.BaseError {\n    constructor() {\n        super('Cannot decode zero data (\"0x\") with ABI parameters.');\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.ZeroDataError'\n        });\n    }\n}\n/**\n * The length of the array value does not match the length specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from('uint256[3]'), [[69n, 420n]])\n * //                                               ↑ expected: 3  ↑ ❌ length: 2\n * // @error: AbiParameters.ArrayLengthMismatchError: ABI encoding array length mismatch\n * // @error: for type `uint256[3]`. Expected: `3`. Given: `2`.\n * ```\n *\n * ### Solution\n *\n * Pass an array of the correct length.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [[69n, 420n, 69n]])\n * //                                                         ↑ ✅ length: 3\n * ```\n */\nexport class ArrayLengthMismatchError extends Errors.BaseError {\n    constructor({ expectedLength, givenLength, type, }) {\n        super(`Array length mismatch for type \\`${type}\\`. Expected: \\`${expectedLength}\\`. Given: \\`${givenLength}\\`.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.ArrayLengthMismatchError'\n        });\n    }\n}\n/**\n * The size of the bytes value does not match the size specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from('bytes8'), [['0xdeadbeefdeadbeefdeadbeef']])\n * //                                            ↑ expected: 8 bytes  ↑ ❌ size: 12 bytes\n * // @error: BytesSizeMismatchError: Size of bytes \"0xdeadbeefdeadbeefdeadbeef\"\n * // @error: (bytes12) does not match expected size (bytes8).\n * ```\n *\n * ### Solution\n *\n * Pass a bytes value of the correct size.\n *\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['bytes8']), ['0xdeadbeefdeadbeef'])\n * //                                                       ↑ ✅ size: 8 bytes\n * ```\n */\nexport class BytesSizeMismatchError extends Errors.BaseError {\n    constructor({ expectedSize, value, }) {\n        super(`Size of bytes \"${value}\" (bytes${Hex.size(value)}) does not match expected size (bytes${expectedSize}).`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.BytesSizeMismatchError'\n        });\n    }\n}\n/**\n * The length of the values to encode does not match the length of the ABI parameters.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['string', 'uint256']), ['hello'])\n * // @error: LengthMismatchError: ABI encoding params/values length mismatch.\n * // @error: Expected length (params): 2\n * // @error: Given length (values): 1\n * ```\n *\n * ### Solution\n *\n * Pass the correct number of values to encode.\n *\n * ### Solution\n *\n * Pass a [valid ABI type](https://docs.soliditylang.org/en/develop/abi-spec.html#types).\n */\nexport class LengthMismatchError extends Errors.BaseError {\n    constructor({ expectedLength, givenLength, }) {\n        super([\n            'ABI encoding parameters/values length mismatch.',\n            `Expected length (parameters): ${expectedLength}`,\n            `Given length (values): ${givenLength}`,\n        ].join('\\n'));\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.LengthMismatchError'\n        });\n    }\n}\n/**\n * The value provided is not a valid array as specified in the corresponding ABI parameter.\n *\n * ### Example\n *\n * ```ts twoslash\n * // @noErrors\n * import { AbiParameters } from 'ox'\n * // ---cut---\n * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [69])\n * ```\n *\n * ### Solution\n *\n * Pass an array value.\n */\nexport class InvalidArrayError extends Errors.BaseError {\n    constructor(value) {\n        super(`Value \\`${value}\\` is not a valid array.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.InvalidArrayError'\n        });\n    }\n}\n/**\n * Throws when the ABI parameter type is invalid.\n *\n * @example\n * ```ts twoslash\n * import { AbiParameters } from 'ox'\n *\n * AbiParameters.decode([{ type: 'lol' }], '0x00000000000000000000000000000000000000000000000000000000000010f')\n * //                             ↑ ❌ invalid type\n * // @error: AbiParameters.InvalidTypeError: Type `lol` is not a valid ABI Type.\n * ```\n */\nexport class InvalidTypeError extends Errors.BaseError {\n    constructor(type) {\n        super(`Type \\`${type}\\` is not a valid ABI Type.`);\n        Object.defineProperty(this, \"name\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: 'AbiParameters.InvalidTypeError'\n        });\n    }\n}\n//# sourceMappingURL=AbiParameters.js.map","import * as abitype from 'abitype';\nimport * as AbiItem from './AbiItem.js';\nimport * as AbiParameters from './AbiParameters.js';\nimport * as Hex from './Hex.js';\n/** @internal */\nexport function decode(abiConstructor, options) {\n    const { bytecode } = options;\n    if (abiConstructor.inputs.length === 0)\n        return undefined;\n    const data = options.data.replace(bytecode, '0x');\n    return AbiParameters.decode(abiConstructor.inputs, data);\n}\n/**\n * ABI-encodes the provided constructor input (`inputs`).\n *\n * @example\n * ```ts twoslash\n * import { AbiConstructor } from 'ox'\n *\n * const constructor = AbiConstructor.from('constructor(address, uint256)')\n *\n * const data = AbiConstructor.encode(constructor, {\n *   bytecode: '0x...',\n *   args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 123n],\n * })\n * ```\n *\n * @example\n * ### End-to-end\n *\n * Below is an end-to-end example of using `AbiConstructor.encode` to encode the constructor of a contract and deploy it.\n *\n * ```ts twoslash\n * import 'ox/window'\n * import { AbiConstructor, Hex } from 'ox'\n *\n * // 1. Instantiate the ABI Constructor.\n * const constructor = AbiConstructor.from(\n *   'constructor(address owner, uint256 amount)',\n * )\n *\n * // 2. Encode the ABI Constructor.\n * const data = AbiConstructor.encode(constructor, {\n *   bytecode: '0x...',\n *   args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 123n],\n * })\n *\n * // 3. Deploy the contract.\n * const hash = await window.ethereum!.request({\n *   method: 'eth_sendTransaction',\n *   params: [{ data }],\n * })\n * ```\n *\n * :::note\n *\n * For simplicity, the above example uses `window.ethereum.request`, but you can use any\n * type of JSON-RPC interface.\n *\n * :::\n *\n * @param abiConstructor - The ABI Constructor to encode.\n * @param options - Encoding options.\n * @returns The encoded constructor.\n */\nexport function encode(abiConstructor, options) {\n    const { bytecode, args } = options;\n    return Hex.concat(bytecode, abiConstructor.inputs?.length && args?.length\n        ? AbiParameters.encode(abiConstructor.inputs, args)\n        : '0x');\n}\n/** @internal */\nexport function format(abiConstructor) {\n    return abitype.formatAbiItem(abiConstructor);\n}\n/** @internal */\nexport function from(abiConstructor) {\n    return AbiItem.from(abiConstructor);\n}\n/** @internal */\nexport function fromAbi(abi) {\n    const item = abi.find((item) => item.type === 'constructor');\n    if (!item)\n        throw new AbiItem.NotFoundError({ name: 'constructor' });\n    return item;\n}\n//# sourceMappingURL=AbiConstructor.js.map","import * as abitype from 'abitype';\nimport * as AbiItem from './AbiItem.js';\nimport * as AbiParameters from './AbiParameters.js';\nimport * as Hex from './Hex.js';\n/**\n * ABI-decodes function arguments according to the ABI Item's input types (`inputs`).\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from('function approve(address, uint256)')\n *\n * const data = AbiFunction.encodeData(\n *   approve,\n *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]\n * )\n * // '0x095ea7b3000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa960450000000000000000000000000000000000000000000000000000000000010f2c'\n *\n * const input = AbiFunction.decodeData(approve, data) // [!code focus]\n * // @log: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]\n * ```\n *\n * @param abiFunction - The ABI Item to decode.\n * @param data - The data to decode.\n */\nexport function decodeData(abiFunction, data) {\n    const { overloads } = abiFunction;\n    if (Hex.size(data) < 4)\n        throw new AbiItem.InvalidSelectorSizeError({ data });\n    if (abiFunction.inputs.length === 0)\n        return undefined;\n    const item = overloads\n        ? fromAbi([abiFunction, ...overloads], data)\n        : abiFunction;\n    if (Hex.size(data) <= 4)\n        return undefined;\n    return AbiParameters.decode(item.inputs, Hex.slice(data, 4));\n}\n/**\n * ABI-decodes a function's result according to the ABI Item's output types (`outputs`).\n *\n * :::tip\n *\n * This function is typically used to decode contract function return values (e.g. the response of an `eth_call` or the `input` property of a Transaction).\n *\n * See the [End-to-end Example](#end-to-end).\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const data = '0x000000000000000000000000000000000000000000000000000000000000002a'\n *\n * const totalSupply = AbiFunction.from('function totalSupply() returns (uint256)')\n *\n * const output = AbiFunction.decodeResult(totalSupply, data)\n * // @log: 42n\n * ```\n *\n * @example\n * You can extract an ABI Function from a JSON ABI with {@link ox#AbiFunction.(fromAbi:function)}:\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const data = '0x000000000000000000000000000000000000000000000000000000000000002a'\n *\n * const erc20Abi = Abi.from([...]) // [!code hl]\n * const totalSupply = AbiFunction.fromAbi(erc20Abi, 'totalSupply') // [!code hl]\n *\n * const output = AbiFunction.decodeResult(totalSupply, data)\n * // @log: 42n\n * ```\n *\n * @example\n * ### End-to-end\n *\n * Below is an end-to-end example of using `AbiFunction.decodeResult` to decode the result of a `balanceOf` contract call on the [Wagmi Mint Example contract](https://etherscan.io/address/0xfba3912ca04dd458c843e2ee08967fc04f3579c2).\n *\n * ```ts twoslash\n * import 'ox/window'\n * import { Abi, AbiFunction } from 'ox'\n *\n * // 1. Extract the Function from the Contract's ABI.\n * const abi = Abi.from([\n *   // ...\n *   {\n *     name: 'balanceOf',\n *     type: 'function',\n *     inputs: [{ name: 'account', type: 'address' }],\n *     outputs: [{ name: 'balance', type: 'uint256' }],\n *     stateMutability: 'view',\n *   },\n *   // ...\n * ])\n * const balanceOf = AbiFunction.fromAbi(abi, 'balanceOf')\n *\n * // 2. Encode the Function Input.\n * const data = AbiFunction.encodeData(\n *   balanceOf,\n *   ['0xd2135CfB216b74109775236E36d4b433F1DF507B']\n * )\n *\n * // 3. Perform the Contract Call.\n * const response = await window.ethereum!.request({\n *   method: 'eth_call',\n *   params: [\n *     {\n *       data,\n *       to: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',\n *     },\n *   ],\n * })\n *\n * // 4. Decode the Function Output. // [!code focus]\n * const balance = AbiFunction.decodeResult(balanceOf, response) // [!code focus]\n * // @log: 42n\n * ```\n *\n * :::note\n *\n * For simplicity, the above example uses `window.ethereum.request`, but you can use any\n * type of JSON-RPC interface.\n *\n * :::\n *\n * @param abiFunction - ABI Function to decode\n * @param data - ABI-encoded function output\n * @param options - Decoding options\n * @returns Decoded function output\n */\nexport function decodeResult(abiFunction, data, options = {}) {\n    const values = AbiParameters.decode(abiFunction.outputs, data, options);\n    if (values && Object.keys(values).length === 0)\n        return undefined;\n    if (values && Object.keys(values).length === 1) {\n        if (Array.isArray(values))\n            return values[0];\n        return Object.values(values)[0];\n    }\n    return values;\n}\n/**\n * ABI-encodes function arguments (`inputs`), prefixed with the 4 byte function selector.\n *\n * :::tip\n *\n * This function is typically used to encode a contract function and its arguments for contract calls (e.g. `data` parameter of an `eth_call` or `eth_sendTransaction`).\n *\n * See the [End-to-end Example](#end-to-end).\n *\n * :::\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from('function approve(address, uint256)')\n *\n * const data = AbiFunction.encodeData( // [!code focus]\n *   approve, // [!code focus]\n *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n] // [!code focus]\n * ) // [!code focus]\n * // @log: '0x095ea7b3000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa960450000000000000000000000000000000000000000000000000000000000010f2c'\n * ```\n *\n * @example\n * You can extract an ABI Function from a JSON ABI with {@link ox#AbiFunction.(fromAbi:function)}:\n *\n * ```ts twoslash\n * // @noErrors\n * import { Abi, AbiFunction } from 'ox'\n *\n * const erc20Abi = Abi.from([...]) // [!code hl]\n * const approve = AbiFunction.fromAbi(erc20Abi, 'approve') // [!code hl]\n *\n * const data = AbiFunction.encodeData(\n *   approve,\n *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n]\n * )\n * // @log: '0x095ea7b3000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa960450000000000000000000000000000000000000000000000000000000000010f2c'\n * ```\n *\n * @example\n * ### End-to-end\n *\n * Below is an end-to-end example of using `AbiFunction.encodeData` to encode the input of a `balanceOf` contract call on the [Wagmi Mint Example contract](https://etherscan.io/address/0xfba3912ca04dd458c843e2ee08967fc04f3579c2).\n *\n * ```ts twoslash\n * import 'ox/window'\n * import { Abi, AbiFunction } from 'ox'\n *\n * // 1. Extract the Function from the Contract's ABI.\n * const abi = Abi.from([\n *   // ...\n *   {\n *     name: 'balanceOf',\n *     type: 'function',\n *     inputs: [{ name: 'account', type: 'address' }],\n *     outputs: [{ name: 'balance', type: 'uint256' }],\n *     stateMutability: 'view',\n *   },\n *   // ...\n * ])\n * const balanceOf = AbiFunction.fromAbi(abi, 'balanceOf')\n *\n * // 2. Encode the Function Input. // [!code focus]\n * const data = AbiFunction.encodeData( // [!code focus]\n *   balanceOf, // [!code focus]\n *   ['0xd2135CfB216b74109775236E36d4b433F1DF507B'] // [!code focus]\n * ) // [!code focus]\n *\n * // 3. Perform the Contract Call.\n * const response = await window.ethereum!.request({\n *   method: 'eth_call',\n *   params: [\n *     {\n *       data,\n *       to: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',\n *     },\n *   ],\n * })\n *\n * // 4. Decode the Function Output.\n * const balance = AbiFunction.decodeResult(balanceOf, response)\n * ```\n *\n * :::note\n *\n * For simplicity, the above example uses `window.ethereum.request`, but you can use any\n * type of JSON-RPC interface.\n *\n * :::\n *\n * @param abiFunction - ABI Function to encode\n * @param args - Function arguments\n * @returns ABI-encoded function name and arguments\n */\nexport function encodeData(abiFunction, ...args) {\n    const { overloads } = abiFunction;\n    const item = overloads\n        ? fromAbi([abiFunction, ...overloads], abiFunction.name, {\n            args: args[0],\n        })\n        : abiFunction;\n    const selector = getSelector(item);\n    const data = args.length > 0\n        ? AbiParameters.encode(item.inputs, args[0])\n        : undefined;\n    return data ? Hex.concat(selector, data) : selector;\n}\n/**\n * ABI-encodes a function's result (`outputs`).\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const totalSupply = AbiFunction.from('function totalSupply() returns (uint256)')\n * const output = AbiFunction.decodeResult(totalSupply, '0x000000000000000000000000000000000000000000000000000000000000002a')\n * // 42n\n *\n * const data = AbiFunction.encodeResult(totalSupply, 42n) // [!code focus]\n * // @log: '0x000000000000000000000000000000000000000000000000000000000000002a'\n * ```\n *\n * @param abiFunction - The ABI item to encode the function output for.\n * @param output - The function output to encode.\n * @param options - Encoding options.\n * @returns The encoded function output.\n */\nexport function encodeResult(abiFunction, output, options = {}) {\n    const { as = 'Array' } = options;\n    const values = (() => {\n        if (abiFunction.outputs.length === 1)\n            return [output];\n        if (Array.isArray(output))\n            return output;\n        if (as === 'Object')\n            return Object.values(output);\n        return [output];\n    })();\n    return AbiParameters.encode(abiFunction.outputs, values);\n}\n/**\n * Formats an {@link ox#AbiFunction.AbiFunction} into a **Human Readable ABI Function**.\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const formatted = AbiFunction.format({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * formatted\n * //    ^?\n *\n *\n * ```\n *\n * @param abiFunction - The ABI Function to format.\n * @returns The formatted ABI Function.\n */\nexport function format(abiFunction) {\n    return abitype.formatAbiItem(abiFunction);\n}\n/**\n * Parses an arbitrary **JSON ABI Function** or **Human Readable ABI Function** into a typed {@link ox#AbiFunction.AbiFunction}.\n *\n * @example\n * ### JSON ABIs\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from({\n *   type: 'function',\n *   name: 'approve',\n *   stateMutability: 'nonpayable',\n *   inputs: [\n *     {\n *       name: 'spender',\n *       type: 'address',\n *     },\n *     {\n *       name: 'amount',\n *       type: 'uint256',\n *     },\n *   ],\n *   outputs: [{ type: 'bool' }],\n * })\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Human Readable ABIs\n *\n * A Human Readable ABI can be parsed into a typed ABI object:\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from(\n *   'function approve(address spender, uint256 amount) returns (bool)' // [!code hl]\n * )\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * It is possible to specify `struct`s along with your definitions:\n *\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const approve = AbiFunction.from([\n *   'struct Foo { address spender; uint256 amount; }', // [!code hl]\n *   'function approve(Foo foo) returns (bool)',\n * ])\n *\n * approve\n * //^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n *\n *\n * @param abiFunction - The ABI Function to parse.\n * @returns Typed ABI Function.\n */\nexport function from(abiFunction, options = {}) {\n    return AbiItem.from(abiFunction, options);\n}\n/**\n * Extracts an {@link ox#AbiFunction.AbiFunction} from an {@link ox#Abi.Abi} given a name and optional arguments.\n *\n * @example\n * ### Extracting by Name\n *\n * ABI Functions can be extracted by their name using the `name` option:\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n *\n * const item = AbiFunction.fromAbi(abi, 'foo') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n * ```\n *\n * @example\n * ### Extracting by Selector\n *\n * ABI Functions can be extract by their selector when {@link ox#Hex.Hex} is provided to `name`.\n *\n * ```ts twoslash\n * import { Abi, AbiFunction } from 'ox'\n *\n * const abi = Abi.from([\n *   'function foo()',\n *   'event Transfer(address owner, address to, uint256 tokenId)',\n *   'function bar(string a) returns (uint256 x)',\n * ])\n * const item = AbiFunction.fromAbi(abi, '0x095ea7b3') // [!code focus]\n * //    ^?\n *\n *\n *\n *\n *\n *\n *\n *\n *\n * ```\n *\n * :::note\n *\n * Extracting via a hex selector is useful when extracting an ABI Function from an `eth_call` RPC response or\n * from a Transaction `input`.\n *\n * :::\n *\n * @param abi - The ABI to extract from.\n * @param name - The name (or selector) of the ABI item to extract.\n * @param options - Extraction options.\n * @returns The ABI item.\n */\nexport function fromAbi(abi, name, options) {\n    const item = AbiItem.fromAbi(abi, name, options);\n    if (item.type !== 'function')\n        throw new AbiItem.NotFoundError({ name, type: 'function' });\n    return item;\n}\n/**\n * Computes the [4-byte selector](https://solidity-by-example.org/function-selector/) for an {@link ox#AbiFunction.AbiFunction}.\n *\n * Useful for computing function selectors for calldata.\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const selector = AbiFunction.getSelector('function ownerOf(uint256 tokenId)')\n * // @log: '0x6352211e'\n * ```\n *\n * @example\n * ```ts twoslash\n * import { AbiFunction } from 'ox'\n *\n * const selector = AbiFunction.getSelector({\n *   inputs: [{ type: 'uint256' }],\n *   name: 'ownerOf',\n *   outputs: [],\n *   stateMutability: 'view',\n *   type: 'function'\n * })\n * // @log: '0x6352211e'\n * ```\n *\n * @param abiItem - The ABI item to compute the selector for.\n * @returns The first 4 bytes of the {@link ox#Hash.(keccak256:function)} hash of the function signature.\n */\nexport function getSelector(abiItem) {\n    return AbiItem.getSelector(abiItem);\n}\n//# sourceMappingURL=AbiFunction.js.map"],"names":["PolkadotService","_PolkadotService","api","chain","create","_moonbeam_network_xcm_utils__WEBPACK_IMPORTED_MODULE_1__","Gu","ws","createMulti","chains","Promise","all","map","decimals","registry","chainDecimals","at","existentialDeposit","consts","balances","eqExistentialDeposit","eqBalances","amount","toBigInt","_moonbeam_network_xcm_types__WEBPACK_IMPORTED_MODULE_0__","nE","fromChainAsset","nativeAsset","query","config","response","module","func","args","transform","getExtrinsic","fn","tx","getArgs","getExtrinsicCallHash","method","toHex","getPaymentInfo","account","extrinsic","paymentInfo","nonce","getFee","info","partialFee","transfer","signer","statusCallback","isSigner","signOptions","withSignedTransaction","resolve","reject","signAndSend","result","isError","dispatchError","toString","txHash","catch","EvmService","_EvmService","client","constructor","viem__WEBPACK_IMPORTED_MODULE_4__","v","getViemChain","transport","viem__WEBPACK_IMPORTED_MODULE_5__","d","address","contract","gas","estimateContractGas","abi","functionName","getGasPrice","getBalance","balance","readContract","name","request","simulateContract","writeContract","asset","builder","build","_moonbeam_network_xcm_builder__WEBPACK_IMPORTED_MODULE_2__","K0","is","Gf","isAnyParachain","polkadot","converted","usesChainDecimals","Lv","copyWith","Cd","evm","Jg","HM","symbol","getAssetMin","zero","getChainAsset","min","getMinAssetId","getMin","fee","big_js__WEBPACK_IMPORTED_MODULE_3__","Z","plus","isSame","toBig","lt","BigInt","toFixed","getMax","minus","getDestinationFee","destination","feeAsset","source","cfg","call","convertToChainDecimals","target","convertDecimals","getExistentialDeposit","getDestinationFeeBalance","feeBalance","route","sourceAddress","isEqual","destinationFee","getDestinationFeeAssetOnSource","getExtrinsicFee","feeConfig","extra","Gh","totalFee","error","getContractFee","toDecimal","getSymbol","cause","getSourceData","destinationAddress","sourcePolkadot","destinationPolkadot","destinationFeeBalance","destinationApi","sourceApi","max","getAssetsBalances","routes","uniqueRoutes","reduce","acc","some","a","getDestinationData","sovereignAccountBalances","getSovereignAccountBalances","$Z","checkSovereignAccountBalances","sovereignAccountAddresses","MX","parachainId","destinationFeeAssetBalance","sovereignAccountAddress","isRelay","relay","generic","sovereignAccountBalance","sovereignAccountFeeAssetBalance","feeAssetBalance","transferAssetBalance","getTransferData","destinationData","sourceData","getEstimate","bigAmount","evmSigner","polkadotSigner","bigintAmount","validateSovereignAccountBalances","DEFAULT_SERVICE","_moonbeam_network_xcm_config__WEBPACK_IMPORTED_MODULE_6__","E4","lX","Sdk","configService","ecosystem","service","assets","getEcosystemAssets","setAsset","sources","getSourceChains","setSource","destinations","getDestinationChains","setDestination","getAssetRoute","setAddresses","sourceChain","getChain","getParachainBalances","getChainRoutes","getRoutes","multicall","parameters","allowFailure","batchSize","batchSize_","blockNumber","blockTag","multicallAddress","multicallAddress_","stateOverride","contracts","batch","getChainContractAddress","chunkedCalls","currentChunk","currentChunkSize","i","length","callData","encodeFunctionData","err","getContractError","docsPath","aggregate3Results","allSettled","getAction","multicall3Abi","calls","results","status","reason","j","push","undefined","aggregate3Result","value","returnData","success","AbiDecodingZeroDataError","RawContractError","data","decodeFunctionResult","BaseError","rest","calldata","to","isNullUniversalResolverError","callType","walk","e","ContractFunctionRevertedError","errorName","includes","panicReasons","encodedLabelToLabelhash","label","indexOf","hash","concat","slice","isHex","namehash","Uint8Array","fill","bytesToHex","labels","split","hashFromEncodedLabel","hashed","toBytes","keccak256","stringToBytes","packetToBytes","packet","replace","bytes","byteLength","offset","list","encoded","labelhash","set","getEnsAddress","param","coinType","gatewayUrls","strict","universalResolverAddress","universalResolverAddress_","functionData","addressResolverAbi","readContractParameters","universalResolverResolveAbi","readContractAction","res","trim","EnsAvatarInvalidMetadataError","metaMessages","JSON","stringify","EnsAvatarInvalidNftUriError","EnsAvatarUriResolutionError","uri","EnsAvatarUnsupportedNamespaceError","namespace","networkRegex","RegExp","ipfsHashRegex","base64Regex","dataURIRegex","isImageUri","fetch","contentType","headers","get","startsWith","globalThis","hasOwnProperty","img","Image","onload","onerror","src","getGateway","custom","defaultGateway","endsWith","resolveAvatarUri","isEncoded","test","isOnChain","ipfsGateway","ipfs","arweaveGateway","arweave","networkRegexMatch","match","protocol","subpath","subtarget","groups","isIPNS","isIPFS","replacedUri","parsedUri","btoa","getJsonImage","image","image_url","image_data","getMetadataAvatarUri","then","json","parseAvatarUri","resolvedURI","getNftTokenUri","nft","contractAddress","type","stateMutability","inputs","outputs","tokenID","parseAvatarRecord","record","parseNftAvatarUri","parseNftUri","uri_","reference","asset_namespace","eip_namespace","chainID","erc_namespace","toLowerCase","Number","parseInt","resolvedNftUri","parse","atob","uriTokenId","padStart","getEnsText","key","textResolverAbi","getEnsAvatar","assetGatewayUrls","getEnsName","reverseNode","substring","universalResolverReverseAbi","resolvedAddress","getEnsResolver","resolverAddress","createAccessList","account_","blobs","gasPrice","maxFeePerBlobGas","maxFeePerGas","maxPriorityFeePerGas","parseAccount","assertRequest","blockNumberHex","numberToHex","chainFormat","formatters","transactionRequest","format","formatTransactionRequest","extract","from","params","accessList","gasUsed","getCallError","createFilterRequestScope","requestMap","onResponse","method_","id","createBlockFilter","getRequest","FilterTypeNotSupportedError","encodeEventTopics","eventName","abiItem","item","getAbiItem","AbiEventNotFoundError","definition","formatAbiItem","signature","toEventSelector","topics","indexedInputs","filter","indexed","args_","Array","isArray","Object","values","x","_","encodeArg","encodeAbiParameters","createContractEventFilter","fromBlock","toBlock","Boolean","createEventFilter","event","events","events_","arguments","flatMap","createPendingTransactionFilter","dataSuffix","estimateGas","sender","getBlobBaseFee","getBlockTransactionCount","count","blockHash","dedupe","hexToNumber","getCode","hex","decodeEventLog","strict_","argTopics","AbiEventSignatureEmptyTopicsError","find","AbiEventSignatureNotFoundError","isUnnamed","topic","DecodeLogTopicsMismatch","decodeTopic","decodedArg","decodeAbiParameters","nonIndexedInputs","decodedData","AbiDecodingDataSizeTooSmallError","PositionOutOfBoundsError","DecodeLogDataMismatch","size","parseEventLogs","logs","log","includesArgs","matchArgs","input","arg","isAddressEqual","every","index","value_","entries","getLogs","formattedLogs","formatLog","getContractEvents","Eip712DomainNotFoundError","getEip712Domain","factory","factoryData","fields","version","chainId","verifyingContract","salt","extensions","domain","getFeeHistory","feeHistory","blockCount","rewardPercentiles","baseFeePerGas","gasUsedRatio","oldestBlock","reward","getFilterChanges","_client","getFilterLogs","getProof","proof","blockTag_","storageKeys","storageProof","getStorageAt","slot","getTransactionConfirmations","transactionReceipt","transaction","getBlockNumber","getTransaction","transactionBlockNumber","Error","shortMessage","options","details","message","docs","join","defineProperty","enumerable","configurable","writable","assertSize","size_","Hex_size","SizeOverflowError","givenSize","maxSize","pad","hex_","dir","SizeExceedsPaddingSizeError","Math","ceil","targetSize","encoder","TextEncoder","hexes","_v","Hex_concat","fromBoolean","padLeft","fromBytes","string","padRight","fromNumber","maxValue","signed","MAX_SAFE_INTEGER","minValue","suffix","IntegerOutOfRangeError","stringValue","fromString","encode","start","end","assertStartOffset","SliceOffsetOutOfBoundsError","position","assertEndOffset","InvalidHexTypeError","space","InvalidHexValueError","charAt","toUpperCase","toRpc","withdrawal","validatorIndex","simulateBlocks","blocks","returnFullTransactions","traceTransfers","validation","blockStateCalls","block","blockOverrides","blobBaseFee","feeRecipient","gasLimit","number","prevRandao","time","withdrawals","call_","stateOverrides","serializeStateOverride","formatBlock","getNodeError","UnknownNodeError","charCodeMap","nine","A","F","f","charCodeToBase16","char","Bytes_encoder","Bytes_SizeOverflowError","Bytes_SizeExceedsPaddingSizeError","Hash_keccak256","as","sha3","fr","Bytes_fromHex","hexString","nibbleLeft","charCodeAt","nibbleRight","LruMap","Map","has","delete","firstKey","keys","next","checksum","caches","addressRegex","Address_assert","InvalidAddressError","InvalidInputError","Address_checksum","hexAddress","Bytes_fromString","bytes_assertSize","Bytes_size","bytes_pad","paddedBytes","padEnd","characters","InvalidChecksumError","Address_validate","normalizeSignature","active","current","level","valid","AbiItem_from","prepare","parseAbiItem","utils","cK","structs","runtime_structs","D","signature_","signatures","N0","errors_abiItem","a_","getSignatureHash","getSelector","human_readable_formatAbiItem","t","AmbiguityError","y","NotFoundError","arrayRegex","bytesRegex","integerRegex","preparedParameters","staticSize","dynamic","staticParameters","dynamicParameters","dynamicSize","AbiParameters_encode","checksumAddress","LengthMismatchError","expectedLength","givenLength","prepareParameters","prepareParameter","parameter","parameter_","arrayComponents","getArrayComponents","matches","encodeArray","InvalidArrayError","ArrayLengthMismatchError","dynamicChild","preparedParam","encodeTuple","components","param_","encodeAddress","encodeBoolean","exec","encodeNumber","encodeBytes","parametersize","bytesSize","BytesSizeMismatchError","expectedSize","encodeString","hexValue","partsLength","parts","InvalidTypeError","encodePacked","types","intMatch","_type","baseType","bits","bytesMatch","arrayMatch","childType","AbiFunction_from","abiFunction","zeroAddress","simulateCalls","block_calls","block_ethPre","block_assetsPre","block_ethPost","block_assetsPost","block_decimals","block_symbols","block_tokenURI","traceAssetChanges","getBalanceData","AbiConstructor","abiConstructor","bytecode","deploylessCallViaBytecodeBytecode","AbiFunction","overloads","AbiFunction_fromAbi","fromAbi","matchedAbiItem","isSelector","validate","assert","abiItems","abiParameter","isArgOfType","argType","abiParameterType","component","ambiguousTypes","getAmbiguousTypes","sourceParameters","targetParameters","parameterIndex","sourceParameter","targetParameter","selector","assetAddresses","flat","resultsStateOverrides","override","block_results","balancesPre","hexToBigInt","balancesPost","symbols","tokenURI","changes","balancePost","balancePre","decimals_","symbol_","tokenURI_","token","change","pre","post","diff","assetChanges","callRequest","minimizedAbi","uninstallFilter","hashMessage","to_","toPrefixedMessage","message_","stringToHex","raw","prefix","erc6492MagicBytes","verifyHash","universalSignatureVerifierAddress","universalSignatureVerifier","signatureHex","serializeSignature","r","s","yParity","yParity_","secp256k1","Signature","toCompactHex","hexToBytes","wrappedSignature","sliceHex","serializeErc6492Signature","concatHex","universalSignatureValidatorAbi","encodeDeployData","universalSignatureValidatorByteCode","hexToBool","getAddress","recoverAddress","CallExecutionError","verifyMessage","hashStruct","primaryType","encodeData","encodedTypes","encodedValues","hashType","encodedHashType","encodeType","unsortedDeps","findTypeDependencies","primaryType_","Set","field","add","sort","encodeField","prepend","lastIndexOf","parsedType","typeValuePairs","verifyTypedData","hashTypedData","EIP712Domain","getTypesForEIP712Domain","validateTypedData","hashDomain","prefixRegex","suffixRegex","verifySiweMessage","scheme","Date","parsed","parseSiweMessage","statement","expirationTime","issuedAt","notBefore","requestId","resources","validateSiweMessage","publicActions","getBlock","getBytecode","getChainId","estimateFeesPerGas","estimateMaxPriorityFeePerGas","getTransactionCount","getTransactionReceipt","prepareTransactionRequest","sendRawTransaction","simulate","waitForTransactionReceipt","watchBlocks","emitFetched","unsubscribe","prevBlock","emitMissed","emitOnBegin","onBlock","onError","includeTransactions","includeTransactions_","poll","poll_","pollingInterval","enablePolling","transports","pollBlocks","observerId","uid","observe","emit","interval","unsubscribe_","subscribe","onData","watchBlockNumber","watchContractEvent","onLogs","pollContractEvent","previousBlockNumber","initialized","unwatch","InvalidInputRpcError","subscribeContractEvent","formatted","watchEvent","pollEvent","watchPendingTransactions","onTransactions","pollPendingTransactions","hashes","createPublicClient","createClient","extend","b","isAddress","InvalidDomainError","InvalidPrimaryTypeError","InvalidStructTypeError","serializeTypedData","domain_","normalizeData","struct","data_","validateData","integerMatch","base","validateReference"],"sourceRoot":""}