@wtflabs/x402 0.0.1-beta.14 → 0.0.1-beta.16

package/dist/cjs/index.js

@@ -1077,1476 +1077,1643 @@ var usdcABI = [
   }
 ];
 
-// src/types/shared/evm/wallet.ts
-var import_viem = require("viem");
-var import_chains = require("viem/chains");
-var import_accounts = require("viem/accounts");
-function isSignerWallet(wallet) {
-  return typeof wallet === "object" && wallet !== null && "chain" in wallet && "transport" in wallet;
-}
-function isAccount(wallet) {
-  const w = wallet;
-  return typeof wallet === "object" && wallet !== null && typeof w.address === "string" && typeof w.type === "string" && // Check for essential signing capabilities
-  typeof w.sign === "function" && typeof w.signMessage === "function" && typeof w.signTypedData === "function" && // Check for transaction signing (required by LocalAccount)
-  typeof w.signTransaction === "function";
-}
-
-// src/schemes/exact/evm/eip3009/sign.ts
-var import_viem2 = require("viem");
-
-// src/shared/base64.ts
-var Base64EncodedRegex = /^[A-Za-z0-9+/]*={0,2}$/;
-function safeBase64Encode(data) {
-  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
-    return globalThis.btoa(data);
-  }
-  return Buffer.from(data).toString("base64");
-}
-
-// src/types/shared/money.ts
-var import_zod = require("zod");
-var moneySchema = import_zod.z.union([import_zod.z.string().transform((x) => x.replace(/[^0-9.-]+/g, "")), import_zod.z.number()]).pipe(import_zod.z.coerce.number().min(1e-4).max(999999999));
-
-// src/types/shared/network.ts
-var import_zod2 = require("zod");
-var NetworkSchema = import_zod2.z.enum([
-  "base-sepolia",
-  "base",
-  "avalanche-fuji",
-  "avalanche",
-  "iotex",
-  "solana-devnet",
-  "solana",
-  "sei",
-  "sei-testnet",
-  "polygon",
-  "polygon-amoy",
-  "peaq",
-  "bsc",
-  "bsc-testnet"
-]);
-var SupportedEVMNetworks = [
-  "base-sepolia",
-  "base",
-  "avalanche-fuji",
-  "avalanche",
-  "iotex",
-  "sei",
-  "sei-testnet",
-  "polygon",
-  "polygon-amoy",
-  "peaq",
-  "bsc",
-  "bsc-testnet"
-];
-var EvmNetworkToChainId = /* @__PURE__ */ new Map([
-  ["base-sepolia", 84532],
-  ["base", 8453],
-  ["avalanche-fuji", 43113],
-  ["avalanche", 43114],
-  ["iotex", 4689],
-  ["sei", 1329],
-  ["sei-testnet", 1328],
-  ["polygon", 137],
-  ["polygon-amoy", 80002],
-  ["peaq", 3338],
-  ["bsc", 56],
-  ["bsc-testnet", 97]
-]);
-var SupportedSVMNetworks = ["solana-devnet", "solana"];
-var SvmNetworkToChainId = /* @__PURE__ */ new Map([
-  ["solana-devnet", 103],
-  ["solana", 101]
-]);
-var ChainIdToNetwork = Object.fromEntries(
-  [...SupportedEVMNetworks, ...SupportedSVMNetworks].map((network) => [
-    EvmNetworkToChainId.get(network),
-    network
-  ])
-);
-
-// src/shared/svm/wallet.ts
-var import_kit2 = require("@solana/kit");
-var import_base = require("@scure/base");
-
-// src/shared/svm/rpc.ts
-var import_kit = require("@solana/kit");
-var DEVNET_RPC_URL = "https://api.devnet.solana.com";
-var MAINNET_RPC_URL = "https://api.mainnet-beta.solana.com";
-var DEVNET_WS_URL = "wss://api.devnet.solana.com";
-var MAINNET_WS_URL = "wss://api.mainnet-beta.solana.com";
-function createDevnetRpcClient(url) {
-  return (0, import_kit.createSolanaRpc)(
-    url ? (0, import_kit.devnet)(url) : (0, import_kit.devnet)(DEVNET_RPC_URL)
-  );
-}
-function createMainnetRpcClient(url) {
-  return (0, import_kit.createSolanaRpc)(
-    url ? (0, import_kit.mainnet)(url) : (0, import_kit.mainnet)(MAINNET_RPC_URL)
-  );
-}
-function getRpcClient(network, url) {
-  if (network === "solana-devnet") {
-    return createDevnetRpcClient(url);
-  } else if (network === "solana") {
-    return createMainnetRpcClient(url);
-  } else {
-    throw new Error("Invalid network");
-  }
-}
-function getRpcSubscriptions(network, url) {
-  if (network === "solana-devnet") {
-    return (0, import_kit.createSolanaRpcSubscriptions)((0, import_kit.devnet)(url ? httpToWs(url) : DEVNET_WS_URL));
-  } else if (network === "solana") {
-    return (0, import_kit.createSolanaRpcSubscriptions)((0, import_kit.mainnet)(url ? httpToWs(url) : MAINNET_WS_URL));
-  } else {
-    throw new Error("Invalid network");
-  }
-}
-function httpToWs(url) {
-  if (url.startsWith("http")) {
-    return url.replace("http", "ws");
-  }
-  return url;
-}
-
-// src/shared/svm/wallet.ts
-function isSignerWallet2(wallet) {
-  return (0, import_kit2.isKeyPairSigner)(wallet);
-}
-
-// src/types/shared/wallet.ts
-function isEvmSignerWallet(wallet) {
-  return isSignerWallet(wallet) || isAccount(wallet);
-}
-function isSvmSignerWallet(wallet) {
-  return isSignerWallet2(wallet);
-}
-function isMultiNetworkSigner(wallet) {
-  return "evm" in wallet && "svm" in wallet;
-}
-
-// src/types/shared/svm/regex.ts
-var SvmAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-
-// src/shared/network.ts
-function getNetworkId(network) {
-  if (EvmNetworkToChainId.has(network)) {
-    return EvmNetworkToChainId.get(network);
-  }
-  if (SvmNetworkToChainId.has(network)) {
-    return SvmNetworkToChainId.get(network);
-  }
-  throw new Error(`Unsupported network: ${network}`);
-}
-
-// src/types/verify/x402Specs.ts
-var import_zod3 = require("zod");
-var EvmMaxAtomicUnits = 40;
-var EvmAddressRegex = /^0x[0-9a-fA-F]{40}$/;
-var MixedAddressRegex = /^0x[a-fA-F0-9]{40}|[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$/;
-var HexEncoded64ByteRegex = /^0x[0-9a-fA-F]{64}$/;
-var EvmSignatureRegex = /^0x[0-9a-fA-F]+$/;
-var schemes = ["exact"];
-var x402Versions = [1];
-var ErrorReasons = [
-  "insufficient_funds",
-  "invalid_exact_evm_payload_authorization_valid_after",
-  "invalid_exact_evm_payload_authorization_valid_before",
-  "invalid_exact_evm_payload_authorization_value",
-  "invalid_exact_evm_payload_signature",
-  "invalid_exact_evm_payload_recipient_mismatch",
-  "invalid_exact_svm_payload_transaction",
-  "invalid_exact_svm_payload_transaction_amount_mismatch",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee",
-  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset",
-  "invalid_exact_svm_payload_transaction_instructions",
-  "invalid_exact_svm_payload_transaction_instructions_length",
-  "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction",
-  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction",
-  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high",
-  "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked",
-  "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked",
-  "invalid_exact_svm_payload_transaction_not_a_transfer_instruction",
-  "invalid_exact_svm_payload_transaction_receiver_ata_not_found",
-  "invalid_exact_svm_payload_transaction_sender_ata_not_found",
-  "invalid_exact_svm_payload_transaction_simulation_failed",
-  "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata",
-  "invalid_network",
-  "invalid_payload",
-  "invalid_payment_requirements",
-  "invalid_scheme",
-  "invalid_payment",
-  "payment_expired",
-  "unsupported_scheme",
-  "invalid_x402_version",
-  "invalid_transaction_state",
-  "settle_exact_svm_block_height_exceeded",
-  "settle_exact_svm_transaction_confirmation_timed_out",
-  "unexpected_settle_error",
-  "unexpected_verify_error",
-  // New error reasons for Permit and Permit2
-  "unsupported_authorization_type",
-  "invalid_authorization_type",
-  "invalid_permit_signature",
-  "invalid_permit2_signature",
-  "invalid_permit2_witness_signature",
-  "witness_recipient_mismatch",
-  "permit_expired",
-  "permit2_expired",
-  "permit2_not_approved",
-  "invalid_token_address",
-  "invalid_spender_address",
-  "token_mismatch",
-  "insufficient_payment_amount",
-  "insufficient_token_balance",
-  "transaction_failed",
-  "settlement_failed"
-];
-var isInteger = (value) => Number.isInteger(Number(value)) && Number(value) >= 0;
-var hasMaxLength = (maxLength) => (value) => value.length <= maxLength;
-var EvmOrSvmAddress = import_zod3.z.string().regex(EvmAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
-var mixedAddressOrSvmAddress = import_zod3.z.string().regex(MixedAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
-var PaymentRequirementsSchema = import_zod3.z.object({
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  maxAmountRequired: import_zod3.z.string().refine(isInteger),
-  resource: import_zod3.z.string().url(),
-  description: import_zod3.z.string(),
-  mimeType: import_zod3.z.string(),
-  outputSchema: import_zod3.z.record(import_zod3.z.any()).optional(),
-  payTo: EvmOrSvmAddress,
-  maxTimeoutSeconds: import_zod3.z.number().int(),
-  asset: mixedAddressOrSvmAddress,
-  paymentType: import_zod3.z.enum(["eip3009", "permit", "permit2"]).optional(),
-  extra: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var ExactEvmPayloadAuthorizationSchema = import_zod3.z.object({
-  from: import_zod3.z.string().regex(EvmAddressRegex),
-  to: import_zod3.z.string().regex(EvmAddressRegex),
-  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  validAfter: import_zod3.z.string().refine(isInteger),
-  validBefore: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().regex(HexEncoded64ByteRegex)
-});
-var PermitEvmPayloadAuthorizationSchema = import_zod3.z.object({
-  owner: import_zod3.z.string().regex(EvmAddressRegex),
-  spender: import_zod3.z.string().regex(EvmAddressRegex),
-  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  deadline: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().refine(isInteger)
-});
-var Permit2EvmPayloadAuthorizationSchema = import_zod3.z.object({
-  owner: import_zod3.z.string().regex(EvmAddressRegex),
-  spender: import_zod3.z.string().regex(EvmAddressRegex),
-  token: import_zod3.z.string().regex(EvmAddressRegex),
-  amount: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
-  deadline: import_zod3.z.string().refine(isInteger),
-  nonce: import_zod3.z.string().refine(isInteger),
-  to: import_zod3.z.string().regex(EvmAddressRegex).optional()
-  // Witness: binds recipient address to signature
-});
-var ExactEvmPayloadSchema = import_zod3.z.discriminatedUnion("authorizationType", [
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("eip3009"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: ExactEvmPayloadAuthorizationSchema
-  }),
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("permit"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: PermitEvmPayloadAuthorizationSchema
-  }),
-  import_zod3.z.object({
-    authorizationType: import_zod3.z.literal("permit2"),
-    signature: import_zod3.z.string().regex(EvmSignatureRegex),
-    authorization: Permit2EvmPayloadAuthorizationSchema
-  })
-]);
-var ExactSvmPayloadSchema = import_zod3.z.object({
-  transaction: import_zod3.z.string().regex(Base64EncodedRegex)
-});
-var PaymentPayloadSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  payload: import_zod3.z.union([ExactEvmPayloadSchema, ExactSvmPayloadSchema])
-});
-var x402ResponseSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  error: import_zod3.z.enum(ErrorReasons).optional(),
-  accepts: import_zod3.z.array(PaymentRequirementsSchema).optional(),
-  payer: import_zod3.z.string().regex(MixedAddressRegex).optional()
-});
-var HTTPVerbsSchema = import_zod3.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
-var HTTPRequestStructureSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("http"),
-  method: HTTPVerbsSchema,
-  queryParams: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
-  bodyType: import_zod3.z.enum(["json", "form-data", "multipart-form-data", "text", "binary"]).optional(),
-  bodyFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional(),
-  headerFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional()
-});
-var RequestStructureSchema = import_zod3.z.discriminatedUnion("type", [
-  HTTPRequestStructureSchema
-  // MCPRequestStructureSchema,
-  // OpenAPIRequestStructureSchema,
-]);
-var DiscoveredResourceSchema = import_zod3.z.object({
-  resource: import_zod3.z.string(),
-  type: import_zod3.z.enum(["http"]),
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  accepts: import_zod3.z.array(PaymentRequirementsSchema),
-  lastUpdated: import_zod3.z.date(),
-  metadata: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var SettleRequestSchema = import_zod3.z.object({
-  paymentPayload: PaymentPayloadSchema,
-  paymentRequirements: PaymentRequirementsSchema
-});
-var VerifyRequestSchema = import_zod3.z.object({
-  paymentPayload: PaymentPayloadSchema,
-  paymentRequirements: PaymentRequirementsSchema
-});
-var VerifyResponseSchema = import_zod3.z.object({
-  isValid: import_zod3.z.boolean(),
-  invalidReason: import_zod3.z.enum(ErrorReasons).optional(),
-  payer: EvmOrSvmAddress.optional()
-});
-var SettleResponseSchema = import_zod3.z.object({
-  success: import_zod3.z.boolean(),
-  errorReason: import_zod3.z.enum(ErrorReasons).optional(),
-  payer: EvmOrSvmAddress.optional(),
-  transaction: import_zod3.z.string().regex(MixedAddressRegex),
-  network: NetworkSchema
-});
-var ListDiscoveryResourcesRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.string().optional(),
-  limit: import_zod3.z.number().optional(),
-  offset: import_zod3.z.number().optional()
-});
-var ListDiscoveryResourcesResponseSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  items: import_zod3.z.array(DiscoveredResourceSchema),
-  pagination: import_zod3.z.object({
-    limit: import_zod3.z.number(),
-    offset: import_zod3.z.number(),
-    total: import_zod3.z.number()
-  })
-});
-var SupportedPaymentKindSchema = import_zod3.z.object({
-  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
-  scheme: import_zod3.z.enum(schemes),
-  network: NetworkSchema,
-  extra: import_zod3.z.record(import_zod3.z.any()).optional()
-});
-var SupportedPaymentKindsResponseSchema = import_zod3.z.object({
-  kinds: import_zod3.z.array(SupportedPaymentKindSchema)
-});
-
-// src/types/verify/facilitator.ts
-var import_zod4 = require("zod");
-var facilitatorRequestSchema = import_zod4.z.object({
-  paymentHeader: import_zod4.z.string(),
-  paymentRequirements: PaymentRequirementsSchema
-});
-
-// src/shared/evm/usdc.ts
-function getUsdcAddress(client) {
-  return config[client.chain.id.toString()].usdcAddress;
-}
-function getUsdcChainConfigForChain(chainId) {
-  return config[chainId.toString()];
-}
-var versionCache = /* @__PURE__ */ new Map();
-async function getVersion(client, tokenAddress) {
-  const address = tokenAddress ?? getUsdcAddress(client);
-  const cacheKey = `${client.chain.id}-${address.toLowerCase()}`;
-  if (versionCache.has(cacheKey)) {
-    return versionCache.get(cacheKey);
-  }
-  let version = "1";
-  try {
-    const eip712DomainABI = [
+// src/types/shared/evm/eip7702ABI.ts
+var EIP7702SellerWalletMinimalAbi = [
+  {
+    inputs: [],
+    name: "InvalidAmount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotOwner",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ReentrancyGuardReentrantCall",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ZeroAddress",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
+      }
+    ],
+    name: "ConfigUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "facilitator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "beneficiaryAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "feeAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "method",
+        type: "string"
+      }
+    ],
+    name: "SettlementExecuted",
+    type: "event"
+  },
+  {
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    inputs: [],
+    name: "BASIS_POINTS",
+    outputs: [
+      {
+        internalType: "uint96",
+        name: "",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_BPS",
+    outputs: [
+      {
+        internalType: "uint96",
+        name: "",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_RECIPIENT",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getConfig",
+    outputs: [
+      {
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
+      },
+      {
+        internalType: "bool",
+        name: "initialized",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getEffectiveConfig",
+    outputs: [
+      {
+        internalType: "address",
+        name: "beneficiary",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "feeRecipient",
+        type: "address"
+      },
+      {
+        internalType: "uint96",
+        name: "feeBps",
+        type: "uint96"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC1155BatchReceived",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC1155Received",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "onERC721Received",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
       {
-        inputs: [],
-        name: "eip712Domain",
-        outputs: [
-          { name: "fields", type: "bytes1" },
-          { name: "name", type: "string" },
-          { name: "version", type: "string" },
-          { name: "chainId", type: "uint256" },
-          { name: "verifyingContract", type: "address" },
-          { name: "salt", type: "bytes32" },
-          { name: "extensions", type: "uint256[]" }
-        ],
-        stateMutability: "view",
-        type: "function"
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validAfter",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validBefore",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "nonce",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
       }
-    ];
-    const result = await client.readContract({
-      address,
-      abi: eip712DomainABI,
-      functionName: "eip712Domain"
-    });
-    version = result[2];
-  } catch {
-    try {
-      const result = await client.readContract({
-        address,
-        abi: usdcABI,
-        functionName: "version"
-      });
-      version = result;
-    } catch {
-      console.warn(
-        `Neither eip712Domain() nor version() available for token ${address}, using default: ${version}`
-      );
-    }
-  }
-  versionCache.set(cacheKey, version);
-  return version;
-}
-
-// src/shared/evm/erc20.ts
-async function getERC20Balance(client, erc20Address, address) {
-  const balance = await client.readContract({
-    address: erc20Address,
-    abi: usdcABI,
-    functionName: "balanceOf",
-    args: [address]
-  });
-  return balance;
-}
-async function getERC20Allowance(client, erc20Address, owner, spender) {
-  const allowance = await client.readContract({
-    address: erc20Address,
-    abi: usdcABI,
-    functionName: "allowance",
-    args: [owner, spender]
-  });
-  return allowance;
-}
-
-// src/shared/svm/transaction.ts
-var import_kit3 = require("@solana/kit");
-var import_token = require("@solana-program/token");
-var import_token_2022 = require("@solana-program/token-2022");
-function decodeTransactionFromPayload(svmPayload) {
-  try {
-    const base64Encoder = (0, import_kit3.getBase64Encoder)();
-    const transactionBytes = base64Encoder.encode(svmPayload.transaction);
-    const transactionDecoder = (0, import_kit3.getTransactionDecoder)();
-    return transactionDecoder.decode(transactionBytes);
-  } catch (error) {
-    console.error("error", error);
-    throw new Error("invalid_exact_svm_payload_transaction");
-  }
-}
-function getTokenPayerFromTransaction(transaction) {
-  const compiled = (0, import_kit3.getCompiledTransactionMessageDecoder)().decode(
-    transaction.messageBytes
-  );
-  const staticAccounts = compiled.staticAccounts ?? [];
-  const instructions = compiled.instructions ?? [];
-  for (const ix of instructions) {
-    const programIndex = ix.programAddressIndex;
-    const programAddress = staticAccounts[programIndex].toString();
-    if (programAddress === import_token.TOKEN_PROGRAM_ADDRESS.toString() || programAddress === import_token_2022.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
-      const accountIndices = ix.accountIndices ?? [];
-      if (accountIndices.length >= 4) {
-        const ownerIndex = accountIndices[3];
-        const ownerAddress = staticAccounts[ownerIndex].toString();
-        if (ownerAddress) return ownerAddress;
+    ],
+    name: "settleWithERC3009",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "payer",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "deadline",
+        type: "uint256"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
       }
-    }
-  }
-  return "";
-}
-async function signAndSimulateTransaction(signer, transaction, rpc) {
-  const signedTransaction = await (0, import_kit3.partiallySignTransaction)([signer.keyPair], transaction);
-  const base64EncodedTransaction = (0, import_kit3.getBase64EncodedWireTransaction)(signedTransaction);
-  const simulateTxConfig = {
-    sigVerify: true,
-    replaceRecentBlockhash: false,
-    commitment: "confirmed",
-    encoding: "base64",
-    accounts: void 0,
-    innerInstructions: void 0,
-    minContextSlot: void 0
-  };
-  const simulateResult = await rpc.simulateTransaction(base64EncodedTransaction, simulateTxConfig).send();
-  return simulateResult;
-}
-
-// src/schemes/exact/evm/eip3009/sign.ts
-async function signAuthorization(walletClient, { from, to, value, validAfter, validBefore, nonce }, { asset, network, extra }) {
-  const chainId = getNetworkId(network);
-  const name = extra?.name;
-  const version = extra?.version;
-  const data = {
-    types: authorizationTypes,
-    domain: {
-      name,
-      version,
-      chainId,
-      verifyingContract: (0, import_viem2.getAddress)(asset)
-    },
-    primaryType: "TransferWithAuthorization",
-    message: {
-      from: (0, import_viem2.getAddress)(from),
-      to: (0, import_viem2.getAddress)(to),
-      value,
-      validAfter,
-      validBefore,
-      nonce
-    }
-  };
-  if (isSignerWallet(walletClient)) {
-    const signature = await walletClient.signTypedData(data);
-    return {
-      signature
-    };
-  } else if (isAccount(walletClient) && walletClient.signTypedData) {
-    const signature = await walletClient.signTypedData(data);
-    return {
-      signature
-    };
-  } else {
-    throw new Error("Invalid wallet client provided does not support signTypedData");
+    ],
+    name: "settleWithPermit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "beneficiary_",
+        type: "address"
+      }
+    ],
+    name: "updateConfig",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    stateMutability: "payable",
+    type: "receive"
   }
+];
+
+// src/types/shared/evm/wallet.ts
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+var import_accounts = require("viem/accounts");
+function isSignerWallet(wallet) {
+  return typeof wallet === "object" && wallet !== null && "chain" in wallet && "transport" in wallet;
 }
-function createNonce() {
-  const cryptoObj = typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function" ? globalThis.crypto : (
-    // Dynamic require is needed to support node.js
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    require("crypto").webcrypto
-  );
-  return (0, import_viem2.toHex)(cryptoObj.getRandomValues(new Uint8Array(32)));
+function isAccount(wallet) {
+  const w = wallet;
+  return typeof wallet === "object" && wallet !== null && typeof w.address === "string" && typeof w.type === "string" && // Check for essential signing capabilities
+  typeof w.sign === "function" && typeof w.signMessage === "function" && typeof w.signTypedData === "function" && // Check for transaction signing (required by LocalAccount)
+  typeof w.signTransaction === "function";
 }
 
-// src/schemes/exact/evm/utils/paymentUtils.ts
-function encodePayment(payment) {
-  let safe;
-  if (SupportedEVMNetworks.includes(payment.network)) {
-    const evmPayload = payment.payload;
-    let processedPayload;
-    if (evmPayload.authorizationType === "eip3009") {
-      processedPayload = {
-        ...evmPayload,
-        authorization: {
-          ...evmPayload.authorization,
-          validAfter: evmPayload.authorization.validAfter.toString(),
-          validBefore: evmPayload.authorization.validBefore.toString()
-        }
-      };
-    } else if (evmPayload.authorizationType === "permit") {
-      processedPayload = {
-        ...evmPayload,
-        authorization: {
-          ...evmPayload.authorization,
-          deadline: evmPayload.authorization.deadline.toString(),
-          nonce: evmPayload.authorization.nonce.toString()
-        }
-      };
-    } else {
-      processedPayload = {
-        ...evmPayload,
-        authorization: {
-          ...evmPayload.authorization,
-          deadline: evmPayload.authorization.deadline.toString(),
-          nonce: evmPayload.authorization.nonce.toString()
-        }
-      };
-    }
-    safe = {
-      ...payment,
-      payload: processedPayload
-    };
-    return safeBase64Encode(JSON.stringify(safe));
-  }
-  if (SupportedSVMNetworks.includes(payment.network)) {
-    safe = { ...payment, payload: payment.payload };
-    return safeBase64Encode(JSON.stringify(safe));
+// src/schemes/exact/evm/eip3009/sign.ts
+var import_viem2 = require("viem");
+
+// src/shared/base64.ts
+var Base64EncodedRegex = /^[A-Za-z0-9+/]*={0,2}$/;
+function safeBase64Encode(data) {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return globalThis.btoa(data);
   }
-  throw new Error("Invalid network");
+  return Buffer.from(data).toString("base64");
 }
 
-// src/schemes/exact/evm/eip3009/client.ts
-function preparePaymentHeader(from, x402Version2, paymentRequirements) {
-  const nonce = createNonce();
-  const validAfter = BigInt(
-    Math.floor(Date.now() / 1e3) - 600
-    // 10 minutes before
-  ).toString();
-  const validBefore = BigInt(
-    Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds)
-  ).toString();
-  return {
-    x402Version: x402Version2,
-    scheme: paymentRequirements.scheme,
-    network: paymentRequirements.network,
-    payload: {
-      authorizationType: "eip3009",
-      signature: void 0,
-      authorization: {
-        from,
-        to: paymentRequirements.extra?.relayer || paymentRequirements.payTo,
-        value: paymentRequirements.maxAmountRequired,
-        validAfter: validAfter.toString(),
-        validBefore: validBefore.toString(),
-        nonce
-      }
-    }
-  };
+// src/types/shared/money.ts
+var import_zod = require("zod");
+var moneySchema = import_zod.z.union([import_zod.z.string().transform((x) => x.replace(/[^0-9.-]+/g, "")), import_zod.z.number()]).pipe(import_zod.z.coerce.number().min(1e-4).max(999999999));
+
+// src/types/shared/network.ts
+var import_zod2 = require("zod");
+var NetworkSchema = import_zod2.z.enum([
+  "base-sepolia",
+  "base",
+  "avalanche-fuji",
+  "avalanche",
+  "iotex",
+  "solana-devnet",
+  "solana",
+  "sei",
+  "sei-testnet",
+  "polygon",
+  "polygon-amoy",
+  "peaq",
+  "bsc",
+  "bsc-testnet"
+]);
+var SupportedEVMNetworks = [
+  "base-sepolia",
+  "base",
+  "avalanche-fuji",
+  "avalanche",
+  "iotex",
+  "sei",
+  "sei-testnet",
+  "polygon",
+  "polygon-amoy",
+  "peaq",
+  "bsc",
+  "bsc-testnet"
+];
+var EvmNetworkToChainId = /* @__PURE__ */ new Map([
+  ["base-sepolia", 84532],
+  ["base", 8453],
+  ["avalanche-fuji", 43113],
+  ["avalanche", 43114],
+  ["iotex", 4689],
+  ["sei", 1329],
+  ["sei-testnet", 1328],
+  ["polygon", 137],
+  ["polygon-amoy", 80002],
+  ["peaq", 3338],
+  ["bsc", 56],
+  ["bsc-testnet", 97]
+]);
+var SupportedSVMNetworks = ["solana-devnet", "solana"];
+var SvmNetworkToChainId = /* @__PURE__ */ new Map([
+  ["solana-devnet", 103],
+  ["solana", 101]
+]);
+var ChainIdToNetwork = Object.fromEntries(
+  [...SupportedEVMNetworks, ...SupportedSVMNetworks].map((network) => [
+    EvmNetworkToChainId.get(network),
+    network
+  ])
+);
+
+// src/shared/svm/wallet.ts
+var import_kit2 = require("@solana/kit");
+var import_base = require("@scure/base");
+
+// src/shared/svm/rpc.ts
+var import_kit = require("@solana/kit");
+var DEVNET_RPC_URL = "https://api.devnet.solana.com";
+var MAINNET_RPC_URL = "https://api.mainnet-beta.solana.com";
+var DEVNET_WS_URL = "wss://api.devnet.solana.com";
+var MAINNET_WS_URL = "wss://api.mainnet-beta.solana.com";
+function createDevnetRpcClient(url) {
+  return (0, import_kit.createSolanaRpc)(
+    url ? (0, import_kit.devnet)(url) : (0, import_kit.devnet)(DEVNET_RPC_URL)
+  );
 }
-async function signPaymentHeader(client, paymentRequirements, unsignedPaymentHeader) {
-  const { authorization } = unsignedPaymentHeader.payload;
-  const { signature } = await signAuthorization(client, authorization, paymentRequirements);
-  return {
-    ...unsignedPaymentHeader,
-    payload: {
-      authorizationType: "eip3009",
-      signature,
-      authorization
-    }
-  };
+function createMainnetRpcClient(url) {
+  return (0, import_kit.createSolanaRpc)(
+    url ? (0, import_kit.mainnet)(url) : (0, import_kit.mainnet)(MAINNET_RPC_URL)
+  );
 }
-async function createPayment(client, x402Version2, paymentRequirements) {
-  const from = isSignerWallet(client) ? client.account.address : client.address;
-  const unsignedPaymentHeader = preparePaymentHeader(from, x402Version2, paymentRequirements);
-  return signPaymentHeader(client, paymentRequirements, unsignedPaymentHeader);
+function getRpcClient(network, url) {
+  if (network === "solana-devnet") {
+    return createDevnetRpcClient(url);
+  } else if (network === "solana") {
+    return createMainnetRpcClient(url);
+  } else {
+    throw new Error("Invalid network");
+  }
 }
-async function createPaymentHeader(client, x402Version2, paymentRequirements) {
-  const payment = await createPayment(client, x402Version2, paymentRequirements);
-  return encodePayment(payment);
+function getRpcSubscriptions(network, url) {
+  if (network === "solana-devnet") {
+    return (0, import_kit.createSolanaRpcSubscriptions)((0, import_kit.devnet)(url ? httpToWs(url) : DEVNET_WS_URL));
+  } else if (network === "solana") {
+    return (0, import_kit.createSolanaRpcSubscriptions)((0, import_kit.mainnet)(url ? httpToWs(url) : MAINNET_WS_URL));
+  } else {
+    throw new Error("Invalid network");
+  }
+}
+function httpToWs(url) {
+  if (url.startsWith("http")) {
+    return url.replace("http", "ws");
+  }
+  return url;
 }
 
-// src/schemes/exact/svm/client.ts
-var import_kit4 = require("@solana/kit");
-var import_token_20222 = require("@solana-program/token-2022");
-var import_token2 = require("@solana-program/token");
-var import_compute_budget = require("@solana-program/compute-budget");
-async function createPaymentHeader2(client, x402Version2, paymentRequirements, config2) {
-  const paymentPayload = await createAndSignPayment(
-    client,
-    x402Version2,
-    paymentRequirements,
-    config2
-  );
-  return encodePayment(paymentPayload);
+// src/shared/svm/wallet.ts
+function isSignerWallet2(wallet) {
+  return (0, import_kit2.isKeyPairSigner)(wallet);
 }
-async function createAndSignPayment(client, x402Version2, paymentRequirements, config2) {
-  const transactionMessage = await createTransferTransactionMessage(
-    client,
-    paymentRequirements,
-    config2
-  );
-  const signedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(transactionMessage);
-  const base64EncodedWireTransaction = (0, import_kit4.getBase64EncodedWireTransaction)(signedTransaction);
-  return {
-    scheme: paymentRequirements.scheme,
-    network: paymentRequirements.network,
-    x402Version: x402Version2,
-    payload: {
-      transaction: base64EncodedWireTransaction
-    }
-  };
+
+// src/types/shared/wallet.ts
+function isEvmSignerWallet(wallet) {
+  return isSignerWallet(wallet) || isAccount(wallet);
 }
-async function createTransferTransactionMessage(client, paymentRequirements, config2) {
-  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-  const transferInstructions = await createAtaAndTransferInstructions(
-    client,
-    paymentRequirements,
-    config2
-  );
-  const feePayer = paymentRequirements.extra?.feePayer;
-  const txToSimulate = (0, import_kit4.pipe)(
-    (0, import_kit4.createTransactionMessage)({ version: 0 }),
-    (tx2) => (0, import_compute_budget.setTransactionMessageComputeUnitPrice)(1, tx2),
-    // 1 microlamport priority fee
-    (tx2) => (0, import_kit4.setTransactionMessageFeePayer)(feePayer, tx2),
-    (tx2) => (0, import_kit4.appendTransactionMessageInstructions)(transferInstructions, tx2)
-  );
-  const estimateComputeUnitLimit = (0, import_compute_budget.estimateComputeUnitLimitFactory)({ rpc });
-  const estimatedUnits = await estimateComputeUnitLimit(txToSimulate);
-  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
-  const tx = (0, import_kit4.pipe)(
-    txToSimulate,
-    (tx2) => (0, import_kit4.prependTransactionMessageInstruction)(
-      (0, import_compute_budget.getSetComputeUnitLimitInstruction)({ units: estimatedUnits }),
-      tx2
-    ),
-    (tx2) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx2)
-  );
-  return tx;
+function isSvmSignerWallet(wallet) {
+  return isSignerWallet2(wallet);
+}
+function isMultiNetworkSigner(wallet) {
+  return "evm" in wallet && "svm" in wallet;
+}
+
+// src/types/shared/svm/regex.ts
+var SvmAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+
+// src/shared/network.ts
+function getNetworkId(network) {
+  if (EvmNetworkToChainId.has(network)) {
+    return EvmNetworkToChainId.get(network);
+  }
+  if (SvmNetworkToChainId.has(network)) {
+    return SvmNetworkToChainId.get(network);
+  }
+  throw new Error(`Unsupported network: ${network}`);
+}
+
+// src/types/verify/x402Specs.ts
+var import_zod3 = require("zod");
+var EvmMaxAtomicUnits = 40;
+var EvmAddressRegex = /^0x[0-9a-fA-F]{40}$/;
+var MixedAddressRegex = /^0x[a-fA-F0-9]{40}|[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$/;
+var HexEncoded64ByteRegex = /^0x[0-9a-fA-F]{64}$/;
+var EvmSignatureRegex = /^0x[0-9a-fA-F]+$/;
+var schemes = ["exact"];
+var x402Versions = [1];
+var ErrorReasons = [
+  "insufficient_funds",
+  "invalid_exact_evm_payload_authorization_valid_after",
+  "invalid_exact_evm_payload_authorization_valid_before",
+  "invalid_exact_evm_payload_authorization_value",
+  "invalid_exact_evm_payload_signature",
+  "invalid_exact_evm_payload_recipient_mismatch",
+  "invalid_exact_svm_payload_transaction",
+  "invalid_exact_svm_payload_transaction_amount_mismatch",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee",
+  "invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset",
+  "invalid_exact_svm_payload_transaction_instructions",
+  "invalid_exact_svm_payload_transaction_instructions_length",
+  "invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction",
+  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction",
+  "invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high",
+  "invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked",
+  "invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked",
+  "invalid_exact_svm_payload_transaction_not_a_transfer_instruction",
+  "invalid_exact_svm_payload_transaction_receiver_ata_not_found",
+  "invalid_exact_svm_payload_transaction_sender_ata_not_found",
+  "invalid_exact_svm_payload_transaction_simulation_failed",
+  "invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata",
+  "invalid_network",
+  "invalid_payload",
+  "invalid_payment_requirements",
+  "invalid_scheme",
+  "invalid_payment",
+  "payment_expired",
+  "unsupported_scheme",
+  "invalid_x402_version",
+  "invalid_transaction_state",
+  "settle_exact_svm_block_height_exceeded",
+  "settle_exact_svm_transaction_confirmation_timed_out",
+  "unexpected_settle_error",
+  "unexpected_verify_error",
+  // New error reasons for Permit and Permit2
+  "unsupported_authorization_type",
+  "invalid_authorization_type",
+  "invalid_permit_signature",
+  "invalid_permit2_signature",
+  "invalid_permit2_witness_signature",
+  "witness_recipient_mismatch",
+  "permit_expired",
+  "permit2_expired",
+  "permit2_not_approved",
+  "invalid_token_address",
+  "invalid_spender_address",
+  "token_mismatch",
+  "insufficient_payment_amount",
+  "insufficient_token_balance",
+  "transaction_failed",
+  "settlement_failed"
+];
+var isInteger = (value) => Number.isInteger(Number(value)) && Number(value) >= 0;
+var hasMaxLength = (maxLength) => (value) => value.length <= maxLength;
+var EvmOrSvmAddress = import_zod3.z.string().regex(EvmAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
+var mixedAddressOrSvmAddress = import_zod3.z.string().regex(MixedAddressRegex).or(import_zod3.z.string().regex(SvmAddressRegex));
+var PaymentRequirementsSchema = import_zod3.z.object({
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  maxAmountRequired: import_zod3.z.string().refine(isInteger),
+  resource: import_zod3.z.string().url(),
+  description: import_zod3.z.string(),
+  mimeType: import_zod3.z.string(),
+  outputSchema: import_zod3.z.record(import_zod3.z.any()).optional(),
+  payTo: EvmOrSvmAddress,
+  maxTimeoutSeconds: import_zod3.z.number().int(),
+  asset: mixedAddressOrSvmAddress,
+  paymentType: import_zod3.z.enum(["eip3009", "permit", "permit2"]).optional(),
+  extra: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var ExactEvmPayloadAuthorizationSchema = import_zod3.z.object({
+  from: import_zod3.z.string().regex(EvmAddressRegex),
+  to: import_zod3.z.string().regex(EvmAddressRegex),
+  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  validAfter: import_zod3.z.string().refine(isInteger),
+  validBefore: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().regex(HexEncoded64ByteRegex)
+});
+var PermitEvmPayloadAuthorizationSchema = import_zod3.z.object({
+  owner: import_zod3.z.string().regex(EvmAddressRegex),
+  spender: import_zod3.z.string().regex(EvmAddressRegex),
+  value: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  deadline: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().refine(isInteger)
+});
+var Permit2EvmPayloadAuthorizationSchema = import_zod3.z.object({
+  owner: import_zod3.z.string().regex(EvmAddressRegex),
+  spender: import_zod3.z.string().regex(EvmAddressRegex),
+  token: import_zod3.z.string().regex(EvmAddressRegex),
+  amount: import_zod3.z.string().refine(isInteger).refine(hasMaxLength(EvmMaxAtomicUnits)),
+  deadline: import_zod3.z.string().refine(isInteger),
+  nonce: import_zod3.z.string().refine(isInteger),
+  to: import_zod3.z.string().regex(EvmAddressRegex).optional()
+  // Witness: binds recipient address to signature
+});
+var ExactEvmPayloadSchema = import_zod3.z.discriminatedUnion("authorizationType", [
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("eip3009"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: ExactEvmPayloadAuthorizationSchema
+  }),
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("permit"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: PermitEvmPayloadAuthorizationSchema
+  }),
+  import_zod3.z.object({
+    authorizationType: import_zod3.z.literal("permit2"),
+    signature: import_zod3.z.string().regex(EvmSignatureRegex),
+    authorization: Permit2EvmPayloadAuthorizationSchema
+  })
+]);
+var ExactSvmPayloadSchema = import_zod3.z.object({
+  transaction: import_zod3.z.string().regex(Base64EncodedRegex)
+});
+var PaymentPayloadSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  payload: import_zod3.z.union([ExactEvmPayloadSchema, ExactSvmPayloadSchema])
+});
+var x402ResponseSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  error: import_zod3.z.enum(ErrorReasons).optional(),
+  accepts: import_zod3.z.array(PaymentRequirementsSchema).optional(),
+  payer: import_zod3.z.string().regex(MixedAddressRegex).optional()
+});
+var HTTPVerbsSchema = import_zod3.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
+var HTTPRequestStructureSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("http"),
+  method: HTTPVerbsSchema,
+  queryParams: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
+  bodyType: import_zod3.z.enum(["json", "form-data", "multipart-form-data", "text", "binary"]).optional(),
+  bodyFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional(),
+  headerFields: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).optional()
+});
+var RequestStructureSchema = import_zod3.z.discriminatedUnion("type", [
+  HTTPRequestStructureSchema
+  // MCPRequestStructureSchema,
+  // OpenAPIRequestStructureSchema,
+]);
+var DiscoveredResourceSchema = import_zod3.z.object({
+  resource: import_zod3.z.string(),
+  type: import_zod3.z.enum(["http"]),
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  accepts: import_zod3.z.array(PaymentRequirementsSchema),
+  lastUpdated: import_zod3.z.date(),
+  metadata: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var SettleRequestSchema = import_zod3.z.object({
+  paymentPayload: PaymentPayloadSchema,
+  paymentRequirements: PaymentRequirementsSchema
+});
+var VerifyRequestSchema = import_zod3.z.object({
+  paymentPayload: PaymentPayloadSchema,
+  paymentRequirements: PaymentRequirementsSchema
+});
+var VerifyResponseSchema = import_zod3.z.object({
+  isValid: import_zod3.z.boolean(),
+  invalidReason: import_zod3.z.enum(ErrorReasons).optional(),
+  payer: EvmOrSvmAddress.optional()
+});
+var SettleResponseSchema = import_zod3.z.object({
+  success: import_zod3.z.boolean(),
+  errorReason: import_zod3.z.enum(ErrorReasons).optional(),
+  payer: EvmOrSvmAddress.optional(),
+  transaction: import_zod3.z.string().regex(MixedAddressRegex),
+  network: NetworkSchema
+});
+var ListDiscoveryResourcesRequestSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  limit: import_zod3.z.number().optional(),
+  offset: import_zod3.z.number().optional()
+});
+var ListDiscoveryResourcesResponseSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  items: import_zod3.z.array(DiscoveredResourceSchema),
+  pagination: import_zod3.z.object({
+    limit: import_zod3.z.number(),
+    offset: import_zod3.z.number(),
+    total: import_zod3.z.number()
+  })
+});
+var SupportedPaymentKindSchema = import_zod3.z.object({
+  x402Version: import_zod3.z.number().refine((val) => x402Versions.includes(val)),
+  scheme: import_zod3.z.enum(schemes),
+  network: NetworkSchema,
+  extra: import_zod3.z.record(import_zod3.z.any()).optional()
+});
+var SupportedPaymentKindsResponseSchema = import_zod3.z.object({
+  kinds: import_zod3.z.array(SupportedPaymentKindSchema)
+});
+
+// src/types/verify/facilitator.ts
+var import_zod4 = require("zod");
+var facilitatorRequestSchema = import_zod4.z.object({
+  paymentHeader: import_zod4.z.string(),
+  paymentRequirements: PaymentRequirementsSchema
+});
+
+// src/shared/evm/usdc.ts
+function getUsdcAddress(client) {
+  return config[client.chain.id.toString()].usdcAddress;
 }
-async function createAtaAndTransferInstructions(client, paymentRequirements, config2) {
-  const { asset } = paymentRequirements;
-  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-  const tokenMint = await (0, import_token_20222.fetchMint)(rpc, asset);
-  const tokenProgramAddress = tokenMint.programAddress;
-  if (tokenProgramAddress.toString() !== import_token2.TOKEN_PROGRAM_ADDRESS.toString() && tokenProgramAddress.toString() !== import_token_20222.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
-    throw new Error("Asset was not created by a known token program");
-  }
-  const instructions = [];
-  const createAtaIx = await createAtaInstructionOrUndefined(
-    paymentRequirements,
-    tokenProgramAddress,
-    config2
-  );
-  if (createAtaIx) {
-    instructions.push(createAtaIx);
-  }
-  const transferIx = await createTransferInstruction(
-    client,
-    paymentRequirements,
-    tokenMint.data.decimals,
-    tokenProgramAddress
-  );
-  instructions.push(transferIx);
-  return instructions;
+function getUsdcChainConfigForChain(chainId) {
+  return config[chainId.toString()];
 }
-async function createAtaInstructionOrUndefined(paymentRequirements, tokenProgramAddress, config2) {
-  const { asset, payTo, extra } = paymentRequirements;
-  const feePayer = extra?.feePayer;
-  if (!feePayer) {
-    throw new Error(
-      "feePayer is required in paymentRequirements.extra in order to set the facilitator as the fee payer for the create associated token account instruction"
-    );
-  }
-  const [destinationATAAddress] = await (0, import_token_20222.findAssociatedTokenPda)({
-    mint: asset,
-    owner: payTo,
-    tokenProgram: tokenProgramAddress
-  });
-  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, destinationATAAddress);
-  if (!maybeAccount.exists) {
-    return (0, import_token_20222.getCreateAssociatedTokenInstruction)({
-      payer: paymentRequirements.extra?.feePayer,
-      ata: destinationATAAddress,
-      owner: payTo,
-      mint: asset,
-      tokenProgram: tokenProgramAddress
-    });
+var versionCache = /* @__PURE__ */ new Map();
+async function getVersion(client, tokenAddress) {
+  const address = tokenAddress ?? getUsdcAddress(client);
+  const cacheKey = `${client.chain.id}-${address.toLowerCase()}`;
+  if (versionCache.has(cacheKey)) {
+    return versionCache.get(cacheKey);
   }
-  return void 0;
-}
-async function createTransferInstruction(client, paymentRequirements, decimals, tokenProgramAddress) {
-  const { asset, maxAmountRequired: amount, payTo } = paymentRequirements;
-  const [sourceATA] = await (0, import_token_20222.findAssociatedTokenPda)({
-    mint: asset,
-    owner: client.address,
-    tokenProgram: tokenProgramAddress
-  });
-  const [destinationATA] = await (0, import_token_20222.findAssociatedTokenPda)({
-    mint: asset,
-    owner: payTo,
-    tokenProgram: tokenProgramAddress
-  });
-  return (0, import_token_20222.getTransferCheckedInstruction)(
-    {
-      source: sourceATA,
-      mint: asset,
-      destination: destinationATA,
-      authority: client,
-      amount: BigInt(amount),
-      decimals
-    },
-    { programAddress: tokenProgramAddress }
-  );
-}
-
-// src/client/createPaymentHeader.ts
-async function createPaymentHeader3(client, x402Version2, paymentRequirements, config2) {
-  if (paymentRequirements.scheme === "exact") {
-    if (SupportedEVMNetworks.includes(paymentRequirements.network)) {
-      const evmClient = isMultiNetworkSigner(client) ? client.evm : client;
-      if (!isEvmSignerWallet(evmClient)) {
-        throw new Error("Invalid evm wallet client provided");
-      }
-      return await createPaymentHeader(
-        evmClient,
-        x402Version2,
-        paymentRequirements
-      );
-    }
-    if (SupportedSVMNetworks.includes(paymentRequirements.network)) {
-      const svmClient = isMultiNetworkSigner(client) ? client.svm : client;
-      if (!isSvmSignerWallet(svmClient)) {
-        throw new Error("Invalid svm wallet client provided");
+  let version = "1";
+  try {
+    const eip712DomainABI = [
+      {
+        inputs: [],
+        name: "eip712Domain",
+        outputs: [
+          { name: "fields", type: "bytes1" },
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" },
+          { name: "salt", type: "bytes32" },
+          { name: "extensions", type: "uint256[]" }
+        ],
+        stateMutability: "view",
+        type: "function"
       }
-      return await createPaymentHeader2(
-        svmClient,
-        x402Version2,
-        paymentRequirements,
-        config2
+    ];
+    const result = await client.readContract({
+      address,
+      abi: eip712DomainABI,
+      functionName: "eip712Domain"
+    });
+    version = result[2];
+  } catch {
+    try {
+      const result = await client.readContract({
+        address,
+        abi: usdcABI,
+        functionName: "version"
+      });
+      version = result;
+    } catch {
+      console.warn(
+        `Neither eip712Domain() nor version() available for token ${address}, using default: ${version}`
       );
     }
-    throw new Error("Unsupported network");
-  }
-  throw new Error("Unsupported scheme");
-}
-
-// src/client/preparePaymentHeader.ts
-function preparePaymentHeader2(from, x402Version2, paymentRequirements) {
-  if (paymentRequirements.scheme === "exact" && SupportedEVMNetworks.includes(paymentRequirements.network)) {
-    return preparePaymentHeader(from, x402Version2, paymentRequirements);
   }
-  throw new Error("Unsupported scheme");
+  versionCache.set(cacheKey, version);
+  return version;
 }
 
-// src/client/selectPaymentRequirements.ts
-function selectPaymentRequirements(paymentRequirements, network, scheme) {
-  paymentRequirements.sort((a, b) => {
-    if (a.network === "base" && b.network !== "base") {
-      return -1;
-    }
-    if (a.network !== "base" && b.network === "base") {
-      return 1;
-    }
-    return 0;
-  });
-  const broadlyAcceptedPaymentRequirements = paymentRequirements.filter((requirement) => {
-    const isExpectedScheme = !scheme || requirement.scheme === scheme;
-    const isExpectedChain = !network || (Array.isArray(network) ? network.includes(requirement.network) : network == requirement.network);
-    return isExpectedScheme && isExpectedChain;
+// src/shared/evm/erc20.ts
+async function getERC20Balance(client, erc20Address, address) {
+  const balance = await client.readContract({
+    address: erc20Address,
+    abi: usdcABI,
+    functionName: "balanceOf",
+    args: [address]
   });
-  const usdcRequirements = broadlyAcceptedPaymentRequirements.filter((requirement) => {
-    return requirement.asset === getUsdcChainConfigForChain(getNetworkId(requirement.network))?.usdcAddress;
+  return balance;
+}
+async function getERC20Allowance(client, erc20Address, owner, spender) {
+  const allowance = await client.readContract({
+    address: erc20Address,
+    abi: usdcABI,
+    functionName: "allowance",
+    args: [owner, spender]
   });
-  if (usdcRequirements.length > 0) {
-    return usdcRequirements[0];
-  }
-  if (broadlyAcceptedPaymentRequirements.length > 0) {
-    return broadlyAcceptedPaymentRequirements[0];
-  }
-  return paymentRequirements[0];
+  return allowance;
 }
 
-// src/client/signPaymentHeader.ts
-async function signPaymentHeader2(client, paymentRequirements, unsignedPaymentHeader) {
-  if (paymentRequirements.scheme === "exact" && SupportedEVMNetworks.includes(paymentRequirements.network)) {
-    const evmClient = isMultiNetworkSigner(client) ? client.evm : client;
-    if (!isEvmSignerWallet(evmClient)) {
-      throw new Error("Invalid evm wallet client provided");
+// src/shared/svm/transaction.ts
+var import_kit3 = require("@solana/kit");
+var import_token = require("@solana-program/token");
+var import_token_2022 = require("@solana-program/token-2022");
+function decodeTransactionFromPayload(svmPayload) {
+  try {
+    const base64Encoder = (0, import_kit3.getBase64Encoder)();
+    const transactionBytes = base64Encoder.encode(svmPayload.transaction);
+    const transactionDecoder = (0, import_kit3.getTransactionDecoder)();
+    return transactionDecoder.decode(transactionBytes);
+  } catch (error) {
+    console.error("error", error);
+    throw new Error("invalid_exact_svm_payload_transaction");
+  }
+}
+function getTokenPayerFromTransaction(transaction) {
+  const compiled = (0, import_kit3.getCompiledTransactionMessageDecoder)().decode(
+    transaction.messageBytes
+  );
+  const staticAccounts = compiled.staticAccounts ?? [];
+  const instructions = compiled.instructions ?? [];
+  for (const ix of instructions) {
+    const programIndex = ix.programAddressIndex;
+    const programAddress = staticAccounts[programIndex].toString();
+    if (programAddress === import_token.TOKEN_PROGRAM_ADDRESS.toString() || programAddress === import_token_2022.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+      const accountIndices = ix.accountIndices ?? [];
+      if (accountIndices.length >= 4) {
+        const ownerIndex = accountIndices[3];
+        const ownerAddress = staticAccounts[ownerIndex].toString();
+        if (ownerAddress) return ownerAddress;
+      }
     }
-    const signedPaymentHeader = await signPaymentHeader(evmClient, paymentRequirements, unsignedPaymentHeader);
-    return encodePayment(signedPaymentHeader);
   }
-  throw new Error("Unsupported scheme");
+  return "";
+}
+async function signAndSimulateTransaction(signer, transaction, rpc) {
+  const signedTransaction = await (0, import_kit3.partiallySignTransaction)([signer.keyPair], transaction);
+  const base64EncodedTransaction = (0, import_kit3.getBase64EncodedWireTransaction)(signedTransaction);
+  const simulateTxConfig = {
+    sigVerify: true,
+    replaceRecentBlockhash: false,
+    commitment: "confirmed",
+    encoding: "base64",
+    accounts: void 0,
+    innerInstructions: void 0,
+    minContextSlot: void 0
+  };
+  const simulateResult = await rpc.simulateTransaction(base64EncodedTransaction, simulateTxConfig).send();
+  return simulateResult;
 }
 
-// src/schemes/exact/evm/eip3009/facilitator.ts
-var import_viem3 = require("viem");
-
-// src/schemes/exact/svm/facilitator/settle.ts
-var import_kit6 = require("@solana/kit");
-var import_transaction_confirmation = require("@solana/transaction-confirmation");
-
-// src/schemes/exact/svm/facilitator/verify.ts
-var import_kit5 = require("@solana/kit");
-var import_compute_budget2 = require("@solana-program/compute-budget");
-var import_token_20223 = require("@solana-program/token-2022");
-var import_token3 = require("@solana-program/token");
-async function verify(signer, payload, paymentRequirements, config2) {
-  try {
-    verifySchemesAndNetworks(payload, paymentRequirements);
-    const svmPayload = payload.payload;
-    const decodedTransaction = decodeTransactionFromPayload(svmPayload);
-    const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-    await transactionIntrospection(svmPayload, paymentRequirements, config2);
-    const simulateResult = await signAndSimulateTransaction(signer, decodedTransaction, rpc);
-    if (simulateResult.value?.err) {
-      throw new Error(`invalid_exact_svm_payload_transaction_simulation_failed`);
+// src/schemes/exact/evm/eip3009/sign.ts
+async function signAuthorization(walletClient, { from, to, value, validAfter, validBefore, nonce }, { asset, network, extra }) {
+  const chainId = getNetworkId(network);
+  const name = extra?.name;
+  const version = extra?.version;
+  const data = {
+    types: authorizationTypes,
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: (0, import_viem2.getAddress)(asset)
+    },
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: (0, import_viem2.getAddress)(from),
+      to: (0, import_viem2.getAddress)(to),
+      value,
+      validAfter,
+      validBefore,
+      nonce
     }
+  };
+  if (isSignerWallet(walletClient)) {
+    const signature = await walletClient.signTypedData(data);
     return {
-      isValid: true,
-      invalidReason: void 0,
-      payer: getTokenPayerFromTransaction(decodedTransaction)
+      signature
     };
-  } catch (error) {
-    if (error instanceof Error) {
-      if (ErrorReasons.includes(error.message)) {
-        return {
-          isValid: false,
-          invalidReason: error.message,
-          payer: (() => {
-            try {
-              const tx = decodeTransactionFromPayload(payload.payload);
-              return getTokenPayerFromTransaction(tx);
-            } catch {
-              return void 0;
-            }
-          })()
-        };
-      }
-    }
-    console.error(error);
+  } else if (isAccount(walletClient) && walletClient.signTypedData) {
+    const signature = await walletClient.signTypedData(data);
     return {
-      isValid: false,
-      invalidReason: "unexpected_verify_error",
-      payer: (() => {
-        try {
-          const tx = decodeTransactionFromPayload(payload.payload);
-          return getTokenPayerFromTransaction(tx);
-        } catch {
-          return void 0;
-        }
-      })()
+      signature
     };
+  } else {
+    throw new Error("Invalid wallet client provided does not support signTypedData");
   }
 }
-function verifySchemesAndNetworks(payload, paymentRequirements) {
-  if (payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
-    throw new Error("unsupported_scheme");
-  }
-  if (payload.network !== paymentRequirements.network || !SupportedSVMNetworks.includes(paymentRequirements.network)) {
-    throw new Error("invalid_network");
-  }
-}
-async function transactionIntrospection(svmPayload, paymentRequirements, config2) {
-  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-  const decodedTransaction = decodeTransactionFromPayload(svmPayload);
-  const compiledTransactionMessage = (0, import_kit5.getCompiledTransactionMessageDecoder)().decode(
-    decodedTransaction.messageBytes
-  );
-  const transactionMessage = (0, import_kit5.decompileTransactionMessage)(
-    compiledTransactionMessage
+function createNonce() {
+  const cryptoObj = typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function" ? globalThis.crypto : (
+    // Dynamic require is needed to support node.js
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require("crypto").webcrypto
   );
-  await verifyTransactionInstructions(transactionMessage, paymentRequirements, rpc);
+  return (0, import_viem2.toHex)(cryptoObj.getRandomValues(new Uint8Array(32)));
 }
-async function verifyTransactionInstructions(transactionMessage, paymentRequirements, rpc) {
-  if (transactionMessage.instructions.length !== 3 && transactionMessage.instructions.length !== 4) {
-    throw new Error(`invalid_exact_svm_payload_transaction_instructions_length`);
+
+// src/schemes/exact/evm/utils/paymentUtils.ts
+function encodePayment(payment) {
+  let safe;
+  if (SupportedEVMNetworks.includes(payment.network)) {
+    const evmPayload = payment.payload;
+    let processedPayload;
+    if (evmPayload.authorizationType === "eip3009") {
+      processedPayload = {
+        ...evmPayload,
+        authorization: {
+          ...evmPayload.authorization,
+          validAfter: evmPayload.authorization.validAfter.toString(),
+          validBefore: evmPayload.authorization.validBefore.toString()
+        }
+      };
+    } else if (evmPayload.authorizationType === "permit") {
+      processedPayload = {
+        ...evmPayload,
+        authorization: {
+          ...evmPayload.authorization,
+          deadline: evmPayload.authorization.deadline.toString(),
+          nonce: evmPayload.authorization.nonce.toString()
+        }
+      };
+    } else {
+      processedPayload = {
+        ...evmPayload,
+        authorization: {
+          ...evmPayload.authorization,
+          deadline: evmPayload.authorization.deadline.toString(),
+          nonce: evmPayload.authorization.nonce.toString()
+        }
+      };
+    }
+    safe = {
+      ...payment,
+      payload: processedPayload
+    };
+    return safeBase64Encode(JSON.stringify(safe));
   }
-  verifyComputeLimitInstruction(transactionMessage.instructions[0]);
-  verifyComputePriceInstruction(transactionMessage.instructions[1]);
-  if (transactionMessage.instructions.length === 3) {
-    await verifyTransferInstruction(
-      transactionMessage.instructions[2],
-      paymentRequirements,
-      {
-        txHasCreateDestATAInstruction: false
-      },
-      rpc
-    );
-  } else {
-    verifyCreateATAInstruction(transactionMessage.instructions[2], paymentRequirements);
-    await verifyTransferInstruction(
-      transactionMessage.instructions[3],
-      paymentRequirements,
-      {
-        txHasCreateDestATAInstruction: true
-      },
-      rpc
-    );
+  if (SupportedSVMNetworks.includes(payment.network)) {
+    safe = { ...payment, payload: payment.payload };
+    return safeBase64Encode(JSON.stringify(safe));
   }
+  throw new Error("Invalid network");
 }
-function verifyComputeLimitInstruction(instruction) {
-  try {
-    if (instruction.programAddress.toString() !== import_compute_budget2.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 2) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`
-      );
+
+// src/schemes/exact/evm/eip3009/client.ts
+function preparePaymentHeader(from, x402Version2, paymentRequirements) {
+  const nonce = createNonce();
+  const validAfter = BigInt(
+    Math.floor(Date.now() / 1e3) - 600
+    // 10 minutes before
+  ).toString();
+  const validBefore = BigInt(
+    Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds)
+  ).toString();
+  return {
+    x402Version: x402Version2,
+    scheme: paymentRequirements.scheme,
+    network: paymentRequirements.network,
+    payload: {
+      authorizationType: "eip3009",
+      signature: void 0,
+      authorization: {
+        from,
+        to: paymentRequirements.payTo,
+        value: paymentRequirements.maxAmountRequired,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      }
     }
-    (0, import_compute_budget2.parseSetComputeUnitLimitInstruction)(
-      instruction
-    );
-  } catch (error) {
-    console.error(error);
-    throw new Error(`invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`);
-  }
-}
-function verifyComputePriceInstruction(instruction) {
-  if (instruction.programAddress.toString() !== import_compute_budget2.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 3) {
-    throw new Error(`invalid_exact_svm_payload_transaction_instructions_compute_price_instruction`);
-  }
-  const parsedInstruction = (0, import_compute_budget2.parseSetComputeUnitPriceInstruction)(
-    instruction
-  );
-  if (parsedInstruction.data.microLamports > 5 * 1e6) {
-    throw new Error(
-      `invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high`
-    );
-  }
+  };
 }
-function verifyCreateATAInstruction(instruction, paymentRequirements) {
-  let createATAInstruction;
-  try {
-    (0, import_kit5.assertIsInstructionWithAccounts)(instruction);
-    (0, import_kit5.assertIsInstructionWithData)(instruction);
-    createATAInstruction = (0, import_token_20223.parseCreateAssociatedTokenInstruction)({
-      ...instruction,
-      data: new Uint8Array(instruction.data)
-    });
-  } catch (error) {
-    console.error(error);
-    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction`);
-  }
-  if (createATAInstruction.accounts.owner.address !== paymentRequirements.payTo) {
-    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee`);
-  }
-  if (createATAInstruction.accounts.mint.address !== paymentRequirements.asset) {
-    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset`);
-  }
+async function signPaymentHeader(client, paymentRequirements, unsignedPaymentHeader) {
+  const { authorization } = unsignedPaymentHeader.payload;
+  const { signature } = await signAuthorization(client, authorization, paymentRequirements);
+  return {
+    ...unsignedPaymentHeader,
+    payload: {
+      authorizationType: "eip3009",
+      signature,
+      authorization
+    }
+  };
 }
-async function verifyTransferInstruction(instruction, paymentRequirements, { txHasCreateDestATAInstruction }, rpc) {
-  const tokenInstruction = getValidatedTransferCheckedInstruction(instruction);
-  await verifyTransferCheckedInstruction(
-    tokenInstruction,
+async function createPayment(client, x402Version2, paymentRequirements) {
+  const from = isSignerWallet(client) ? client.account.address : client.address;
+  const unsignedPaymentHeader = preparePaymentHeader(from, x402Version2, paymentRequirements);
+  return signPaymentHeader(client, paymentRequirements, unsignedPaymentHeader);
+}
+async function createPaymentHeader(client, x402Version2, paymentRequirements) {
+  const payment = await createPayment(client, x402Version2, paymentRequirements);
+  return encodePayment(payment);
+}
+
+// src/schemes/exact/svm/client.ts
+var import_kit4 = require("@solana/kit");
+var import_token_20222 = require("@solana-program/token-2022");
+var import_token2 = require("@solana-program/token");
+var import_compute_budget = require("@solana-program/compute-budget");
+async function createPaymentHeader2(client, x402Version2, paymentRequirements, config2) {
+  const paymentPayload = await createAndSignPayment(
+    client,
+    x402Version2,
     paymentRequirements,
-    {
-      txHasCreateDestATAInstruction
-    },
-    rpc
+    config2
   );
+  return encodePayment(paymentPayload);
 }
-async function verifyTransferCheckedInstruction(parsedInstruction, paymentRequirements, { txHasCreateDestATAInstruction }, rpc) {
-  const tokenProgramAddress = parsedInstruction.programAddress.toString() === import_token3.TOKEN_PROGRAM_ADDRESS.toString() ? import_token3.TOKEN_PROGRAM_ADDRESS : import_token_20223.TOKEN_2022_PROGRAM_ADDRESS;
-  const payToATA = await (0, import_token_20223.findAssociatedTokenPda)({
-    mint: paymentRequirements.asset,
-    owner: paymentRequirements.payTo,
-    tokenProgram: tokenProgramAddress
-  });
-  if (parsedInstruction.accounts.destination.address !== payToATA[0]) {
-    throw new Error(`invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata`);
-  }
-  const addresses = [parsedInstruction.accounts.source.address, payToATA[0]];
-  const maybeAccounts = await (0, import_kit5.fetchEncodedAccounts)(rpc, addresses);
-  const missingAccounts = maybeAccounts.filter((a) => !a.exists);
-  for (const missingAccount of missingAccounts) {
-    if (missingAccount.address === parsedInstruction.accounts.source.address) {
-      throw new Error(`invalid_exact_svm_payload_transaction_sender_ata_not_found`);
-    }
-    if (missingAccount.address === payToATA[0] && !txHasCreateDestATAInstruction) {
-      throw new Error(`invalid_exact_svm_payload_transaction_receiver_ata_not_found`);
+async function createAndSignPayment(client, x402Version2, paymentRequirements, config2) {
+  const transactionMessage = await createTransferTransactionMessage(
+    client,
+    paymentRequirements,
+    config2
+  );
+  const signedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(transactionMessage);
+  const base64EncodedWireTransaction = (0, import_kit4.getBase64EncodedWireTransaction)(signedTransaction);
+  return {
+    scheme: paymentRequirements.scheme,
+    network: paymentRequirements.network,
+    x402Version: x402Version2,
+    payload: {
+      transaction: base64EncodedWireTransaction
     }
-  }
-  const instructionAmount = parsedInstruction.data.amount;
-  const paymentRequirementsAmount = BigInt(paymentRequirements.maxAmountRequired);
-  if (instructionAmount !== paymentRequirementsAmount) {
-    throw new Error(`invalid_exact_svm_payload_transaction_amount_mismatch`);
-  }
+  };
 }
-function getValidatedTransferCheckedInstruction(instruction) {
-  try {
-    (0, import_kit5.assertIsInstructionWithData)(instruction);
-    (0, import_kit5.assertIsInstructionWithAccounts)(instruction);
-  } catch (error) {
-    console.error(error);
-    throw new Error(`invalid_exact_svm_payload_transaction_instructions`);
-  }
-  let tokenInstruction;
-  if (instruction.programAddress.toString() === import_token3.TOKEN_PROGRAM_ADDRESS.toString()) {
-    const identifiedInstruction = (0, import_token3.identifyTokenInstruction)(instruction);
-    if (identifiedInstruction !== import_token3.TokenInstruction.TransferChecked) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked`
-      );
-    }
-    tokenInstruction = (0, import_token3.parseTransferCheckedInstruction)({
-      ...instruction,
-      data: new Uint8Array(instruction.data)
-    });
-  } else if (instruction.programAddress.toString() === import_token_20223.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
-    const identifiedInstruction = (0, import_token_20223.identifyToken2022Instruction)(instruction);
-    if (identifiedInstruction !== import_token_20223.Token2022Instruction.TransferChecked) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked`
-      );
-    }
-    tokenInstruction = (0, import_token_20223.parseTransferCheckedInstruction)({
-      ...instruction,
-      data: new Uint8Array(instruction.data)
-    });
-  } else {
-    throw new Error(`invalid_exact_svm_payload_transaction_not_a_transfer_instruction`);
-  }
-  return tokenInstruction;
+async function createTransferTransactionMessage(client, paymentRequirements, config2) {
+  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
+  const transferInstructions = await createAtaAndTransferInstructions(
+    client,
+    paymentRequirements,
+    config2
+  );
+  const feePayer = paymentRequirements.extra?.feePayer;
+  const txToSimulate = (0, import_kit4.pipe)(
+    (0, import_kit4.createTransactionMessage)({ version: 0 }),
+    (tx2) => (0, import_compute_budget.setTransactionMessageComputeUnitPrice)(1, tx2),
+    // 1 microlamport priority fee
+    (tx2) => (0, import_kit4.setTransactionMessageFeePayer)(feePayer, tx2),
+    (tx2) => (0, import_kit4.appendTransactionMessageInstructions)(transferInstructions, tx2)
+  );
+  const estimateComputeUnitLimit = (0, import_compute_budget.estimateComputeUnitLimitFactory)({ rpc });
+  const estimatedUnits = await estimateComputeUnitLimit(txToSimulate);
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+  const tx = (0, import_kit4.pipe)(
+    txToSimulate,
+    (tx2) => (0, import_kit4.prependTransactionMessageInstruction)(
+      (0, import_compute_budget.getSetComputeUnitLimitInstruction)({ units: estimatedUnits }),
+      tx2
+    ),
+    (tx2) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx2)
+  );
+  return tx;
 }
-
-// src/schemes/exact/svm/facilitator/settle.ts
-async function settle(signer, payload, paymentRequirements, config2) {
-  const verifyResponse = await verify(signer, payload, paymentRequirements, config2);
-  if (!verifyResponse.isValid) {
-    return {
-      success: false,
-      errorReason: verifyResponse.invalidReason,
-      network: payload.network,
-      transaction: ""
-    };
-  }
-  const svmPayload = payload.payload;
-  const decodedTransaction = decodeTransactionFromPayload(svmPayload);
-  const signedTransaction = await (0, import_kit6.signTransaction)([signer.keyPair], decodedTransaction);
-  const payer = getTokenPayerFromTransaction(decodedTransaction);
+async function createAtaAndTransferInstructions(client, paymentRequirements, config2) {
+  const { asset } = paymentRequirements;
   const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
-  const rpcSubscriptions = getRpcSubscriptions(
-    paymentRequirements.network,
-    config2?.svmConfig?.rpcUrl
+  const tokenMint = await (0, import_token_20222.fetchMint)(rpc, asset);
+  const tokenProgramAddress = tokenMint.programAddress;
+  if (tokenProgramAddress.toString() !== import_token2.TOKEN_PROGRAM_ADDRESS.toString() && tokenProgramAddress.toString() !== import_token_20222.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+    throw new Error("Asset was not created by a known token program");
+  }
+  const instructions = [];
+  const createAtaIx = await createAtaInstructionOrUndefined(
+    paymentRequirements,
+    tokenProgramAddress,
+    config2
   );
-  try {
-    const { success, errorReason, signature } = await sendAndConfirmSignedTransaction(
-      signedTransaction,
-      rpc,
-      rpcSubscriptions
-    );
-    return {
-      success,
-      errorReason,
-      payer,
-      transaction: signature,
-      network: payload.network
-    };
-  } catch (error) {
-    console.error("Unexpected error during transaction settlement:", error);
-    return {
-      success: false,
-      errorReason: "unexpected_settle_error",
-      network: payload.network,
-      transaction: (0, import_kit6.getSignatureFromTransaction)(signedTransaction),
-      payer
-    };
+  if (createAtaIx) {
+    instructions.push(createAtaIx);
   }
+  const transferIx = await createTransferInstruction(
+    client,
+    paymentRequirements,
+    tokenMint.data.decimals,
+    tokenProgramAddress
+  );
+  instructions.push(transferIx);
+  return instructions;
 }
-async function sendSignedTransaction(signedTransaction, rpc, sendTxConfig = {
-  skipPreflight: true,
-  encoding: "base64"
-}) {
-  const base64EncodedTransaction = (0, import_kit6.getBase64EncodedWireTransaction)(signedTransaction);
-  return await rpc.sendTransaction(base64EncodedTransaction, sendTxConfig).send();
-}
-async function confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
-  const signature = (0, import_kit6.getSignatureFromTransaction)(signedTransaction);
-  const abortController = new AbortController();
-  const timeout = setTimeout(() => {
-    abortController.abort("Transaction confirmation timed out after 60 seconds");
-  }, 6e4);
-  try {
-    const compiledTransactionMessage = (0, import_kit6.getCompiledTransactionMessageDecoder)().decode(
-      signedTransaction.messageBytes
-    );
-    const decompiledTransactionMessage = await (0, import_kit6.decompileTransactionMessageFetchingLookupTables)(
-      compiledTransactionMessage,
-      rpc
+async function createAtaInstructionOrUndefined(paymentRequirements, tokenProgramAddress, config2) {
+  const { asset, payTo, extra } = paymentRequirements;
+  const feePayer = extra?.feePayer;
+  if (!feePayer) {
+    throw new Error(
+      "feePayer is required in paymentRequirements.extra in order to set the facilitator as the fee payer for the create associated token account instruction"
     );
-    (0, import_kit6.assertIsTransactionMessageWithBlockhashLifetime)(decompiledTransactionMessage);
-    const signedTransactionWithBlockhashLifetime = {
-      ...signedTransaction,
-      lifetimeConstraint: decompiledTransactionMessage.lifetimeConstraint
-    };
-    const commitment = "confirmed";
-    const getRecentSignatureConfirmationPromise = (0, import_transaction_confirmation.createRecentSignatureConfirmationPromiseFactory)({
-      rpc,
-      rpcSubscriptions
-    });
-    const getBlockHeightExceedencePromise = (0, import_transaction_confirmation.createBlockHeightExceedencePromiseFactory)({
-      rpc,
-      rpcSubscriptions
-    });
-    const config2 = {
-      abortSignal: abortController.signal,
-      commitment,
-      getBlockHeightExceedencePromise,
-      getRecentSignatureConfirmationPromise
-    };
-    await (0, import_transaction_confirmation.waitForRecentTransactionConfirmation)({
-      ...config2,
-      transaction: signedTransactionWithBlockhashLifetime
+  }
+  const [destinationATAAddress] = await (0, import_token_20222.findAssociatedTokenPda)({
+    mint: asset,
+    owner: payTo,
+    tokenProgram: tokenProgramAddress
+  });
+  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
+  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, destinationATAAddress);
+  if (!maybeAccount.exists) {
+    return (0, import_token_20222.getCreateAssociatedTokenInstruction)({
+      payer: paymentRequirements.extra?.feePayer,
+      ata: destinationATAAddress,
+      owner: payTo,
+      mint: asset,
+      tokenProgram: tokenProgramAddress
     });
-    return {
-      success: true,
-      signature
-    };
-  } catch (error) {
-    console.error(error);
-    if ((0, import_kit6.isSolanaError)(error, import_kit6.SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED)) {
-      return {
-        success: false,
-        errorReason: "settle_exact_svm_block_height_exceeded",
-        signature
-      };
-    } else if (error instanceof DOMException && error.name === "AbortError") {
-      return {
-        success: false,
-        errorReason: "settle_exact_svm_transaction_confirmation_timed_out",
-        signature
-      };
-    } else {
-      throw error;
-    }
-  } finally {
-    clearTimeout(timeout);
   }
+  return void 0;
 }
-async function sendAndConfirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
-  await sendSignedTransaction(signedTransaction, rpc);
-  return await confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions);
-}
-
-// src/schemes/exact/index.ts
-var SCHEME = "exact";
-
-// src/types/shared/evm/permitProxyABI.ts
-var permitProxyContractABI = [
-  // settleWithPermit - 使用 EIP-2612 Permit 进行结算
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "deadline",
-        type: "uint256"
-      },
-      {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
-      },
-      {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
-      }
-    ],
-    name: "settleWithPermit",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  // settleWithERC3009 - 使用 EIP-3009 TransferWithAuthorization 进行结算
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "validAfter",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "validBefore",
-        type: "uint256"
-      },
-      {
-        internalType: "bytes32",
-        name: "nonce",
-        type: "bytes32"
-      },
-      {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
-      },
-      {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
-      }
-    ],
-    name: "settleWithERC3009",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  // settleWithERC3009Direct - 直接结算（无手续费）
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "validAfter",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "validBefore",
-        type: "uint256"
-      },
-      {
-        internalType: "bytes32",
-        name: "nonce",
-        type: "bytes32"
-      },
-      {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
-      },
-      {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
-      }
-    ],
-    name: "settleWithERC3009Direct",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  // Events
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "seller",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "sellerAmount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "feeAmount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "string",
-        name: "path",
-        type: "string"
+async function createTransferInstruction(client, paymentRequirements, decimals, tokenProgramAddress) {
+  const { asset, maxAmountRequired: amount, payTo } = paymentRequirements;
+  const [sourceATA] = await (0, import_token_20222.findAssociatedTokenPda)({
+    mint: asset,
+    owner: client.address,
+    tokenProgram: tokenProgramAddress
+  });
+  const [destinationATA] = await (0, import_token_20222.findAssociatedTokenPda)({
+    mint: asset,
+    owner: payTo,
+    tokenProgram: tokenProgramAddress
+  });
+  return (0, import_token_20222.getTransferCheckedInstruction)(
+    {
+      source: sourceATA,
+      mint: asset,
+      destination: destinationATA,
+      authority: client,
+      amount: BigInt(amount),
+      decimals
+    },
+    { programAddress: tokenProgramAddress }
+  );
+}
+
+// src/client/createPaymentHeader.ts
+async function createPaymentHeader3(client, x402Version2, paymentRequirements, config2) {
+  if (paymentRequirements.scheme === "exact") {
+    if (SupportedEVMNetworks.includes(paymentRequirements.network)) {
+      const evmClient = isMultiNetworkSigner(client) ? client.evm : client;
+      if (!isEvmSignerWallet(evmClient)) {
+        throw new Error("Invalid evm wallet client provided");
       }
-    ],
-    name: "SettledSplit",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
+      return await createPaymentHeader(
+        evmClient,
+        x402Version2,
+        paymentRequirements
+      );
+    }
+    if (SupportedSVMNetworks.includes(paymentRequirements.network)) {
+      const svmClient = isMultiNetworkSigner(client) ? client.svm : client;
+      if (!isSvmSignerWallet(svmClient)) {
+        throw new Error("Invalid svm wallet client provided");
+      }
+      return await createPaymentHeader2(
+        svmClient,
+        x402Version2,
+        paymentRequirements,
+        config2
+      );
+    }
+    throw new Error("Unsupported network");
+  }
+  throw new Error("Unsupported scheme");
+}
+
+// src/client/preparePaymentHeader.ts
+function preparePaymentHeader2(from, x402Version2, paymentRequirements) {
+  if (paymentRequirements.scheme === "exact" && SupportedEVMNetworks.includes(paymentRequirements.network)) {
+    return preparePaymentHeader(from, x402Version2, paymentRequirements);
+  }
+  throw new Error("Unsupported scheme");
+}
+
+// src/client/selectPaymentRequirements.ts
+function selectPaymentRequirements(paymentRequirements, network, scheme) {
+  paymentRequirements.sort((a, b) => {
+    if (a.network === "base" && b.network !== "base") {
+      return -1;
+    }
+    if (a.network !== "base" && b.network === "base") {
+      return 1;
+    }
+    return 0;
+  });
+  const broadlyAcceptedPaymentRequirements = paymentRequirements.filter((requirement) => {
+    const isExpectedScheme = !scheme || requirement.scheme === scheme;
+    const isExpectedChain = !network || (Array.isArray(network) ? network.includes(requirement.network) : network == requirement.network);
+    return isExpectedScheme && isExpectedChain;
+  });
+  const usdcRequirements = broadlyAcceptedPaymentRequirements.filter((requirement) => {
+    return requirement.asset === getUsdcChainConfigForChain(getNetworkId(requirement.network))?.usdcAddress;
+  });
+  if (usdcRequirements.length > 0) {
+    return usdcRequirements[0];
+  }
+  if (broadlyAcceptedPaymentRequirements.length > 0) {
+    return broadlyAcceptedPaymentRequirements[0];
+  }
+  return paymentRequirements[0];
+}
+
+// src/client/signPaymentHeader.ts
+async function signPaymentHeader2(client, paymentRequirements, unsignedPaymentHeader) {
+  if (paymentRequirements.scheme === "exact" && SupportedEVMNetworks.includes(paymentRequirements.network)) {
+    const evmClient = isMultiNetworkSigner(client) ? client.evm : client;
+    if (!isEvmSignerWallet(evmClient)) {
+      throw new Error("Invalid evm wallet client provided");
+    }
+    const signedPaymentHeader = await signPaymentHeader(evmClient, paymentRequirements, unsignedPaymentHeader);
+    return encodePayment(signedPaymentHeader);
+  }
+  throw new Error("Unsupported scheme");
+}
+
+// src/schemes/exact/evm/eip3009/facilitator.ts
+var import_viem3 = require("viem");
+
+// src/schemes/exact/svm/facilitator/settle.ts
+var import_kit6 = require("@solana/kit");
+var import_transaction_confirmation = require("@solana/transaction-confirmation");
+
+// src/schemes/exact/svm/facilitator/verify.ts
+var import_kit5 = require("@solana/kit");
+var import_compute_budget2 = require("@solana-program/compute-budget");
+var import_token_20223 = require("@solana-program/token-2022");
+var import_token3 = require("@solana-program/token");
+async function verify(signer, payload, paymentRequirements, config2) {
+  try {
+    verifySchemesAndNetworks(payload, paymentRequirements);
+    const svmPayload = payload.payload;
+    const decodedTransaction = decodeTransactionFromPayload(svmPayload);
+    const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
+    await transactionIntrospection(svmPayload, paymentRequirements, config2);
+    const simulateResult = await signAndSimulateTransaction(signer, decodedTransaction, rpc);
+    if (simulateResult.value?.err) {
+      throw new Error(`invalid_exact_svm_payload_transaction_simulation_failed`);
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: getTokenPayerFromTransaction(decodedTransaction)
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (ErrorReasons.includes(error.message)) {
+        return {
+          isValid: false,
+          invalidReason: error.message,
+          payer: (() => {
+            try {
+              const tx = decodeTransactionFromPayload(payload.payload);
+              return getTokenPayerFromTransaction(tx);
+            } catch {
+              return void 0;
+            }
+          })()
+        };
+      }
+    }
+    console.error(error);
+    return {
+      isValid: false,
+      invalidReason: "unexpected_verify_error",
+      payer: (() => {
+        try {
+          const tx = decodeTransactionFromPayload(payload.payload);
+          return getTokenPayerFromTransaction(tx);
+        } catch {
+          return void 0;
+        }
+      })()
+    };
+  }
+}
+function verifySchemesAndNetworks(payload, paymentRequirements) {
+  if (payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
+    throw new Error("unsupported_scheme");
+  }
+  if (payload.network !== paymentRequirements.network || !SupportedSVMNetworks.includes(paymentRequirements.network)) {
+    throw new Error("invalid_network");
+  }
+}
+async function transactionIntrospection(svmPayload, paymentRequirements, config2) {
+  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
+  const decodedTransaction = decodeTransactionFromPayload(svmPayload);
+  const compiledTransactionMessage = (0, import_kit5.getCompiledTransactionMessageDecoder)().decode(
+    decodedTransaction.messageBytes
+  );
+  const transactionMessage = (0, import_kit5.decompileTransactionMessage)(
+    compiledTransactionMessage
+  );
+  await verifyTransactionInstructions(transactionMessage, paymentRequirements, rpc);
+}
+async function verifyTransactionInstructions(transactionMessage, paymentRequirements, rpc) {
+  if (transactionMessage.instructions.length !== 3 && transactionMessage.instructions.length !== 4) {
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions_length`);
+  }
+  verifyComputeLimitInstruction(transactionMessage.instructions[0]);
+  verifyComputePriceInstruction(transactionMessage.instructions[1]);
+  if (transactionMessage.instructions.length === 3) {
+    await verifyTransferInstruction(
+      transactionMessage.instructions[2],
+      paymentRequirements,
       {
-        indexed: true,
-        internalType: "address",
-        name: "seller",
-        type: "address"
+        txHasCreateDestATAInstruction: false
       },
+      rpc
+    );
+  } else {
+    verifyCreateATAInstruction(transactionMessage.instructions[2], paymentRequirements);
+    await verifyTransferInstruction(
+      transactionMessage.instructions[3],
+      paymentRequirements,
       {
-        indexed: false,
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
+        txHasCreateDestATAInstruction: true
       },
-      {
-        indexed: false,
-        internalType: "string",
-        name: "path",
-        type: "string"
-      }
-    ],
-    name: "SettledDirect",
-    type: "event"
+      rpc
+    );
+  }
+}
+function verifyComputeLimitInstruction(instruction) {
+  try {
+    if (instruction.programAddress.toString() !== import_compute_budget2.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 2) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`
+      );
+    }
+    (0, import_compute_budget2.parseSetComputeUnitLimitInstruction)(
+      instruction
+    );
+  } catch (error) {
+    console.error(error);
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`);
+  }
+}
+function verifyComputePriceInstruction(instruction) {
+  if (instruction.programAddress.toString() !== import_compute_budget2.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 3) {
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions_compute_price_instruction`);
+  }
+  const parsedInstruction = (0, import_compute_budget2.parseSetComputeUnitPriceInstruction)(
+    instruction
+  );
+  if (parsedInstruction.data.microLamports > 5 * 1e6) {
+    throw new Error(
+      `invalid_exact_svm_payload_transaction_instructions_compute_price_instruction_too_high`
+    );
+  }
+}
+function verifyCreateATAInstruction(instruction, paymentRequirements) {
+  let createATAInstruction;
+  try {
+    (0, import_kit5.assertIsInstructionWithAccounts)(instruction);
+    (0, import_kit5.assertIsInstructionWithData)(instruction);
+    createATAInstruction = (0, import_token_20223.parseCreateAssociatedTokenInstruction)({
+      ...instruction,
+      data: new Uint8Array(instruction.data)
+    });
+  } catch (error) {
+    console.error(error);
+    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction`);
   }
-];
+  if (createATAInstruction.accounts.owner.address !== paymentRequirements.payTo) {
+    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_payee`);
+  }
+  if (createATAInstruction.accounts.mint.address !== paymentRequirements.asset) {
+    throw new Error(`invalid_exact_svm_payload_transaction_create_ata_instruction_incorrect_asset`);
+  }
+}
+async function verifyTransferInstruction(instruction, paymentRequirements, { txHasCreateDestATAInstruction }, rpc) {
+  const tokenInstruction = getValidatedTransferCheckedInstruction(instruction);
+  await verifyTransferCheckedInstruction(
+    tokenInstruction,
+    paymentRequirements,
+    {
+      txHasCreateDestATAInstruction
+    },
+    rpc
+  );
+}
+async function verifyTransferCheckedInstruction(parsedInstruction, paymentRequirements, { txHasCreateDestATAInstruction }, rpc) {
+  const tokenProgramAddress = parsedInstruction.programAddress.toString() === import_token3.TOKEN_PROGRAM_ADDRESS.toString() ? import_token3.TOKEN_PROGRAM_ADDRESS : import_token_20223.TOKEN_2022_PROGRAM_ADDRESS;
+  const payToATA = await (0, import_token_20223.findAssociatedTokenPda)({
+    mint: paymentRequirements.asset,
+    owner: paymentRequirements.payTo,
+    tokenProgram: tokenProgramAddress
+  });
+  if (parsedInstruction.accounts.destination.address !== payToATA[0]) {
+    throw new Error(`invalid_exact_svm_payload_transaction_transfer_to_incorrect_ata`);
+  }
+  const addresses = [parsedInstruction.accounts.source.address, payToATA[0]];
+  const maybeAccounts = await (0, import_kit5.fetchEncodedAccounts)(rpc, addresses);
+  const missingAccounts = maybeAccounts.filter((a) => !a.exists);
+  for (const missingAccount of missingAccounts) {
+    if (missingAccount.address === parsedInstruction.accounts.source.address) {
+      throw new Error(`invalid_exact_svm_payload_transaction_sender_ata_not_found`);
+    }
+    if (missingAccount.address === payToATA[0] && !txHasCreateDestATAInstruction) {
+      throw new Error(`invalid_exact_svm_payload_transaction_receiver_ata_not_found`);
+    }
+  }
+  const instructionAmount = parsedInstruction.data.amount;
+  const paymentRequirementsAmount = BigInt(paymentRequirements.maxAmountRequired);
+  if (instructionAmount !== paymentRequirementsAmount) {
+    throw new Error(`invalid_exact_svm_payload_transaction_amount_mismatch`);
+  }
+}
+function getValidatedTransferCheckedInstruction(instruction) {
+  try {
+    (0, import_kit5.assertIsInstructionWithData)(instruction);
+    (0, import_kit5.assertIsInstructionWithAccounts)(instruction);
+  } catch (error) {
+    console.error(error);
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions`);
+  }
+  let tokenInstruction;
+  if (instruction.programAddress.toString() === import_token3.TOKEN_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = (0, import_token3.identifyTokenInstruction)(instruction);
+    if (identifiedInstruction !== import_token3.TokenInstruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked`
+      );
+    }
+    tokenInstruction = (0, import_token3.parseTransferCheckedInstruction)({
+      ...instruction,
+      data: new Uint8Array(instruction.data)
+    });
+  } else if (instruction.programAddress.toString() === import_token_20223.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = (0, import_token_20223.identifyToken2022Instruction)(instruction);
+    if (identifiedInstruction !== import_token_20223.Token2022Instruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked`
+      );
+    }
+    tokenInstruction = (0, import_token_20223.parseTransferCheckedInstruction)({
+      ...instruction,
+      data: new Uint8Array(instruction.data)
+    });
+  } else {
+    throw new Error(`invalid_exact_svm_payload_transaction_not_a_transfer_instruction`);
+  }
+  return tokenInstruction;
+}
+
+// src/schemes/exact/svm/facilitator/settle.ts
+async function settle(signer, payload, paymentRequirements, config2) {
+  const verifyResponse = await verify(signer, payload, paymentRequirements, config2);
+  if (!verifyResponse.isValid) {
+    return {
+      success: false,
+      errorReason: verifyResponse.invalidReason,
+      network: payload.network,
+      transaction: ""
+    };
+  }
+  const svmPayload = payload.payload;
+  const decodedTransaction = decodeTransactionFromPayload(svmPayload);
+  const signedTransaction = await (0, import_kit6.signTransaction)([signer.keyPair], decodedTransaction);
+  const payer = getTokenPayerFromTransaction(decodedTransaction);
+  const rpc = getRpcClient(paymentRequirements.network, config2?.svmConfig?.rpcUrl);
+  const rpcSubscriptions = getRpcSubscriptions(
+    paymentRequirements.network,
+    config2?.svmConfig?.rpcUrl
+  );
+  try {
+    const { success, errorReason, signature } = await sendAndConfirmSignedTransaction(
+      signedTransaction,
+      rpc,
+      rpcSubscriptions
+    );
+    return {
+      success,
+      errorReason,
+      payer,
+      transaction: signature,
+      network: payload.network
+    };
+  } catch (error) {
+    console.error("Unexpected error during transaction settlement:", error);
+    return {
+      success: false,
+      errorReason: "unexpected_settle_error",
+      network: payload.network,
+      transaction: (0, import_kit6.getSignatureFromTransaction)(signedTransaction),
+      payer
+    };
+  }
+}
+async function sendSignedTransaction(signedTransaction, rpc, sendTxConfig = {
+  skipPreflight: true,
+  encoding: "base64"
+}) {
+  const base64EncodedTransaction = (0, import_kit6.getBase64EncodedWireTransaction)(signedTransaction);
+  return await rpc.sendTransaction(base64EncodedTransaction, sendTxConfig).send();
+}
+async function confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
+  const signature = (0, import_kit6.getSignatureFromTransaction)(signedTransaction);
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort("Transaction confirmation timed out after 60 seconds");
+  }, 6e4);
+  try {
+    const compiledTransactionMessage = (0, import_kit6.getCompiledTransactionMessageDecoder)().decode(
+      signedTransaction.messageBytes
+    );
+    const decompiledTransactionMessage = await (0, import_kit6.decompileTransactionMessageFetchingLookupTables)(
+      compiledTransactionMessage,
+      rpc
+    );
+    (0, import_kit6.assertIsTransactionMessageWithBlockhashLifetime)(decompiledTransactionMessage);
+    const signedTransactionWithBlockhashLifetime = {
+      ...signedTransaction,
+      lifetimeConstraint: decompiledTransactionMessage.lifetimeConstraint
+    };
+    const commitment = "confirmed";
+    const getRecentSignatureConfirmationPromise = (0, import_transaction_confirmation.createRecentSignatureConfirmationPromiseFactory)({
+      rpc,
+      rpcSubscriptions
+    });
+    const getBlockHeightExceedencePromise = (0, import_transaction_confirmation.createBlockHeightExceedencePromiseFactory)({
+      rpc,
+      rpcSubscriptions
+    });
+    const config2 = {
+      abortSignal: abortController.signal,
+      commitment,
+      getBlockHeightExceedencePromise,
+      getRecentSignatureConfirmationPromise
+    };
+    await (0, import_transaction_confirmation.waitForRecentTransactionConfirmation)({
+      ...config2,
+      transaction: signedTransactionWithBlockhashLifetime
+    });
+    return {
+      success: true,
+      signature
+    };
+  } catch (error) {
+    console.error(error);
+    if ((0, import_kit6.isSolanaError)(error, import_kit6.SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED)) {
+      return {
+        success: false,
+        errorReason: "settle_exact_svm_block_height_exceeded",
+        signature
+      };
+    } else if (error instanceof DOMException && error.name === "AbortError") {
+      return {
+        success: false,
+        errorReason: "settle_exact_svm_transaction_confirmation_timed_out",
+        signature
+      };
+    } else {
+      throw error;
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sendAndConfirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
+  await sendSignedTransaction(signedTransaction, rpc);
+  return await confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions);
+}
+
+// src/schemes/exact/index.ts
+var SCHEME = "exact";
 
 // src/schemes/exact/evm/eip3009/facilitator.ts
 async function verify2(client, payload, paymentRequirements) {
@@ -2612,7 +2779,7 @@ async function verify2(client, payload, paymentRequirements) {
       payer: exactEvmPayload.authorization.from
     };
   }
-  if ((0, import_viem3.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem3.getAddress)(paymentRequirements.payTo) && (0, import_viem3.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem3.getAddress)(paymentRequirements.extra?.relayer)) {
+  if ((0, import_viem3.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem3.getAddress)(paymentRequirements.payTo)) {
     return {
       isValid: false,
       invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
@@ -2685,57 +2852,36 @@ async function settle2(wallet, paymentPayload, paymentRequirements) {
     };
   }
   const { signature } = (0, import_viem3.parseErc6492Signature)(payload.signature);
-  let tx;
-  if (paymentRequirements.extra?.relayer) {
-    const sig = (0, import_viem3.hexToSignature)(signature);
-    const v = Number(sig.v);
-    const r = sig.r;
-    const s = sig.s;
-    tx = await wallet.writeContract({
-      address: paymentRequirements.extra.relayer,
-      abi: permitProxyContractABI,
-      functionName: "settleWithERC3009",
-      args: [
-        paymentRequirements.asset,
-        // token
-        payload.authorization.from,
-        // payer
-        paymentRequirements.payTo,
-        // seller
-        BigInt(payload.authorization.value),
-        // amount
-        BigInt(payload.authorization.validAfter),
-        // validAfter
-        BigInt(payload.authorization.validBefore),
-        // validBefore
-        payload.authorization.nonce,
-        // nonce
-        v,
-        // v (uint8)
-        r,
-        // r (bytes32)
-        s
-        // s (bytes32)
-      ],
-      chain: wallet.chain
-    });
-  } else {
-    tx = await wallet.writeContract({
-      address: paymentRequirements.asset,
-      abi: usdcABI,
-      functionName: "transferWithAuthorization",
-      args: [
-        payload.authorization.from,
-        payload.authorization.to,
-        BigInt(payload.authorization.value),
-        BigInt(payload.authorization.validAfter),
-        BigInt(payload.authorization.validBefore),
-        payload.authorization.nonce,
-        signature
-      ],
-      chain: wallet.chain
-    });
-  }
+  const sig = (0, import_viem3.hexToSignature)(signature);
+  const v = Number(sig.v);
+  const r = sig.r;
+  const s = sig.s;
+  const tx = await wallet.writeContract({
+    address: paymentRequirements.payTo,
+    abi: EIP7702SellerWalletMinimalAbi,
+    functionName: "settleWithERC3009",
+    args: [
+      paymentRequirements.asset,
+      // token
+      payload.authorization.from,
+      // payer
+      BigInt(payload.authorization.value),
+      // amount
+      BigInt(payload.authorization.validAfter),
+      // validAfter
+      BigInt(payload.authorization.validBefore),
+      // validBefore
+      payload.authorization.nonce,
+      // nonce
+      v,
+      // v (uint8)
+      r,
+      // r (bytes32)
+      s
+      // s (bytes32)
+    ],
+    chain: wallet.chain
+  });
   const receipt = await wallet.waitForTransactionReceipt({ hash: tx });
   if (receipt.status !== "success") {
     return {
@@ -2838,22 +2984,12 @@ async function verify3(client, payload, paymentRequirements) {
       payer: owner
     };
   }
-  if (paymentRequirements.extra?.relayer) {
-    if ((0, import_viem5.getAddress)(spender) !== (0, import_viem5.getAddress)(paymentRequirements.extra?.relayer)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
-  } else {
-    if (client.account && (0, import_viem5.getAddress)(spender) !== (0, import_viem5.getAddress)(client.account.address)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
+  if ((0, import_viem5.getAddress)(spender) !== (0, import_viem5.getAddress)(paymentRequirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_spender_address",
+      payer: owner
+    };
   }
   const balance = await getERC20Balance(client, erc20Address, owner);
   if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
@@ -2896,84 +3032,40 @@ async function settle3(wallet, paymentPayload, paymentRequirements) {
       payer: permitPayload.authorization.owner
     };
   }
-  const { owner, spender, value, deadline } = permitPayload.authorization;
+  const { owner, value, deadline } = permitPayload.authorization;
   const { v, r, s } = splitSignature(permitPayload.signature);
   const tokenAddress = paymentRequirements.asset;
-  const txNonce = await wallet.getTransactionCount({
-    address: wallet.account.address
+  const transactionHash = await wallet.writeContract({
+    address: paymentRequirements.payTo,
+    abi: EIP7702SellerWalletMinimalAbi,
+    functionName: "settleWithPermit",
+    args: [
+      tokenAddress,
+      // token
+      owner,
+      // payer
+      BigInt(value),
+      // amount
+      BigInt(deadline),
+      // deadline
+      v,
+      // v
+      r,
+      // r
+      s
+      // s
+    ],
+    chain: wallet.chain
   });
-  let transactionHash;
-  if (paymentRequirements.extra?.relayer) {
-    transactionHash = await wallet.writeContract({
-      address: paymentRequirements.extra.relayer,
-      abi: permitProxyContractABI,
-      functionName: "settleWithPermit",
-      args: [
-        tokenAddress,
-        // token
-        owner,
-        // payer
-        paymentRequirements.payTo,
-        // seller
-        BigInt(value),
-        // amount
-        BigInt(deadline),
-        // deadline
-        v,
-        // v
-        r,
-        // r
-        s
-        // s
-      ],
-      chain: wallet.chain,
-      nonce: txNonce
-    });
-    const receipt = await wallet.waitForTransactionReceipt({ hash: transactionHash });
-    if (receipt.status !== "success") {
-      return {
-        success: false,
-        errorReason: "transaction_failed",
-        transaction: transactionHash,
-        network: paymentPayload.network,
-        payer: owner
-      };
-    }
-  } else {
-    const [permitTx, transferTx] = await Promise.all([
-      // Call permit to approve the spender
-      wallet.writeContract({
-        address: tokenAddress,
-        abi: erc20PermitABI,
-        functionName: "permit",
-        args: [owner, spender, BigInt(value), BigInt(deadline), v, r, s],
-        chain: wallet.chain,
-        nonce: txNonce
-      }),
-      // Call transferFrom to transfer tokens to payTo address
-      wallet.writeContract({
-        address: tokenAddress,
-        abi: erc20PermitABI,
-        functionName: "transferFrom",
-        args: [owner, paymentRequirements.payTo, BigInt(value)],
-        chain: wallet.chain,
-        nonce: txNonce + 1
-      })
-    ]);
-    const [, receipt] = await Promise.all([
-      wallet.waitForTransactionReceipt({ hash: permitTx }),
-      wallet.waitForTransactionReceipt({ hash: transferTx })
-    ]);
-    if (receipt.status !== "success") {
-      return {
-        success: false,
-        errorReason: "transaction_failed",
-        transaction: transferTx,
-        network: paymentPayload.network,
-        payer: owner
-      };
-    }
-    transactionHash = transferTx;
+  const receipt = await wallet.waitForTransactionReceipt({ hash: transactionHash });
+  if (receipt.status !== "success") {
+    return {
+      success: false,
+      errorReason: "transaction_failed",
+      transaction: transactionHash,
+      network: paymentPayload.network,
+      payer: owner
+    };
   }
   return {
     success: true,