agents 0.2.9 → 0.2.11

package/dist/mcp/x402.js

@@ -1,3195 +1,194 @@
-import {
-  AbiDecodingZeroDataError,
-  AtomicReadyWalletRejectedUpgradeError,
-  AtomicityNotSupportedError,
-  BaseError,
-  BundleTooLargeError,
-  BytesSizeMismatchError,
-  ChainDisconnectedError,
-  ChainMismatchError,
-  ChainNotFoundError,
-  ContractFunctionExecutionError,
-  ContractFunctionRevertedError,
-  ContractFunctionZeroDataError,
-  DuplicateIdError,
-  FeeCapTooHighError,
-  HttpRequestError,
-  InternalRpcError,
-  InvalidAddressError,
-  InvalidChainIdError,
-  InvalidInputRpcError,
-  InvalidLegacyVError,
-  InvalidParamsRpcError,
-  InvalidRequestRpcError,
-  InvalidSerializableTransactionError,
-  InvalidStorageKeySizeError,
-  JsonRpcVersionUnsupportedError,
-  LimitExceededRpcError,
-  LruMap,
-  MethodNotFoundRpcError,
-  MethodNotSupportedRpcError,
-  ParseRpcError,
-  ProviderDisconnectedError,
-  RawContractError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  RpcRequestError,
-  SwitchChainError,
-  TimeoutError,
-  TipAboveFeeCapError,
-  TransactionExecutionError,
-  TransactionRejectedRpcError,
-  UnauthorizedProviderError,
-  UnknownBundleIdError,
-  UnknownNodeError,
-  UnknownRpcError,
-  UnsupportedChainIdError,
-  UnsupportedNonOptionalCapabilityError,
-  UnsupportedProviderMethodError,
-  UserRejectedRequestError,
-  assertRequest,
-  bytesRegex,
-  bytesToHex,
-  checksumAddress,
-  concat,
-  concatHex,
-  createBatchScheduler,
-  createCursor,
-  defineFormatter,
-  encodeDeployData,
-  encodeFunctionData,
-  extract,
-  formatEther,
-  formatGwei,
-  formatTransactionRequest,
-  getAddress,
-  getNodeError,
-  hexToBigInt,
-  hexToBytes,
-  hexToNumber,
-  integerRegex,
-  isAddress,
-  isAddressEqual,
-  isHex,
-  keccak256,
-  maxUint256,
-  numberToHex,
-  parseAccount,
-  prettyPrint,
-  serializeStateOverride,
-  size,
-  slice,
-  sliceHex,
-  stringToHex,
-  stringify,
-  toBytes,
-  toHex,
-  trim,
-  withResolvers
-} from "../chunk-JJBFIGUC.js";
-import {
-  sha256
-} from "../chunk-5Y6BEZDY.js";
-import "../chunk-TYAY6AU6.js";
-import "../chunk-PR4QN5HX.js";
-
-// ../../node_modules/viem/_esm/utils/chain/defineChain.js
-function defineChain(chain) {
-  return {
-    formatters: void 0,
-    fees: void 0,
-    serializers: void 0,
-    ...chain
-  };
-}
-
-// ../../node_modules/viem/_esm/utils/formatters/transaction.js
-var transactionType = {
-  "0x0": "legacy",
-  "0x1": "eip2930",
-  "0x2": "eip1559",
-  "0x3": "eip4844",
-  "0x4": "eip7702"
-};
-function formatTransaction(transaction) {
-  const transaction_ = {
-    ...transaction,
-    blockHash: transaction.blockHash ? transaction.blockHash : null,
-    blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
-    chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
-    gas: transaction.gas ? BigInt(transaction.gas) : void 0,
-    gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
-    maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
-    maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
-    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
-    nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
-    to: transaction.to ? transaction.to : null,
-    transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
-    type: transaction.type ? transactionType[transaction.type] : void 0,
-    typeHex: transaction.type ? transaction.type : void 0,
-    value: transaction.value ? BigInt(transaction.value) : void 0,
-    v: transaction.v ? BigInt(transaction.v) : void 0
-  };
-  if (transaction.authorizationList)
-    transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);
-  transaction_.yParity = (() => {
-    if (transaction.yParity)
-      return Number(transaction.yParity);
-    if (typeof transaction_.v === "bigint") {
-      if (transaction_.v === 0n || transaction_.v === 27n)
-        return 0;
-      if (transaction_.v === 1n || transaction_.v === 28n)
-        return 1;
-      if (transaction_.v >= 35n)
-        return transaction_.v % 2n === 0n ? 1 : 0;
-    }
-    return void 0;
-  })();
-  if (transaction_.type === "legacy") {
-    delete transaction_.accessList;
-    delete transaction_.maxFeePerBlobGas;
-    delete transaction_.maxFeePerGas;
-    delete transaction_.maxPriorityFeePerGas;
-    delete transaction_.yParity;
-  }
-  if (transaction_.type === "eip2930") {
-    delete transaction_.maxFeePerBlobGas;
-    delete transaction_.maxFeePerGas;
-    delete transaction_.maxPriorityFeePerGas;
-  }
-  if (transaction_.type === "eip1559") {
-    delete transaction_.maxFeePerBlobGas;
-  }
-  return transaction_;
-}
-var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
-function formatAuthorizationList(authorizationList) {
-  return authorizationList.map((authorization) => ({
-    address: authorization.address,
-    chainId: Number(authorization.chainId),
-    nonce: Number(authorization.nonce),
-    r: authorization.r,
-    s: authorization.s,
-    yParity: Number(authorization.yParity)
-  }));
-}
-
-// ../../node_modules/viem/_esm/utils/formatters/block.js
-function formatBlock(block) {
-  const transactions = (block.transactions ?? []).map((transaction) => {
-    if (typeof transaction === "string")
-      return transaction;
-    return formatTransaction(transaction);
-  });
-  return {
-    ...block,
-    baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
-    blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
-    difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
-    excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
-    gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
-    gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
-    hash: block.hash ? block.hash : null,
-    logsBloom: block.logsBloom ? block.logsBloom : null,
-    nonce: block.nonce ? block.nonce : null,
-    number: block.number ? BigInt(block.number) : null,
-    size: block.size ? BigInt(block.size) : void 0,
-    timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
-    transactions,
-    totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
-  };
-}
-var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);
-
-// ../../node_modules/viem/_esm/utils/formatters/log.js
-function formatLog(log, { args, eventName } = {}) {
-  return {
-    ...log,
-    blockHash: log.blockHash ? log.blockHash : null,
-    blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
-    logIndex: log.logIndex ? Number(log.logIndex) : null,
-    transactionHash: log.transactionHash ? log.transactionHash : null,
-    transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
-    ...eventName ? { args, eventName } : {}
-  };
-}
-
-// ../../node_modules/viem/_esm/utils/formatters/transactionReceipt.js
-var receiptStatuses = {
-  "0x0": "reverted",
-  "0x1": "success"
-};
-function formatTransactionReceipt(transactionReceipt) {
-  const receipt = {
-    ...transactionReceipt,
-    blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
-    contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
-    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
-    effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
-    gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
-    logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
-    to: transactionReceipt.to ? transactionReceipt.to : null,
-    transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
-    status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
-    type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
-  };
-  if (transactionReceipt.blobGasPrice)
-    receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
-  if (transactionReceipt.blobGasUsed)
-    receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
-  return receipt;
-}
-var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);
-
-// ../../node_modules/viem/_esm/utils/encoding/toRlp.js
-function toRlp(bytes, to = "hex") {
-  const encodable = getEncodable(bytes);
-  const cursor = createCursor(new Uint8Array(encodable.length));
-  encodable.encode(cursor);
-  if (to === "hex")
-    return bytesToHex(cursor.bytes);
-  return cursor.bytes;
-}
-function getEncodable(bytes) {
-  if (Array.isArray(bytes))
-    return getEncodableList(bytes.map((x) => getEncodable(x)));
-  return getEncodableBytes(bytes);
-}
-function getEncodableList(list) {
-  const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
-  const sizeOfBodyLength = getSizeOfLength(bodyLength);
-  const length = (() => {
-    if (bodyLength <= 55)
-      return 1 + bodyLength;
-    return 1 + sizeOfBodyLength + bodyLength;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bodyLength <= 55) {
-        cursor.pushByte(192 + bodyLength);
-      } else {
-        cursor.pushByte(192 + 55 + sizeOfBodyLength);
-        if (sizeOfBodyLength === 1)
-          cursor.pushUint8(bodyLength);
-        else if (sizeOfBodyLength === 2)
-          cursor.pushUint16(bodyLength);
-        else if (sizeOfBodyLength === 3)
-          cursor.pushUint24(bodyLength);
-        else
-          cursor.pushUint32(bodyLength);
-      }
-      for (const { encode } of list) {
-        encode(cursor);
-      }
-    }
-  };
-}
-function getEncodableBytes(bytesOrHex) {
-  const bytes = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
-  const sizeOfBytesLength = getSizeOfLength(bytes.length);
-  const length = (() => {
-    if (bytes.length === 1 && bytes[0] < 128)
-      return 1;
-    if (bytes.length <= 55)
-      return 1 + bytes.length;
-    return 1 + sizeOfBytesLength + bytes.length;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bytes.length === 1 && bytes[0] < 128) {
-        cursor.pushBytes(bytes);
-      } else if (bytes.length <= 55) {
-        cursor.pushByte(128 + bytes.length);
-        cursor.pushBytes(bytes);
-      } else {
-        cursor.pushByte(128 + 55 + sizeOfBytesLength);
-        if (sizeOfBytesLength === 1)
-          cursor.pushUint8(bytes.length);
-        else if (sizeOfBytesLength === 2)
-          cursor.pushUint16(bytes.length);
-        else if (sizeOfBytesLength === 3)
-          cursor.pushUint24(bytes.length);
-        else
-          cursor.pushUint32(bytes.length);
-        cursor.pushBytes(bytes);
-      }
-    }
-  };
-}
-function getSizeOfLength(length) {
-  if (length < 2 ** 8)
-    return 1;
-  if (length < 2 ** 16)
-    return 2;
-  if (length < 2 ** 24)
-    return 3;
-  if (length < 2 ** 32)
-    return 4;
-  throw new BaseError("Length is too large.");
-}
-
-// ../../node_modules/viem/_esm/utils/authorization/serializeAuthorizationList.js
-function serializeAuthorizationList(authorizationList) {
-  if (!authorizationList || authorizationList.length === 0)
-    return [];
-  const serializedAuthorizationList = [];
-  for (const authorization of authorizationList) {
-    const { chainId, nonce, ...signature } = authorization;
-    const contractAddress = authorization.address;
-    serializedAuthorizationList.push([
-      chainId ? toHex(chainId) : "0x",
-      contractAddress,
-      nonce ? toHex(nonce) : "0x",
-      ...toYParitySignatureArray({}, signature)
-    ]);
-  }
-  return serializedAuthorizationList;
-}
-
-// ../../node_modules/viem/_esm/utils/blob/blobsToCommitments.js
-function blobsToCommitments(parameters) {
-  const { kzg } = 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 commitments = [];
-  for (const blob of blobs)
-    commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
-  return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
-}
-
-// ../../node_modules/viem/_esm/utils/blob/blobsToProofs.js
-function blobsToProofs(parameters) {
-  const { kzg } = 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 commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
-  const proofs = [];
-  for (let i = 0; i < blobs.length; i++) {
-    const blob = blobs[i];
-    const commitment = commitments[i];
-    proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
-  }
-  return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
-}
-
-// ../../node_modules/@noble/hashes/esm/sha256.js
-var sha2562 = sha256;
-
-// ../../node_modules/viem/_esm/utils/hash/sha256.js
-function sha2563(value, to_) {
-  const to = to_ || "hex";
-  const bytes = sha2562(isHex(value, { strict: false }) ? toBytes(value) : value);
-  if (to === "bytes")
-    return bytes;
-  return toHex(bytes);
-}
-
-// ../../node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
-function commitmentToVersionedHash(parameters) {
-  const { commitment, version = 1 } = parameters;
-  const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
-  const versionedHash = sha2563(commitment, "bytes");
-  versionedHash.set([version], 0);
-  return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
-}
-
-// ../../node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
-function commitmentsToVersionedHashes(parameters) {
-  const { commitments, version } = parameters;
-  const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
-  const hashes = [];
-  for (const commitment of commitments) {
-    hashes.push(commitmentToVersionedHash({
-      commitment,
-      to,
-      version
-    }));
-  }
-  return hashes;
-}
-
-// ../../node_modules/viem/_esm/constants/blob.js
-var blobsPerTransaction = 6;
-var bytesPerFieldElement = 32;
-var fieldElementsPerBlob = 4096;
-var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
-var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - // terminator byte (0x80).
-1 - // zero byte (0x00) appended to each field element.
-1 * fieldElementsPerBlob * blobsPerTransaction;
-
-// ../../node_modules/viem/_esm/constants/kzg.js
-var versionedHashVersionKzg = 1;
-
-// ../../node_modules/viem/_esm/errors/blob.js
-var BlobSizeTooLargeError = class extends BaseError {
-  constructor({ maxSize, size: size3 }) {
-    super("Blob size is too large.", {
-      metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
-      name: "BlobSizeTooLargeError"
-    });
-  }
-};
-var EmptyBlobError = class extends BaseError {
-  constructor() {
-    super("Blob data must not be empty.", { name: "EmptyBlobError" });
-  }
-};
-var InvalidVersionedHashSizeError = class extends BaseError {
-  constructor({ hash, size: size3 }) {
-    super(`Versioned hash "${hash}" size is invalid.`, {
-      metaMessages: ["Expected: 32", `Received: ${size3}`],
-      name: "InvalidVersionedHashSizeError"
-    });
-  }
-};
-var InvalidVersionedHashVersionError = class extends BaseError {
-  constructor({ hash, version }) {
-    super(`Versioned hash "${hash}" version is invalid.`, {
-      metaMessages: [
-        `Expected: ${versionedHashVersionKzg}`,
-        `Received: ${version}`
-      ],
-      name: "InvalidVersionedHashVersionError"
-    });
-  }
-};
-
-// ../../node_modules/viem/_esm/utils/blob/toBlobs.js
-function toBlobs(parameters) {
-  const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
-  const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
-  const size_ = size(data);
-  if (!size_)
-    throw new EmptyBlobError();
-  if (size_ > maxBytesPerTransaction)
-    throw new BlobSizeTooLargeError({
-      maxSize: maxBytesPerTransaction,
-      size: size_
-    });
-  const blobs = [];
-  let active = true;
-  let position = 0;
-  while (active) {
-    const blob = createCursor(new Uint8Array(bytesPerBlob));
-    let size3 = 0;
-    while (size3 < fieldElementsPerBlob) {
-      const bytes = data.slice(position, position + (bytesPerFieldElement - 1));
-      blob.pushByte(0);
-      blob.pushBytes(bytes);
-      if (bytes.length < 31) {
-        blob.pushByte(128);
-        active = false;
-        break;
-      }
-      size3++;
-      position += 31;
-    }
-    blobs.push(blob);
-  }
-  return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
-}
-
-// ../../node_modules/viem/_esm/utils/blob/toBlobSidecars.js
-function toBlobSidecars(parameters) {
-  const { data, kzg, to } = parameters;
-  const blobs = parameters.blobs ?? toBlobs({ data, to });
-  const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
-  const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
-  const sidecars = [];
-  for (let i = 0; i < blobs.length; i++)
-    sidecars.push({
-      blob: blobs[i],
-      commitment: commitments[i],
-      proof: proofs[i]
-    });
-  return sidecars;
-}
-
-// ../../node_modules/viem/_esm/utils/transaction/assertTransaction.js
-function assertTransactionEIP7702(transaction) {
-  const { authorizationList } = transaction;
-  if (authorizationList) {
-    for (const authorization of authorizationList) {
-      const { chainId } = authorization;
-      const address = authorization.address;
-      if (!isAddress(address))
-        throw new InvalidAddressError({ address });
-      if (chainId < 0)
-        throw new InvalidChainIdError({ chainId });
-    }
-  }
-  assertTransactionEIP1559(transaction);
-}
-function assertTransactionEIP4844(transaction) {
-  const { blobVersionedHashes } = transaction;
-  if (blobVersionedHashes) {
-    if (blobVersionedHashes.length === 0)
-      throw new EmptyBlobError();
-    for (const hash of blobVersionedHashes) {
-      const size_ = size(hash);
-      const version = hexToNumber(slice(hash, 0, 1));
-      if (size_ !== 32)
-        throw new InvalidVersionedHashSizeError({ hash, size: size_ });
-      if (version !== versionedHashVersionKzg)
-        throw new InvalidVersionedHashVersionError({
-          hash,
-          version
-        });
-    }
-  }
-  assertTransactionEIP1559(transaction);
-}
-function assertTransactionEIP1559(transaction) {
-  const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
-  if (chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (maxFeePerGas && maxFeePerGas > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas });
-  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
-    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
-}
-function assertTransactionEIP2930(transaction) {
-  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
-  if (chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
-  if (gasPrice && gasPrice > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
-}
-function assertTransactionLegacy(transaction) {
-  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (typeof chainId !== "undefined" && chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
-  if (gasPrice && gasPrice > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
-}
-
-// ../../node_modules/viem/_esm/utils/transaction/getTransactionType.js
-function getTransactionType(transaction) {
-  if (transaction.type)
-    return transaction.type;
-  if (typeof transaction.authorizationList !== "undefined")
-    return "eip7702";
-  if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
-    return "eip4844";
-  if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
-    return "eip1559";
-  }
-  if (typeof transaction.gasPrice !== "undefined") {
-    if (typeof transaction.accessList !== "undefined")
-      return "eip2930";
-    return "legacy";
-  }
-  throw new InvalidSerializableTransactionError({ transaction });
-}
-
-// ../../node_modules/viem/_esm/utils/transaction/serializeAccessList.js
-function serializeAccessList(accessList) {
-  if (!accessList || accessList.length === 0)
-    return [];
-  const serializedAccessList = [];
-  for (let i = 0; i < accessList.length; i++) {
-    const { address, storageKeys } = accessList[i];
-    for (let j = 0; j < storageKeys.length; j++) {
-      if (storageKeys[j].length - 2 !== 64) {
-        throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
-      }
-    }
-    if (!isAddress(address, { strict: false })) {
-      throw new InvalidAddressError({ address });
-    }
-    serializedAccessList.push([address, storageKeys]);
-  }
-  return serializedAccessList;
-}
-
-// ../../node_modules/viem/_esm/utils/transaction/serializeTransaction.js
-function serializeTransaction(transaction, signature) {
-  const type = getTransactionType(transaction);
-  if (type === "eip1559")
-    return serializeTransactionEIP1559(transaction, signature);
-  if (type === "eip2930")
-    return serializeTransactionEIP2930(transaction, signature);
-  if (type === "eip4844")
-    return serializeTransactionEIP4844(transaction, signature);
-  if (type === "eip7702")
-    return serializeTransactionEIP7702(transaction, signature);
-  return serializeTransactionLegacy(transaction, signature);
-}
-function serializeTransactionEIP7702(transaction, signature) {
-  const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP7702(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
-  return concatHex([
-    "0x04",
-    toRlp([
-      numberToHex(chainId),
-      nonce ? numberToHex(nonce) : "0x",
-      maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-      maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-      gas ? numberToHex(gas) : "0x",
-      to ?? "0x",
-      value ? numberToHex(value) : "0x",
-      data ?? "0x",
-      serializedAccessList,
-      serializedAuthorizationList,
-      ...toYParitySignatureArray(transaction, signature)
-    ])
-  ]);
-}
-function serializeTransactionEIP4844(transaction, signature) {
-  const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP4844(transaction);
-  let blobVersionedHashes = transaction.blobVersionedHashes;
-  let sidecars = transaction.sidecars;
-  if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
-    const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
-    const kzg = transaction.kzg;
-    const commitments2 = blobsToCommitments({
-      blobs: blobs2,
-      kzg
-    });
-    if (typeof blobVersionedHashes === "undefined")
-      blobVersionedHashes = commitmentsToVersionedHashes({
-        commitments: commitments2
-      });
-    if (typeof sidecars === "undefined") {
-      const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
-      sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
-    }
-  }
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    maxFeePerBlobGas ? numberToHex(maxFeePerBlobGas) : "0x",
-    blobVersionedHashes ?? [],
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  const blobs = [];
-  const commitments = [];
-  const proofs = [];
-  if (sidecars)
-    for (let i = 0; i < sidecars.length; i++) {
-      const { blob, commitment, proof } = sidecars[i];
-      blobs.push(blob);
-      commitments.push(commitment);
-      proofs.push(proof);
-    }
-  return concatHex([
-    "0x03",
-    sidecars ? (
-      // If sidecars are enabled, envelope turns into a "wrapper":
-      toRlp([serializedTransaction, blobs, commitments, proofs])
-    ) : (
-      // If sidecars are disabled, standard envelope is used:
-      toRlp(serializedTransaction)
-    )
-  ]);
-}
-function serializeTransactionEIP1559(transaction, signature) {
-  const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP1559(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  return concatHex([
-    "0x02",
-    toRlp(serializedTransaction)
-  ]);
-}
-function serializeTransactionEIP2930(transaction, signature) {
-  const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
-  assertTransactionEIP2930(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    gasPrice ? numberToHex(gasPrice) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  return concatHex([
-    "0x01",
-    toRlp(serializedTransaction)
-  ]);
-}
-function serializeTransactionLegacy(transaction, signature) {
-  const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
-  assertTransactionLegacy(transaction);
-  let serializedTransaction = [
-    nonce ? numberToHex(nonce) : "0x",
-    gasPrice ? numberToHex(gasPrice) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x"
-  ];
-  if (signature) {
-    const v = (() => {
-      if (signature.v >= 35n) {
-        const inferredChainId = (signature.v - 35n) / 2n;
-        if (inferredChainId > 0)
-          return signature.v;
-        return 27n + (signature.v === 35n ? 0n : 1n);
-      }
-      if (chainId > 0)
-        return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
-      const v2 = 27n + (signature.v === 27n ? 0n : 1n);
-      if (signature.v !== v2)
-        throw new InvalidLegacyVError({ v: signature.v });
-      return v2;
-    })();
-    const r = trim(signature.r);
-    const s = trim(signature.s);
-    serializedTransaction = [
-      ...serializedTransaction,
-      numberToHex(v),
-      r === "0x00" ? "0x" : r,
-      s === "0x00" ? "0x" : s
-    ];
-  } else if (chainId > 0) {
-    serializedTransaction = [
-      ...serializedTransaction,
-      numberToHex(chainId),
-      "0x",
-      "0x"
-    ];
-  }
-  return toRlp(serializedTransaction);
-}
-function toYParitySignatureArray(transaction, signature_) {
-  const signature = signature_ ?? transaction;
-  const { v, yParity } = signature;
-  if (typeof signature.r === "undefined")
-    return [];
-  if (typeof signature.s === "undefined")
-    return [];
-  if (typeof v === "undefined" && typeof yParity === "undefined")
-    return [];
-  const r = trim(signature.r);
-  const s = trim(signature.s);
-  const yParity_ = (() => {
-    if (typeof yParity === "number")
-      return yParity ? numberToHex(1) : "0x";
-    if (v === 0n)
-      return "0x";
-    if (v === 1n)
-      return numberToHex(1);
-    return v === 27n ? "0x" : numberToHex(1);
-  })();
-  return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
-}
-
-// ../../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/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";
-        }
-        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";
-      }
-      return transaction;
-    }
-  }),
-  transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
-    format(args) {
-      return {
-        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
-      };
-    }
-  })
-};
-
-// ../../node_modules/viem/_esm/op-stack/serializers.js
-function serializeTransaction2(transaction, signature) {
-  if (isDeposit(transaction))
-    return serializeTransactionDeposit(transaction);
-  return serializeTransaction(transaction, signature);
-}
-var serializers = {
-  transaction: serializeTransaction2
-};
-function serializeTransactionDeposit(transaction) {
-  assertTransactionDeposit(transaction);
-  const { sourceHash, data, from, gas, isSystemTx, mint, to, value } = transaction;
-  const serializedTransaction = [
-    sourceHash,
-    from,
-    to ?? "0x",
-    mint ? toHex(mint) : "0x",
-    value ? toHex(value) : "0x",
-    gas ? toHex(gas) : "0x",
-    isSystemTx ? "0x1" : "0x",
-    data ?? "0x"
-  ];
-  return concatHex([
-    "0x7e",
-    toRlp(serializedTransaction)
-  ]);
-}
-function isDeposit(transaction) {
-  if (transaction.type === "deposit")
-    return true;
-  if (typeof transaction.sourceHash !== "undefined")
-    return true;
-  return false;
-}
-function assertTransactionDeposit(transaction) {
-  const { from, to } = transaction;
-  if (from && !isAddress(from))
-    throw new InvalidAddressError({ address: from });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-}
-
-// ../../node_modules/viem/_esm/op-stack/chainConfig.js
-var chainConfig = {
-  blockTime: 2e3,
-  contracts,
-  formatters,
-  serializers
-};
-
-// ../../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/viem/_esm/chains/definitions/baseSepolia.js
-var sourceId2 = 11155111;
-var baseSepolia = /* @__PURE__ */ defineChain({
-  ...chainConfig,
-  id: 84532,
-  network: "base-sepolia",
-  name: "Base Sepolia",
-  nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ["https://sepolia.base.org"]
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: "Basescan",
-      url: "https://sepolia.basescan.org",
-      apiUrl: "https://api-sepolia.basescan.org/api"
-    }
-  },
-  contracts: {
-    ...chainConfig.contracts,
-    disputeGameFactory: {
-      [sourceId2]: {
-        address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
-      }
-    },
-    l2OutputOracle: {
-      [sourceId2]: {
-        address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
-      }
-    },
-    portal: {
-      [sourceId2]: {
-        address: "0x49f53e41452c74589e85ca1677426ba426459e85",
-        blockCreated: 4446677
-      }
-    },
-    l1StandardBridge: {
-      [sourceId2]: {
-        address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
-        blockCreated: 4446677
-      }
-    },
-    multicall3: {
-      address: "0xca11bde05977b3631167028862be2a173976ca11",
-      blockCreated: 1059647
-    }
-  },
-  testnet: true,
-  sourceId: sourceId2
-});
-var baseSepoliaPreconf = /* @__PURE__ */ defineChain({
-  ...baseSepolia,
-  experimental_preconfirmationTime: 200,
-  rpcUrls: {
-    default: {
-      http: ["https://sepolia-preconf.base.org"]
-    }
-  }
-});
-
-// ../../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/viem/_esm/errors/account.js
-var AccountNotFoundError = class extends BaseError {
-  constructor({ docsPath } = {}) {
-    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,
-      docsSlug: "account",
-      name: "AccountNotFoundError"
-    });
-  }
-};
-var AccountTypeNotSupportedError = class extends BaseError {
-  constructor({ docsPath, metaMessages, type }) {
-    super(`Account type "${type}" is not supported.`, {
-      docsPath,
-      metaMessages,
-      name: "AccountTypeNotSupportedError"
-    });
-  }
-};
-
-// src/mcp/x402.ts
+import { base, baseSepolia } from "viem/chains";
 import { processPriceToAtomicAmount } from "x402/shared";
 import { exact } from "x402/schemes";
 import { useFacilitator } from "x402/verify";
-
-// ../../node_modules/viem/_esm/utils/getAction.js
-function getAction(client, actionFn, name) {
-  const action_implicit = client[actionFn.name];
-  if (typeof action_implicit === "function")
-    return action_implicit;
-  const action_explicit = client[name];
-  if (typeof action_explicit === "function")
-    return action_explicit;
-  return (params) => actionFn(client, params);
-}
-
-// ../../node_modules/viem/_esm/utils/errors/getContractError.js
-var EXECUTION_REVERTED_ERROR_CODE = 3;
-function getContractError(err, { abi, address, args, docsPath, 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 = (() => {
-    if (err instanceof AbiDecodingZeroDataError)
-      return new ContractFunctionZeroDataError({ functionName });
-    if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || details || message || shortMessage)) {
-      return new ContractFunctionRevertedError({
-        abi,
-        data: typeof data === "object" ? data.data : data,
-        functionName,
-        message: error instanceof RpcRequestError ? details : shortMessage ?? message
-      });
-    }
-    return err;
-  })();
-  return new ContractFunctionExecutionError(cause, {
-    abi,
-    args,
-    contractAddress: address,
-    docsPath,
-    functionName,
-    sender
-  });
-}
-
-// ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
-function publicKeyToAddress(publicKey) {
-  const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
-  return checksumAddress(`0x${address}`);
-}
-
-// ../../node_modules/viem/_esm/utils/signature/recoverPublicKey.js
-async function recoverPublicKey({ hash, signature }) {
-  const hashHex = isHex(hash) ? hash : toHex(hash);
-  const { secp256k1 } = await import("../secp256k1-M22GZP2U.js");
-  const signature_ = (() => {
-    if (typeof signature === "object" && "r" in signature && "s" in signature) {
-      const { r, s, v, yParity } = signature;
-      const yParityOrV2 = Number(yParity ?? v);
-      const recoveryBit2 = toRecoveryBit(yParityOrV2);
-      return new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
-    }
-    const signatureHex = isHex(signature) ? signature : toHex(signature);
-    if (size(signatureHex) !== 65)
-      throw new Error("invalid signature length");
-    const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
-    const recoveryBit = toRecoveryBit(yParityOrV);
-    return secp256k1.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
-  })();
-  const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
-  return `0x${publicKey}`;
-}
-function toRecoveryBit(yParityOrV) {
-  if (yParityOrV === 0 || yParityOrV === 1)
-    return yParityOrV;
-  if (yParityOrV === 27)
-    return 0;
-  if (yParityOrV === 28)
-    return 1;
-  throw new Error("Invalid yParityOrV value");
-}
-
-// ../../node_modules/viem/_esm/utils/signature/recoverAddress.js
-async function recoverAddress({ hash, signature }) {
-  return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
-}
-
-// ../../node_modules/viem/_esm/utils/authorization/hashAuthorization.js
-function hashAuthorization(parameters) {
-  const { chainId, nonce, to } = parameters;
-  const address = parameters.contractAddress ?? parameters.address;
-  const hash = keccak256(concatHex([
-    "0x05",
-    toRlp([
-      chainId ? numberToHex(chainId) : "0x",
-      address,
-      nonce ? numberToHex(nonce) : "0x"
-    ])
-  ]));
-  if (to === "bytes")
-    return hexToBytes(hash);
-  return hash;
-}
-
-// ../../node_modules/viem/_esm/utils/authorization/recoverAuthorizationAddress.js
-async function recoverAuthorizationAddress(parameters) {
-  const { authorization, signature } = parameters;
-  return recoverAddress({
-    hash: hashAuthorization(authorization),
-    signature: signature ?? authorization
-  });
-}
-
-// ../../node_modules/viem/_esm/errors/estimateGas.js
-var EstimateGasExecutionError = class extends BaseError {
-  constructor(cause, { account, docsPath, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
-    const prettyArgs = prettyPrint({
-      from: account?.address,
-      to,
-      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
-      data,
-      gas,
-      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
-      nonce
-    });
-    super(cause.shortMessage, {
-      cause,
-      docsPath,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Estimate Gas Arguments:",
-        prettyArgs
-      ].filter(Boolean),
-      name: "EstimateGasExecutionError"
-    });
-    Object.defineProperty(this, "cause", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.cause = cause;
-  }
-};
-
-// ../../node_modules/viem/_esm/utils/errors/getEstimateGasError.js
-function getEstimateGasError(err, { docsPath, ...args }) {
-  const cause = (() => {
-    const cause2 = getNodeError(err, args);
-    if (cause2 instanceof UnknownNodeError)
-      return err;
-    return cause2;
-  })();
-  return new EstimateGasExecutionError(cause, {
-    docsPath,
-    ...args
-  });
-}
-
-// ../../node_modules/viem/_esm/errors/fee.js
-var BaseFeeScalarError = class extends BaseError {
-  constructor() {
-    super("`baseFeeMultiplier` must be greater than 1.", {
-      name: "BaseFeeScalarError"
-    });
-  }
-};
-var Eip1559FeesNotSupportedError = class extends BaseError {
-  constructor() {
-    super("Chain does not support EIP-1559 fees.", {
-      name: "Eip1559FeesNotSupportedError"
-    });
-  }
-};
-var MaxFeePerGasTooLowError = class extends BaseError {
-  constructor({ maxPriorityFeePerGas }) {
-    super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
-  }
-};
-
-// ../../node_modules/viem/_esm/errors/block.js
-var BlockNotFoundError = class extends BaseError {
-  constructor({ blockHash, blockNumber }) {
-    let identifier = "Block";
-    if (blockHash)
-      identifier = `Block at hash "${blockHash}"`;
-    if (blockNumber)
-      identifier = `Block at number "${blockNumber}"`;
-    super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
-  }
-};
-
-// ../../node_modules/viem/_esm/actions/public/getBlock.js
-async function getBlock(client, { blockHash, blockNumber, blockTag = client.experimental_blockTag ?? "latest", includeTransactions: includeTransactions_ } = {}) {
-  const includeTransactions = includeTransactions_ ?? false;
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  let block = null;
-  if (blockHash) {
-    block = await client.request({
-      method: "eth_getBlockByHash",
-      params: [blockHash, includeTransactions]
-    }, { dedupe: true });
-  } else {
-    block = await client.request({
-      method: "eth_getBlockByNumber",
-      params: [blockNumberHex || blockTag, includeTransactions]
-    }, { dedupe: Boolean(blockNumberHex) });
-  }
-  if (!block)
-    throw new BlockNotFoundError({ blockHash, blockNumber });
-  const format = client.chain?.formatters?.block?.format || formatBlock;
-  return format(block);
-}
-
-// ../../node_modules/viem/_esm/actions/public/getGasPrice.js
-async function getGasPrice(client) {
-  const gasPrice = await client.request({
-    method: "eth_gasPrice"
-  });
-  return BigInt(gasPrice);
-}
-
-// ../../node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
-async function internal_estimateMaxPriorityFeePerGas(client, args) {
-  const { block: block_, chain = client.chain, request } = args || {};
-  try {
-    const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
-    if (typeof maxPriorityFeePerGas === "function") {
-      const block = block_ || await getAction(client, getBlock, "getBlock")({});
-      const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
-        block,
-        client,
-        request
-      });
-      if (maxPriorityFeePerGas_ === null)
-        throw new Error();
-      return maxPriorityFeePerGas_;
-    }
-    if (typeof maxPriorityFeePerGas !== "undefined")
-      return maxPriorityFeePerGas;
-    const maxPriorityFeePerGasHex = await client.request({
-      method: "eth_maxPriorityFeePerGas"
-    });
-    return hexToBigInt(maxPriorityFeePerGasHex);
-  } catch {
-    const [block, gasPrice] = await Promise.all([
-      block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}),
-      getAction(client, getGasPrice, "getGasPrice")({})
-    ]);
-    if (typeof block.baseFeePerGas !== "bigint")
-      throw new Eip1559FeesNotSupportedError();
-    const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
-    if (maxPriorityFeePerGas < 0n)
-      return 0n;
-    return maxPriorityFeePerGas;
-  }
-}
-
-// ../../node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
-async function internal_estimateFeesPerGas(client, args) {
-  const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
-  const baseFeeMultiplier = await (async () => {
-    if (typeof chain?.fees?.baseFeeMultiplier === "function")
-      return chain.fees.baseFeeMultiplier({
-        block: block_,
-        client,
-        request
-      });
-    return chain?.fees?.baseFeeMultiplier ?? 1.2;
-  })();
-  if (baseFeeMultiplier < 1)
-    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 block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
-  if (typeof chain?.fees?.estimateFeesPerGas === "function") {
-    const fees = await chain.fees.estimateFeesPerGas({
-      block: block_,
-      client,
-      multiply,
-      request,
-      type
-    });
-    if (fees !== null)
-      return fees;
-  }
-  if (type === "eip1559") {
-    if (typeof block.baseFeePerGas !== "bigint")
-      throw new Eip1559FeesNotSupportedError();
-    const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
-      block,
-      chain,
-      request
-    });
-    const baseFeePerGas = multiply(block.baseFeePerGas);
-    const maxFeePerGas = request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas;
-    return {
-      maxFeePerGas,
-      maxPriorityFeePerGas
-    };
-  }
-  const gasPrice = request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({}));
-  return {
-    gasPrice
-  };
-}
-
-// ../../node_modules/viem/_esm/actions/public/getTransactionCount.js
-async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
-  const count = await client.request({
-    method: "eth_getTransactionCount",
-    params: [
-      address,
-      typeof blockNumber === "bigint" ? numberToHex(blockNumber) : blockTag
-    ]
-  }, {
-    dedupe: Boolean(blockNumber)
-  });
-  return hexToNumber(count);
-}
-
-// ../../node_modules/viem/_esm/actions/public/getChainId.js
-async function getChainId(client) {
-  const chainIdHex = await client.request({
-    method: "eth_chainId"
-  }, { dedupe: true });
-  return hexToNumber(chainIdHex);
-}
-
-// ../../node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
-var defaultParameters = [
-  "blobVersionedHashes",
-  "chainId",
-  "fees",
-  "gas",
-  "nonce",
-  "type"
-];
-var eip1559NetworkCache = /* @__PURE__ */ new Map();
-async function prepareTransactionRequest(client, args) {
-  const { account: account_ = client.account, blobs, chain, gas, kzg, nonce, nonceManager, parameters = defaultParameters, type } = args;
-  const account = account_ ? parseAccount(account_) : account_;
-  const request = { ...args, ...account ? { from: account?.address } : {} };
-  let block;
-  async function getBlock2() {
-    if (block)
-      return block;
-    block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
-    return block;
-  }
-  let chainId;
-  async function getChainId2() {
-    if (chainId)
-      return chainId;
-    if (chain)
-      return chain.id;
-    if (typeof args.chainId !== "undefined")
-      return args.chainId;
-    const chainId_ = await getAction(client, getChainId, "getChainId")({});
-    chainId = chainId_;
-    return chainId;
-  }
-  if (parameters.includes("nonce") && typeof nonce === "undefined" && account) {
-    if (nonceManager) {
-      const chainId2 = await getChainId2();
-      request.nonce = await nonceManager.consume({
-        address: account.address,
-        chainId: chainId2,
-        client
-      });
-    } else {
-      request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
-        address: account.address,
-        blockTag: "pending"
-      });
-    }
-  }
-  if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
-    const commitments = blobsToCommitments({ blobs, kzg });
-    if (parameters.includes("blobVersionedHashes")) {
-      const versionedHashes = commitmentsToVersionedHashes({
-        commitments,
-        to: "hex"
-      });
-      request.blobVersionedHashes = versionedHashes;
-    }
-    if (parameters.includes("sidecars")) {
-      const proofs = blobsToProofs({ blobs, commitments, kzg });
-      const sidecars = toBlobSidecars({
-        blobs,
-        commitments,
-        proofs,
-        to: "hex"
-      });
-      request.sidecars = sidecars;
-    }
-  }
-  if (parameters.includes("chainId"))
-    request.chainId = await getChainId2();
-  if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") {
-    try {
-      request.type = getTransactionType(request);
-    } catch {
-      let isEip1559Network = eip1559NetworkCache.get(client.uid);
-      if (typeof isEip1559Network === "undefined") {
-        const block2 = await getBlock2();
-        isEip1559Network = typeof block2?.baseFeePerGas === "bigint";
-        eip1559NetworkCache.set(client.uid, isEip1559Network);
-      }
-      request.type = isEip1559Network ? "eip1559" : "legacy";
-    }
-  }
-  if (parameters.includes("fees")) {
-    if (request.type !== "legacy" && request.type !== "eip2930") {
-      if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
-        const block2 = await getBlock2();
-        const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
-          block: block2,
-          chain,
-          request
-        });
-        if (typeof args.maxPriorityFeePerGas === "undefined" && args.maxFeePerGas && args.maxFeePerGas < maxPriorityFeePerGas)
-          throw new MaxFeePerGasTooLowError({
-            maxPriorityFeePerGas
-          });
-        request.maxPriorityFeePerGas = maxPriorityFeePerGas;
-        request.maxFeePerGas = maxFeePerGas;
-      }
-    } else {
-      if (typeof args.maxFeePerGas !== "undefined" || typeof args.maxPriorityFeePerGas !== "undefined")
-        throw new Eip1559FeesNotSupportedError();
-      if (typeof args.gasPrice === "undefined") {
-        const block2 = await getBlock2();
-        const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
-          block: block2,
-          chain,
-          request,
-          type: "legacy"
-        });
-        request.gasPrice = gasPrice_;
-      }
-    }
-  }
-  if (parameters.includes("gas") && typeof gas === "undefined")
-    request.gas = await getAction(client, estimateGas, "estimateGas")({
-      ...request,
-      account: account ? { address: account.address, type: "json-rpc" } : account
-    });
-  assertRequest(request);
-  delete request.parameters;
-  return request;
-}
-
-// ../../node_modules/viem/_esm/actions/public/getBalance.js
-async function getBalance(client, { address, blockNumber, blockTag = client.experimental_blockTag ?? "latest" }) {
-  const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
-  const balance = await client.request({
-    method: "eth_getBalance",
-    params: [address, blockNumberHex || blockTag]
-  });
-  return BigInt(balance);
-}
-
-// ../../node_modules/viem/_esm/actions/public/estimateGas.js
-async function estimateGas(client, args) {
-  const { account: account_ = client.account } = args;
-  const account = account_ ? parseAccount(account_) : void 0;
-  try {
-    let estimateGas_rpc2 = function(parameters) {
-      const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
-      return client.request({
-        method: "eth_estimateGas",
-        params: rpcStateOverride2 ? [
-          request2,
-          block2 ?? client.experimental_blockTag ?? "latest",
-          rpcStateOverride2
-        ] : block2 ? [request2, block2] : [request2]
-      });
-    };
-    var estimateGas_rpc = estimateGas_rpc2;
-    const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = await prepareTransactionRequest(client, {
-      ...args,
-      parameters: (
-        // Some RPC Providers do not compute versioned hashes from blobs. We will need
-        // to compute them.
-        account?.type === "local" ? void 0 : ["blobVersionedHashes"]
-      )
-    });
-    const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
-    const block = blockNumberHex || blockTag;
-    const rpcStateOverride = serializeStateOverride(stateOverride);
-    const to = await (async () => {
-      if (rest.to)
-        return rest.to;
-      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;
-    })();
-    assertRequest(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 }),
-      from: account?.address,
-      accessList,
-      authorizationList,
-      blobs,
-      blobVersionedHashes,
-      data,
-      gas,
-      gasPrice,
-      maxFeePerBlobGas,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to,
-      value
-    });
-    let estimate = BigInt(await estimateGas_rpc2({ block, request, rpcStateOverride }));
-    if (authorizationList) {
-      const value2 = await getBalance(client, { address: request.from });
-      const estimates = await Promise.all(authorizationList.map(async (authorization) => {
-        const { address } = authorization;
-        const estimate2 = await estimateGas_rpc2({
-          block,
-          request: {
-            authorizationList: void 0,
-            data,
-            from: account?.address,
-            to: address,
-            value: numberToHex(value2)
-          },
-          rpcStateOverride
-        }).catch(() => 100000n);
-        return 2n * BigInt(estimate2);
-      }));
-      estimate += estimates.reduce((acc, curr) => acc + curr, 0n);
-    }
-    return estimate;
-  } catch (err) {
-    throw getEstimateGasError(err, {
-      ...args,
-      account,
-      chain: client.chain
-    });
-  }
-}
-
-// ../../node_modules/viem/_esm/utils/observe.js
-var listenersCache = /* @__PURE__ */ new Map();
-var cleanupCache = /* @__PURE__ */ new Map();
-var callbackCount = 0;
-function observe(observerId, callbacks, fn) {
-  const callbackId = ++callbackCount;
-  const getListeners = () => listenersCache.get(observerId) || [];
-  const unsubscribe = () => {
-    const listeners2 = getListeners();
-    listenersCache.set(observerId, listeners2.filter((cb) => cb.id !== callbackId));
-  };
-  const unwatch = () => {
-    const listeners2 = getListeners();
-    if (!listeners2.some((cb) => cb.id === callbackId))
-      return;
-    const cleanup2 = cleanupCache.get(observerId);
-    if (listeners2.length === 1 && cleanup2) {
-      const p = cleanup2();
-      if (p instanceof Promise)
-        p.catch(() => {
-        });
-    }
-    unsubscribe();
-  };
-  const listeners = getListeners();
-  listenersCache.set(observerId, [
-    ...listeners,
-    { id: callbackId, fns: callbacks }
-  ]);
-  if (listeners && listeners.length > 0)
-    return unwatch;
-  const emit = {};
-  for (const key in callbacks) {
-    emit[key] = ((...args) => {
-      const listeners2 = getListeners();
-      if (listeners2.length === 0)
-        return;
-      for (const listener of listeners2)
-        listener.fns[key]?.(...args);
-    });
-  }
-  const cleanup = fn(emit);
-  if (typeof cleanup === "function")
-    cleanupCache.set(observerId, cleanup);
-  return unwatch;
-}
-
-// ../../node_modules/viem/_esm/utils/wait.js
-async function wait(time) {
-  return new Promise((res) => setTimeout(res, time));
-}
-
-// ../../node_modules/viem/_esm/utils/poll.js
-function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
-  let active = true;
-  const unwatch = () => active = false;
-  const watch = async () => {
-    let data;
-    if (emitOnBegin)
-      data = await fn({ unpoll: unwatch });
-    const initialWait = await initialWaitTime?.(data) ?? interval;
-    await wait(initialWait);
-    const poll2 = async () => {
-      if (!active)
-        return;
-      await fn({ unpoll: unwatch });
-      await wait(interval);
-      poll2();
-    };
-    poll2();
-  };
-  watch();
-  return unwatch;
-}
-
-// ../../node_modules/viem/_esm/utils/errors/getTransactionError.js
-function getTransactionError(err, { docsPath, ...args }) {
-  const cause = (() => {
-    const cause2 = getNodeError(err, args);
-    if (cause2 instanceof UnknownNodeError)
-      return err;
-    return cause2;
-  })();
-  return new TransactionExecutionError(cause, {
-    docsPath,
-    ...args
-  });
-}
-
-// ../../node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
-async function sendRawTransaction(client, { serializedTransaction }) {
-  return client.request({
-    method: "eth_sendRawTransaction",
-    params: [serializedTransaction]
-  }, { retryCount: 0 });
-}
-
-// ../../node_modules/viem/_esm/actions/wallet/sendTransaction.js
-var supportsWalletNamespace = new LruMap(128);
-async function sendTransaction(client, parameters) {
-  const { account: account_ = client.account, chain = client.chain, accessList, authorizationList, blobs, data, 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;
-  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")({});
-        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,
-        authorizationList,
-        blobs,
-        chainId,
-        data,
-        from: account?.address,
-        gas,
-        gasPrice,
-        maxFeePerBlobGas,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        nonce,
-        to,
-        type,
-        value
-      });
-      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((hash) => {
-            supportsWalletNamespace.set(client.uid, true);
-            return hash;
-          }).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") {
-      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
-        account,
-        accessList,
-        authorizationList,
-        blobs,
-        chain,
-        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;
-    throw getTransactionError(err, {
-      ...parameters,
-      account,
-      chain: parameters.chain || void 0
-    });
-  }
-}
-
-// ../../node_modules/viem/_esm/actions/wallet/writeContract.js
-async function writeContract(client, parameters) {
-  const { abi, account: account_ = client.account, address, args, dataSuffix, functionName, ...request } = parameters;
-  if (typeof account_ === "undefined")
-    throw new AccountNotFoundError({
-      docsPath: "/docs/contract/writeContract"
-    });
-  const account = account_ ? parseAccount(account_) : null;
-  const data = encodeFunctionData({
-    abi,
-    args,
-    functionName
-  });
-  try {
-    return await getAction(client, sendTransaction, "sendTransaction")({
-      data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
-      to: address,
-      account,
-      ...request
-    });
-  } catch (error) {
-    throw getContractError(error, {
-      abi,
-      address,
-      args,
-      docsPath: "/docs/contract/writeContract",
-      functionName,
-      sender: account?.address
-    });
-  }
-}
-
-// ../../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/viem/_esm/utils/promise/withRetry.js
-function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true } = {}) {
-  return new Promise((resolve, reject) => {
-    const attemptRetry = async ({ count = 0 } = {}) => {
-      const retry = async ({ error }) => {
-        const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
-        if (delay)
-          await wait(delay);
-        attemptRetry({ count: count + 1 });
-      };
-      try {
-        const data = await fn();
-        resolve(data);
-      } catch (err) {
-        if (count < retryCount && await shouldRetry2({ count, error: err }))
-          return retry({ error: err });
-        reject(err);
-      }
-    };
-    attemptRetry();
-  });
-}
-
-// ../../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, capabilities, chain = client.chain, experimental_fallback, experimental_fallbackDelay = 32, forceAtomic = false, id, version = "2.0.0" } = parameters;
-  const account = account_ ? parseAccount(account_) : null;
-  const calls = parameters.calls.map((call_) => {
-    const call = call_;
-    const data = call.abi ? encodeFunctionData({
-      abi: call.abi,
-      functionName: call.functionName,
-      args: call.args
-    }) : call.data;
-    return {
-      data: call.dataSuffix && data ? concat([data, call.dataSuffix]) : data,
-      to: call.to,
-      value: call.value ? numberToHex(call.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") || error.details.toLowerCase().includes("feature toggled misconfigured"))) {
-      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 promises = [];
-      for (const call of calls) {
-        const promise = sendTransaction(client, {
-          account,
-          chain,
-          data: call.data,
-          to: call.to,
-          value: call.value ? hexToBigInt(call.value) : void 0
-        });
-        promises.push(promise);
-        if (experimental_fallbackDelay > 0)
-          await new Promise((resolve) => setTimeout(resolve, experimental_fallbackDelay));
-      }
-      const results = await Promise.allSettled(promises);
-      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/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((hash) => fallbackTransactionErrorMagicIdentifier.slice(2) !== hash ? client.request({
-        method: "eth_getTransactionReceipt",
-        params: [`0x${hash}`]
-      }, { 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/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/viem/_esm/utils/uid.js
-var size2 = 256;
-var index = size2;
-var buffer;
-function uid(length = 11) {
-  if (!buffer || index + length > size2 * 2) {
-    buffer = "";
-    index = 0;
-    for (let i = 0; i < size2; i++) {
-      buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
-    }
-  }
-  return buffer.substring(index, index++ + length);
-}
-
-// ../../node_modules/viem/_esm/clients/createClient.js
-function createClient(parameters) {
-  const { batch, chain, ccipRead, key = "base", name = "Base Client", type = "base" } = parameters;
-  const experimental_blockTag = parameters.experimental_blockTag ?? (typeof chain?.experimental_preconfirmationTime === "number" ? "pending" : void 0);
-  const blockTime = chain?.blockTime ?? 12e3;
-  const defaultPollingInterval = Math.min(Math.max(Math.floor(blockTime / 2), 500), 4e3);
-  const pollingInterval = parameters.pollingInterval ?? defaultPollingInterval;
-  const cacheTime = parameters.cacheTime ?? pollingInterval;
-  const account = parameters.account ? parseAccount(parameters.account) : void 0;
-  const { config, request, value } = parameters.transport({
-    chain,
-    pollingInterval
-  });
-  const transport = { ...config, ...value };
-  const client = {
-    account,
-    batch,
-    cacheTime,
-    ccipRead,
-    chain,
-    key,
-    name,
-    pollingInterval,
-    request,
-    transport,
-    type,
-    uid: uid(),
-    ...experimental_blockTag ? { experimental_blockTag } : {}
-  };
-  function extend(base2) {
-    return (extendFn) => {
-      const extended = extendFn(base2);
-      for (const key2 in client)
-        delete extended[key2];
-      const combined = { ...base2, ...extended };
-      return Object.assign(combined, { extend: extend(combined) });
-    };
-  }
-  return Object.assign(client, { extend: extend(client) });
-}
-
-// ../../node_modules/viem/_esm/utils/promise/withDedupe.js
-var promiseCache = /* @__PURE__ */ new LruMap(8192);
-function withDedupe(fn, { enabled = true, id }) {
-  if (!enabled || !id)
-    return fn();
-  if (promiseCache.get(id))
-    return promiseCache.get(id);
-  const promise = fn().finally(() => promiseCache.delete(id));
-  promiseCache.set(id, promise);
-  return promise;
-}
-
-// ../../node_modules/viem/_esm/utils/buildRequest.js
-function buildRequest(request, options = {}) {
-  return async (args, overrideOptions = {}) => {
-    const { dedupe = false, methods, retryDelay = 150, retryCount = 3, uid: uid2 } = {
-      ...options,
-      ...overrideOptions
-    };
-    const { method } = args;
-    if (methods?.exclude?.includes(method))
-      throw new MethodNotSupportedRpcError(new Error("method not supported"), {
-        method
-      });
-    if (methods?.include && !methods.include.includes(method))
-      throw new MethodNotSupportedRpcError(new Error("method not supported"), {
-        method
-      });
-    const requestId = dedupe ? stringToHex(`${uid2}.${stringify(args)}`) : void 0;
-    return withDedupe(() => withRetry(async () => {
-      try {
-        return await request(args);
-      } catch (err_) {
-        const err = err_;
-        switch (err.code) {
-          // -32700
-          case ParseRpcError.code:
-            throw new ParseRpcError(err);
-          // -32600
-          case InvalidRequestRpcError.code:
-            throw new InvalidRequestRpcError(err);
-          // -32601
-          case MethodNotFoundRpcError.code:
-            throw new MethodNotFoundRpcError(err, { method: args.method });
-          // -32602
-          case InvalidParamsRpcError.code:
-            throw new InvalidParamsRpcError(err);
-          // -32603
-          case InternalRpcError.code:
-            throw new InternalRpcError(err);
-          // -32000
-          case InvalidInputRpcError.code:
-            throw new InvalidInputRpcError(err);
-          // -32001
-          case ResourceNotFoundRpcError.code:
-            throw new ResourceNotFoundRpcError(err);
-          // -32002
-          case ResourceUnavailableRpcError.code:
-            throw new ResourceUnavailableRpcError(err);
-          // -32003
-          case TransactionRejectedRpcError.code:
-            throw new TransactionRejectedRpcError(err);
-          // -32004
-          case MethodNotSupportedRpcError.code:
-            throw new MethodNotSupportedRpcError(err, {
-              method: args.method
-            });
-          // -32005
-          case LimitExceededRpcError.code:
-            throw new LimitExceededRpcError(err);
-          // -32006
-          case JsonRpcVersionUnsupportedError.code:
-            throw new JsonRpcVersionUnsupportedError(err);
-          // 4001
-          case UserRejectedRequestError.code:
-            throw new UserRejectedRequestError(err);
-          // 4100
-          case UnauthorizedProviderError.code:
-            throw new UnauthorizedProviderError(err);
-          // 4200
-          case UnsupportedProviderMethodError.code:
-            throw new UnsupportedProviderMethodError(err);
-          // 4900
-          case ProviderDisconnectedError.code:
-            throw new ProviderDisconnectedError(err);
-          // 4901
-          case ChainDisconnectedError.code:
-            throw new ChainDisconnectedError(err);
-          // 4902
-          case SwitchChainError.code:
-            throw new SwitchChainError(err);
-          // 5700
-          case UnsupportedNonOptionalCapabilityError.code:
-            throw new UnsupportedNonOptionalCapabilityError(err);
-          // 5710
-          case UnsupportedChainIdError.code:
-            throw new UnsupportedChainIdError(err);
-          // 5720
-          case DuplicateIdError.code:
-            throw new DuplicateIdError(err);
-          // 5730
-          case UnknownBundleIdError.code:
-            throw new UnknownBundleIdError(err);
-          // 5740
-          case BundleTooLargeError.code:
-            throw new BundleTooLargeError(err);
-          // 5750
-          case AtomicReadyWalletRejectedUpgradeError.code:
-            throw new AtomicReadyWalletRejectedUpgradeError(err);
-          // 5760
-          case AtomicityNotSupportedError.code:
-            throw new AtomicityNotSupportedError(err);
-          // CAIP-25: User Rejected Error
-          // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
-          case 5e3:
-            throw new UserRejectedRequestError(err);
-          default:
-            if (err_ instanceof BaseError)
-              throw err_;
-            throw new UnknownRpcError(err);
-        }
-      }
-    }, {
-      delay: ({ count, error }) => {
-        if (error && error instanceof HttpRequestError) {
-          const retryAfter = error?.headers?.get("Retry-After");
-          if (retryAfter?.match(/\d/))
-            return Number.parseInt(retryAfter, 10) * 1e3;
-        }
-        return ~~(1 << count) * retryDelay;
-      },
-      retryCount,
-      shouldRetry: ({ error }) => shouldRetry(error)
-    }), { enabled: dedupe, id: requestId });
-  };
-}
-function shouldRetry(error) {
-  if ("code" in error && typeof error.code === "number") {
-    if (error.code === -1)
-      return true;
-    if (error.code === LimitExceededRpcError.code)
-      return true;
-    if (error.code === InternalRpcError.code)
-      return true;
-    return false;
-  }
-  if (error instanceof HttpRequestError && error.status) {
-    if (error.status === 403)
-      return true;
-    if (error.status === 408)
-      return true;
-    if (error.status === 413)
-      return true;
-    if (error.status === 429)
-      return true;
-    if (error.status === 500)
-      return true;
-    if (error.status === 502)
-      return true;
-    if (error.status === 503)
-      return true;
-    if (error.status === 504)
-      return true;
-    return false;
-  }
-  return true;
-}
-
-// ../../node_modules/viem/_esm/utils/promise/withTimeout.js
-function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
-  return new Promise((resolve, reject) => {
-    ;
-    (async () => {
-      let timeoutId;
-      try {
-        const controller = new AbortController();
-        if (timeout > 0) {
-          timeoutId = setTimeout(() => {
-            if (signal) {
-              controller.abort();
-            } else {
-              reject(errorInstance);
-            }
-          }, timeout);
-        }
-        resolve(await fn({ signal: controller?.signal || null }));
-      } catch (err) {
-        if (err?.name === "AbortError")
-          reject(errorInstance);
-        reject(err);
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    })();
-  });
-}
-
-// ../../node_modules/viem/_esm/utils/rpc/id.js
-function createIdStore() {
-  return {
-    current: 0,
-    take() {
-      return this.current++;
-    },
-    reset() {
-      this.current = 0;
-    }
-  };
-}
-var idCache = /* @__PURE__ */ createIdStore();
-
-// ../../node_modules/viem/_esm/utils/rpc/http.js
-function getHttpRpcClient(url, options = {}) {
-  return {
-    async request(params) {
-      const { body, fetchFn = options.fetchFn ?? fetch, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
-      const fetchOptions = {
-        ...options.fetchOptions ?? {},
-        ...params.fetchOptions ?? {}
-      };
-      const { headers, method, signal: signal_ } = fetchOptions;
-      try {
-        const response = await withTimeout(async ({ signal }) => {
-          const init = {
-            ...fetchOptions,
-            body: Array.isArray(body) ? stringify(body.map((body2) => ({
-              jsonrpc: "2.0",
-              id: body2.id ?? idCache.take(),
-              ...body2
-            }))) : stringify({
-              jsonrpc: "2.0",
-              id: body.id ?? idCache.take(),
-              ...body
-            }),
-            headers: {
-              "Content-Type": "application/json",
-              ...headers
-            },
-            method: method || "POST",
-            signal: signal_ || (timeout > 0 ? signal : null)
-          };
-          const request = new Request(url, init);
-          const args = await onRequest?.(request, init) ?? { ...init, url };
-          const response2 = await fetchFn(args.url ?? url, args);
-          return response2;
-        }, {
-          errorInstance: new TimeoutError({ body, url }),
-          timeout,
-          signal: true
-        });
-        if (onResponse)
-          await onResponse(response);
-        let data;
-        if (response.headers.get("Content-Type")?.startsWith("application/json"))
-          data = await response.json();
-        else {
-          data = await response.text();
-          try {
-            data = JSON.parse(data || "{}");
-          } catch (err) {
-            if (response.ok)
-              throw err;
-            data = { error: data };
-          }
-        }
-        if (!response.ok) {
-          throw new HttpRequestError({
-            body,
-            details: stringify(data.error) || response.statusText,
-            headers: response.headers,
-            status: response.status,
-            url
-          });
-        }
-        return data;
-      } catch (err) {
-        if (err instanceof HttpRequestError)
-          throw err;
-        if (err instanceof TimeoutError)
-          throw err;
-        throw new HttpRequestError({
-          body,
-          cause: err,
-          url
-        });
-      }
-    }
-  };
-}
-
-// ../../node_modules/viem/_esm/errors/typedData.js
-var InvalidDomainError = class extends BaseError {
-  constructor({ domain }) {
-    super(`Invalid domain "${stringify(domain)}".`, {
-      metaMessages: ["Must be a valid EIP-712 domain."]
-    });
-  }
-};
-var InvalidPrimaryTypeError = class extends BaseError {
-  constructor({ primaryType, types }) {
-    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
-      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
-      metaMessages: ["Check that the primary type is a key in `types`."]
-    });
-  }
-};
-var InvalidStructTypeError = class extends BaseError {
-  constructor({ type }) {
-    super(`Struct type "${type}" is invalid.`, {
-      metaMessages: ["Struct type must not be a Solidity type."],
-      name: "InvalidStructTypeError"
-    });
-  }
-};
-
-// ../../node_modules/viem/_esm/utils/typedData.js
-function serializeTypedData(parameters) {
-  const { domain: domain_, message: message_, primaryType, types } = parameters;
-  const normalizeData = (struct, data_) => {
-    const data = { ...data_ };
-    for (const param of struct) {
-      const { name, type } = param;
-      if (type === "address")
-        data[name] = data[name].toLowerCase();
-    }
-    return data;
-  };
-  const domain = (() => {
-    if (!types.EIP712Domain)
-      return {};
-    if (!domain_)
-      return {};
-    return normalizeData(types.EIP712Domain, domain_);
-  })();
-  const message = (() => {
-    if (primaryType === "EIP712Domain")
-      return void 0;
-    return normalizeData(types[primaryType], message_);
-  })();
-  return stringify({ domain, message, primaryType, types });
-}
-function validateTypedData(parameters) {
-  const { domain, message, primaryType, types } = parameters;
-  const validateData = (struct, data) => {
-    for (const param of struct) {
-      const { name, type } = param;
-      const value = data[name];
-      const integerMatch = type.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base2, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base2 === "int",
-          size: Number.parseInt(size_, 10) / 8
-        });
-      }
-      if (type === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError({ address: value });
-      const bytesMatch = type.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== Number.parseInt(size_, 10))
-          throw new BytesSizeMismatchError({
-            expectedSize: Number.parseInt(size_, 10),
-            givenSize: size(value)
-          });
-      }
-      const struct2 = types[type];
-      if (struct2) {
-        validateReference(type);
-        validateData(struct2, value);
-      }
-    }
-  };
-  if (types.EIP712Domain && domain) {
-    if (typeof domain !== "object")
-      throw new InvalidDomainError({ domain });
-    validateData(types.EIP712Domain, domain);
-  }
-  if (primaryType !== "EIP712Domain") {
-    if (types[primaryType])
-      validateData(types[primaryType], message);
-    else
-      throw new InvalidPrimaryTypeError({ primaryType, types });
-  }
-}
-function getTypesForEIP712Domain({ domain }) {
-  return [
-    typeof domain?.name === "string" && { name: "name", type: "string" },
-    domain?.version && { name: "version", type: "string" },
-    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
-      name: "chainId",
-      type: "uint256"
-    },
-    domain?.verifyingContract && {
-      name: "verifyingContract",
-      type: "address"
-    },
-    domain?.salt && { name: "salt", type: "bytes32" }
-  ].filter(Boolean);
-}
-function validateReference(type) {
-  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
-    throw new InvalidStructTypeError({ type });
-}
-
-// ../../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/viem/_esm/actions/wallet/deployContract.js
-function deployContract(walletClient, parameters) {
-  const { abi, args, bytecode, ...request } = parameters;
-  const calldata = encodeDeployData({ abi, args, bytecode });
-  return sendTransaction(walletClient, {
-    ...request,
-    ...request.authorizationList ? { to: null } : {},
-    data: calldata
-  });
-}
-
-// ../../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/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/viem/_esm/actions/wallet/getPermissions.js
-async function getPermissions(client) {
-  const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
-  return permissions;
-}
-
-// ../../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/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/viem/_esm/actions/wallet/requestPermissions.js
-async function requestPermissions(client, permissions) {
-  return client.request({
-    method: "wallet_requestPermissions",
-    params: [permissions]
-  }, { retryCount: 0 });
-}
-
-// ../../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/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/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/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 formatters2 = chain?.formatters || client.chain?.formatters;
-  const format = formatters2?.transactionRequest?.format || formatTransactionRequest;
-  if (account.signTransaction)
-    return account.signTransaction({
-      ...transaction,
-      chainId
-    }, { serializer: client.chain?.serializers?.transaction });
-  return await client.request({
-    method: "eth_signTransaction",
-    params: [
-      {
-        ...format(transaction),
-        chainId: numberToHex(chainId),
-        from: account.address
-      }
-    ]
-  }, { retryCount: 0 });
-}
-
-// ../../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/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/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/viem/_esm/clients/decorators/wallet.js
-function walletActions(client) {
-  return {
-    addChain: (args) => addChain(client, args),
-    deployContract: (args) => deployContract(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),
-    sendRawTransaction: (args) => sendRawTransaction(client, args),
-    sendTransaction: (args) => sendTransaction(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)
-  };
-}
-
-// ../../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/viem/_esm/clients/transports/createTransport.js
-function createTransport({ key, methods, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
-  const uid2 = uid();
-  return {
-    config: {
-      key,
-      methods,
-      name,
-      request,
-      retryCount,
-      retryDelay,
-      timeout,
-      type
-    },
-    request: buildRequest(request, { methods, retryCount, retryDelay, uid: uid2 }),
-    value
-  };
-}
-
-// ../../node_modules/viem/_esm/errors/transport.js
-var UrlRequiredError = class extends BaseError {
-  constructor() {
-    super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
-      docsPath: "/docs/clients/intro",
-      name: "UrlRequiredError"
-    });
-  }
-};
-
-// ../../node_modules/viem/_esm/clients/transports/http.js
-function http(url, config = {}) {
-  const { batch, fetchFn, fetchOptions, key = "http", methods, name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay, raw } = config;
-  return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
-    const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
-    const retryCount = config.retryCount ?? retryCount_;
-    const timeout = timeout_ ?? config.timeout ?? 1e4;
-    const url_ = url || chain?.rpcUrls.default.http[0];
-    if (!url_)
-      throw new UrlRequiredError();
-    const rpcClient = getHttpRpcClient(url_, {
-      fetchFn,
-      fetchOptions,
-      onRequest: onFetchRequest,
-      onResponse: onFetchResponse,
-      timeout
-    });
-    return createTransport({
-      key,
-      methods,
-      name,
-      async request({ method, params }) {
-        const body = { method, params };
-        const { schedule } = createBatchScheduler({
-          id: url_,
-          wait: wait2,
-          shouldSplitBatch(requests) {
-            return requests.length > batchSize;
-          },
-          fn: (body2) => rpcClient.request({
-            body: body2
-          }),
-          sort: (a, b) => a.id - b.id
-        });
-        const fn = async (body2) => batch ? schedule(body2) : [
-          await rpcClient.request({
-            body: body2
-          })
-        ];
-        const [{ error, result }] = await fn(body);
-        if (raw)
-          return { error, result };
-        if (error)
-          throw new RpcRequestError({
-            body,
-            error,
-            url: url_
-          });
-        return result;
-      },
-      retryCount,
-      retryDelay,
-      timeout,
-      type: "http"
-    }, {
-      fetchOptions,
-      url: url_
-    });
-  };
-}
-
-// src/mcp/x402.ts
+import { createWalletClient, http } from "viem";
 import { createPaymentHeader } from "x402/client";
+
+//#region src/mcp/x402.ts
 function withX402(server, cfg) {
-  const { verify, settle } = useFacilitator(cfg.facilitator);
-  const x402Version = cfg.version ?? 1;
-  function paidTool(name, description, priceUSD, paramsSchema, annotations, cb) {
-    return server.tool(
-      name,
-      description,
-      paramsSchema,
-      { ...annotations, paymentHint: true, paymentPriceUSD: priceUSD },
-      (async (args, extra) => {
-        const atomic = processPriceToAtomicAmount(priceUSD, cfg.network);
-        if ("error" in atomic) {
-          const payload = { x402Version, error: "PRICE_COMPUTE_FAILED" };
-          return {
-            isError: true,
-            _meta: { "x402/error": payload },
-            content: [{ type: "text", text: JSON.stringify(payload) }]
-          };
-        }
-        const { maxAmountRequired, asset } = atomic;
-        const requirements = {
-          scheme: "exact",
-          network: cfg.network,
-          maxAmountRequired,
-          payTo: cfg.recipient,
-          asset: asset.address,
-          maxTimeoutSeconds: 300,
-          resource: `x402://${name}`,
-          mimeType: "application/json",
-          description,
-          extra: "eip712" in asset ? asset.eip712 : void 0
-        };
-        const headers = extra?.requestInfo?.headers ?? {};
-        const token = extra?._meta?.["x402/payment"] ?? headers["X-PAYMENT"];
-        const paymentRequired = (reason = "PAYMENT_REQUIRED", extraFields = {}) => {
-          const payload = {
-            x402Version,
-            error: reason,
-            accepts: [requirements],
-            ...extraFields
-          };
-          return {
-            isError: true,
-            _meta: { "x402/error": payload },
-            content: [{ type: "text", text: JSON.stringify(payload) }]
-          };
-        };
-        if (!token || typeof token !== "string") return paymentRequired();
-        let decoded;
-        try {
-          decoded = exact.evm.decodePayment(token);
-          decoded.x402Version = x402Version;
-        } catch {
-          return paymentRequired("INVALID_PAYMENT");
-        }
-        const vr = await verify(decoded, requirements);
-        if (!vr.isValid) {
-          return paymentRequired(vr.invalidReason ?? "INVALID_PAYMENT", {
-            payer: vr.payer
-          });
-        }
-        let result;
-        let failed = false;
-        try {
-          result = await cb(args, extra);
-          if (result && typeof result === "object" && "isError" in result && result.isError) {
-            failed = true;
-          }
-        } catch (e) {
-          failed = true;
-          result = {
-            isError: true,
-            content: [
-              { type: "text", text: `Tool execution failed: ${String(e)}` }
-            ]
-          };
-        }
-        if (!failed) {
-          try {
-            const s = await settle(decoded, requirements);
-            if (s.success) {
-              result._meta ??= {};
-              result._meta["x402/payment-response"] = {
-                success: true,
-                transaction: s.transaction,
-                network: s.network,
-                payer: s.payer
-              };
-            } else {
-              return paymentRequired(s.errorReason ?? "SETTLEMENT_FAILED");
-            }
-          } catch {
-            return paymentRequired("SETTLEMENT_FAILED");
-          }
-        }
-        return result;
-      })
-    );
-  }
-  Object.defineProperty(server, "paidTool", {
-    value: paidTool,
-    writable: false,
-    enumerable: false,
-    configurable: true
-  });
-  return server;
-}
-var toChain = (network) => {
-  switch (network) {
-    case "base":
-      return base;
-    case "base-sepolia":
-      return baseSepolia;
-    default:
-      throw new Error(`Unsupported network: ${network}`);
-  }
+	const { verify, settle } = useFacilitator(cfg.facilitator);
+	const x402Version = cfg.version ?? 1;
+	function paidTool(name, description, priceUSD, paramsSchema, annotations, cb) {
+		return server.tool(name, description, paramsSchema, {
+			...annotations,
+			paymentHint: true,
+			paymentPriceUSD: priceUSD
+		}, (async (args, extra) => {
+			const atomic = processPriceToAtomicAmount(priceUSD, cfg.network);
+			if ("error" in atomic) {
+				const payload = {
+					x402Version,
+					error: "PRICE_COMPUTE_FAILED"
+				};
+				return {
+					isError: true,
+					_meta: { "x402/error": payload },
+					content: [{
+						type: "text",
+						text: JSON.stringify(payload)
+					}]
+				};
+			}
+			const { maxAmountRequired, asset } = atomic;
+			const requirements = {
+				scheme: "exact",
+				network: cfg.network,
+				maxAmountRequired,
+				payTo: cfg.recipient,
+				asset: asset.address,
+				maxTimeoutSeconds: 300,
+				resource: `x402://${name}`,
+				mimeType: "application/json",
+				description,
+				extra: "eip712" in asset ? asset.eip712 : void 0
+			};
+			const headers = extra?.requestInfo?.headers ?? {};
+			const token = extra?._meta?.["x402/payment"] ?? headers["X-PAYMENT"];
+			const paymentRequired = (reason = "PAYMENT_REQUIRED", extraFields = {}) => {
+				const payload = {
+					x402Version,
+					error: reason,
+					accepts: [requirements],
+					...extraFields
+				};
+				return {
+					isError: true,
+					_meta: { "x402/error": payload },
+					content: [{
+						type: "text",
+						text: JSON.stringify(payload)
+					}]
+				};
+			};
+			if (!token || typeof token !== "string") return paymentRequired();
+			let decoded;
+			try {
+				decoded = exact.evm.decodePayment(token);
+				decoded.x402Version = x402Version;
+			} catch {
+				return paymentRequired("INVALID_PAYMENT");
+			}
+			const vr = await verify(decoded, requirements);
+			if (!vr.isValid) return paymentRequired(vr.invalidReason ?? "INVALID_PAYMENT", { payer: vr.payer });
+			let result;
+			let failed = false;
+			try {
+				result = await cb(args, extra);
+				if (result && typeof result === "object" && "isError" in result && result.isError) failed = true;
+			} catch (e) {
+				failed = true;
+				result = {
+					isError: true,
+					content: [{
+						type: "text",
+						text: `Tool execution failed: ${String(e)}`
+					}]
+				};
+			}
+			if (!failed) try {
+				const s = await settle(decoded, requirements);
+				if (s.success) {
+					result._meta ??= {};
+					result._meta["x402/payment-response"] = {
+						success: true,
+						transaction: s.transaction,
+						network: s.network,
+						payer: s.payer
+					};
+				} else return paymentRequired(s.errorReason ?? "SETTLEMENT_FAILED");
+			} catch {
+				return paymentRequired("SETTLEMENT_FAILED");
+			}
+			return result;
+		}));
+	}
+	Object.defineProperty(server, "paidTool", {
+		value: paidTool,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+	return server;
+}
+const toChain = (network) => {
+	switch (network) {
+		case "base": return base;
+		case "base-sepolia": return baseSepolia;
+		default: throw new Error(`Unsupported network: ${network}`);
+	}
 };
 function withX402Client(client, x402Config) {
-  const { network, account, version } = x402Config;
-  const wallet = createWalletClient({
-    account,
-    transport: http(),
-    chain: toChain(network)
-  });
-  const maxPaymentValue = x402Config.maxPaymentValue ?? BigInt(0.1 * 10 ** 6);
-  const _listTools = client.listTools.bind(client);
-  const listTools = async (params, options) => {
-    const toolsRes = await _listTools(params, options);
-    toolsRes.tools = toolsRes.tools.map((tool) => {
-      let description = tool.description;
-      if (tool.annotations?.paymentHint) {
-        const cost = tool.annotations?.paymentPriceUSD ? `$${tool.annotations?.paymentPriceUSD}` : "an unknown amount";
-        description += ` (This is a paid tool, you will be charged ${cost} for its execution)`;
-      }
-      return {
-        ...tool,
-        description
-      };
-    });
-    return toolsRes;
-  };
-  const _callTool = client.callTool.bind(client);
-  const callToolWithPayment = async (x402ConfirmationCallback, params, resultSchema, options) => {
-    const res = await _callTool(params, resultSchema, options);
-    console.log("res", res);
-    const maybeX402Error = res._meta?.["x402/error"];
-    if (res.isError && maybeX402Error && maybeX402Error.accepts && Array.isArray(maybeX402Error.accepts) && maybeX402Error.accepts.length > 0) {
-      const accepts = maybeX402Error.accepts;
-      const confirmationCallback = x402ConfirmationCallback ?? x402Config.confirmationCallback;
-      if (confirmationCallback && !await confirmationCallback(accepts)) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: "User declined payment" }]
-        };
-      }
-      const req = accepts.find((a) => a?.scheme === "exact" && a?.network === network) ?? accepts[0];
-      if (!req || req.scheme !== "exact") return res;
-      const maxAmountRequired = BigInt(req.maxAmountRequired);
-      if (maxAmountRequired > maxPaymentValue) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: `Payment exceeds client cap: ${maxAmountRequired} > ${maxPaymentValue}`
-            }
-          ]
-        };
-      }
-      const token = await createPaymentHeader(
-        wallet,
-        version ?? 1,
-        req
-      );
-      return _callTool(
-        {
-          ...params,
-          _meta: {
-            ...params._meta,
-            "x402/payment": token
-          }
-        },
-        resultSchema,
-        options
-      );
-    }
-    return res;
-  };
-  const _client = client;
-  _client.listTools = listTools;
-  Object.defineProperty(_client, "callTool", {
-    value: callToolWithPayment,
-    writable: false,
-    enumerable: false,
-    configurable: true
-  });
-  return _client;
-}
-export {
-  withX402,
-  withX402Client
-};
+	const { network, account, version } = x402Config;
+	const wallet = createWalletClient({
+		account,
+		transport: http(),
+		chain: toChain(network)
+	});
+	const maxPaymentValue = x402Config.maxPaymentValue ?? BigInt(.1 * 10 ** 6);
+	const _listTools = client.listTools.bind(client);
+	const listTools = async (params, options) => {
+		const toolsRes = await _listTools(params, options);
+		toolsRes.tools = toolsRes.tools.map((tool) => {
+			let description = tool.description;
+			if (tool.annotations?.paymentHint) {
+				const cost = tool.annotations?.paymentPriceUSD ? `$${tool.annotations?.paymentPriceUSD}` : "an unknown amount";
+				description += ` (This is a paid tool, you will be charged ${cost} for its execution)`;
+			}
+			return {
+				...tool,
+				description
+			};
+		});
+		return toolsRes;
+	};
+	const _callTool = client.callTool.bind(client);
+	const callToolWithPayment = async (x402ConfirmationCallback, params, resultSchema, options) => {
+		const res = await _callTool(params, resultSchema, options);
+		console.log("res", res);
+		const maybeX402Error = res._meta?.["x402/error"];
+		if (res.isError && maybeX402Error && maybeX402Error.accepts && Array.isArray(maybeX402Error.accepts) && maybeX402Error.accepts.length > 0) {
+			const accepts = maybeX402Error.accepts;
+			const confirmationCallback = x402ConfirmationCallback ?? x402Config.confirmationCallback;
+			if (confirmationCallback && !await confirmationCallback(accepts)) return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: "User declined payment"
+				}]
+			};
+			const req = accepts.find((a) => a?.scheme === "exact" && a?.network === network) ?? accepts[0];
+			if (!req || req.scheme !== "exact") return res;
+			const maxAmountRequired = BigInt(req.maxAmountRequired);
+			if (maxAmountRequired > maxPaymentValue) return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: `Payment exceeds client cap: ${maxAmountRequired} > ${maxPaymentValue}`
+				}]
+			};
+			const token = await createPaymentHeader(wallet, version ?? 1, req);
+			return _callTool({
+				...params,
+				_meta: {
+					...params._meta,
+					"x402/payment": token
+				}
+			}, resultSchema, options);
+		}
+		return res;
+	};
+	const _client = client;
+	_client.listTools = listTools;
+	Object.defineProperty(_client, "callTool", {
+		value: callToolWithPayment,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+	return _client;
+}
+
+//#endregion
+export { withX402, withX402Client };
 //# sourceMappingURL=x402.js.map