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

package/dist/cjs/facilitator/index.js

@@ -1190,968 +1190,1135 @@ var usdcABI = [
   }
 ];
 
-// 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;
-}
-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"
+      },
       {
-        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: "bytes",
+        name: "",
+        type: "bytes"
       }
-    ];
-    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: "onERC721Received",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
       }
-    }
-  }
-  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/svm/facilitator/settle.ts
-var import_kit5 = require("@solana/kit");
-var import_transaction_confirmation = require("@solana/transaction-confirmation");
-
-// src/schemes/exact/svm/facilitator/verify.ts
-var import_kit4 = require("@solana/kit");
-var import_compute_budget = require("@solana-program/compute-budget");
-var import_token_20222 = require("@solana-program/token-2022");
-var import_token2 = 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;
-            }
-          })()
-        };
+    ],
+    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: "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"
       }
-    }
-    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_kit4.getCompiledTransactionMessageDecoder)().decode(
-    decodedTransaction.messageBytes
-  );
-  const transactionMessage = (0, import_kit4.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,
+    ],
+    name: "settleWithERC3009",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
       {
-        txHasCreateDestATAInstruction: false
+        internalType: "address",
+        name: "payer",
+        type: "address"
       },
-      rpc
-    );
-  } else {
-    verifyCreateATAInstruction(transactionMessage.instructions[2], paymentRequirements);
-    await verifyTransferInstruction(
-      transactionMessage.instructions[3],
-      paymentRequirements,
       {
-        txHasCreateDestATAInstruction: true
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
       },
-      rpc
-    );
-  }
-}
-function verifyComputeLimitInstruction(instruction) {
-  try {
-    if (instruction.programAddress.toString() !== import_compute_budget.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 2) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`
-      );
-    }
-    (0, import_compute_budget.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_budget.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_budget.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_kit4.assertIsInstructionWithAccounts)(instruction);
-    (0, import_kit4.assertIsInstructionWithData)(instruction);
-    createATAInstruction = (0, import_token_20222.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_token2.TOKEN_PROGRAM_ADDRESS.toString() ? import_token2.TOKEN_PROGRAM_ADDRESS : import_token_20222.TOKEN_2022_PROGRAM_ADDRESS;
-  const payToATA = await (0, import_token_20222.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_kit4.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`);
+      {
+        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"
+  },
+  {
+    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"
   }
-}
-function getValidatedTransferCheckedInstruction(instruction) {
-  try {
-    (0, import_kit4.assertIsInstructionWithData)(instruction);
-    (0, import_kit4.assertIsInstructionWithAccounts)(instruction);
-  } catch (error) {
-    console.error(error);
-    throw new Error(`invalid_exact_svm_payload_transaction_instructions`);
+];
+
+// 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);
   }
-  let tokenInstruction;
-  if (instruction.programAddress.toString() === import_token2.TOKEN_PROGRAM_ADDRESS.toString()) {
-    const identifiedInstruction = (0, import_token2.identifyTokenInstruction)(instruction);
-    if (identifiedInstruction !== import_token2.TokenInstruction.TransferChecked) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked`
-      );
-    }
-    tokenInstruction = (0, import_token2.parseTransferCheckedInstruction)({
-      ...instruction,
-      data: new Uint8Array(instruction.data)
-    });
-  } else if (instruction.programAddress.toString() === import_token_20222.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
-    const identifiedInstruction = (0, import_token_20222.identifyToken2022Instruction)(instruction);
-    if (identifiedInstruction !== import_token_20222.Token2022Instruction.TransferChecked) {
-      throw new Error(
-        `invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked`
-      );
-    }
-    tokenInstruction = (0, import_token_20222.parseTransferCheckedInstruction)({
-      ...instruction,
-      data: new Uint8Array(instruction.data)
-    });
-  } else {
-    throw new Error(`invalid_exact_svm_payload_transaction_not_a_transfer_instruction`);
+  if (SvmNetworkToChainId.has(network)) {
+    return SvmNetworkToChainId.get(network);
   }
-  return tokenInstruction;
+  throw new Error(`Unsupported network: ${network}`);
 }
 
-// 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_kit5.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_kit5.getSignatureFromTransaction)(signedTransaction),
-      payer
-    };
-  }
-}
-async function sendSignedTransaction(signedTransaction, rpc, sendTxConfig = {
-  skipPreflight: true,
-  encoding: "base64"
-}) {
-  const base64EncodedTransaction = (0, import_kit5.getBase64EncodedWireTransaction)(signedTransaction);
-  return await rpc.sendTransaction(base64EncodedTransaction, sendTxConfig).send();
+// 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 confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
-  const signature = (0, import_kit5.getSignatureFromTransaction)(signedTransaction);
-  const abortController = new AbortController();
-  const timeout = setTimeout(() => {
-    abortController.abort("Transaction confirmation timed out after 60 seconds");
-  }, 6e4);
+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 compiledTransactionMessage = (0, import_kit5.getCompiledTransactionMessageDecoder)().decode(
-      signedTransaction.messageBytes
-    );
-    const decompiledTransactionMessage = await (0, import_kit5.decompileTransactionMessageFetchingLookupTables)(
-      compiledTransactionMessage,
-      rpc
-    );
-    (0, import_kit5.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 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"
+      }
+    ];
+    const result = await client.readContract({
+      address,
+      abi: eip712DomainABI,
+      functionName: "eip712Domain"
     });
-    return {
-      success: true,
-      signature
-    };
-  } catch (error) {
-    console.error(error);
-    if ((0, import_kit5.isSolanaError)(error, import_kit5.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;
+    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}`
+      );
     }
-  } finally {
-    clearTimeout(timeout);
   }
+  versionCache.set(cacheKey, version);
+  return version;
 }
-async function sendAndConfirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
-  await sendSignedTransaction(signedTransaction, rpc);
-  return await confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions);
-}
-
-// src/schemes/exact/svm/client.ts
-var import_kit6 = require("@solana/kit");
-var import_token_20223 = require("@solana-program/token-2022");
-var import_token3 = require("@solana-program/token");
-var import_compute_budget2 = require("@solana-program/compute-budget");
 
-// src/schemes/exact/index.ts
-var SCHEME = "exact";
+// 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/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"
+// 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: "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"
+    }
+  }
+  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/svm/facilitator/settle.ts
+var import_kit5 = require("@solana/kit");
+var import_transaction_confirmation = require("@solana/transaction-confirmation");
+
+// src/schemes/exact/svm/facilitator/verify.ts
+var import_kit4 = require("@solana/kit");
+var import_compute_budget = require("@solana-program/compute-budget");
+var import_token_20222 = require("@solana-program/token-2022");
+var import_token2 = 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;
+            }
+          })()
+        };
       }
-    ],
-    name: "SettledSplit",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "payer",
-        type: "address"
-      },
+    }
+    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_kit4.getCompiledTransactionMessageDecoder)().decode(
+    decodedTransaction.messageBytes
+  );
+  const transactionMessage = (0, import_kit4.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_budget.COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 2) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`
+      );
+    }
+    (0, import_compute_budget.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_budget.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_budget.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_kit4.assertIsInstructionWithAccounts)(instruction);
+    (0, import_kit4.assertIsInstructionWithData)(instruction);
+    createATAInstruction = (0, import_token_20222.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_token2.TOKEN_PROGRAM_ADDRESS.toString() ? import_token2.TOKEN_PROGRAM_ADDRESS : import_token_20222.TOKEN_2022_PROGRAM_ADDRESS;
+  const payToATA = await (0, import_token_20222.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_kit4.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_kit4.assertIsInstructionWithData)(instruction);
+    (0, import_kit4.assertIsInstructionWithAccounts)(instruction);
+  } catch (error) {
+    console.error(error);
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions`);
+  }
+  let tokenInstruction;
+  if (instruction.programAddress.toString() === import_token2.TOKEN_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = (0, import_token2.identifyTokenInstruction)(instruction);
+    if (identifiedInstruction !== import_token2.TokenInstruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked`
+      );
+    }
+    tokenInstruction = (0, import_token2.parseTransferCheckedInstruction)({
+      ...instruction,
+      data: new Uint8Array(instruction.data)
+    });
+  } else if (instruction.programAddress.toString() === import_token_20222.TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = (0, import_token_20222.identifyToken2022Instruction)(instruction);
+    if (identifiedInstruction !== import_token_20222.Token2022Instruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked`
+      );
+    }
+    tokenInstruction = (0, import_token_20222.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_kit5.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_kit5.getSignatureFromTransaction)(signedTransaction),
+      payer
+    };
+  }
+}
+async function sendSignedTransaction(signedTransaction, rpc, sendTxConfig = {
+  skipPreflight: true,
+  encoding: "base64"
+}) {
+  const base64EncodedTransaction = (0, import_kit5.getBase64EncodedWireTransaction)(signedTransaction);
+  return await rpc.sendTransaction(base64EncodedTransaction, sendTxConfig).send();
+}
+async function confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
+  const signature = (0, import_kit5.getSignatureFromTransaction)(signedTransaction);
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort("Transaction confirmation timed out after 60 seconds");
+  }, 6e4);
+  try {
+    const compiledTransactionMessage = (0, import_kit5.getCompiledTransactionMessageDecoder)().decode(
+      signedTransaction.messageBytes
+    );
+    const decompiledTransactionMessage = await (0, import_kit5.decompileTransactionMessageFetchingLookupTables)(
+      compiledTransactionMessage,
+      rpc
+    );
+    (0, import_kit5.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_kit5.isSolanaError)(error, import_kit5.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/svm/client.ts
+var import_kit6 = require("@solana/kit");
+var import_token_20223 = require("@solana-program/token-2022");
+var import_token3 = require("@solana-program/token");
+var import_compute_budget2 = require("@solana-program/compute-budget");
+
+// src/schemes/exact/index.ts
+var SCHEME = "exact";
 
 // src/schemes/exact/evm/eip3009/facilitator.ts
 async function verify2(client, payload, paymentRequirements) {
@@ -2217,7 +2384,7 @@ async function verify2(client, payload, paymentRequirements) {
       payer: exactEvmPayload.authorization.from
     };
   }
-  if ((0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.payTo) && (0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.extra?.relayer)) {
+  if ((0, import_viem2.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem2.getAddress)(paymentRequirements.payTo)) {
     return {
       isValid: false,
       invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
@@ -2290,57 +2457,36 @@ async function settle2(wallet, paymentPayload, paymentRequirements) {
     };
   }
   const { signature } = (0, import_viem2.parseErc6492Signature)(payload.signature);
-  let tx;
-  if (paymentRequirements.extra?.relayer) {
-    const sig = (0, import_viem2.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_viem2.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 {
@@ -2443,22 +2589,12 @@ async function verify3(client, payload, paymentRequirements) {
       payer: owner
     };
   }
-  if (paymentRequirements.extra?.relayer) {
-    if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.extra?.relayer)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
-  } else {
-    if (client.account && (0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(client.account.address)) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_spender_address",
-        payer: owner
-      };
-    }
+  if ((0, import_viem4.getAddress)(spender) !== (0, import_viem4.getAddress)(paymentRequirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_spender_address",
+      payer: owner
+    };
   }
   const balance = await getERC20Balance(client, erc20Address, owner);
   if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
@@ -2501,84 +2637,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,