tenjin-cli 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/{chunk-IPOWB3G3.js → chunk-UGX7YPX2.js}

@@ -1,9 +1,17 @@
 import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
 import {
+  assertTransactionEIP1559,
+  assertTransactionEIP2930,
+  assertTransactionEIP4844,
+  assertTransactionEIP7702,
+  assertTransactionLegacy,
   blobsToCommitments,
   blobsToProofs,
+  commitmentToVersionedHash,
   commitmentsToVersionedHashes,
+  getTransactionCount,
   getTransactionType,
+  getTypesForEIP712Domain,
   hashAuthorization,
   hashMessage,
   hashTypedData,
@@ -11,12 +19,17 @@ import {
   publicKeyToAddress,
   serializeSignature,
   serializeTransaction,
+  serializeTypedData,
   toBlobSidecars,
-  toRlp
-} from "./chunk-T4LKNY7T.js";
+  toRlp,
+  validateTypedData
+} from "./chunk-NCE5NSN6.js";
+import {
+  ripemd160
+} from "./chunk-RY4XKNV3.js";
 import {
   secp256k1
-} from "./chunk-Q53IYV2G.js";
+} from "./chunk-QVX5MWJZ.js";
 import {
   AtomicReadyWalletRejectedUpgradeError,
   AtomicityNotSupportedError,
@@ -43,6 +56,7 @@ import {
   ResourceUnavailableRpcError,
   ResponseBodyTooLargeError,
   RpcRequestError,
+  SocketClosedError,
   SwitchChainError,
   TimeoutError,
   TransactionRejectedRpcError,
@@ -54,11 +68,15 @@ import {
   UnsupportedProviderMethodError,
   UserRejectedRequestError,
   WalletConnectSessionSettlementError,
+  WebSocketRequestError,
   addressResolverAbi,
   assertRequest,
+  batchGatewayAbi,
   call,
+  ccipRequest,
   createBatchScheduler,
   decodeAbiParameters,
+  decodeErrorResult,
   decodeFunctionResult,
   defineFormatter,
   deploylessCallViaBytecodeBytecode,
@@ -71,7 +89,6 @@ import {
   extract,
   formatAbiItem as formatAbiItem2,
   formatAbiParameters,
-  formatBlockParameter,
   formatTransactionRequest,
   getAbiItem,
   getAbortError,
@@ -86,57 +103,86 @@ import {
   parseAbiItem,
   parseAbiParameters,
   serializeStateOverride,
+  solidityError,
   textResolverAbi,
   toEventSelector,
   toRpc,
   universalResolverResolveAbi,
   universalResolverReverseAbi,
   withResolvers
-} from "./chunk-LPRVHM7P.js";
+} from "./chunk-ZMHYXMO6.js";
 import {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
   AbiDecodingDataSizeTooSmallError,
   AbiDecodingZeroDataError,
+  AbiEncodingLengthMismatchError,
   AbiEventNotFoundError,
   AbiEventSignatureEmptyTopicsError,
   AbiEventSignatureNotFoundError,
   BaseError,
   BaseError2,
+  BytesSizeMismatchError,
+  ChainMismatchError,
+  ChainNotFoundError,
   DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
-  IntegerOutOfRangeError,
+  ExecutionRevertedError,
+  IntegerOutOfRangeError2 as IntegerOutOfRangeError,
   InvalidAddressError,
+  InvalidHexValueError,
+  InvalidLegacyVError,
+  InvalidSerializedTransactionError,
+  InvalidSerializedTransactionTypeError,
+  InvalidYParityError,
   LruMap,
   PositionOutOfBoundsError,
+  RlpDepthLimitExceededError,
+  RlpListBoundaryExceededError,
+  RlpTrailingBytesError,
   TransactionExecutionError,
   TransactionNotFoundError,
   TransactionReceiptNotFoundError,
   TransactionReceiptRevertedError,
   UnknownNodeError,
+  UnsupportedPackedAbiType,
   WaitForTransactionReceiptTimeoutError,
+  arrayRegex,
+  boolToHex,
+  bytesRegex,
   bytesToHex,
+  checksumAddress,
   concat,
   concat2,
   concatHex,
+  createCursor,
   encodeAbiParameters,
+  etherUnits,
   formatAbiItem,
+  formatBlockParameter,
   formatEther,
   formatGwei,
   formatUnits,
   from,
   fromBoolean,
   fromBytes,
-  fromHex,
+  fromHex2 as fromHex,
   fromNumber,
   fromString,
   fromString2,
   getAddress,
+  gweiUnits,
   hexToBigInt,
   hexToBool,
+  hexToBytes,
   hexToNumber,
+  integerRegex,
   isAddress,
   isHex,
   keccak256,
   numberToHex,
+  pad,
+  padHex,
   padLeft,
   padRight,
   parseAccount,
@@ -147,7 +193,9 @@ import {
   slice,
   slice2,
   slice3,
+  sliceHex,
   stringToBytes,
+  stringToHex,
   stringify,
   stringify2,
   toBigInt,
@@ -162,10 +210,10 @@ import {
   trimLeft2,
   validate,
   validate2
-} from "./chunk-BRJHUQSY.js";
+} from "./chunk-YALGASEU.js";
 import {
   __export
-} from "./chunk-3IMLRUZE.js";
+} from "./chunk-ZXTAQYNA.js";
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/getAction.js
 function getAction(client, actionFn, name) {
@@ -272,7 +320,7 @@ async function createContractEventFilter(client, parameters) {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/errors/getContractError.js
 var EXECUTION_REVERTED_ERROR_CODE = 3;
-function getContractError(err, { abi: abi2, address, args, docsPath: docsPath3, functionName, sender }) {
+function getContractError(err, { abi: abi2, address, args, docsPath: docsPath4, functionName, sender }) {
   const error = err instanceof RawContractError ? err : err instanceof BaseError ? err.walk((err2) => "data" in err2) || err.walk() : {};
   const { code, data, details, message, shortMessage } = error;
   const cause = (() => {
@@ -293,7 +341,7 @@ function getContractError(err, { abi: abi2, address, args, docsPath: docsPath3,
     abi: abi2,
     args,
     contractAddress: address,
-    docsPath: docsPath3,
+    docsPath: docsPath4,
     functionName,
     sender
   });
@@ -302,7 +350,7 @@ function getContractError(err, { abi: abi2, address, args, docsPath: docsPath3,
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
 async function recoverPublicKey({ hash: hash2, signature }) {
   const hashHex = isHex(hash2) ? hash2 : toHex(hash2);
-  const { secp256k1: secp256k12 } = await import("./secp256k1-BEZS642W.js");
+  const { secp256k1: secp256k12 } = await import("./secp256k1-N3ZHU7LB.js");
   const signature_ = (() => {
     if (typeof signature === "object" && "r" in signature && "s" in signature) {
       const { r, s, v, yParity } = signature;
@@ -346,7 +394,7 @@ async function recoverAuthorizationAddress(parameters) {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/estimateGas.js
 var EstimateGasExecutionError = class extends BaseError {
-  constructor(cause, { account, docsPath: docsPath3, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
+  constructor(cause, { account, docsPath: docsPath4, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
     const prettyArgs = prettyPrint({
       from: account?.address,
       to,
@@ -360,7 +408,7 @@ var EstimateGasExecutionError = class extends BaseError {
     });
     super(cause.shortMessage, {
       cause,
-      docsPath: docsPath3,
+      docsPath: docsPath4,
       metaMessages: [
         ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
         "Estimate Gas Arguments:",
@@ -379,7 +427,7 @@ var EstimateGasExecutionError = class extends BaseError {
 };
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
-function getEstimateGasError(err, { docsPath: docsPath3, ...args }) {
+function getEstimateGasError(err, { docsPath: docsPath4, ...args }) {
   const cause = (() => {
     const cause2 = getNodeError(err, args);
     if (cause2 instanceof UnknownNodeError)
@@ -387,7 +435,7 @@ function getEstimateGasError(err, { docsPath: docsPath3, ...args }) {
     return cause2;
   })();
   return new EstimateGasExecutionError(cause, {
-    docsPath: docsPath3,
+    docsPath: docsPath4,
     ...args
   });
 }
@@ -613,7 +661,7 @@ async function internal_estimateFeesPerGas(client, args) {
     throw new BaseFeeScalarError();
   const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
   const denominator = 10 ** decimals;
-  const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
+  const multiply = (base) => base * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
   const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
   if (typeof chain?.fees?.estimateFeesPerGas === "function") {
     const fees = await chain.fees.estimateFeesPerGas({
@@ -647,25 +695,8 @@ async function internal_estimateFeesPerGas(client, args) {
   };
 }
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/getTransactionCount.js
-async function getTransactionCount(client, { address, blockHash, blockNumber, blockTag = "latest", requireCanonical }) {
-  const block = formatBlockParameter({
-    blockHash,
-    blockNumber,
-    blockTag,
-    requireCanonical
-  });
-  const count = await client.request({
-    method: "eth_getTransactionCount",
-    params: [address, block]
-  }, {
-    dedupe: typeof blockNumber === "bigint" || blockHash !== void 0
-  });
-  return hexToNumber(count);
-}
-
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/errors/getTransactionError.js
-function getTransactionError(err, { docsPath: docsPath3, ...args }) {
+function getTransactionError(err, { docsPath: docsPath4, ...args }) {
   const cause = (() => {
     const cause2 = getNodeError(err, args);
     if (cause2 instanceof UnknownNodeError)
@@ -673,7 +704,7 @@ function getTransactionError(err, { docsPath: docsPath3, ...args }) {
     return cause2;
   })();
   return new TransactionExecutionError(cause, {
-    docsPath: docsPath3,
+    docsPath: docsPath4,
     ...args
   });
 }
@@ -688,17 +719,17 @@ async function getChainId(client) {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/fillTransaction.js
 async function fillTransaction(client, parameters) {
-  const { account = client.account, accessList, authorizationList, chain = client.chain, blobVersionedHashes, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce: nonce_, nonceManager, to, type, value, ...rest } = parameters;
+  const { account = client.account, accessList, authorizationList, chain = client.chain, blobVersionedHashes, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce: nonce_, nonceManager: nonceManager2, to, type, value, ...rest } = parameters;
   const nonce = await (async () => {
     if (!account)
       return nonce_;
-    if (!nonceManager)
+    if (!nonceManager2)
       return nonce_;
     if (typeof nonce_ !== "undefined")
       return nonce_;
     const account_ = parseAccount(account);
     const chainId = chain ? chain.id : await getAction(client, getChainId, "getChainId")({});
-    return await nonceManager.consume({
+    return await nonceManager2.consume({
       address: account_.address,
       chainId,
       client
@@ -768,7 +799,7 @@ async function fillTransaction(client, parameters) {
       throw new BaseFeeScalarError();
     const decimals = feeMultiplier.toString().split(".")[1]?.length ?? 0;
     const denominator = 10 ** decimals;
-    const multiplyFee = (base2) => base2 * BigInt(Math.ceil(feeMultiplier * denominator)) / BigInt(denominator);
+    const multiplyFee = (base) => base * BigInt(Math.ceil(feeMultiplier * denominator)) / BigInt(denominator);
     if (!transaction.feePayerSignature) {
       if (transaction.maxFeePerGas && !parameters.maxFeePerGas)
         transaction.maxFeePerGas = multiplyFee(transaction.maxFeePerGas);
@@ -806,7 +837,7 @@ async function prepareTransactionRequest(client, args) {
   let request = args;
   request.account ??= client.account;
   request.parameters ??= defaultParameters;
-  const { account: account_, chain = client.chain, nonceManager, parameters } = request;
+  const { account: account_, chain = client.chain, nonceManager: nonceManager2, parameters } = request;
   const prepareTransactionRequest2 = (() => {
     if (typeof chain?.prepareTransactionRequest === "function")
       return {
@@ -834,9 +865,9 @@ async function prepareTransactionRequest(client, args) {
   }
   const account = account_ ? parseAccount(account_) : account_;
   let nonce = request.nonce;
-  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager) {
+  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager2) {
     const chainId2 = await getChainId2();
-    nonce = await nonceManager.consume({
+    nonce = await nonceManager2.consume({
       address: account.address,
       chainId: chainId2,
       client
@@ -928,7 +959,7 @@ async function prepareTransactionRequest(client, args) {
     block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
     return block;
   }
-  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && !nonceManager)
+  if (parameters.includes("nonce") && typeof nonce === "undefined" && account && !nonceManager2)
     request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
       address: account.address,
       blockTag: "pending"
@@ -1809,17 +1840,34 @@ function watchContractEvent(client, parameters) {
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/account.js
 var AccountNotFoundError = class extends BaseError {
-  constructor({ docsPath: docsPath3 } = {}) {
+  constructor({ docsPath: docsPath4 } = {}) {
     super([
       "Could not find an Account to execute with this Action.",
       "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
     ].join("\n"), {
-      docsPath: docsPath3,
+      docsPath: docsPath4,
       docsSlug: "account",
       name: "AccountNotFoundError"
     });
   }
 };
+var AccountTypeNotSupportedError = class extends BaseError {
+  constructor({ docsPath: docsPath4, metaMessages, type }) {
+    super(`Account type "${type}" is not supported.`, {
+      docsPath: docsPath4,
+      metaMessages,
+      name: "AccountTypeNotSupportedError"
+    });
+  }
+};
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
+function assertCurrentChain({ chain, currentChainId }) {
+  if (!chain)
+    throw new ChainNotFoundError();
+  if (currentChainId !== chain.id)
+    throw new ChainMismatchError({ chain, currentChainId });
+}
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
 async function sendRawTransaction(client, { serializedTransaction }) {
@@ -1829,6 +1877,381 @@ async function sendRawTransaction(client, { serializedTransaction }) {
   }, { retryCount: 0 });
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendTransaction.js
+var supportsWalletNamespace = new LruMap(128);
+async function sendTransaction(client, parameters) {
+  const { account: account_ = client.account, assertChainId = true, chain = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, type, value, ...rest } = parameters;
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const account = account_ ? parseAccount(account_) : null;
+  let nonceManagerParameters;
+  try {
+    assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      if (parameters.to === null)
+        return void 0;
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0]
+        }).catch(() => {
+          throw new BaseError("`to` is required. Could not infer from `authorizationList`.");
+        });
+      return void 0;
+    })();
+    if (account?.type === "json-rpc" || account === null) {
+      let chainId;
+      if (chain !== null) {
+        chainId = await getAction(client, getChainId, "getChainId")({});
+        if (assertChainId)
+          assertCurrentChain({
+            currentChainId: chainId,
+            chain
+          });
+      }
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+      const format = chainFormat || formatTransactionRequest;
+      const request = format({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        account,
+        authorizationList,
+        blobs,
+        chainId,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        type,
+        value
+      }, "sendTransaction");
+      const isWalletNamespaceSupported = supportsWalletNamespace.get(client.uid);
+      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
+      try {
+        return await client.request({
+          method,
+          params: [request]
+        }, { retryCount: 0 });
+      } catch (e) {
+        if (isWalletNamespaceSupported === false)
+          throw e;
+        const error = e;
+        if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
+          return await client.request({
+            method: "wallet_sendTransaction",
+            params: [request]
+          }, { retryCount: 0 }).then((hash2) => {
+            supportsWalletNamespace.set(client.uid, true);
+            return hash2;
+          }).catch((e2) => {
+            const walletNamespaceError = e2;
+            if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
+              supportsWalletNamespace.set(client.uid, false);
+              throw error;
+            }
+            throw walletNamespaceError;
+          });
+        }
+        throw error;
+      }
+    }
+    if (account?.type === "local") {
+      if (account.nonceManager && typeof nonce === "undefined") {
+        const requestChainId = rest.chainId;
+        const chainId = await (async () => {
+          if (typeof requestChainId === "number")
+            return requestChainId;
+          if (chain)
+            return chain.id;
+          return getAction(client, getChainId, "getChainId")({});
+        })();
+        nonceManagerParameters = { address: account.address, chainId };
+      }
+      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager: account.nonceManager,
+        parameters: [...defaultParameters, "sidecars"],
+        type,
+        value,
+        ...rest,
+        to
+      });
+      const serializer = chain?.serializers?.transaction;
+      const serializedTransaction = await account.signTransaction(request, {
+        serializer
+      });
+      return await getAction(client, sendRawTransaction, "sendRawTransaction")({
+        serializedTransaction
+      });
+    }
+    if (account?.type === "smart")
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          "Consider using the `sendUserOperation` Action instead."
+        ],
+        docsPath: "/docs/actions/bundler/sendUserOperation",
+        type: "smart"
+      });
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/actions/wallet/sendTransaction",
+      type: account?.type
+    });
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError)
+      throw err;
+    if (nonceManagerParameters)
+      account?.nonceManager?.reset(nonceManagerParameters);
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || void 0
+    });
+  }
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/writeContract.js
+async function writeContract(client, parameters) {
+  return writeContract.internal(client, sendTransaction, "sendTransaction", parameters);
+}
+(function(writeContract2) {
+  async function internal(client, actionFn, name, parameters) {
+    const { abi: abi2, account: account_ = client.account, address, args, functionName, ...request } = parameters;
+    if (typeof account_ === "undefined")
+      throw new AccountNotFoundError({
+        docsPath: "/docs/contract/writeContract"
+      });
+    const account = account_ ? parseAccount(account_) : null;
+    const data = encodeFunctionData({
+      abi: abi2,
+      args,
+      functionName
+    });
+    try {
+      return await getAction(client, actionFn, name)({
+        data,
+        to: address,
+        account,
+        ...request
+      });
+    } catch (error) {
+      throw getContractError(error, {
+        abi: abi2,
+        address,
+        args,
+        docsPath: "/docs/contract/writeContract",
+        functionName,
+        sender: account?.address
+      });
+    }
+  }
+  writeContract2.internal = internal;
+})(writeContract || (writeContract = {}));
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/getContract.js
+function getContract({ abi: abi2, address, client: client_ }) {
+  const client = client_;
+  const [publicClient, walletClient] = (() => {
+    if (!client)
+      return [void 0, void 0];
+    if ("public" in client && "wallet" in client)
+      return [client.public, client.wallet];
+    if ("public" in client)
+      return [client.public, void 0];
+    if ("wallet" in client)
+      return [void 0, client.wallet];
+    return [client, client];
+  })();
+  const hasPublicClient = publicClient !== void 0 && publicClient !== null;
+  const hasWalletClient = walletClient !== void 0 && walletClient !== null;
+  const contract = {};
+  let hasReadFunction = false;
+  let hasWriteFunction = false;
+  let hasEvent = false;
+  for (const item of abi2) {
+    if (item.type === "function")
+      if (item.stateMutability === "view" || item.stateMutability === "pure")
+        hasReadFunction = true;
+      else
+        hasWriteFunction = true;
+    else if (item.type === "event")
+      hasEvent = true;
+    if (hasReadFunction && hasWriteFunction && hasEvent)
+      break;
+  }
+  if (hasPublicClient) {
+    if (hasReadFunction)
+      contract.read = new Proxy({}, {
+        get(_, functionName) {
+          return (...parameters) => {
+            const { args, options } = getFunctionParameters(parameters);
+            return getAction(publicClient, readContract, "readContract")({
+              abi: abi2,
+              address,
+              functionName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+    if (hasWriteFunction)
+      contract.simulate = new Proxy({}, {
+        get(_, functionName) {
+          return (...parameters) => {
+            const { args, options } = getFunctionParameters(parameters);
+            return getAction(publicClient, simulateContract, "simulateContract")({
+              abi: abi2,
+              address,
+              functionName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+    if (hasEvent) {
+      contract.createEventFilter = new Proxy({}, {
+        get(_, eventName) {
+          return (...parameters) => {
+            const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
+            const { args, options } = getEventParameters(parameters, abiEvent);
+            return getAction(publicClient, createContractEventFilter, "createContractEventFilter")({
+              abi: abi2,
+              address,
+              eventName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+      contract.getEvents = new Proxy({}, {
+        get(_, eventName) {
+          return (...parameters) => {
+            const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
+            const { args, options } = getEventParameters(parameters, abiEvent);
+            return getAction(publicClient, getContractEvents, "getContractEvents")({
+              abi: abi2,
+              address,
+              eventName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+      contract.watchEvent = new Proxy({}, {
+        get(_, eventName) {
+          return (...parameters) => {
+            const abiEvent = abi2.find((x) => x.type === "event" && x.name === eventName);
+            const { args, options } = getEventParameters(parameters, abiEvent);
+            return getAction(publicClient, watchContractEvent, "watchContractEvent")({
+              abi: abi2,
+              address,
+              eventName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+    }
+  }
+  if (hasWalletClient) {
+    if (hasWriteFunction)
+      contract.write = new Proxy({}, {
+        get(_, functionName) {
+          return (...parameters) => {
+            const { args, options } = getFunctionParameters(parameters);
+            return getAction(walletClient, writeContract, "writeContract")({
+              abi: abi2,
+              address,
+              functionName,
+              args,
+              ...options
+            });
+          };
+        }
+      });
+  }
+  if (hasPublicClient || hasWalletClient) {
+    if (hasWriteFunction)
+      contract.estimateGas = new Proxy({}, {
+        get(_, functionName) {
+          return (...parameters) => {
+            const { args, options } = getFunctionParameters(parameters);
+            const client2 = publicClient ?? walletClient;
+            return getAction(client2, estimateContractGas, "estimateContractGas")({
+              abi: abi2,
+              address,
+              functionName,
+              args,
+              ...options,
+              account: options.account ?? walletClient.account
+            });
+          };
+        }
+      });
+  }
+  contract.address = address;
+  contract.abi = abi2;
+  return contract;
+}
+function getFunctionParameters(values) {
+  const hasArgs = values.length && Array.isArray(values[0]);
+  const args = hasArgs ? values[0] : [];
+  const options = (hasArgs ? values[1] : values[0]) ?? {};
+  return { args, options };
+}
+function getEventParameters(values, abiEvent) {
+  let hasArgs = false;
+  if (Array.isArray(values[0]))
+    hasArgs = true;
+  else if (values.length === 1) {
+    hasArgs = abiEvent.inputs.some((x) => x.indexed);
+  } else if (values.length === 2) {
+    hasArgs = true;
+  }
+  const args = hasArgs ? values[0] : void 0;
+  const options = (hasArgs ? values[1] : values[0]) ?? {};
+  return { args, options };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/calls.js
+var BundleFailedError = class extends BaseError {
+  constructor(result) {
+    super(`Call bundle failed with status: ${result.statusCode}`, {
+      name: "BundleFailedError"
+    });
+    Object.defineProperty(this, "result", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.result = result;
+  }
+};
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/promise/withRetry.js
 function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true, signal } = {}) {
   return new Promise((resolve, reject) => {
@@ -1897,6 +2320,244 @@ function formatTransactionReceipt(transactionReceipt, _) {
 }
 var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendCalls.js
+var fallbackMagicIdentifier = "0x5792579257925792579257925792579257925792579257925792579257925792";
+var fallbackTransactionErrorMagicIdentifier = numberToHex(0, {
+  size: 32
+});
+async function sendCalls(client, parameters) {
+  const { account: account_ = client.account, chain = client.chain, experimental_fallback, experimental_fallbackDelay = 32, forceAtomic = false, id, version = "2.0.0" } = parameters;
+  const account = account_ ? parseAccount(account_) : null;
+  let capabilities = parameters.capabilities;
+  if (client.dataSuffix && !parameters.capabilities?.dataSuffix) {
+    if (typeof client.dataSuffix === "string")
+      capabilities = {
+        ...parameters.capabilities,
+        dataSuffix: { value: client.dataSuffix, optional: true }
+      };
+    else
+      capabilities = {
+        ...parameters.capabilities,
+        dataSuffix: {
+          value: client.dataSuffix.value,
+          ...client.dataSuffix.required ? {} : { optional: true }
+        }
+      };
+  }
+  const calls = parameters.calls.map((call_) => {
+    const call2 = call_;
+    const data = call2.abi ? encodeFunctionData({
+      abi: call2.abi,
+      functionName: call2.functionName,
+      args: call2.args
+    }) : call2.data;
+    return {
+      data: call2.dataSuffix && data ? concat([data, call2.dataSuffix]) : data,
+      to: call2.to,
+      value: call2.value ? numberToHex(call2.value) : void 0
+    };
+  });
+  try {
+    const response = await client.request({
+      method: "wallet_sendCalls",
+      params: [
+        {
+          atomicRequired: forceAtomic,
+          calls,
+          capabilities,
+          chainId: numberToHex(chain.id),
+          from: account?.address,
+          id,
+          version
+        }
+      ]
+    }, { retryCount: 0 });
+    if (typeof response === "string")
+      return { id: response };
+    return response;
+  } catch (err) {
+    const error = err;
+    if (experimental_fallback && (error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.name === "UnknownRpcError" || error.details.toLowerCase().includes("does not exist / is not available") || error.details.toLowerCase().includes("missing or invalid. request()") || error.details.toLowerCase().includes("did not match any variant of untagged enum") || error.details.toLowerCase().includes("account upgraded to unsupported contract") || error.details.toLowerCase().includes("eip-7702 not supported") || error.details.toLowerCase().includes("unsupported wc_ method") || // magic.link
+    error.details.toLowerCase().includes("feature toggled misconfigured") || // Trust Wallet
+    error.details.toLowerCase().includes("jsonrpcengine: response has no error or result for request"))) {
+      if (capabilities) {
+        const hasNonOptionalCapability = Object.values(capabilities).some((capability) => !capability.optional);
+        if (hasNonOptionalCapability) {
+          const message = "non-optional `capabilities` are not supported on fallback to `eth_sendTransaction`.";
+          throw new UnsupportedNonOptionalCapabilityError(new BaseError(message, {
+            details: message
+          }));
+        }
+      }
+      if (forceAtomic && calls.length > 1) {
+        const message = "`forceAtomic` is not supported on fallback to `eth_sendTransaction`.";
+        throw new AtomicityNotSupportedError(new BaseError(message, {
+          details: message
+        }));
+      }
+      const results = [];
+      for (const call2 of calls) {
+        try {
+          const value = await sendTransaction(client, {
+            account,
+            chain,
+            data: call2.data,
+            to: call2.to,
+            value: call2.value ? hexToBigInt(call2.value) : void 0
+          });
+          results.push({ status: "fulfilled", value });
+        } catch (reason) {
+          results.push({ reason, status: "rejected" });
+        }
+        if (experimental_fallbackDelay > 0)
+          await new Promise((resolve) => setTimeout(resolve, experimental_fallbackDelay));
+      }
+      if (results.every((r) => r.status === "rejected"))
+        throw results[0].reason;
+      const hashes = results.map((result) => {
+        if (result.status === "fulfilled")
+          return result.value;
+        return fallbackTransactionErrorMagicIdentifier;
+      });
+      return {
+        id: concat([
+          ...hashes,
+          numberToHex(chain.id, { size: 32 }),
+          fallbackMagicIdentifier
+        ])
+      };
+    }
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain
+    });
+  }
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/getCallsStatus.js
+async function getCallsStatus(client, parameters) {
+  async function getStatus(id) {
+    const isTransactions = id.endsWith(fallbackMagicIdentifier.slice(2));
+    if (isTransactions) {
+      const chainId2 = trim(sliceHex(id, -64, -32));
+      const hashes = sliceHex(id, 0, -64).slice(2).match(/.{1,64}/g);
+      const receipts2 = await Promise.all(hashes.map((hash2) => fallbackTransactionErrorMagicIdentifier.slice(2) !== hash2 ? client.request({
+        method: "eth_getTransactionReceipt",
+        params: [`0x${hash2}`]
+      }, { dedupe: true }) : void 0));
+      const status2 = (() => {
+        if (receipts2.some((r) => r === null))
+          return 100;
+        if (receipts2.every((r) => r?.status === "0x1"))
+          return 200;
+        if (receipts2.every((r) => r?.status === "0x0"))
+          return 500;
+        return 600;
+      })();
+      return {
+        atomic: false,
+        chainId: hexToNumber(chainId2),
+        receipts: receipts2.filter(Boolean),
+        status: status2,
+        version: "2.0.0"
+      };
+    }
+    return client.request({
+      method: "wallet_getCallsStatus",
+      params: [id]
+    });
+  }
+  const { atomic = false, chainId, receipts, version = "2.0.0", ...response } = await getStatus(parameters.id);
+  const [status, statusCode] = (() => {
+    const statusCode2 = response.status;
+    if (statusCode2 >= 100 && statusCode2 < 200)
+      return ["pending", statusCode2];
+    if (statusCode2 >= 200 && statusCode2 < 300)
+      return ["success", statusCode2];
+    if (statusCode2 >= 300 && statusCode2 < 700)
+      return ["failure", statusCode2];
+    if (statusCode2 === "CONFIRMED")
+      return ["success", 200];
+    if (statusCode2 === "PENDING")
+      return ["pending", 100];
+    return [void 0, statusCode2];
+  })();
+  return {
+    ...response,
+    atomic,
+    // @ts-expect-error: for backwards compatibility
+    chainId: chainId ? hexToNumber(chainId) : void 0,
+    receipts: receipts?.map((receipt) => ({
+      ...receipt,
+      blockNumber: hexToBigInt(receipt.blockNumber),
+      gasUsed: hexToBigInt(receipt.gasUsed),
+      status: receiptStatuses[receipt.status]
+    })) ?? [],
+    statusCode,
+    status,
+    version
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/waitForCallsStatus.js
+async function waitForCallsStatus(client, parameters) {
+  const {
+    id,
+    pollingInterval = client.pollingInterval,
+    status = ({ statusCode }) => statusCode === 200 || statusCode >= 300,
+    retryCount = 4,
+    retryDelay = ({ count }) => ~~(1 << count) * 200,
+    // exponential backoff
+    timeout = 6e4,
+    throwOnFailure = false
+  } = parameters;
+  const observerId = stringify(["waitForCallsStatus", client.uid, id]);
+  const { promise, resolve, reject } = withResolvers();
+  let timer;
+  const unobserve = observe(observerId, { resolve, reject }, (emit) => {
+    const unpoll = poll(async () => {
+      const done = (fn) => {
+        clearTimeout(timer);
+        unpoll();
+        fn();
+        unobserve();
+      };
+      try {
+        const result = await withRetry(async () => {
+          const result2 = await getAction(client, getCallsStatus, "getCallsStatus")({ id });
+          if (throwOnFailure && result2.status === "failure")
+            throw new BundleFailedError(result2);
+          return result2;
+        }, {
+          retryCount,
+          delay: retryDelay
+        });
+        if (!status(result))
+          return;
+        done(() => emit.resolve(result));
+      } catch (error) {
+        done(() => emit.reject(error));
+      }
+    }, {
+      interval: pollingInterval,
+      emitOnBegin: true
+    });
+    return unpoll;
+  });
+  timer = timeout ? setTimeout(() => {
+    unobserve();
+    clearTimeout(timer);
+    reject(new WaitForCallsStatusTimeoutError({ id }));
+  }, timeout) : void 0;
+  return await promise;
+}
+var WaitForCallsStatusTimeoutError = class extends BaseError {
+  constructor({ id }) {
+    super(`Timed out while waiting for call bundle with id "${id}" to be confirmed.`, { name: "WaitForCallsStatusTimeoutError" });
+  }
+};
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/uid.js
 var size4 = 256;
 var index = size4;
@@ -1944,14 +2605,14 @@ function createClient(parameters) {
     uid: uid(),
     ...experimental_blockTag ? { experimental_blockTag } : {}
   };
-  function extend(base2) {
+  function extend(base) {
     return (extendFn) => {
-      const extended = extendFn(base2);
+      const extended = extendFn(base);
       for (const key2 in client)
         delete extended[key2];
-      const combined = { ...base2, ...extended };
+      const combined = { ...base, ...extended };
       for (const key2 in extended) {
-        const a = base2[key2];
+        const a = base[key2];
         const b = extended[key2];
         if (isPlainObject(a) && isPlainObject(b))
           combined[key2] = { ...a, ...b };
@@ -1991,6 +2652,9 @@ function bindActionDecorators(client, action) {
       wrapped[key] = action[key];
   return wrapped;
 }
+function rpcSchema() {
+  return null;
+}
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/ens/errors.js
 function isNullUniversalResolverError(err) {
@@ -2183,6 +2847,13 @@ var EnsAvatarUnsupportedNamespaceError = class extends BaseError {
     super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
   }
 };
+var EnsInvalidChainIdError = class extends BaseError {
+  constructor({ chainId }) {
+    super(`Invalid ENSIP-11 chainId: ${chainId}. Must be between 0 and 0x7fffffff, or 1.`, {
+      name: "EnsInvalidChainIdError"
+    });
+  }
+};
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/ens/avatar/utils.js
 var networkRegex = /(?<protocol>https?:\/\/[^/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
@@ -2215,12 +2886,12 @@ async function isImageUri(uri) {
     });
   }
 }
-function getGateway(custom, defaultGateway) {
-  if (!custom)
+function getGateway(custom2, defaultGateway) {
+  if (!custom2)
     return defaultGateway;
-  if (custom.endsWith("/"))
-    return custom.slice(0, -1);
-  return custom;
+  if (custom2.endsWith("/"))
+    return custom2.slice(0, -1);
+  return custom2;
 }
 function resolveAvatarUri({ uri, gatewayUrls }) {
   const isEncoded = base64Regex.test(uri);
@@ -2859,6 +3530,109 @@ async function getFilterLogs(_client, { filter }) {
   });
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/abi/encodePacked.js
+function encodePacked(types, values) {
+  if (types.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: types.length,
+      givenLength: values.length
+    });
+  const data = [];
+  for (let i = 0; i < types.length; i++) {
+    const type = types[i];
+    const value = values[i];
+    data.push(encode(type, value));
+  }
+  return concatHex(data);
+}
+function encode(type, value, isArray = false) {
+  if (type === "address") {
+    const address = value;
+    if (!isAddress(address))
+      throw new InvalidAddressError({ address });
+    return pad(address.toLowerCase(), {
+      size: isArray ? 32 : null
+    });
+  }
+  if (type === "string")
+    return stringToHex(value);
+  if (type === "bytes")
+    return value;
+  if (type === "bool")
+    return pad(boolToHex(value), { size: isArray ? 32 : 1 });
+  const intMatch = type.match(integerRegex);
+  if (intMatch) {
+    const [_type, baseType, bits = "256"] = intMatch;
+    const size5 = Number.parseInt(bits, 10) / 8;
+    return numberToHex(value, {
+      size: isArray ? 32 : size5,
+      signed: baseType === "int"
+    });
+  }
+  const bytesMatch = type.match(bytesRegex);
+  if (bytesMatch) {
+    const [_type, size5] = bytesMatch;
+    if (Number.parseInt(size5, 10) !== (value.length - 2) / 2)
+      throw new BytesSizeMismatchError({
+        expectedSize: Number.parseInt(size5, 10),
+        givenSize: (value.length - 2) / 2
+      });
+    return pad(value, { dir: "right", size: isArray ? 32 : null });
+  }
+  const arrayMatch = type.match(arrayRegex);
+  if (arrayMatch && Array.isArray(value)) {
+    const [_type, childType] = arrayMatch;
+    const data = [];
+    for (let i = 0; i < value.length; i++) {
+      data.push(encode(childType, value[i], true));
+    }
+    if (data.length === 0)
+      return "0x";
+    return concatHex(data);
+  }
+  throw new UnsupportedPackedAbiType(type);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/data/isBytes.js
+function isBytes(value) {
+  if (!value)
+    return false;
+  if (typeof value !== "object")
+    return false;
+  if (!("BYTES_PER_ELEMENT" in value))
+    return false;
+  return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/address/getContractAddress.js
+function getContractAddress(opts) {
+  if (opts.opcode === "CREATE2")
+    return getCreate2Address(opts);
+  return getCreateAddress(opts);
+}
+function getCreateAddress(opts) {
+  const from13 = toBytes(getAddress(opts.from));
+  let nonce = toBytes(opts.nonce);
+  if (nonce[0] === 0)
+    nonce = new Uint8Array([]);
+  return getAddress(`0x${keccak256(toRlp([from13, nonce], "bytes")).slice(26)}`);
+}
+function getCreate2Address(opts) {
+  const from13 = toBytes(getAddress(opts.from));
+  const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {
+    size: 32
+  });
+  const bytecodeHash = (() => {
+    if ("bytecodeHash" in opts) {
+      if (isBytes(opts.bytecodeHash))
+        return opts.bytecodeHash;
+      return toBytes(opts.bytecodeHash);
+    }
+    return keccak256(opts.bytecode, "bytes");
+  })();
+  return getAddress(slice(keccak256(concat([toBytes("0xff"), from13, salt, bytecodeHash])), 12));
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/authorization/verifyAuthorization.js
 async function verifyAuthorization({ address, authorization, signature }) {
   return isAddressEqual(getAddress(address), await recoverAuthorizationAddress({
@@ -3064,6 +3838,59 @@ function hashString(str, seed = 0) {
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/ccipTunnel.js
+function ccipReadTunnel({ batchGateways, ccipRequest: ccipRequest2 = ccipRequest }) {
+  return {
+    async request({ data, sender, urls }) {
+      if (urls.includes(localBatchGatewayUrl)) {
+        return ccipRequest2({
+          data,
+          sender,
+          urls: batchGateways
+        });
+      } else {
+        const [failures, responses] = decodeFunctionResult({
+          abi: batchGatewayAbi,
+          functionName: "query",
+          data: await ccipRequest2({
+            data: encodeFunctionData({
+              abi: batchGatewayAbi,
+              functionName: "query",
+              args: [[{ sender, data, urls }]]
+            }),
+            sender,
+            urls: batchGateways
+          })
+        });
+        if (failures[0]) {
+          let error;
+          try {
+            const res = decodeErrorResult({
+              abi: [...batchGatewayAbi, solidityError],
+              data: responses[0]
+            });
+            if (res.errorName === "HttpError") {
+              error = new HttpRequestError({
+                body: { message: res.args[1] },
+                status: res.args[0],
+                url: urls.join(" | ")
+              });
+            } else {
+              const message = res.args[0];
+              if (message) {
+                error = new Error(message);
+              }
+            }
+          } catch {
+          }
+          throw error ?? new Error("An unknown error occurred.");
+        }
+        return responses[0];
+      }
+    }
+  };
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/chain/defineChain.js
 function defineChain(chain) {
   const chainInstance = {
@@ -3072,10 +3899,10 @@ function defineChain(chain) {
     serializers: void 0,
     ...chain
   };
-  function extend(base2) {
+  function extend(base) {
     return (fnOrExtended) => {
-      const properties = typeof fnOrExtended === "function" ? fnOrExtended(base2) : fnOrExtended;
-      const combined = { ...base2, ...properties };
+      const properties = typeof fnOrExtended === "function" ? fnOrExtended(base) : fnOrExtended;
+      const combined = { ...base, ...properties };
       return Object.assign(combined, { extend: extend(combined) });
     };
   }
@@ -3083,9 +3910,96 @@ function defineChain(chain) {
     extend: extend(chainInstance)
   });
 }
+function extendSchema() {
+  return {};
+}
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/promise/withTimeout.js
-function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/chain/extractChain.js
+function extractChain({ chains, id }) {
+  return chains.find((chain) => chain.id === id);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/encoding/fromRlp.js
+var rlpDepthLimit = 1024;
+function fromRlp(value, to = "hex") {
+  const bytes = (() => {
+    if (typeof value === "string") {
+      if (value.length > 3 && value.length % 2 !== 0)
+        throw new InvalidHexValueError(value);
+      return hexToBytes(value);
+    }
+    return value;
+  })();
+  const cursor = createCursor(bytes, {
+    recursiveReadLimit: Number.POSITIVE_INFINITY
+  });
+  const result = fromRlpCursor(cursor, to);
+  if (cursor.position < cursor.bytes.length)
+    throw new RlpTrailingBytesError({
+      count: cursor.bytes.length - cursor.position
+    });
+  return result;
+}
+function fromRlpCursor(cursor, to = "hex", recursiveDepth = 0) {
+  if (recursiveDepth >= rlpDepthLimit)
+    throw new RlpDepthLimitExceededError({ limit: rlpDepthLimit });
+  if (cursor.bytes.length === 0)
+    return to === "hex" ? bytesToHex(cursor.bytes) : cursor.bytes;
+  const prefix = cursor.readByte();
+  if (prefix < 128)
+    cursor.decrementPosition(1);
+  if (prefix < 192) {
+    const length2 = readLength(cursor, prefix, 128);
+    const bytes = cursor.readBytes(length2);
+    return to === "hex" ? bytesToHex(bytes) : bytes;
+  }
+  const length = readLength(cursor, prefix, 192);
+  return readList(cursor, length, to, recursiveDepth + 1);
+}
+function readLength(cursor, prefix, offset) {
+  if (offset === 128 && prefix < 128)
+    return 1;
+  if (prefix <= offset + 55)
+    return prefix - offset;
+  if (prefix === offset + 55 + 1)
+    return cursor.readUint8();
+  if (prefix === offset + 55 + 2)
+    return cursor.readUint16();
+  if (prefix === offset + 55 + 3)
+    return cursor.readUint24();
+  if (prefix === offset + 55 + 4)
+    return cursor.readUint32();
+  throw new BaseError("Invalid RLP prefix");
+}
+function readList(cursor, length, to, recursiveDepth) {
+  const position = cursor.position;
+  const value = [];
+  while (cursor.position - position < length)
+    value.push(fromRlpCursor(cursor, to, recursiveDepth));
+  if (cursor.position - position !== length)
+    throw new RlpListBoundaryExceededError({
+      consumed: cursor.position - position,
+      declared: length
+    });
+  return value;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/hash/isHash.js
+function isHash(hash2) {
+  return isHex(hash2) && size(hash2) === 32;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/hash/ripemd160.js
+function ripemd1602(value, to_) {
+  const to = to_ || "hex";
+  const bytes = ripemd160(isHex(value, { strict: false }) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/promise/withTimeout.js
+function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
   return new Promise((resolve, reject) => {
     ;
     (async () => {
@@ -3289,6 +4203,266 @@ function parseUrl(url_) {
   }
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/rpc/socket.js
+var socketClientCache = /* @__PURE__ */ new Map();
+async function getSocketRpcClient(parameters) {
+  const { getSocket: getSocket2, keepAlive = true, key = "socket", reconnect = true, url } = parameters;
+  const { interval: keepAliveInterval = 3e4 } = typeof keepAlive === "object" ? keepAlive : {};
+  const { attempts = 5, delay = 2e3 } = typeof reconnect === "object" ? reconnect : {};
+  const id = JSON.stringify({ keepAlive, key, url, reconnect });
+  let socketClient = socketClientCache.get(id);
+  if (socketClient)
+    return socketClient;
+  let reconnectCount = 0;
+  const { schedule } = createBatchScheduler({
+    id,
+    fn: async () => {
+      const requests = /* @__PURE__ */ new Map();
+      const subscriptions = /* @__PURE__ */ new Map();
+      let error;
+      let socket;
+      let keepAliveTimer;
+      let reconnectTimer;
+      let reconnectInProgress = false;
+      let intentionallyClosed = false;
+      function attemptReconnect() {
+        if (reconnect && !intentionallyClosed && reconnectCount < attempts) {
+          if (reconnectInProgress)
+            return;
+          reconnectInProgress = true;
+          reconnectCount++;
+          socket?.close();
+          reconnectTimer = setTimeout(async () => {
+            reconnectTimer = void 0;
+            if (intentionallyClosed) {
+              reconnectInProgress = false;
+              return;
+            }
+            await setup().catch(console.error);
+            reconnectInProgress = false;
+          }, delay);
+        } else {
+          requests.clear();
+          subscriptions.clear();
+        }
+      }
+      async function setup() {
+        const result = await getSocket2({
+          onClose() {
+            for (const request of requests.values())
+              request.onError?.(new SocketClosedError({ url }));
+            for (const subscription of subscriptions.values())
+              subscription.onError?.(new SocketClosedError({ url }));
+            attemptReconnect();
+          },
+          onError(error_) {
+            error = error_;
+            for (const request of requests.values())
+              request.onError?.(error);
+            for (const subscription of subscriptions.values())
+              subscription.onError?.(error);
+            attemptReconnect();
+          },
+          onOpen() {
+            error = void 0;
+            reconnectCount = 0;
+          },
+          onResponse(data) {
+            const isSubscription = data.method === "eth_subscription";
+            const id2 = isSubscription ? data.params.subscription : data.id;
+            const cache = isSubscription ? subscriptions : requests;
+            const callback = cache.get(id2);
+            if (callback)
+              callback.onResponse(data);
+            if (!isSubscription)
+              cache.delete(id2);
+          }
+        });
+        if (intentionallyClosed) {
+          result.close();
+          return result;
+        }
+        socket = result;
+        if (keepAlive) {
+          if (keepAliveTimer)
+            clearInterval(keepAliveTimer);
+          keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval);
+        }
+        if (reconnect && subscriptions.size > 0) {
+          const subscriptionEntries = subscriptions.entries();
+          for (const [key2, { onResponse, body, onError }] of subscriptionEntries) {
+            if (!body)
+              continue;
+            subscriptions.delete(key2);
+            socketClient?.request({ body, onResponse, onError });
+          }
+        }
+        return result;
+      }
+      await setup();
+      error = void 0;
+      socketClient = {
+        close() {
+          intentionallyClosed = true;
+          keepAliveTimer && clearInterval(keepAliveTimer);
+          if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = void 0;
+            reconnectInProgress = false;
+          }
+          socket.close();
+          socketClientCache.delete(id);
+        },
+        get socket() {
+          return socket;
+        },
+        request({ body, onError, onResponse }) {
+          if (error && onError)
+            onError(error);
+          const id2 = body.id ?? idCache.take();
+          const callback = (response) => {
+            if (typeof response.id === "number" && id2 !== response.id)
+              return;
+            if (body.method === "eth_subscribe" && typeof response.result === "string")
+              subscriptions.set(response.result, {
+                onResponse: callback,
+                onError,
+                body
+              });
+            onResponse(response);
+          };
+          if (body.method === "eth_unsubscribe")
+            subscriptions.delete(body.params?.[0]);
+          requests.set(id2, { onResponse: callback, onError });
+          try {
+            socket.request({
+              body: {
+                jsonrpc: "2.0",
+                id: id2,
+                ...body
+              }
+            });
+          } catch (error2) {
+            onError?.(error2);
+          }
+        },
+        requestAsync({ body, timeout = 1e4 }) {
+          return withTimeout(() => new Promise((onResponse, onError) => this.request({
+            body,
+            onError,
+            onResponse
+          })), {
+            errorInstance: new TimeoutError({ body, url }),
+            timeout
+          });
+        },
+        requests,
+        subscriptions,
+        url
+      };
+      socketClientCache.set(id, socketClient);
+      return [socketClient];
+    }
+  });
+  const [_, [socketClient_]] = await schedule();
+  return socketClient_;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/rpc/webSocket.js
+async function getWebSocketRpcClient(url, options = {}) {
+  const { keepAlive, reconnect } = options;
+  return getSocketRpcClient({
+    async getSocket({ onClose, onError, onOpen, onResponse }) {
+      const WebSocket = await import("./_esm-C5CRWCYU.js").then((module) => module.WebSocket);
+      const socket = new WebSocket(url);
+      function onClose_() {
+        socket.removeEventListener("close", onClose_);
+        socket.removeEventListener("message", onMessage);
+        socket.removeEventListener("error", onError);
+        socket.removeEventListener("open", onOpen);
+        onClose();
+      }
+      function onMessage({ data }) {
+        if (typeof data === "string" && data.trim().length === 0)
+          return;
+        try {
+          const _data = JSON.parse(data);
+          onResponse(_data);
+        } catch (error) {
+          onError(error);
+        }
+      }
+      socket.addEventListener("close", onClose_);
+      socket.addEventListener("message", onMessage);
+      socket.addEventListener("error", onError);
+      socket.addEventListener("open", onOpen);
+      if (socket.readyState === WebSocket.CONNECTING) {
+        await new Promise((resolve, reject) => {
+          if (!socket)
+            return;
+          socket.onopen = resolve;
+          socket.onerror = reject;
+        });
+      }
+      const { close: close_ } = socket;
+      return Object.assign(socket, {
+        close() {
+          close_.bind(socket)();
+          onClose_();
+        },
+        ping() {
+          try {
+            if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
+              throw new WebSocketRequestError({
+                url: socket.url,
+                cause: new SocketClosedError({ url: socket.url })
+              });
+            const body = {
+              jsonrpc: "2.0",
+              id: null,
+              method: "net_version",
+              params: []
+            };
+            socket.send(JSON.stringify(body));
+          } catch (error) {
+            onError(error);
+          }
+        },
+        request({ body }) {
+          if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
+            throw new WebSocketRequestError({
+              body,
+              url: socket.url,
+              cause: new SocketClosedError({ url: socket.url })
+            });
+          return socket.send(JSON.stringify(body));
+        }
+      });
+    },
+    keepAlive,
+    reconnect,
+    url
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/rpc/compat.js
+async function getSocket(url) {
+  const client = await getWebSocketRpcClient(url);
+  return Object.assign(client.socket, {
+    requests: client.requests,
+    subscriptions: client.subscriptions
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/constants/bytes.js
+var erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
+var zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/isErc6492Signature.js
+function isErc6492Signature(signature) {
+  return sliceHex(signature, -32) === erc6492MagicBytes;
+}
+
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/erc8010/SignatureErc8010.js
 var SignatureErc8010_exports = {};
 __export(SignatureErc8010_exports, {
@@ -3583,9 +4757,9 @@ var InvalidChecksumError = class extends BaseError2 {
 };
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Solidity.js
-var arrayRegex = /^(.*)\[([0-9]*)\]$/;
-var bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-var 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)?$/;
+var arrayRegex2 = /^(.*)\[([0-9]*)\]$/;
+var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+var integerRegex2 = /^(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)?$/;
 var maxInt8 = 2n ** (8n - 1n) - 1n;
 var maxInt16 = 2n ** (16n - 1n) - 1n;
 var maxInt24 = 2n ** (24n - 1n) - 1n;
@@ -3685,19 +4859,19 @@ var maxUint256 = 2n ** 256n - 1n;
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/internal/abiParameters.js
 function decodeParameter(cursor, param, options) {
-  const { checksumAddress, staticPosition } = options;
+  const { checksumAddress: checksumAddress2, staticPosition } = options;
   const arrayComponents = getArrayComponents(param.type);
   if (arrayComponents) {
     const [length, type] = arrayComponents;
-    return decodeArray(cursor, { ...param, type }, { checksumAddress, length, staticPosition });
+    return decodeArray(cursor, { ...param, type }, { checksumAddress: checksumAddress2, length, staticPosition });
   }
   if (param.type === "tuple")
     return decodeTuple(cursor, param, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       staticPosition
     });
   if (param.type === "address")
-    return decodeAddress2(cursor, { checksum: checksumAddress });
+    return decodeAddress2(cursor, { checksum: checksumAddress2 });
   if (param.type === "bool")
     return decodeBool(cursor);
   if (param.type.startsWith("bytes"))
@@ -3717,7 +4891,7 @@ function decodeAddress2(cursor, options = {}) {
   return [wrap3(fromBytes(slice3(value, -20))), 32];
 }
 function decodeArray(cursor, param, options) {
-  const { checksumAddress, length, staticPosition } = options;
+  const { checksumAddress: checksumAddress2, length, staticPosition } = options;
   if (!length) {
     const offset = toNumber2(cursor.readBytes(sizeOfOffset));
     const start = staticPosition + offset;
@@ -3730,7 +4904,7 @@ function decodeArray(cursor, param, options) {
     for (let i = 0; i < length2; ++i) {
       cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
       const [data, consumed_] = decodeParameter(cursor, param, {
-        checksumAddress,
+        checksumAddress: checksumAddress2,
         staticPosition: startOfData
       });
       consumed2 += consumed_;
@@ -3746,7 +4920,7 @@ function decodeArray(cursor, param, options) {
     for (let i = 0; i < length; ++i) {
       cursor.setPosition(start + i * 32);
       const [data] = decodeParameter(cursor, param, {
-        checksumAddress,
+        checksumAddress: checksumAddress2,
         staticPosition: start
       });
       value2.push(data);
@@ -3758,7 +4932,7 @@ function decodeArray(cursor, param, options) {
   const value = [];
   for (let i = 0; i < length; ++i) {
     const [data, consumed_] = decodeParameter(cursor, param, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       staticPosition: staticPosition + consumed
     });
     consumed += consumed_;
@@ -3796,7 +4970,7 @@ function decodeNumber(cursor, param) {
   ];
 }
 function decodeTuple(cursor, param, options) {
-  const { checksumAddress, staticPosition } = options;
+  const { checksumAddress: checksumAddress2, staticPosition } = options;
   const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
   const value = hasUnnamedChild ? [] : {};
   let consumed = 0;
@@ -3807,7 +4981,7 @@ function decodeTuple(cursor, param, options) {
       const component = param.components[i];
       cursor.setPosition(start + consumed);
       const [data, consumed_] = decodeParameter(cursor, component, {
-        checksumAddress,
+        checksumAddress: checksumAddress2,
         staticPosition: start
       });
       consumed += consumed_;
@@ -3819,7 +4993,7 @@ function decodeTuple(cursor, param, options) {
   for (let i = 0; i < param.components.length; ++i) {
     const component = param.components[i];
     const [data, consumed_] = decodeParameter(cursor, component, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       staticPosition
     });
     value[hasUnnamedChild ? i : component?.name] = data;
@@ -3841,24 +5015,24 @@ function decodeString(cursor, { staticPosition }) {
   cursor.setPosition(staticPosition + 32);
   return [value, 32];
 }
-function prepareParameters({ checksumAddress, parameters, values }) {
+function prepareParameters({ checksumAddress: checksumAddress2, parameters, values }) {
   const preparedParameters = [];
   for (let i = 0; i < parameters.length; i++) {
     preparedParameters.push(prepareParameter({
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       parameter: parameters[i],
       value: values[i]
     }));
   }
   return preparedParameters;
 }
-function prepareParameter({ checksumAddress = false, parameter: parameter_, value }) {
+function prepareParameter({ checksumAddress: checksumAddress2 = false, parameter: parameter_, value }) {
   const parameter = parameter_;
   const arrayComponents = getArrayComponents(parameter.type);
   if (arrayComponents) {
     const [length, type] = arrayComponents;
     return encodeArray(value, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       length,
       parameter: {
         ...parameter,
@@ -3868,13 +5042,13 @@ function prepareParameter({ checksumAddress = false, parameter: parameter_, valu
   }
   if (parameter.type === "tuple") {
     return encodeTuple(value, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       parameter
     });
   }
   if (parameter.type === "address") {
     return encodeAddress(value, {
-      checksum: checksumAddress
+      checksum: checksumAddress2
     });
   }
   if (parameter.type === "bool") {
@@ -3882,7 +5056,7 @@ function prepareParameter({ checksumAddress = false, parameter: parameter_, valu
   }
   if (parameter.type.startsWith("uint") || parameter.type.startsWith("int")) {
     const signed = parameter.type.startsWith("int");
-    const [, , size5 = "256"] = integerRegex.exec(parameter.type) ?? [];
+    const [, , size5 = "256"] = integerRegex2.exec(parameter.type) ?? [];
     return encodeNumber(value, {
       signed,
       size: Number(size5)
@@ -3896,7 +5070,7 @@ function prepareParameter({ checksumAddress = false, parameter: parameter_, valu
   }
   throw new InvalidTypeError(parameter.type);
 }
-function encode(preparedParameters) {
+function encode2(preparedParameters) {
   let staticSize = 0;
   for (let i = 0; i < preparedParameters.length; i++) {
     const { dynamic, encoded } = preparedParameters[i];
@@ -3929,7 +5103,7 @@ function encodeAddress(value, options) {
   };
 }
 function encodeArray(value, options) {
-  const { checksumAddress, length, parameter } = options;
+  const { checksumAddress: checksumAddress2, length, parameter } = options;
   const dynamic = length === null;
   if (!Array.isArray(value))
     throw new InvalidArrayError(value);
@@ -3943,7 +5117,7 @@ function encodeArray(value, options) {
   const preparedParameters = [];
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParameter({
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       parameter,
       value: value[i]
     });
@@ -3952,7 +5126,7 @@ function encodeArray(value, options) {
     preparedParameters.push(preparedParam);
   }
   if (dynamic || dynamicChild) {
-    const data = encode(preparedParameters);
+    const data = encode2(preparedParameters);
     if (dynamic) {
       const length2 = fromNumber(preparedParameters.length, { size: 32 });
       return {
@@ -3981,7 +5155,7 @@ function encodeBytes(value, { type }) {
     };
   }
   if (bytesSize !== Number.parseInt(parametersize, 10))
-    throw new BytesSizeMismatchError({
+    throw new BytesSizeMismatchError2({
       expectedSize: Number.parseInt(parametersize, 10),
       value
     });
@@ -4026,14 +5200,14 @@ function encodeString(value) {
   };
 }
 function encodeTuple(value, options) {
-  const { checksumAddress, parameter } = options;
+  const { checksumAddress: checksumAddress2, parameter } = options;
   let dynamic = false;
   const preparedParameters = [];
   for (let i = 0; i < parameter.components.length; i++) {
     const param_ = parameter.components[i];
     const index2 = Array.isArray(value) ? i : param_.name;
     const preparedParam = prepareParameter({
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       parameter: param_,
       value: value[index2]
     });
@@ -4043,7 +5217,7 @@ function encodeTuple(value, options) {
   }
   return {
     dynamic,
-    encoded: dynamic ? encode(preparedParameters) : concat2(...preparedParameters.map(({ encoded }) => encoded))
+    encoded: dynamic ? encode2(preparedParameters) : concat2(...preparedParameters.map(({ encoded }) => encoded))
   };
 }
 function getArrayComponents(type) {
@@ -4276,7 +5450,7 @@ var RecursiveReadLimitExceededError = class extends BaseError2 {
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/AbiParameters.js
 function decode(parameters, data, options = {}) {
-  const { as = "Array", checksumAddress = false } = options;
+  const { as = "Array", checksumAddress: checksumAddress2 = false } = options;
   const bytes = typeof data === "string" ? fromHex(data) : data;
   const cursor = create(bytes);
   if (size3(bytes) === 0 && parameters.length > 0)
@@ -4293,7 +5467,7 @@ function decode(parameters, data, options = {}) {
     const param = parameters[i];
     cursor.setPosition(consumed);
     const [data2, consumed_] = decodeParameter(cursor, param, {
-      checksumAddress,
+      checksumAddress: checksumAddress2,
       staticPosition: 0
     });
     consumed += consumed_;
@@ -4304,24 +5478,24 @@ function decode(parameters, data, options = {}) {
   }
   return values;
 }
-function encode2(parameters, values, options) {
-  const { checksumAddress = false } = options ?? {};
+function encode3(parameters, values, options) {
+  const { checksumAddress: checksumAddress2 = false } = options ?? {};
   if (parameters.length !== values.length)
     throw new LengthMismatchError({
       expectedLength: parameters.length,
       givenLength: values.length
     });
   const preparedParameters = prepareParameters({
-    checksumAddress,
+    checksumAddress: checksumAddress2,
     parameters,
     values
   });
-  const data = encode(preparedParameters);
+  const data = encode2(preparedParameters);
   if (data.length === 0)
     return "0x";
   return data;
 }
-function encodePacked(types, values) {
+function encodePacked2(types, values) {
   if (types.length !== values.length)
     throw new LengthMismatchError({
       expectedLength: types.length,
@@ -4331,12 +5505,12 @@ function encodePacked(types, values) {
   for (let i = 0; i < types.length; i++) {
     const type = types[i];
     const value = values[i];
-    data.push(encodePacked.encode(type, value));
+    data.push(encodePacked2.encode(type, value));
   }
   return concat2(...data);
 }
-(function(encodePacked2) {
-  function encode4(type, value, isArray = false) {
+(function(encodePacked3) {
+  function encode5(type, value, isArray = false) {
     if (type === "address") {
       const address = value;
       assert2(address);
@@ -4348,7 +5522,7 @@ function encodePacked(types, values) {
       return value;
     if (type === "bool")
       return padLeft(fromBoolean(value), isArray ? 32 : 1);
-    const intMatch = type.match(integerRegex);
+    const intMatch = type.match(integerRegex2);
     if (intMatch) {
       const [_type, baseType, bits = "256"] = intMatch;
       const size5 = Number.parseInt(bits, 10) / 8;
@@ -4357,22 +5531,22 @@ function encodePacked(types, values) {
         signed: baseType === "int"
       });
     }
-    const bytesMatch = type.match(bytesRegex);
+    const bytesMatch = type.match(bytesRegex2);
     if (bytesMatch) {
       const [_type, size5] = bytesMatch;
       if (Number.parseInt(size5, 10) !== (value.length - 2) / 2)
-        throw new BytesSizeMismatchError({
+        throw new BytesSizeMismatchError2({
           expectedSize: Number.parseInt(size5, 10),
           value
         });
       return padRight(value, isArray ? 32 : 0);
     }
-    const arrayMatch = type.match(arrayRegex);
+    const arrayMatch = type.match(arrayRegex2);
     if (arrayMatch && Array.isArray(value)) {
       const [_type, childType] = arrayMatch;
       const data = [];
       for (let i = 0; i < value.length; i++) {
-        data.push(encode4(childType, value[i], true));
+        data.push(encode5(childType, value[i], true));
       }
       if (data.length === 0)
         return "0x";
@@ -4380,8 +5554,8 @@ function encodePacked(types, values) {
     }
     throw new InvalidTypeError(type);
   }
-  encodePacked2.encode = encode4;
-})(encodePacked || (encodePacked = {}));
+  encodePacked3.encode = encode5;
+})(encodePacked2 || (encodePacked2 = {}));
 function from4(parameters) {
   if (Array.isArray(parameters) && typeof parameters[0] === "string")
     return parseAbiParameters(parameters);
@@ -4427,7 +5601,7 @@ var ArrayLengthMismatchError = class extends BaseError2 {
     });
   }
 };
-var BytesSizeMismatchError = class extends BaseError2 {
+var BytesSizeMismatchError2 = class extends BaseError2 {
   constructor({ expectedSize, value }) {
     super(`Size of bytes "${value}" (bytes${size2(value)}) does not match expected size (bytes${expectedSize}).`);
     Object.defineProperty(this, "name", {
@@ -4519,8 +5693,8 @@ function getEncodableList(list) {
         else
           cursor.pushUint32(bodyLength);
       }
-      for (const { encode: encode4 } of list) {
-        encode4(cursor);
+      for (const { encode: encode5 } of list) {
+        encode5(cursor);
       }
     }
   };
@@ -4584,7 +5758,7 @@ function assert3(signature, options = {}) {
   if (signature.s < 0n || signature.s > maxUint256)
     throw new InvalidSError({ value: signature.s });
   if (typeof signature.yParity === "number" && signature.yParity !== 0 && signature.yParity !== 1)
-    throw new InvalidYParityError({ value: signature.yParity });
+    throw new InvalidYParityError2({ value: signature.yParity });
 }
 function fromBytes3(signature) {
   return fromHex4(fromBytes(signature));
@@ -4601,7 +5775,7 @@ function fromHex4(signature) {
     try {
       return vToYParity(yParity2);
     } catch {
-      throw new InvalidYParityError({ value: yParity2 });
+      throw new InvalidYParityError2({ value: yParity2 });
     }
   })();
   if (typeof yParity === "undefined")
@@ -4655,7 +5829,7 @@ function fromRpc(signature) {
     if (typeof v === "number" && typeof yParity2 !== "number")
       yParity2 = vToYParity(v);
     if (typeof yParity2 !== "number")
-      throw new InvalidYParityError({ value: signature.yParity });
+      throw new InvalidYParityError2({ value: signature.yParity });
     return yParity2;
   })();
   return {
@@ -4730,7 +5904,7 @@ var InvalidSError = class extends BaseError2 {
     });
   }
 };
-var InvalidYParityError = class extends BaseError2 {
+var InvalidYParityError2 = class extends BaseError2 {
   constructor({ value }) {
     super(`Value \`${value}\` is an invalid y-parity value. Y-parity must be 0 or 1.`);
     Object.defineProperty(this, "name", {
@@ -4845,7 +6019,7 @@ function wrap(value) {
     payload: getSignPayload(value.authorization),
     signature: from6(value.authorization)
   });
-  const suffix = encode2(suffixParameters, [
+  const suffix = encode3(suffixParameters, [
     {
       ...value.authorization,
       delegation: value.authorization.address,
@@ -4877,6 +6051,499 @@ var InvalidWrappedSignatureError = class extends BaseError2 {
   }
 };
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/isErc8010Signature.js
+function isErc8010Signature(signature) {
+  return SignatureErc8010_exports.validate(signature);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/parseErc6492Signature.js
+function parseErc6492Signature(signature) {
+  if (!isErc6492Signature(signature))
+    return { signature };
+  const [address, data, signature_] = decodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], signature);
+  return { address, data, signature: signature_ };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/parseErc8010Signature.js
+function parseErc8010Signature(signature) {
+  if (!isErc8010Signature(signature))
+    return { signature };
+  const { authorization: authorization_ox, to, ...rest } = SignatureErc8010_exports.unwrap(signature);
+  return {
+    authorization: {
+      address: authorization_ox.address,
+      chainId: authorization_ox.chainId,
+      nonce: Number(authorization_ox.nonce),
+      r: numberToHex(authorization_ox.r, { size: 32 }),
+      s: numberToHex(authorization_ox.s, { size: 32 }),
+      yParity: authorization_ox.yParity
+    },
+    ...to ? { address: to } : {},
+    ...rest
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/recoverMessageAddress.js
+async function recoverMessageAddress({ message, signature }) {
+  return recoverAddress({ hash: hashMessage(message), signature });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/recoverTypedDataAddress.js
+async function recoverTypedDataAddress(parameters) {
+  const { domain, message, primaryType, signature, types } = parameters;
+  return recoverAddress({
+    hash: hashTypedData({
+      domain,
+      message,
+      primaryType,
+      types
+    }),
+    signature
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/serializeErc6492Signature.js
+function serializeErc6492Signature(parameters) {
+  const { address, data, signature, to = "hex" } = parameters;
+  const signature_ = concatHex([
+    encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
+    erc6492MagicBytes
+  ]);
+  if (to === "hex")
+    return signature_;
+  return hexToBytes(signature_);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/serializeErc8010Signature.js
+function serializeErc8010Signature(parameters) {
+  const { address, data, signature, to = "hex" } = parameters;
+  const signature_ = SignatureErc8010_exports.wrap({
+    authorization: {
+      address: parameters.authorization.address,
+      chainId: parameters.authorization.chainId,
+      nonce: BigInt(parameters.authorization.nonce),
+      r: BigInt(parameters.authorization.r),
+      s: BigInt(parameters.authorization.s),
+      yParity: parameters.authorization.yParity
+    },
+    data,
+    signature,
+    to: address
+  });
+  if (to === "hex")
+    return signature_;
+  return hexToBytes(signature_);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/verifyHash.js
+async function verifyHash({ address, hash: hash2, signature }) {
+  return isAddressEqual(getAddress(address), await recoverAddress({ hash: hash2, signature }));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/verifyMessage.js
+async function verifyMessage({ address, message, signature }) {
+  return isAddressEqual(getAddress(address), await recoverMessageAddress({ message, signature }));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/verifyTypedData.js
+async function verifyTypedData(parameters) {
+  const { address, domain, message, primaryType, signature, types } = parameters;
+  return isAddressEqual(getAddress(address), await recoverTypedDataAddress({
+    domain,
+    message,
+    primaryType,
+    signature,
+    types
+  }));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/transaction/getSerializedTransactionType.js
+function getSerializedTransactionType(serializedTransaction) {
+  const serializedType = sliceHex(serializedTransaction, 0, 1);
+  if (serializedType === "0x04")
+    return "eip7702";
+  if (serializedType === "0x03")
+    return "eip4844";
+  if (serializedType === "0x02")
+    return "eip1559";
+  if (serializedType === "0x01")
+    return "eip2930";
+  if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
+    return "legacy";
+  throw new InvalidSerializedTransactionTypeError({ serializedType });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/transaction/parseTransaction.js
+function parseTransaction(serializedTransaction) {
+  const type = getSerializedTransactionType(serializedTransaction);
+  if (type === "eip1559")
+    return parseTransactionEIP1559(serializedTransaction);
+  if (type === "eip2930")
+    return parseTransactionEIP2930(serializedTransaction);
+  if (type === "eip4844")
+    return parseTransactionEIP4844(serializedTransaction);
+  if (type === "eip7702")
+    return parseTransactionEIP7702(serializedTransaction);
+  return parseTransactionLegacy(serializedTransaction);
+}
+function parseTransactionEIP7702(serializedTransaction) {
+  const transactionArray = toTransactionArray(serializedTransaction);
+  const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, v, r, s] = transactionArray;
+  if (transactionArray.length !== 10 && transactionArray.length !== 13)
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        authorizationList,
+        ...transactionArray.length > 9 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip7702"
+    });
+  const transaction = {
+    chainId: hexToNumber(chainId),
+    type: "eip7702"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce))
+    transaction.nonce = nonce === "0x" ? 0 : hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  if (authorizationList.length !== 0 && authorizationList !== "0x")
+    transaction.authorizationList = parseAuthorizationList(authorizationList);
+  assertTransactionEIP7702(transaction);
+  const signature = transactionArray.length === 13 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionEIP4844(serializedTransaction) {
+  const transactionOrWrapperArray = toTransactionArray(serializedTransaction);
+  const hasNetworkWrapper = transactionOrWrapperArray.length === 4;
+  const transactionArray = hasNetworkWrapper ? transactionOrWrapperArray[0] : transactionOrWrapperArray;
+  const wrapperArray = hasNetworkWrapper ? transactionOrWrapperArray.slice(1) : [];
+  const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, maxFeePerBlobGas, blobVersionedHashes, v, r, s] = transactionArray;
+  const [blobs, commitments, proofs] = wrapperArray;
+  if (!(transactionArray.length === 11 || transactionArray.length === 14))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...transactionArray.length > 9 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip4844"
+    });
+  const transaction = {
+    blobVersionedHashes,
+    chainId: hexToNumber(chainId),
+    to,
+    type: "eip4844"
+  };
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce))
+    transaction.nonce = nonce === "0x" ? 0 : hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== "0x")
+    transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas);
+  if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  if (blobs && commitments && proofs)
+    transaction.sidecars = toBlobSidecars({
+      blobs,
+      commitments,
+      proofs
+    });
+  assertTransactionEIP4844(transaction);
+  const signature = transactionArray.length === 14 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionEIP1559(serializedTransaction) {
+  const transactionArray = toTransactionArray(serializedTransaction);
+  const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, v, r, s] = transactionArray;
+  if (!(transactionArray.length === 9 || transactionArray.length === 12))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...transactionArray.length > 9 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip1559"
+    });
+  const transaction = {
+    chainId: hexToNumber(chainId),
+    type: "eip1559"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce))
+    transaction.nonce = nonce === "0x" ? 0 : hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  assertTransactionEIP1559(transaction);
+  const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionEIP2930(serializedTransaction) {
+  const transactionArray = toTransactionArray(serializedTransaction);
+  const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
+  if (!(transactionArray.length === 8 || transactionArray.length === 11))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        gasPrice,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...transactionArray.length > 8 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip2930"
+    });
+  const transaction = {
+    chainId: hexToNumber(chainId),
+    type: "eip2930"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce))
+    transaction.nonce = nonce === "0x" ? 0 : hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(gasPrice) && gasPrice !== "0x")
+    transaction.gasPrice = hexToBigInt(gasPrice);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  assertTransactionEIP2930(transaction);
+  const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionLegacy(serializedTransaction) {
+  const transactionArray = fromRlp(serializedTransaction, "hex");
+  const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
+  if (!(transactionArray.length === 6 || transactionArray.length === 9))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        nonce,
+        gasPrice,
+        gas,
+        to,
+        value,
+        data,
+        ...transactionArray.length > 6 ? {
+          v: chainIdOrV_,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "legacy"
+    });
+  const transaction = {
+    type: "legacy"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce))
+    transaction.nonce = nonce === "0x" ? 0 : hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(gasPrice) && gasPrice !== "0x")
+    transaction.gasPrice = hexToBigInt(gasPrice);
+  assertTransactionLegacy(transaction);
+  if (transactionArray.length === 6)
+    return transaction;
+  const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
+  if (s === "0x" && r === "0x") {
+    if (chainIdOrV > 0)
+      transaction.chainId = Number(chainIdOrV);
+    return transaction;
+  }
+  const v = chainIdOrV;
+  const chainId = Number((v - 35n) / 2n);
+  if (chainId > 0)
+    transaction.chainId = chainId;
+  else if (v !== 27n && v !== 28n)
+    throw new InvalidLegacyVError({ v });
+  transaction.v = v;
+  transaction.s = s;
+  transaction.r = r;
+  transaction.yParity = v % 2n === 0n ? 1 : 0;
+  return transaction;
+}
+function toTransactionArray(serializedTransaction) {
+  return fromRlp(`0x${serializedTransaction.slice(4)}`, "hex");
+}
+function parseAccessList(accessList_) {
+  const accessList = [];
+  for (let i = 0; i < accessList_.length; i++) {
+    const [address, storageKeys] = accessList_[i];
+    if (!isAddress(address, { strict: false }))
+      throw new InvalidAddressError({ address });
+    accessList.push({
+      address,
+      storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
+    });
+  }
+  return accessList;
+}
+function parseAuthorizationList(serializedAuthorizationList) {
+  const authorizationList = [];
+  for (let i = 0; i < serializedAuthorizationList.length; i++) {
+    const [chainId, address, nonce, yParity, r, s] = serializedAuthorizationList[i];
+    authorizationList.push({
+      address,
+      chainId: chainId === "0x" ? 0 : hexToNumber(chainId),
+      nonce: nonce === "0x" ? 0 : hexToNumber(nonce),
+      ...parseEIP155Signature([yParity, r, s])
+    });
+  }
+  return authorizationList;
+}
+function parseEIP155Signature(transactionArray) {
+  const signature = transactionArray.slice(-3);
+  const yParity = signature[0] === "0x" ? 0n : hexToBigInt(signature[0]);
+  if (yParity !== 0n && yParity !== 1n)
+    throw new InvalidYParityError({ yParity });
+  const v = yParity === 0n ? 27n : 28n;
+  return {
+    r: padHex(signature[1], { size: 32 }),
+    s: padHex(signature[2], { size: 32 }),
+    v,
+    yParity: v === 27n ? 0 : 1
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/unit.js
+var InvalidDecimalNumberError = class extends BaseError {
+  constructor({ value }) {
+    super(`Number \`${value}\` is not a valid decimal number.`, {
+      name: "InvalidDecimalNumberError"
+    });
+  }
+};
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
+    throw new InvalidDecimalNumberError({ value });
+  let [integer, fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    if (Math.round(Number(`.${fraction}`)) === 1)
+      integer = `${BigInt(integer) + 1n}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [left, unit, right] = [
+      fraction.slice(0, decimals - 1),
+      fraction.slice(decimals - 1, decimals),
+      fraction.slice(decimals)
+    ];
+    const rounded = Math.round(Number(`${unit}.${right}`));
+    if (rounded > 9)
+      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
+    else
+      fraction = `${left}${rounded}`;
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1);
+      integer = `${BigInt(integer) + 1n}`;
+    }
+    fraction = fraction.slice(0, decimals);
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/unit/parseEther.js
+function parseEther(ether, unit = "wei") {
+  return parseUnits(ether, etherUnits[unit]);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/unit/parseGwei.js
+function parseGwei(ether, unit = "wei") {
+  return parseUnits(ether, gweiUnits[unit]);
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/formatters/proof.js
 function formatStorageProof(storageProof) {
   return storageProof.map((proof) => ({
@@ -4999,7 +6666,7 @@ async function getTransactionReceipt(client, { hash: hash2 }) {
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/multicall.js
 async function multicall(client, parameters) {
   const { account, authorizationList, allowFailure = true, blockHash, blockNumber, blockOverrides, blockTag, requireCanonical, stateOverride } = parameters;
-  const contracts2 = parameters.contracts;
+  const contracts = parameters.contracts;
   const batch = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
   const batchSize = parameters.batchSize ?? batch.batchSize ?? 1024;
   const deployless = parameters.deployless ?? batch.deployless ?? false;
@@ -5020,8 +6687,8 @@ async function multicall(client, parameters) {
   const chunkedCalls = [[]];
   let currentChunk = 0;
   let currentChunkSize = 0;
-  for (let i = 0; i < contracts2.length; i++) {
-    const { abi: abi2, address, args, functionName } = contracts2[i];
+  for (let i = 0; i < contracts.length; i++) {
+    const { abi: abi2, address, args, functionName } = contracts[i];
     try {
       const callData = encodeFunctionData({ abi: abi2, args, functionName });
       currentChunkSize += (callData.length - 2) / 2;
@@ -5097,7 +6764,7 @@ async function multicall(client, parameters) {
     for (let j = 0; j < aggregate3Result.length; j++) {
       const { returnData, success } = aggregate3Result[j];
       const { callData } = chunkedCalls[i][j];
-      const { abi: abi2, address, functionName, args } = contracts2[results.length];
+      const { abi: abi2, address, functionName, args } = contracts[results.length];
       try {
         if (callData === "0x")
           throw new AbiDecodingZeroDataError();
@@ -5124,7 +6791,7 @@ async function multicall(client, parameters) {
       }
     }
   }
-  if (results.length !== contracts2.length)
+  if (results.length !== contracts.length)
     throw new BaseError("multicall results mismatch");
   return results;
 }
@@ -5482,7 +7149,7 @@ var NotFoundError = class extends BaseError2 {
 };
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/AbiConstructor.js
-function encode3(...parameters) {
+function encode4(...parameters) {
   const [abiConstructor, options] = (() => {
     if (Array.isArray(parameters[0])) {
       const [abi2, options2] = parameters;
@@ -5491,7 +7158,7 @@ function encode3(...parameters) {
     return parameters;
   })();
   const { bytecode, args } = options;
-  return concat2(bytecode, abiConstructor.inputs?.length && args?.length ? encode2(abiConstructor.inputs, args) : "0x");
+  return concat2(bytecode, abiConstructor.inputs?.length && args?.length ? encode3(abiConstructor.inputs, args) : "0x");
 }
 function from10(abiConstructor) {
   return from9(abiConstructor);
@@ -5518,7 +7185,7 @@ function encodeData(...parameters) {
     args
   }) : abiFunction;
   const selector = getSelector2(item);
-  const data = args.length > 0 ? encode2(item.inputs, args) : void 0;
+  const data = args.length > 0 ? encode3(item.inputs, args) : void 0;
   return data ? concat2(selector, data) : selector;
 }
 function from11(abiFunction, options = {}) {
@@ -5545,7 +7212,7 @@ async function simulateCalls(client, parameters) {
   const account = parameters.account ? parseAccount(parameters.account) : void 0;
   if (traceAssetChanges && !account)
     throw new BaseError("`account` is required when `traceAssetChanges` is true");
-  const getBalanceData = account ? encode3(from10("constructor(bytes, bytes)"), {
+  const getBalanceData = account ? encode4(from10("constructor(bytes, bytes)"), {
     bytecode: deploylessCallViaBytecodeBytecode,
     args: [
       getBalanceCode,
@@ -5810,7 +7477,7 @@ function unwrap2(wrapped) {
 }
 function wrap2(value) {
   const { data, signature, to } = value;
-  return concat2(encode2(from4("address, bytes, bytes"), [
+  return concat2(encode3(from4("address, bytes, bytes"), [
     to,
     data,
     signature
@@ -5837,7 +7504,7 @@ var InvalidWrappedSignatureError2 = class extends BaseError2 {
 };
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/verifyHash.js
-async function verifyHash(client, parameters) {
+async function verifyHash2(client, parameters) {
   const { address, chain = client.chain, hash: hash2, erc6492VerifierAddress: verifierAddress = parameters.universalSignatureVerifierAddress ?? chain?.contracts?.erc6492Verifier?.address, multicallAddress = parameters.multicallAddress ?? chain?.contracts?.multicall3?.address, mode = "auto" } = parameters;
   if (chain?.verifyHash)
     return await chain.verifyHash(client, parameters);
@@ -6010,9 +7677,9 @@ var VerificationError = class extends Error {
 };
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/verifyMessage.js
-async function verifyMessage(client, { address, message, factory, factoryData, signature, ...callRequest }) {
+async function verifyMessage2(client, { address, message, factory, factoryData, signature, ...callRequest }) {
   const hash2 = hashMessage(message);
-  return getAction(client, verifyHash, "verifyHash")({
+  return getAction(client, verifyHash2, "verifyHash")({
     address,
     factory,
     factoryData,
@@ -6023,10 +7690,10 @@ async function verifyMessage(client, { address, message, factory, factoryData, s
 }
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/verifyTypedData.js
-async function verifyTypedData(client, parameters) {
+async function verifyTypedData2(client, parameters) {
   const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
   const hash2 = hashTypedData({ message, primaryType, types, domain });
-  return getAction(client, verifyHash, "verifyHash")({
+  return getAction(client, verifyHash2, "verifyHash")({
     address,
     factory,
     factoryData,
@@ -6682,7 +8349,7 @@ async function verifySiweMessage(client, parameters) {
   if (!isValid)
     return false;
   const hash2 = hashMessage(message);
-  return verifyHash(client, {
+  return verifyHash2(client, {
     address: parsed.address,
     hash: hash2,
     signature,
@@ -6694,6 +8361,22 @@ async function verifySiweMessage(client, parameters) {
 function toAmount(amount, decimals) {
   return { amount, decimals, formatted: formatUnits(amount, decimals) };
 }
+function toBaseUnits(amount, decimals) {
+  if (typeof amount === "bigint")
+    return amount;
+  const resolved = amount.decimals ?? decimals;
+  return parseUnits(amount.formatted, requireTokenDecimals(resolved));
+}
+function requireTokenDecimals(decimals) {
+  if (decimals === void 0)
+    throw new Error("Token decimals are required. Pass `amount.decimals` or select a declared token.");
+  return decimals;
+}
+function resolveAmountDecimals(amount, decimals) {
+  if (typeof amount === "bigint")
+    return decimals;
+  return amount.decimals ?? decimals;
+}
 function resolveToken(client, parameters) {
   const { decimals, token } = parameters;
   const declared = findDeclaredToken(client, token);
@@ -6770,6 +8453,10 @@ async function resolveTokenWithDecimals(client, parameters) {
     })
   };
 }
+function pickWriteParameters(parameters) {
+  const { account, chain, gas, maxFeePerGas, maxPriorityFeePerGas, nonce } = parameters;
+  return { account, chain, gas, maxFeePerGas, maxPriorityFeePerGas, nonce };
+}
 function defineCall(call2) {
   return {
     ...call2,
@@ -6778,6 +8465,60 @@ function defineCall(call2) {
   };
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/token/approve.js
+async function approve(client, parameters) {
+  return approve.inner(writeContract, client, parameters);
+}
+(function(approve2) {
+  async function inner(action, client, parameters) {
+    return await action(client, {
+      ...parameters,
+      ...approve2.call(client, parameters)
+    });
+  }
+  approve2.inner = inner;
+  function call2(client, parameters) {
+    return defineCall(getCall(client, parameters));
+  }
+  approve2.call = call2;
+  async function estimateGas2(client, parameters) {
+    return estimateContractGas(client, {
+      ...pickWriteParameters(parameters),
+      ...approve2.call(client, parameters)
+    });
+  }
+  approve2.estimateGas = estimateGas2;
+  async function simulate(client, parameters) {
+    return simulateContract(client, {
+      ...pickWriteParameters(parameters),
+      ...approve2.call(client, parameters)
+    });
+  }
+  approve2.simulate = simulate;
+  function extractEvent(logs) {
+    const [log] = parseEventLogs({
+      abi: erc20Abi,
+      logs,
+      eventName: "Approval",
+      strict: true
+    });
+    if (!log)
+      throw new Error("`Approval` event not found.");
+    return log;
+  }
+  approve2.extractEvent = extractEvent;
+})(approve || (approve = {}));
+function getCall(client, parameters) {
+  const { amount, spender, token } = parameters;
+  const { address, decimals } = resolveToken(client, { token });
+  return {
+    abi: erc20Abi,
+    address,
+    args: [spender, toBaseUnits(amount, decimals)],
+    functionName: "approve"
+  };
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendRawTransactionSync.js
 async function sendRawTransactionSync(client, { serializedTransaction, throwOnReceiptRevert, timeout }) {
   const receipt = await client.request({
@@ -6791,6 +8532,193 @@ async function sendRawTransactionSync(client, { serializedTransaction, throwOnRe
   return formatted;
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendTransactionSync.js
+var supportsWalletNamespace2 = new LruMap(128);
+async function sendTransactionSync(client, parameters) {
+  const { account: account_ = client.account, assertChainId = true, chain = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, pollingInterval, throwOnReceiptRevert, type, value, ...rest } = parameters;
+  const timeout = parameters.timeout ?? Math.max((chain?.blockTime ?? 0) * 3, 5e3);
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync"
+    });
+  const account = account_ ? parseAccount(account_) : null;
+  let nonceManagerParameters;
+  try {
+    assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      if (parameters.to === null)
+        return void 0;
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0]
+        }).catch(() => {
+          throw new BaseError("`to` is required. Could not infer from `authorizationList`.");
+        });
+      return void 0;
+    })();
+    if (account?.type === "json-rpc" || account === null) {
+      let chainId;
+      if (chain !== null) {
+        chainId = await getAction(client, getChainId, "getChainId")({});
+        if (assertChainId)
+          assertCurrentChain({
+            currentChainId: chainId,
+            chain
+          });
+      }
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+      const format = chainFormat || formatTransactionRequest;
+      const request = format({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        account,
+        authorizationList,
+        blobs,
+        chainId,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        type,
+        value
+      }, "sendTransaction");
+      const isWalletNamespaceSupported = supportsWalletNamespace2.get(client.uid);
+      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
+      const hash2 = await (async () => {
+        try {
+          return await client.request({
+            method,
+            params: [request]
+          }, { retryCount: 0 });
+        } catch (e) {
+          if (isWalletNamespaceSupported === false)
+            throw e;
+          const error = e;
+          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
+            return await client.request({
+              method: "wallet_sendTransaction",
+              params: [request]
+            }, { retryCount: 0 }).then((hash3) => {
+              supportsWalletNamespace2.set(client.uid, true);
+              return hash3;
+            }).catch((e2) => {
+              const walletNamespaceError = e2;
+              if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
+                supportsWalletNamespace2.set(client.uid, false);
+                throw error;
+              }
+              throw walletNamespaceError;
+            });
+          }
+          throw error;
+        }
+      })();
+      const receipt = await getAction(client, waitForTransactionReceipt, "waitForTransactionReceipt")({
+        checkReplacement: false,
+        hash: hash2,
+        pollingInterval,
+        timeout
+      });
+      if (throwOnReceiptRevert && receipt.status === "reverted")
+        throw new TransactionReceiptRevertedError({ receipt });
+      return receipt;
+    }
+    if (account?.type === "local") {
+      if (account.nonceManager && typeof nonce === "undefined") {
+        const requestChainId = rest.chainId;
+        const chainId = await (async () => {
+          if (typeof requestChainId === "number")
+            return requestChainId;
+          if (chain)
+            return chain.id;
+          return getAction(client, getChainId, "getChainId")({});
+        })();
+        nonceManagerParameters = { address: account.address, chainId };
+      }
+      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager: account.nonceManager,
+        parameters: [...defaultParameters, "sidecars"],
+        type,
+        value,
+        ...rest,
+        to
+      });
+      const serializer = chain?.serializers?.transaction;
+      const serializedTransaction = await account.signTransaction(request, {
+        serializer
+      });
+      return await getAction(client, sendRawTransactionSync, "sendRawTransactionSync")({
+        serializedTransaction,
+        throwOnReceiptRevert,
+        timeout: parameters.timeout
+      });
+    }
+    if (account?.type === "smart")
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          "Consider using the `sendUserOperation` Action instead."
+        ],
+        docsPath: "/docs/actions/bundler/sendUserOperation",
+        type: "smart"
+      });
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync",
+      type: account?.type
+    });
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError)
+      throw err;
+    if (nonceManagerParameters && !(err instanceof TransactionReceiptRevertedError))
+      account?.nonceManager?.reset(nonceManagerParameters);
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || void 0
+    });
+  }
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/writeContractSync.js
+async function writeContractSync(client, parameters) {
+  return writeContract.internal(client, sendTransactionSync, "sendTransactionSync", parameters);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/token/approveSync.js
+async function approveSync(client, parameters) {
+  const { amount, token, throwOnReceiptRevert = true } = parameters;
+  const { decimals } = resolveToken(client, { token });
+  const resolved = resolveAmountDecimals(amount, decimals);
+  const receipt = await approve.inner(writeContractSync, client, {
+    ...parameters,
+    throwOnReceiptRevert
+  });
+  const { args } = approve.extractEvent(receipt.logs);
+  return {
+    ...args,
+    ...resolved === void 0 ? {} : { decimals: resolved, formatted: formatUnits(args.value, resolved) },
+    receipt
+  };
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/token/getAllowance.js
 async function getAllowance(client, parameters) {
   const { account, decimals, spender, token, ...rest } = parameters;
@@ -6911,6 +8839,85 @@ async function getTotalSupply(client, parameters) {
   getTotalSupply2.call = call2;
 })(getTotalSupply || (getTotalSupply = {}));
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/token/transfer.js
+async function transfer(client, parameters) {
+  return transfer.inner(writeContract, client, parameters);
+}
+(function(transfer2) {
+  async function inner(action, client, parameters) {
+    return await action(client, {
+      ...parameters,
+      ...transfer2.call(client, parameters)
+    });
+  }
+  transfer2.inner = inner;
+  function call2(client, parameters) {
+    return defineCall(getCall2(client, parameters));
+  }
+  transfer2.call = call2;
+  async function estimateGas2(client, parameters) {
+    return estimateContractGas(client, {
+      ...pickWriteParameters(parameters),
+      ...transfer2.call(client, parameters)
+    });
+  }
+  transfer2.estimateGas = estimateGas2;
+  async function simulate(client, parameters) {
+    return simulateContract(client, {
+      ...pickWriteParameters(parameters),
+      ...transfer2.call(client, parameters)
+    });
+  }
+  transfer2.simulate = simulate;
+  function extractEvent(logs) {
+    const [log] = parseEventLogs({
+      abi: erc20Abi,
+      logs,
+      eventName: "Transfer",
+      strict: true
+    });
+    if (!log)
+      throw new Error("`Transfer` event not found.");
+    return log;
+  }
+  transfer2.extractEvent = extractEvent;
+})(transfer || (transfer = {}));
+function getCall2(client, parameters) {
+  const { amount, from: from13, to, token } = parameters;
+  const { address, decimals } = resolveToken(client, { token });
+  const value = toBaseUnits(amount, decimals);
+  if (from13)
+    return {
+      abi: erc20Abi,
+      address,
+      args: [from13, to, value],
+      functionName: "transferFrom"
+    };
+  return {
+    abi: erc20Abi,
+    address,
+    args: [to, value],
+    functionName: "transfer"
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/token/transferSync.js
+async function transferSync(client, parameters) {
+  const { amount, token, throwOnReceiptRevert = true } = parameters;
+  const { decimals } = resolveToken(client, { token });
+  const resolved = resolveAmountDecimals(amount, decimals);
+  const receipt = await transfer.inner(writeContractSync, client, {
+    ...parameters,
+    throwOnReceiptRevert
+  });
+  const { args } = transfer.extractEvent(receipt.logs);
+  return {
+    ...args,
+    ...resolved === void 0 ? {} : { decimals: resolved, formatted: formatUnits(args.value, resolved) },
+    receipt
+  };
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/decorators/public.js
 function publicActions(client) {
   return {
@@ -6963,10 +8970,10 @@ function publicActions(client) {
     simulateBlocks: (args) => simulateBlocks(client, args),
     simulateCalls: (args) => simulateCalls(client, args),
     simulateContract: (args) => simulateContract(client, args),
-    verifyHash: (args) => verifyHash(client, args),
-    verifyMessage: (args) => verifyMessage(client, args),
+    verifyHash: (args) => verifyHash2(client, args),
+    verifyMessage: (args) => verifyMessage2(client, args),
     verifySiweMessage: (args) => verifySiweMessage(client, args),
-    verifyTypedData: (args) => verifyTypedData(client, args),
+    verifyTypedData: (args) => verifyTypedData2(client, args),
     uninstallFilter: (args) => uninstallFilter(client, args),
     waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
     watchBlocks: (args) => watchBlocks(client, args),
@@ -6998,7 +9005,672 @@ function createPublicClient(parameters) {
   return client.extend(publicActions);
 }
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/transports/createTransport.js
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/dropTransaction.js
+async function dropTransaction(client, { hash: hash2 }) {
+  await client.request({
+    method: `${client.mode}_dropTransaction`,
+    params: [hash2]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/dumpState.js
+async function dumpState(client) {
+  return client.request({
+    method: `${client.mode}_dumpState`
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/getAutomine.js
+async function getAutomine(client) {
+  if (client.mode === "ganache")
+    return await client.request({
+      method: "eth_mining"
+    });
+  return await client.request({
+    method: `${client.mode}_getAutomine`
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/getTxpoolContent.js
+async function getTxpoolContent(client) {
+  return await client.request({
+    method: "txpool_content"
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/getTxpoolStatus.js
+async function getTxpoolStatus(client) {
+  const { pending, queued } = await client.request({
+    method: "txpool_status"
+  });
+  return {
+    pending: hexToNumber(pending),
+    queued: hexToNumber(queued)
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/impersonateAccount.js
+async function impersonateAccount(client, { address }) {
+  await client.request({
+    method: `${client.mode}_impersonateAccount`,
+    params: [address]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/increaseTime.js
+async function increaseTime(client, { seconds }) {
+  return await client.request({
+    method: "evm_increaseTime",
+    params: [numberToHex(seconds)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/inspectTxpool.js
+async function inspectTxpool(client) {
+  return await client.request({
+    method: "txpool_inspect"
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/loadState.js
+async function loadState(client, { state }) {
+  await client.request({
+    method: `${client.mode}_loadState`,
+    params: [state]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/mine.js
+async function mine(client, { blocks, interval }) {
+  if (client.mode === "ganache")
+    await client.request({
+      method: "evm_mine",
+      params: [{ blocks: numberToHex(blocks) }]
+    });
+  else
+    await client.request({
+      method: `${client.mode}_mine`,
+      params: [numberToHex(blocks), numberToHex(interval || 0)]
+    });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/removeBlockTimestampInterval.js
+async function removeBlockTimestampInterval(client) {
+  await client.request({
+    method: `${client.mode}_removeBlockTimestampInterval`
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/reset.js
+async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
+  await client.request({
+    method: `${client.mode}_reset`,
+    params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/revert.js
+async function revert(client, { id }) {
+  await client.request({
+    method: "evm_revert",
+    params: [id]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/sendUnsignedTransaction.js
+async function sendUnsignedTransaction(client, args) {
+  const { accessList, data, from: from13, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest } = args;
+  const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+  const format = chainFormat || formatTransactionRequest;
+  const request = format({
+    // Pick out extra data that might exist on the chain's transaction request type.
+    ...extract(rest, { format: chainFormat }),
+    accessList,
+    data,
+    from: from13,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
+  }, "sendUnsignedTransaction");
+  const hash2 = await client.request({
+    method: "eth_sendUnsignedTransaction",
+    params: [request]
+  });
+  return hash2;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setAutomine.js
+async function setAutomine(client, enabled) {
+  if (client.mode === "ganache") {
+    if (enabled)
+      await client.request({ method: "miner_start" });
+    else
+      await client.request({ method: "miner_stop" });
+  } else
+    await client.request({
+      method: "evm_setAutomine",
+      params: [enabled]
+    });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setBalance.js
+async function setBalance(client, { address, value }) {
+  if (client.mode === "ganache")
+    await client.request({
+      method: "evm_setAccountBalance",
+      params: [address, numberToHex(value)]
+    });
+  else
+    await client.request({
+      method: `${client.mode}_setBalance`,
+      params: [address, numberToHex(value)]
+    });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setBlockGasLimit.js
+async function setBlockGasLimit(client, { gasLimit }) {
+  await client.request({
+    method: "evm_setBlockGasLimit",
+    params: [numberToHex(gasLimit)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setBlockTimestampInterval.js
+async function setBlockTimestampInterval(client, { interval }) {
+  const interval_ = (() => {
+    if (client.mode === "hardhat")
+      return interval * 1e3;
+    return interval;
+  })();
+  await client.request({
+    method: `${client.mode}_setBlockTimestampInterval`,
+    params: [interval_]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setCode.js
+async function setCode(client, { address, bytecode }) {
+  if (client.mode === "ganache")
+    await client.request({
+      method: "evm_setAccountCode",
+      params: [address, bytecode]
+    });
+  else
+    await client.request({
+      method: `${client.mode}_setCode`,
+      params: [address, bytecode]
+    });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setCoinbase.js
+async function setCoinbase(client, { address }) {
+  await client.request({
+    method: `${client.mode}_setCoinbase`,
+    params: [address]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setIntervalMining.js
+async function setIntervalMining(client, { interval }) {
+  const interval_ = (() => {
+    if (client.mode === "hardhat")
+      return interval * 1e3;
+    return interval;
+  })();
+  await client.request({
+    method: "evm_setIntervalMining",
+    params: [interval_]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setLoggingEnabled.js
+async function setLoggingEnabled(client, enabled) {
+  await client.request({
+    method: `${client.mode}_setLoggingEnabled`,
+    params: [enabled]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setMinGasPrice.js
+async function setMinGasPrice(client, { gasPrice }) {
+  await client.request({
+    method: `${client.mode}_setMinGasPrice`,
+    params: [numberToHex(gasPrice)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setNextBlockBaseFeePerGas.js
+async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
+  await client.request({
+    method: `${client.mode}_setNextBlockBaseFeePerGas`,
+    params: [numberToHex(baseFeePerGas)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setNextBlockTimestamp.js
+async function setNextBlockTimestamp(client, { timestamp }) {
+  await client.request({
+    method: "evm_setNextBlockTimestamp",
+    params: [numberToHex(timestamp)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setNonce.js
+async function setNonce(client, { address, nonce }) {
+  await client.request({
+    method: `${client.mode}_setNonce`,
+    params: [address, numberToHex(nonce)]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setRpcUrl.js
+async function setRpcUrl(client, jsonRpcUrl) {
+  await client.request({
+    method: `${client.mode}_setRpcUrl`,
+    params: [jsonRpcUrl]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/setStorageAt.js
+async function setStorageAt(client, { address, index: index2, value }) {
+  await client.request({
+    method: `${client.mode}_setStorageAt`,
+    params: [
+      address,
+      typeof index2 === "number" ? numberToHex(index2) : index2,
+      value
+    ]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/snapshot.js
+async function snapshot(client) {
+  return await client.request({
+    method: "evm_snapshot"
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/test/stopImpersonatingAccount.js
+async function stopImpersonatingAccount(client, { address }) {
+  await client.request({
+    method: `${client.mode}_stopImpersonatingAccount`,
+    params: [address]
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/decorators/test.js
+function testActions({ mode }) {
+  return (client_) => {
+    const client = client_.extend(() => ({
+      mode
+    }));
+    return {
+      dropTransaction: (args) => dropTransaction(client, args),
+      dumpState: () => dumpState(client),
+      getAutomine: () => getAutomine(client),
+      getTxpoolContent: () => getTxpoolContent(client),
+      getTxpoolStatus: () => getTxpoolStatus(client),
+      impersonateAccount: (args) => impersonateAccount(client, args),
+      increaseTime: (args) => increaseTime(client, args),
+      inspectTxpool: () => inspectTxpool(client),
+      loadState: (args) => loadState(client, args),
+      mine: (args) => mine(client, args),
+      removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
+      reset: (args) => reset(client, args),
+      revert: (args) => revert(client, args),
+      sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
+      setAutomine: (args) => setAutomine(client, args),
+      setBalance: (args) => setBalance(client, args),
+      setBlockGasLimit: (args) => setBlockGasLimit(client, args),
+      setBlockTimestampInterval: (args) => setBlockTimestampInterval(client, args),
+      setCode: (args) => setCode(client, args),
+      setCoinbase: (args) => setCoinbase(client, args),
+      setIntervalMining: (args) => setIntervalMining(client, args),
+      setLoggingEnabled: (args) => setLoggingEnabled(client, args),
+      setMinGasPrice: (args) => setMinGasPrice(client, args),
+      setNextBlockBaseFeePerGas: (args) => setNextBlockBaseFeePerGas(client, args),
+      setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
+      setNonce: (args) => setNonce(client, args),
+      setRpcUrl: (args) => setRpcUrl(client, args),
+      setStorageAt: (args) => setStorageAt(client, args),
+      snapshot: () => snapshot(client),
+      stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args)
+    };
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/createTestClient.js
+function createTestClient(parameters) {
+  const { key = "test", name = "Test Client", mode } = parameters;
+  const client = createClient({
+    ...parameters,
+    key,
+    name,
+    type: "testClient"
+  });
+  return client.extend((config) => ({
+    mode,
+    ...testActions({ mode })(config)
+  }));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/addChain.js
+async function addChain(client, { chain }) {
+  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
+  await client.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id),
+        chainName: name,
+        nativeCurrency,
+        rpcUrls: rpcUrls.default.http,
+        blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
+      }
+    ]
+  }, { dedupe: true, retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/deployContract.js
+function deployContract(walletClient, parameters) {
+  const { abi: abi2, args, bytecode, ...request } = parameters;
+  const calldata = encodeDeployData({ abi: abi2, args, bytecode });
+  return sendTransaction(walletClient, {
+    ...request,
+    ...request.authorizationList ? { to: null } : {},
+    data: calldata
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/getAddresses.js
+async function getAddresses(client) {
+  if (client.account?.type === "local")
+    return [client.account.address];
+  const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
+  return addresses.map((address) => checksumAddress(address));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/getCapabilities.js
+async function getCapabilities(client, parameters = {}) {
+  const { account = client.account, chainId } = parameters;
+  const account_ = account ? parseAccount(account) : void 0;
+  const params = chainId ? [account_?.address, [numberToHex(chainId)]] : [account_?.address];
+  const capabilities_raw = await client.request({
+    method: "wallet_getCapabilities",
+    params
+  });
+  const capabilities = {};
+  for (const [chainId2, capabilities_] of Object.entries(capabilities_raw)) {
+    capabilities[Number(chainId2)] = {};
+    for (let [key, value] of Object.entries(capabilities_)) {
+      if (key === "addSubAccount")
+        key = "unstable_addSubAccount";
+      capabilities[Number(chainId2)][key] = value;
+    }
+  }
+  return typeof chainId === "number" ? capabilities[chainId] : capabilities;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/getPermissions.js
+async function getPermissions(client) {
+  const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
+  return permissions;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/prepareAuthorization.js
+async function prepareAuthorization(client, parameters) {
+  const { account: account_ = client.account, chainId, nonce } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/eip7702/prepareAuthorization"
+    });
+  const account = parseAccount(account_);
+  const executor = (() => {
+    if (!parameters.executor)
+      return void 0;
+    if (parameters.executor === "self")
+      return parameters.executor;
+    return parseAccount(parameters.executor);
+  })();
+  const authorization = {
+    address: parameters.contractAddress ?? parameters.address,
+    chainId,
+    nonce
+  };
+  if (typeof authorization.chainId === "undefined")
+    authorization.chainId = client.chain?.id ?? await getAction(client, getChainId, "getChainId")({});
+  if (typeof authorization.nonce === "undefined") {
+    authorization.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
+      address: account.address,
+      blockTag: "pending"
+    });
+    if (executor === "self" || executor?.address && isAddressEqual(executor.address, account.address))
+      authorization.nonce += 1;
+  }
+  return authorization;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/requestAddresses.js
+async function requestAddresses(client) {
+  const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
+  return addresses.map((address) => getAddress(address));
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/requestPermissions.js
+async function requestPermissions(client, permissions) {
+  return client.request({
+    method: "wallet_requestPermissions",
+    params: [permissions]
+  }, { retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/sendCallsSync.js
+async function sendCallsSync(client, parameters) {
+  const { chain = client.chain } = parameters;
+  const timeout = parameters.timeout ?? Math.max((chain?.blockTime ?? 0) * 3, 5e3);
+  const result = await getAction(client, sendCalls, "sendCalls")(parameters);
+  const status = await getAction(client, waitForCallsStatus, "waitForCallsStatus")({
+    ...parameters,
+    id: result.id,
+    timeout
+  });
+  return status;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/showCallsStatus.js
+async function showCallsStatus(client, parameters) {
+  const { id } = parameters;
+  await client.request({
+    method: "wallet_showCallsStatus",
+    params: [id]
+  });
+  return;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/signAuthorization.js
+async function signAuthorization(client, parameters) {
+  const { account: account_ = client.account } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/eip7702/signAuthorization"
+    });
+  const account = parseAccount(account_);
+  if (!account.signAuthorization)
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/eip7702/signAuthorization",
+      metaMessages: [
+        "The `signAuthorization` Action does not support JSON-RPC Accounts."
+      ],
+      type: account.type
+    });
+  const authorization = await prepareAuthorization(client, parameters);
+  return account.signAuthorization(authorization);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/signMessage.js
+async function signMessage(client, { account: account_ = client.account, message }) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const account = parseAccount(account_);
+  if (account.signMessage)
+    return account.signMessage({ message });
+  const message_ = (() => {
+    if (typeof message === "string")
+      return stringToHex(message);
+    if (message.raw instanceof Uint8Array)
+      return toHex(message.raw);
+    return message.raw;
+  })();
+  return client.request({
+    method: "personal_sign",
+    params: [message_, account.address]
+  }, { retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/signTransaction.js
+async function signTransaction(client, parameters) {
+  const { account: account_ = client.account, chain = client.chain, ...transaction } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTransaction"
+    });
+  const account = parseAccount(account_);
+  assertRequest({
+    account,
+    ...parameters
+  });
+  const chainId = await getAction(client, getChainId, "getChainId")({});
+  if (chain !== null)
+    assertCurrentChain({
+      currentChainId: chainId,
+      chain
+    });
+  const formatters = chain?.formatters || client.chain?.formatters;
+  const format = formatters?.transactionRequest?.format || formatTransactionRequest;
+  if (account.signTransaction)
+    return account.signTransaction({
+      ...transaction,
+      account,
+      chainId
+    }, { serializer: client.chain?.serializers?.transaction });
+  return await client.request({
+    method: "eth_signTransaction",
+    params: [
+      {
+        ...format({
+          ...transaction,
+          account
+        }, "signTransaction"),
+        chainId: numberToHex(chainId),
+        from: account.address
+      }
+    ]
+  }, { retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/signTypedData.js
+async function signTypedData(client, parameters) {
+  const { account: account_ = client.account, domain, message, primaryType } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const account = parseAccount(account_);
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...parameters.types
+  };
+  validateTypedData({ domain, message, primaryType, types });
+  if (account.signTypedData)
+    return account.signTypedData({ domain, message, primaryType, types });
+  const typedData = serializeTypedData({ domain, message, primaryType, types });
+  return client.request({
+    method: "eth_signTypedData_v4",
+    params: [account.address, typedData]
+  }, { retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/switchChain.js
+async function switchChain(client, { id }) {
+  await client.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id)
+      }
+    ]
+  }, { retryCount: 0 });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/wallet/watchAsset.js
+async function watchAsset(client, params) {
+  const added = await client.request({
+    method: "wallet_watchAsset",
+    params
+  }, { retryCount: 0 });
+  return added;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/decorators/wallet.js
+function walletActions(client) {
+  return {
+    addChain: (args) => addChain(client, args),
+    deployContract: (args) => deployContract(client, args),
+    fillTransaction: (args) => fillTransaction(client, args),
+    getAddresses: () => getAddresses(client),
+    getCallsStatus: (args) => getCallsStatus(client, args),
+    getCapabilities: (args) => getCapabilities(client, args),
+    getChainId: () => getChainId(client),
+    getPermissions: () => getPermissions(client),
+    prepareAuthorization: (args) => prepareAuthorization(client, args),
+    prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
+    requestAddresses: () => requestAddresses(client),
+    requestPermissions: (args) => requestPermissions(client, args),
+    sendCalls: (args) => sendCalls(client, args),
+    sendCallsSync: (args) => sendCallsSync(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendRawTransactionSync: (args) => sendRawTransactionSync(client, args),
+    sendTransaction: (args) => sendTransaction(client, args),
+    sendTransactionSync: (args) => sendTransactionSync(client, args),
+    showCallsStatus: (args) => showCallsStatus(client, args),
+    signAuthorization: (args) => signAuthorization(client, args),
+    signMessage: (args) => signMessage(client, args),
+    signTransaction: (args) => signTransaction(client, args),
+    signTypedData: (args) => signTypedData(client, args),
+    switchChain: (args) => switchChain(client, args),
+    waitForCallsStatus: (args) => waitForCallsStatus(client, args),
+    watchAsset: (args) => watchAsset(client, args),
+    writeContract: (args) => writeContract(client, args),
+    writeContractSync: (args) => writeContractSync(client, args),
+    token: {
+      approve: bindActionDecorators(client, approve),
+      approveSync: bindActionDecorators(client, approveSync),
+      transfer: bindActionDecorators(client, transfer),
+      transferSync: bindActionDecorators(client, transferSync)
+    }
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/createWalletClient.js
+function createWalletClient(parameters) {
+  const { key = "wallet", name = "Wallet Client", transport } = parameters;
+  const client = createClient({
+    ...parameters,
+    key,
+    name,
+    transport,
+    type: "walletClient"
+  });
+  return client.extend(walletActions);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/transports/createTransport.js
 function createTransport({ key, methods, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
   const uid2 = uid();
   return {
@@ -7017,6 +9689,153 @@ function createTransport({ key, methods, name, request, retryCount = 3, retryDel
   };
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/transports/custom.js
+function custom(provider, config = {}) {
+  const { key = "custom", methods, name = "Custom Provider", retryDelay } = config;
+  return ({ retryCount: defaultRetryCount }) => createTransport({
+    key,
+    methods,
+    name,
+    request: provider.request.bind(provider),
+    retryCount: config.retryCount ?? defaultRetryCount,
+    retryDelay,
+    type: "custom"
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/transports/fallback.js
+function fallback(transports_, config = {}) {
+  const { key = "fallback", name = "Fallback", rank = false, shouldThrow: shouldThrow_ = shouldThrow, retryCount, retryDelay } = config;
+  return (({ chain, pollingInterval = 4e3, timeout, ...rest }) => {
+    let transports = transports_;
+    let onResponse = () => {
+    };
+    const transport = createTransport({
+      key,
+      name,
+      async request({ method, params }) {
+        let includes;
+        const fetch2 = async (i = 0) => {
+          const transport2 = transports[i]({
+            ...rest,
+            chain,
+            retryCount: 0,
+            timeout
+          });
+          try {
+            const response = await transport2.request({
+              method,
+              params
+            });
+            onResponse({
+              method,
+              params,
+              response,
+              transport: transport2,
+              status: "success"
+            });
+            return response;
+          } catch (err) {
+            onResponse({
+              error: err,
+              method,
+              params,
+              transport: transport2,
+              status: "error"
+            });
+            if (shouldThrow_(err))
+              throw err;
+            if (i === transports.length - 1)
+              throw err;
+            includes ??= transports.slice(i + 1).some((transport3) => {
+              const { include, exclude } = transport3({ chain }).config.methods || {};
+              if (include)
+                return include.includes(method);
+              if (exclude)
+                return !exclude.includes(method);
+              return true;
+            });
+            if (!includes)
+              throw err;
+            return fetch2(i + 1);
+          }
+        };
+        return fetch2();
+      },
+      retryCount,
+      retryDelay,
+      type: "fallback"
+    }, {
+      onResponse: (fn) => onResponse = fn,
+      transports: transports.map((fn) => fn({ chain, retryCount: 0 }))
+    });
+    if (rank) {
+      const rankOptions = typeof rank === "object" ? rank : {};
+      rankTransports({
+        chain,
+        interval: rankOptions.interval ?? pollingInterval,
+        onTransports: (transports_2) => transports = transports_2,
+        ping: rankOptions.ping,
+        sampleCount: rankOptions.sampleCount,
+        timeout: rankOptions.timeout,
+        transports,
+        weights: rankOptions.weights
+      });
+    }
+    return transport;
+  });
+}
+function shouldThrow(error) {
+  if ("code" in error && typeof error.code === "number") {
+    if (error.code === TransactionRejectedRpcError.code || error.code === UserRejectedRequestError.code || error.code === WalletConnectSessionSettlementError.code || ExecutionRevertedError.nodeMessage.test(error.message) || error.code === 5e3)
+      return true;
+  }
+  return false;
+}
+function rankTransports({ chain, interval = 4e3, onTransports, ping, sampleCount = 10, timeout = 1e3, transports, weights = {} }) {
+  const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
+  const samples = [];
+  const rankTransports_ = async () => {
+    const sample = await Promise.all(transports.map(async (transport) => {
+      const transport_ = transport({ chain, retryCount: 0, timeout });
+      const start = Date.now();
+      let end;
+      let success;
+      try {
+        await (ping ? ping({ transport: transport_ }) : transport_.request({ method: "net_listening" }));
+        success = 1;
+      } catch {
+        success = 0;
+      } finally {
+        end = Date.now();
+      }
+      const latency = end - start;
+      return { latency, success };
+    }));
+    samples.push(sample);
+    if (samples.length > sampleCount)
+      samples.shift();
+    const maxLatency = Math.max(...samples.map((sample2) => Math.max(...sample2.map(({ latency }) => latency))));
+    const scores = transports.map((_, i) => {
+      const latencies = samples.map((sample2) => sample2[i].latency);
+      const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) / latencies.length;
+      const latencyScore = 1 - meanLatency / maxLatency;
+      const successes = samples.map((sample2) => sample2[i].success);
+      const stabilityScore = successes.reduce((acc, success) => acc + success, 0) / successes.length;
+      if (stabilityScore === 0)
+        return [0, i];
+      return [
+        latencyWeight * latencyScore + stabilityWeight * stabilityScore,
+        i
+      ];
+    }).sort((a, b) => b[0] - a[0]);
+    onTransports(scores.map(([, i]) => transports[i]));
+    await wait(interval);
+    rankTransports_();
+  };
+  rankTransports_();
+}
+
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/errors/transport.js
 var UrlRequiredError = class extends BaseError {
   constructor() {
@@ -7104,194 +9923,383 @@ function http(url, config = {}) {
   };
 }
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/op-stack/contracts.js
-var contracts = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/clients/transports/webSocket.js
+function webSocket(url, config = {}) {
+  const { keepAlive, key = "webSocket", methods, name = "WebSocket JSON-RPC", reconnect, retryDelay } = config;
+  return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
+    const retryCount = config.retryCount ?? retryCount_;
+    const timeout = timeout_ ?? config.timeout ?? 1e4;
+    const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
+    const wsRpcClientOpts = { keepAlive, reconnect };
+    if (!url_)
+      throw new UrlRequiredError();
+    return createTransport({
+      key,
+      methods,
+      name,
+      async request({ method, params }) {
+        const body = { method, params };
+        const rpcClient = await getWebSocketRpcClient(url_, wsRpcClientOpts);
+        const { error, result } = await rpcClient.requestAsync({
+          body,
+          timeout
+        });
+        if (error)
+          throw new RpcRequestError({
+            body,
+            error,
+            url: url_
+          });
+        return result;
+      },
+      retryCount,
+      retryDelay,
+      timeout,
+      type: "webSocket"
+    }, {
+      getSocket() {
+        return getSocket(url_);
+      },
+      getRpcClient() {
+        return getWebSocketRpcClient(url_, wsRpcClientOpts);
+      },
+      async subscribe({ params, onData, onError }) {
+        const rpcClient = await getWebSocketRpcClient(url_, wsRpcClientOpts);
+        const { result: subscriptionId } = await new Promise((resolve, reject) => rpcClient.request({
+          body: {
+            method: "eth_subscribe",
+            params
+          },
+          onError(error) {
+            reject(error);
+            onError?.(error);
+            return;
+          },
+          onResponse(response) {
+            if (response.error) {
+              reject(response.error);
+              onError?.(response.error);
+              return;
+            }
+            if (typeof response.id === "number") {
+              resolve(response);
+              return;
+            }
+            if (response.method !== "eth_subscription")
+              return;
+            onData(response.params);
+          }
+        }));
+        return {
+          subscriptionId,
+          async unsubscribe() {
+            return new Promise((resolve) => rpcClient.request({
+              body: {
+                method: "eth_unsubscribe",
+                params: [subscriptionId]
+              },
+              onResponse: resolve
+            }));
+          }
+        };
+      }
+    });
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/types/eip1193.js
+var ProviderRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "details", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.code = code;
+    this.details = message;
   }
 };
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/op-stack/formatters.js
-var formatters = {
-  block: /* @__PURE__ */ defineBlock({
-    format(args) {
-      const transactions = args.transactions?.map((transaction) => {
-        if (typeof transaction === "string")
-          return transaction;
-        const formatted = formatTransaction(transaction);
-        if (formatted.typeHex === "0x7e") {
-          formatted.isSystemTx = transaction.isSystemTx;
-          formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : void 0;
-          formatted.sourceHash = transaction.sourceHash;
-          formatted.type = "deposit";
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/abi/decodeDeployData.js
+var docsPath3 = "/docs/contract/decodeDeployData";
+function decodeDeployData(parameters) {
+  const { abi: abi2, bytecode, data } = parameters;
+  if (data === bytecode)
+    return { bytecode };
+  const description = abi2.find((x) => "type" in x && x.type === "constructor");
+  if (!description)
+    throw new AbiConstructorNotFoundError({ docsPath: docsPath3 });
+  if (!("inputs" in description))
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath3 });
+  if (!description.inputs || description.inputs.length === 0)
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath3 });
+  const args = decodeAbiParameters(description.inputs, `0x${data.replace(bytecode, "")}`);
+  return { args, bytecode };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/blob/fromBlobs.js
+function fromBlobs(parameters) {
+  const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
+  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
+  const length = blobs.reduce((length2, blob) => length2 + blob.length, 0);
+  const data = createCursor(new Uint8Array(length));
+  let active = true;
+  for (const blob of blobs) {
+    const cursor = createCursor(blob);
+    while (active && cursor.position < blob.length) {
+      cursor.incrementPosition(1);
+      let consume = 31;
+      if (blob.length - cursor.position < 31)
+        consume = blob.length - cursor.position;
+      for (const _ in Array.from({ length: consume })) {
+        const byte = cursor.readByte();
+        const isTerminator = byte === 128 && !cursor.inspectBytes(cursor.remaining).includes(128);
+        if (isTerminator) {
+          active = false;
+          break;
         }
-        return formatted;
-      });
-      return {
-        transactions,
-        stateRoot: args.stateRoot
-      };
-    }
-  }),
-  transaction: /* @__PURE__ */ defineTransaction({
-    format(args) {
-      const transaction = {};
-      if (args.type === "0x7e") {
-        transaction.isSystemTx = args.isSystemTx;
-        transaction.mint = args.mint ? hexToBigInt(args.mint) : void 0;
-        transaction.sourceHash = args.sourceHash;
-        transaction.type = "deposit";
+        data.pushByte(byte);
       }
-      return transaction;
-    }
-  }),
-  transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
-    format(args) {
-      return {
-        ...args.depositNonce ? { depositNonce: hexToBigInt(args.depositNonce) } : {},
-        ...args.depositReceiptVersion ? { depositReceiptVersion: hexToNumber(args.depositReceiptVersion) } : {},
-        l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
-        l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
-        l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
-        l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null
-      };
     }
-  })
-};
+  }
+  const trimmedData = data.bytes.slice(0, data.position);
+  return to === "hex" ? bytesToHex(trimmedData) : trimmedData;
+}
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/op-stack/serializers.js
-function serializeTransaction2(transaction, signature) {
-  if (isDeposit(transaction))
-    return serializeTransactionDeposit(transaction);
-  return serializeTransaction(transaction, signature);
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/blob/sidecarsToVersionedHashes.js
+function sidecarsToVersionedHashes(parameters) {
+  const { sidecars, version } = parameters;
+  const to = parameters.to ?? (typeof sidecars[0].blob === "string" ? "hex" : "bytes");
+  const hashes = [];
+  for (const { commitment } of sidecars) {
+    hashes.push(commitmentToVersionedHash({
+      commitment,
+      to,
+      version
+    }));
+  }
+  return hashes;
 }
-var serializers = {
-  transaction: serializeTransaction2
-};
-function serializeTransactionDeposit(transaction) {
-  assertTransactionDeposit(transaction);
-  const { sourceHash, data, from: from13, gas, isSystemTx, mint, to, value } = transaction;
-  const serializedTransaction = [
-    sourceHash,
-    from13,
-    to ?? "0x",
-    mint ? toHex(mint) : "0x",
-    value ? toHex(value) : "0x",
-    gas ? toHex(gas) : "0x",
-    isSystemTx ? "0x1" : "0x",
-    data ?? "0x"
-  ];
-  return concatHex([
-    "0x7e",
-    toRlp(serializedTransaction)
-  ]);
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/ens/toCoinType.js
+var SLIP44_MSB = 2147483648;
+function toCoinType(chainId) {
+  if (chainId === 1)
+    return 60n;
+  if (chainId >= SLIP44_MSB || chainId < 0)
+    throw new EnsInvalidChainIdError({ chainId });
+  return BigInt((2147483648 | chainId) >>> 0);
 }
-function isDeposit(transaction) {
-  if (transaction.type === "deposit")
-    return true;
-  if (typeof transaction.sourceHash !== "undefined")
-    return true;
-  return false;
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/kzg/defineKzg.js
+function defineKzg({ blobToKzgCommitment, computeBlobKzgProof }) {
+  return {
+    blobToKzgCommitment,
+    computeBlobKzgProof
+  };
 }
-function assertTransactionDeposit(transaction) {
-  const { from: from13, to } = transaction;
-  if (from13 && !isAddress(from13))
-    throw new InvalidAddressError({ address: from13 });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/kzg/setupKzg.js
+function setupKzg(parameters, path) {
+  try {
+    parameters.loadTrustedSetup(path);
+  } catch (e) {
+    const error = e;
+    if (!error.message.includes("trusted setup is already loaded"))
+      throw error;
+  }
+  return defineKzg(parameters);
 }
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/op-stack/chainConfig.js
-var chainConfig = {
-  blockTime: 2e3,
-  contracts,
-  formatters,
-  serializers
-};
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/compactSignatureToSignature.js
+function compactSignatureToSignature({ r, yParityAndS }) {
+  const yParityAndS_bytes = hexToBytes(yParityAndS);
+  const yParity = yParityAndS_bytes[0] & 128 ? 1 : 0;
+  const s = yParityAndS_bytes;
+  if (yParity === 1)
+    s[0] &= 127;
+  return { r, s: bytesToHex(s), yParity };
+}
 
-// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/chains/definitions/base.js
-var sourceId = 1;
-var base = /* @__PURE__ */ defineChain({
-  ...chainConfig,
-  id: 8453,
-  name: "Base",
-  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ["https://mainnet.base.org"]
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: "Basescan",
-      url: "https://basescan.org",
-      apiUrl: "https://api.basescan.org/api"
-    }
-  },
-  contracts: {
-    ...chainConfig.contracts,
-    disputeGameFactory: {
-      [sourceId]: {
-        address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e"
-      }
-    },
-    l2OutputOracle: {
-      [sourceId]: {
-        address: "0x56315b90c40730925ec5485cf004d835058518A0"
-      }
-    },
-    multicall3: {
-      address: "0xca11bde05977b3631167028862be2a173976ca11",
-      blockCreated: 5022
-    },
-    portal: {
-      [sourceId]: {
-        address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
-        blockCreated: 17482143
-      }
-    },
-    l1StandardBridge: {
-      [sourceId]: {
-        address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
-        blockCreated: 17482143
-      }
-    }
-  },
-  sourceId
-});
-var basePreconf = /* @__PURE__ */ defineChain({
-  ...base,
-  experimental_preconfirmationTime: 200,
-  rpcUrls: {
-    default: {
-      http: ["https://mainnet-preconf.base.org"]
-    }
-  }
-});
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/parseCompactSignature.js
+function parseCompactSignature(signatureHex) {
+  const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
+  return {
+    r: numberToHex(r, { size: 32 }),
+    yParityAndS: numberToHex(s, { size: 32 })
+  };
+}
 
-// src/lib/usdc.ts
-var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var USDC_DECIMALS = 6;
-async function getUsdcBalance(address, rpcUrl) {
-  const client = createPublicClient({ chain: base, transport: http(rpcUrl) });
-  return client.readContract({
-    address: USDC_ADDRESS,
-    abi: erc20Abi,
-    functionName: "balanceOf",
-    args: [address]
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/parseSignature.js
+function parseSignature(signatureHex) {
+  const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
+  const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
+  const [v, yParity] = (() => {
+    if (yParityOrV === 0 || yParityOrV === 1)
+      return [void 0, yParityOrV];
+    if (yParityOrV === 27)
+      return [BigInt(yParityOrV), 0];
+    if (yParityOrV === 28)
+      return [BigInt(yParityOrV), 1];
+    throw new Error("Invalid yParityOrV value");
+  })();
+  if (typeof v !== "undefined")
+    return {
+      r: numberToHex(r, { size: 32 }),
+      s: numberToHex(s, { size: 32 }),
+      v,
+      yParity
+    };
+  return {
+    r: numberToHex(r, { size: 32 }),
+    s: numberToHex(s, { size: 32 }),
+    yParity
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/recoverTransactionAddress.js
+async function recoverTransactionAddress(parameters) {
+  const { serializedTransaction, signature: signature_ } = parameters;
+  const transaction = parseTransaction(serializedTransaction);
+  const signature = signature_ ?? {
+    r: transaction.r,
+    s: transaction.s,
+    v: transaction.v,
+    yParity: transaction.yParity
+  };
+  const serialized = serializeTransaction({
+    ...transaction,
+    r: void 0,
+    s: void 0,
+    v: void 0,
+    yParity: void 0,
+    sidecars: void 0
+  });
+  return await recoverAddress({
+    hash: keccak256(serialized),
+    signature
   });
 }
 
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/serializeCompactSignature.js
+function serializeCompactSignature({ r, yParityAndS }) {
+  return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(yParityAndS)).toCompactHex()}`;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/signatureToCompactSignature.js
+function signatureToCompactSignature(signature) {
+  const { r, s, v, yParity } = signature;
+  const yParity_ = Number(yParity ?? v - 27n);
+  let yParityAndS = s;
+  if (yParity_ === 1) {
+    const bytes = hexToBytes(s);
+    bytes[0] |= 128;
+    yParityAndS = bytesToHex(bytes);
+  }
+  return { r, yParityAndS };
+}
+
 export {
-  USDC_ADDRESS,
-  USDC_DECIMALS,
-  getUsdcBalance
+  FilterTypeNotSupportedError,
+  encodeEventTopics,
+  getContractError,
+  recoverPublicKey,
+  recoverAddress,
+  EstimateGasExecutionError,
+  BaseFeeScalarError,
+  Eip1559FeesNotSupportedError,
+  MaxFeePerGasTooLowError,
+  BlockNotFoundError,
+  transactionType,
+  formatTransaction,
+  defineTransaction,
+  formatBlock,
+  defineBlock,
+  formatLog,
+  decodeEventLog,
+  parseEventLogs,
+  withCache,
+  assertCurrentChain,
+  getContract,
+  BundleFailedError,
+  withRetry,
+  formatTransactionReceipt,
+  defineTransactionReceipt,
+  WaitForCallsStatusTimeoutError,
+  createClient,
+  rpcSchema,
+  namehash,
+  labelhash,
+  EnsAvatarInvalidNftUriError,
+  EnsAvatarUriResolutionError,
+  EnsAvatarUnsupportedNamespaceError,
+  EnsInvalidChainIdError,
+  encodePacked,
+  isBytes,
+  getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  ccipReadTunnel,
+  defineChain,
+  extendSchema,
+  extractChain,
+  fromRlp,
+  isHash,
+  ripemd1602 as ripemd160,
+  withTimeout,
+  zeroHash,
+  isErc6492Signature,
+  isErc8010Signature,
+  parseErc6492Signature,
+  parseErc8010Signature,
+  recoverMessageAddress,
+  recoverTypedDataAddress,
+  serializeErc6492Signature,
+  serializeErc8010Signature,
+  verifyHash,
+  verifyMessage,
+  verifyTypedData,
+  getSerializedTransactionType,
+  parseTransaction,
+  InvalidDecimalNumberError,
+  parseUnits,
+  parseEther,
+  parseGwei,
+  ethAddress,
+  zeroAddress,
+  publicActions,
+  createPublicClient,
+  testActions,
+  createTestClient,
+  walletActions,
+  createWalletClient,
+  createTransport,
+  custom,
+  fallback,
+  shouldThrow,
+  UrlRequiredError,
+  http,
+  webSocket,
+  ProviderRpcError,
+  decodeDeployData,
+  fromBlobs,
+  sidecarsToVersionedHashes,
+  toCoinType,
+  defineKzg,
+  setupKzg,
+  compactSignatureToSignature,
+  parseCompactSignature,
+  parseSignature,
+  recoverTransactionAddress,
+  serializeCompactSignature,
+  signatureToCompactSignature
 };
-//# sourceMappingURL=chunk-IPOWB3G3.js.map
+//# sourceMappingURL=chunk-UGX7YPX2.js.map