@wtflabs/x402 0.0.1-beta.0

package/dist/esm/chunk-57UEJN5U.mjs

@@ -0,0 +1,1416 @@
+import {
+  createAndSignPayment,
+  createNonce,
+  createPayment,
+  createPaymentHeader,
+  createPaymentHeader2,
+  decodePayment,
+  encodePayment,
+  preparePaymentHeader,
+  signAuthorization,
+  signPaymentHeader
+} from "./chunk-RX2JKK4O.mjs";
+import {
+  ErrorReasons,
+  PERMIT2_ADDRESS,
+  SupportedSVMNetworks,
+  authorizationTypes,
+  decodeTransactionFromPayload,
+  erc20PermitABI,
+  getNetworkId,
+  getRpcClient,
+  getRpcSubscriptions,
+  getTokenPayerFromTransaction,
+  isSignerWallet,
+  permit2ABI,
+  permit2Types,
+  permitTypes,
+  signAndSimulateTransaction
+} from "./chunk-UCBE7FDY.mjs";
+import {
+  getERC20Allowance,
+  getERC20Balance,
+  getVersion,
+  usdcABI
+} from "./chunk-5LTKIVOA.mjs";
+import {
+  __export,
+  config
+} from "./chunk-AQQR4PXH.mjs";
+
+// src/schemes/exact/index.ts
+var exact_exports = {};
+__export(exact_exports, {
+  SCHEME: () => SCHEME,
+  evm: () => evm_exports,
+  svm: () => svm_exports
+});
+
+// src/schemes/exact/evm/index.ts
+var evm_exports = {};
+__export(evm_exports, {
+  decodePayment: () => decodePayment,
+  eip3009: () => eip3009_exports,
+  encodePayment: () => encodePayment,
+  permit: () => permit_exports,
+  permit2: () => permit2_exports,
+  settle: () => settle4,
+  verify: () => verify4
+});
+
+// src/schemes/exact/evm/eip3009/facilitator.ts
+import { getAddress, parseErc6492Signature } from "viem";
+async function verify(client, payload, paymentRequirements) {
+  const exactEvmPayload = payload.payload;
+  if (exactEvmPayload.authorizationType !== "eip3009") {
+    return {
+      isValid: false,
+      invalidReason: "unsupported_authorization_type",
+      payer: ""
+    };
+  }
+  if (payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
+    return {
+      isValid: false,
+      invalidReason: `unsupported_scheme`,
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  let name;
+  let chainId;
+  let erc20Address;
+  let version;
+  try {
+    chainId = getNetworkId(payload.network);
+    name = paymentRequirements.extra?.name ?? config[chainId.toString()].usdcName;
+    erc20Address = paymentRequirements.asset;
+    version = paymentRequirements.extra?.version ?? await getVersion(client, erc20Address);
+  } catch {
+    return {
+      isValid: false,
+      invalidReason: `invalid_network`,
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  const permitTypedData = {
+    types: authorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: erc20Address
+    },
+    message: {
+      from: exactEvmPayload.authorization.from,
+      to: exactEvmPayload.authorization.to,
+      value: exactEvmPayload.authorization.value,
+      validAfter: exactEvmPayload.authorization.validAfter,
+      validBefore: exactEvmPayload.authorization.validBefore,
+      nonce: exactEvmPayload.authorization.nonce
+    }
+  };
+  const recoveredAddress = await client.verifyTypedData({
+    address: exactEvmPayload.authorization.from,
+    ...permitTypedData,
+    signature: exactEvmPayload.signature
+  });
+  if (!recoveredAddress) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_signature",
+      //"Invalid permit signature",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  if (getAddress(exactEvmPayload.authorization.to) !== getAddress(paymentRequirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  if (BigInt(exactEvmPayload.authorization.validBefore) < BigInt(Math.floor(Date.now() / 1e3) + 6)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_authorization_valid_before",
+      //"Deadline on permit isn't far enough in the future",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  if (BigInt(exactEvmPayload.authorization.validAfter) > BigInt(Math.floor(Date.now() / 1e3))) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_authorization_valid_after",
+      //"Deadline on permit is in the future",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  const balance = await getERC20Balance(
+    client,
+    erc20Address,
+    exactEvmPayload.authorization.from
+  );
+  if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "insufficient_funds",
+      //"Client does not have enough funds",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  if (BigInt(exactEvmPayload.authorization.value) < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_authorization_value",
+      //"Value in payload is not enough to cover paymentRequirements.maxAmountRequired",
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  return {
+    isValid: true,
+    invalidReason: void 0,
+    payer: exactEvmPayload.authorization.from
+  };
+}
+async function settle(wallet, paymentPayload, paymentRequirements) {
+  const payload = paymentPayload.payload;
+  if (payload.authorizationType !== "eip3009") {
+    return {
+      success: false,
+      errorReason: "unsupported_authorization_type",
+      transaction: "",
+      network: paymentPayload.network,
+      payer: ""
+    };
+  }
+  const valid = await verify(wallet, paymentPayload, paymentRequirements);
+  if (!valid.isValid) {
+    return {
+      success: false,
+      network: paymentPayload.network,
+      transaction: "",
+      errorReason: valid.invalidReason ?? "invalid_scheme",
+      //`Payment is no longer valid: ${valid.invalidReason}`,
+      payer: payload.authorization.from
+    };
+  }
+  const { signature } = parseErc6492Signature(payload.signature);
+  const 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 receipt = await wallet.waitForTransactionReceipt({ hash: tx });
+  if (receipt.status !== "success") {
+    return {
+      success: false,
+      errorReason: "invalid_transaction_state",
+      //`Transaction failed`,
+      transaction: tx,
+      network: paymentPayload.network,
+      payer: payload.authorization.from
+    };
+  }
+  return {
+    success: true,
+    transaction: tx,
+    network: paymentPayload.network,
+    payer: payload.authorization.from
+  };
+}
+
+// src/schemes/exact/evm/permit/facilitator.ts
+import { getAddress as getAddress3 } from "viem";
+
+// src/schemes/exact/evm/permit/sign.ts
+import { getAddress as getAddress2 } from "viem";
+async function signPermit(walletClient, { owner, spender, value, deadline }, { asset, network }) {
+  const chainId = getNetworkId(network);
+  const tokenAddress = getAddress2(asset);
+  let nonce;
+  let name;
+  let version;
+  if (isSignerWallet(walletClient)) {
+    [nonce, name, version] = await Promise.all([
+      walletClient.readContract({
+        address: tokenAddress,
+        abi: erc20PermitABI,
+        functionName: "nonces",
+        args: [getAddress2(owner)]
+      }),
+      walletClient.readContract({
+        address: tokenAddress,
+        abi: erc20PermitABI,
+        functionName: "name"
+      }),
+      walletClient.readContract({
+        address: tokenAddress,
+        abi: erc20PermitABI,
+        functionName: "version"
+      })
+    ]);
+  } else {
+    throw new Error("Local account signing for permit requires a connected client");
+  }
+  const data = {
+    types: permitTypes,
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: tokenAddress
+    },
+    primaryType: "Permit",
+    message: {
+      owner: getAddress2(owner),
+      spender: getAddress2(spender),
+      value,
+      nonce,
+      deadline
+    }
+  };
+  if (isSignerWallet(walletClient)) {
+    const signature = await walletClient.signTypedData(data);
+    return {
+      signature,
+      nonce: nonce.toString()
+    };
+  }
+  const account = walletClient;
+  if (account.signTypedData) {
+    const signature = await account.signTypedData(data);
+    return {
+      signature,
+      nonce: nonce.toString()
+    };
+  }
+  throw new Error("Invalid wallet client provided does not support signTypedData");
+}
+function splitSignature(signature) {
+  const sig = signature.slice(2);
+  const r = `0x${sig.slice(0, 64)}`;
+  const s = `0x${sig.slice(64, 128)}`;
+  let v = parseInt(sig.slice(128, 130), 16);
+  if (v < 27) {
+    v += 27;
+  }
+  return { v, r, s };
+}
+
+// src/types/shared/evm/permitProxyABI.ts
+var permitProxyContractABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        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"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "permitAndTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/schemes/exact/evm/permit/facilitator.ts
+async function verify2(client, payload, paymentRequirements) {
+  if (payload.payload.authorizationType !== "permit" || payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
+    return {
+      isValid: false,
+      invalidReason: "unsupported_scheme"
+    };
+  }
+  const permitPayload = payload.payload;
+  const { owner, spender, value, deadline, nonce } = permitPayload.authorization;
+  let name;
+  let version;
+  let erc20Address;
+  let chainId;
+  try {
+    chainId = getNetworkId(payload.network);
+    erc20Address = paymentRequirements.asset;
+    name = paymentRequirements.extra?.name ?? await client.readContract({
+      address: erc20Address,
+      abi: erc20PermitABI,
+      functionName: "name"
+    });
+    version = paymentRequirements.extra?.version ?? await getVersion(client, erc20Address);
+  } catch {
+    return {
+      isValid: false,
+      invalidReason: "invalid_network",
+      payer: owner
+    };
+  }
+  const permitTypedData = {
+    types: permitTypes,
+    domain: {
+      name,
+      version,
+      chainId,
+      verifyingContract: erc20Address
+    },
+    primaryType: "Permit",
+    message: {
+      owner: getAddress3(owner),
+      spender: getAddress3(spender),
+      value,
+      nonce,
+      deadline
+    }
+  };
+  const recoveredAddress = await client.verifyTypedData({
+    address: owner,
+    ...permitTypedData,
+    signature: permitPayload.signature
+  });
+  if (!recoveredAddress) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_permit_signature",
+      payer: owner
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(deadline) < now) {
+    return {
+      isValid: false,
+      invalidReason: "permit_expired",
+      payer: owner
+    };
+  }
+  if (paymentRequirements.extra?.proxyAddress) {
+    if (getAddress3(spender) !== getAddress3(paymentRequirements.extra?.proxyAddress)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_spender_address",
+        payer: owner
+      };
+    }
+  } else {
+    if (client.account && getAddress3(spender) !== getAddress3(client.account.address)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_spender_address",
+        payer: owner
+      };
+    }
+  }
+  const balance = await getERC20Balance(client, erc20Address, owner);
+  if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "insufficient_funds",
+      payer: owner
+    };
+  }
+  if (BigInt(value) < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_authorization_value",
+      payer: owner
+    };
+  }
+  return {
+    isValid: true,
+    payer: owner
+  };
+}
+async function settle2(wallet, paymentPayload, paymentRequirements) {
+  const permitPayload = paymentPayload.payload;
+  if (permitPayload.authorizationType !== "permit") {
+    return {
+      success: false,
+      errorReason: "invalid_authorization_type",
+      transaction: "",
+      network: paymentPayload.network,
+      payer: ""
+    };
+  }
+  const valid = await verify2(wallet, paymentPayload, paymentRequirements);
+  if (!valid.isValid) {
+    return {
+      success: false,
+      network: paymentPayload.network,
+      transaction: "",
+      errorReason: valid.invalidReason ?? "invalid_payment",
+      payer: permitPayload.authorization.owner
+    };
+  }
+  const { owner, spender, value, deadline } = permitPayload.authorization;
+  const { v, r, s } = splitSignature(permitPayload.signature);
+  const tokenAddress = paymentRequirements.asset;
+  const txNonce = await wallet.getTransactionCount({
+    address: wallet.account.address
+  });
+  let transactionHash;
+  if (paymentRequirements.extra?.proxyAddress) {
+    transactionHash = await wallet.writeContract({
+      address: paymentRequirements.extra.proxyAddress,
+      abi: permitProxyContractABI,
+      functionName: "permitAndTransfer",
+      args: [
+        tokenAddress,
+        owner,
+        spender,
+        BigInt(value),
+        BigInt(deadline),
+        v,
+        r,
+        s,
+        paymentRequirements.payTo
+      ],
+      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;
+  }
+  return {
+    success: true,
+    transaction: transactionHash,
+    network: paymentPayload.network,
+    payer: owner
+  };
+}
+
+// src/schemes/exact/evm/permit2/facilitator.ts
+import { getAddress as getAddress4 } from "viem";
+async function verify3(client, payload, paymentRequirements) {
+  if (payload.payload.authorizationType !== "permit2" || payload.scheme !== SCHEME || paymentRequirements.scheme !== SCHEME) {
+    return {
+      isValid: false,
+      invalidReason: "unsupported_scheme"
+    };
+  }
+  const permit2Payload = payload.payload;
+  const { owner, spender, token, amount, deadline, nonce } = permit2Payload.authorization;
+  const chainId = getNetworkId(payload.network);
+  const tokenAddress = getAddress4(token);
+  const ownerAddress = getAddress4(owner);
+  const permit2TypedData = {
+    types: permit2Types,
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    primaryType: "PermitTransferFrom",
+    message: {
+      permitted: {
+        token: tokenAddress,
+        amount
+      },
+      spender: getAddress4(spender),
+      nonce,
+      deadline
+    }
+  };
+  const recoveredAddress = await client.verifyTypedData({
+    address: ownerAddress,
+    ...permit2TypedData,
+    signature: permit2Payload.signature
+  });
+  if (!recoveredAddress) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_permit2_signature",
+      payer: owner
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(deadline) < now) {
+    return {
+      isValid: false,
+      invalidReason: "permit2_expired",
+      payer: owner
+    };
+  }
+  if (client.account && getAddress4(spender) !== getAddress4(client.account.address)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_spender_address",
+      payer: owner
+    };
+  }
+  if (tokenAddress.toLowerCase() !== paymentRequirements.asset.toLowerCase()) {
+    return {
+      isValid: false,
+      invalidReason: "token_mismatch",
+      payer: owner
+    };
+  }
+  const allowance = await getERC20Allowance(client, tokenAddress, ownerAddress, PERMIT2_ADDRESS);
+  if (allowance < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "permit2_not_approved",
+      payer: owner
+    };
+  }
+  const balance = await getERC20Balance(client, tokenAddress, ownerAddress);
+  if (balance < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "insufficient_funds",
+      payer: owner
+    };
+  }
+  if (BigInt(amount) < BigInt(paymentRequirements.maxAmountRequired)) {
+    return {
+      isValid: false,
+      invalidReason: "invalid_exact_evm_payload_authorization_value",
+      payer: owner
+    };
+  }
+  return {
+    isValid: true,
+    payer: owner
+  };
+}
+async function settle3(wallet, paymentPayload, paymentRequirements) {
+  const permit2Payload = paymentPayload.payload;
+  if (permit2Payload.authorizationType !== "permit2") {
+    return {
+      success: false,
+      errorReason: "invalid_authorization_type",
+      transaction: "",
+      network: paymentPayload.network,
+      payer: ""
+    };
+  }
+  const valid = await verify3(wallet, paymentPayload, paymentRequirements);
+  if (!valid.isValid) {
+    return {
+      success: false,
+      network: paymentPayload.network,
+      transaction: "",
+      errorReason: valid.invalidReason ?? "invalid_payment",
+      payer: permit2Payload.authorization.owner
+    };
+  }
+  const { owner, token, amount, deadline, nonce } = permit2Payload.authorization;
+  const tokenAddress = getAddress4(token);
+  const ownerAddress = getAddress4(owner);
+  const tx = await wallet.writeContract({
+    address: PERMIT2_ADDRESS,
+    abi: permit2ABI,
+    functionName: "permitTransferFrom",
+    args: [
+      {
+        permitted: {
+          token: tokenAddress,
+          amount: BigInt(amount)
+        },
+        nonce: BigInt(nonce),
+        deadline: BigInt(deadline)
+      },
+      {
+        to: paymentRequirements.payTo,
+        requestedAmount: BigInt(amount)
+      },
+      ownerAddress,
+      permit2Payload.signature
+    ],
+    chain: wallet.chain
+  });
+  const receipt = await wallet.waitForTransactionReceipt({ hash: tx });
+  if (receipt.status !== "success") {
+    return {
+      success: false,
+      errorReason: "transaction_failed",
+      transaction: tx,
+      network: paymentPayload.network,
+      payer: owner
+    };
+  }
+  return {
+    success: true,
+    transaction: tx,
+    network: paymentPayload.network,
+    payer: owner
+  };
+}
+
+// src/schemes/exact/evm/eip3009/index.ts
+var eip3009_exports = {};
+__export(eip3009_exports, {
+  createNonce: () => createNonce,
+  createPayment: () => createPayment,
+  createPaymentHeader: () => createPaymentHeader,
+  preparePaymentHeader: () => preparePaymentHeader,
+  settle: () => settle,
+  signAuthorization: () => signAuthorization,
+  signPaymentHeader: () => signPaymentHeader,
+  verify: () => verify
+});
+
+// src/schemes/exact/evm/permit/index.ts
+var permit_exports = {};
+__export(permit_exports, {
+  createPayment: () => createPayment2,
+  createPaymentHeader: () => createPaymentHeader3,
+  preparePaymentHeader: () => preparePaymentHeader2,
+  settle: () => settle2,
+  signPaymentHeader: () => signPaymentHeader2,
+  signPermit: () => signPermit,
+  splitSignature: () => splitSignature,
+  verify: () => verify2
+});
+
+// src/schemes/exact/evm/permit/client.ts
+function preparePaymentHeader2(from, x402Version, paymentRequirements) {
+  const deadline = BigInt(
+    Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds)
+  ).toString();
+  return {
+    x402Version,
+    scheme: paymentRequirements.scheme,
+    network: paymentRequirements.network,
+    payload: {
+      authorizationType: "permit",
+      signature: void 0,
+      authorization: {
+        owner: from,
+        spender: paymentRequirements.payTo,
+        value: paymentRequirements.maxAmountRequired,
+        deadline
+      }
+    }
+  };
+}
+async function signPaymentHeader2(client, paymentRequirements, unsignedPaymentHeader) {
+  const { owner, spender, value, deadline } = unsignedPaymentHeader.payload.authorization;
+  const { signature, nonce } = await signPermit(
+    client,
+    { owner, spender, value, deadline },
+    paymentRequirements
+  );
+  return {
+    ...unsignedPaymentHeader,
+    payload: {
+      authorizationType: "permit",
+      signature,
+      authorization: {
+        owner,
+        spender,
+        value,
+        deadline,
+        nonce: nonce.toString()
+      }
+    }
+  };
+}
+async function createPayment2(client, x402Version, paymentRequirements) {
+  const from = isSignerWallet(client) ? client.account.address : client.address;
+  const unsignedPaymentHeader = preparePaymentHeader2(from, x402Version, paymentRequirements);
+  return signPaymentHeader2(client, paymentRequirements, unsignedPaymentHeader);
+}
+async function createPaymentHeader3(client, x402Version, paymentRequirements) {
+  const payment = await createPayment2(client, x402Version, paymentRequirements);
+  return encodePayment(payment);
+}
+
+// src/schemes/exact/evm/permit2/index.ts
+var permit2_exports = {};
+__export(permit2_exports, {
+  createPayment: () => createPayment3,
+  createPaymentHeader: () => createPaymentHeader4,
+  createPermit2Nonce: () => createPermit2Nonce,
+  preparePaymentHeader: () => preparePaymentHeader3,
+  settle: () => settle3,
+  signPaymentHeader: () => signPaymentHeader3,
+  signPermit2: () => signPermit2,
+  verify: () => verify3
+});
+
+// src/schemes/exact/evm/permit2/sign.ts
+import { getAddress as getAddress5 } from "viem";
+async function signPermit2(walletClient, { owner, spender, token, amount, deadline }, { network }) {
+  const chainId = getNetworkId(network);
+  const tokenAddress = getAddress5(token);
+  const ownerAddress = getAddress5(owner);
+  const spenderAddress = getAddress5(spender);
+  const nonce = await createPermit2Nonce(walletClient, ownerAddress);
+  const data = {
+    types: permit2Types,
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    primaryType: "PermitTransferFrom",
+    message: {
+      permitted: {
+        token: tokenAddress,
+        amount: BigInt(amount)
+      },
+      spender: spenderAddress,
+      nonce,
+      deadline: BigInt(deadline)
+    }
+  };
+  if (isSignerWallet(walletClient)) {
+    const signature = await walletClient.signTypedData(data);
+    return {
+      signature,
+      nonce: nonce.toString()
+    };
+  }
+  const account = walletClient;
+  if (account.signTypedData) {
+    const signature = await account.signTypedData(data);
+    return {
+      signature,
+      nonce: nonce.toString()
+    };
+  }
+  throw new Error("Invalid wallet client provided does not support signTypedData");
+}
+async function createPermit2Nonce(walletClient, ownerAddress) {
+  if (!isSignerWallet(walletClient)) {
+    throw new Error("Local account signing for permit2 requires a connected client");
+  }
+  const timestamp = BigInt(Math.floor(Date.now() / 1e3));
+  const randomOffset = BigInt(Math.floor(Math.random() * 1e3));
+  let nonce = timestamp * 1000n + randomOffset;
+  try {
+    const wordPos = nonce / 256n;
+    const bitIndex = nonce % 256n;
+    const bitmap = await walletClient.readContract({
+      address: PERMIT2_ADDRESS,
+      abi: permit2ABI,
+      functionName: "nonceBitmap",
+      args: [ownerAddress, wordPos]
+    });
+    const used = bitmap >> bitIndex & 1n;
+    if (used === 1n) {
+      nonce += 1n;
+    }
+  } catch (error) {
+    console.warn("Could not check nonce bitmap, using timestamp-based nonce:", error);
+  }
+  return nonce;
+}
+
+// src/schemes/exact/evm/permit2/client.ts
+function preparePaymentHeader3(from, x402Version, paymentRequirements) {
+  const deadline = BigInt(
+    Math.floor(Date.now() / 1e3 + paymentRequirements.maxTimeoutSeconds)
+  ).toString();
+  return {
+    x402Version,
+    scheme: paymentRequirements.scheme,
+    network: paymentRequirements.network,
+    payload: {
+      authorizationType: "permit2",
+      signature: void 0,
+      authorization: {
+        owner: from,
+        spender: paymentRequirements.payTo,
+        token: paymentRequirements.asset,
+        amount: paymentRequirements.maxAmountRequired,
+        deadline
+      }
+    }
+  };
+}
+async function signPaymentHeader3(client, paymentRequirements, unsignedPaymentHeader) {
+  const { owner, spender, token, amount, deadline } = unsignedPaymentHeader.payload.authorization;
+  const { signature, nonce } = await signPermit2(
+    client,
+    { owner, spender, token, amount, deadline },
+    paymentRequirements
+  );
+  return {
+    ...unsignedPaymentHeader,
+    payload: {
+      authorizationType: "permit2",
+      signature,
+      authorization: {
+        owner,
+        spender,
+        token,
+        amount,
+        deadline,
+        nonce
+      }
+    }
+  };
+}
+async function createPayment3(client, x402Version, paymentRequirements) {
+  const from = isSignerWallet(client) ? client.account.address : client.address;
+  const unsignedPaymentHeader = preparePaymentHeader3(from, x402Version, paymentRequirements);
+  return signPaymentHeader3(client, paymentRequirements, unsignedPaymentHeader);
+}
+async function createPaymentHeader4(client, x402Version, paymentRequirements) {
+  const payment = await createPayment3(client, x402Version, paymentRequirements);
+  return encodePayment(payment);
+}
+
+// src/schemes/exact/evm/index.ts
+async function verify4(client, payload, paymentRequirements) {
+  const exactEvmPayload = payload.payload;
+  switch (exactEvmPayload.authorizationType) {
+    case "eip3009":
+      return verify(
+        client,
+        payload,
+        paymentRequirements
+      );
+    case "permit":
+      return verify2(client, payload, paymentRequirements);
+    case "permit2":
+      return verify3(
+        client,
+        payload,
+        paymentRequirements
+      );
+    default:
+      return {
+        isValid: false,
+        invalidReason: "unsupported_authorization_type",
+        payer: ""
+      };
+  }
+}
+async function settle4(wallet, paymentPayload, paymentRequirements) {
+  const payload = paymentPayload.payload;
+  switch (payload.authorizationType) {
+    case "eip3009":
+      return settle(
+        wallet,
+        paymentPayload,
+        paymentRequirements
+      );
+    case "permit":
+      return settle2(
+        wallet,
+        paymentPayload,
+        paymentRequirements
+      );
+    case "permit2":
+      return settle3(
+        wallet,
+        paymentPayload,
+        paymentRequirements
+      );
+    default:
+      return {
+        success: false,
+        errorReason: "unsupported_authorization_type",
+        transaction: "",
+        network: paymentPayload.network,
+        payer: ""
+      };
+  }
+}
+
+// src/schemes/exact/svm/index.ts
+var svm_exports = {};
+__export(svm_exports, {
+  confirmSignedTransaction: () => confirmSignedTransaction,
+  createAndSignPayment: () => createAndSignPayment,
+  createPaymentHeader: () => createPaymentHeader2,
+  getValidatedTransferCheckedInstruction: () => getValidatedTransferCheckedInstruction,
+  sendAndConfirmSignedTransaction: () => sendAndConfirmSignedTransaction,
+  sendSignedTransaction: () => sendSignedTransaction,
+  settle: () => settle5,
+  transactionIntrospection: () => transactionIntrospection,
+  verify: () => verify5,
+  verifyComputeLimitInstruction: () => verifyComputeLimitInstruction,
+  verifyComputePriceInstruction: () => verifyComputePriceInstruction,
+  verifyCreateATAInstruction: () => verifyCreateATAInstruction,
+  verifySchemesAndNetworks: () => verifySchemesAndNetworks,
+  verifyTransactionInstructions: () => verifyTransactionInstructions,
+  verifyTransferCheckedInstruction: () => verifyTransferCheckedInstruction,
+  verifyTransferInstruction: () => verifyTransferInstruction
+});
+
+// src/schemes/exact/svm/facilitator/settle.ts
+import {
+  assertIsTransactionMessageWithBlockhashLifetime,
+  decompileTransactionMessageFetchingLookupTables,
+  getBase64EncodedWireTransaction,
+  getCompiledTransactionMessageDecoder as getCompiledTransactionMessageDecoder2,
+  getSignatureFromTransaction,
+  isSolanaError,
+  signTransaction,
+  SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED
+} from "@solana/kit";
+import {
+  createBlockHeightExceedencePromiseFactory,
+  waitForRecentTransactionConfirmation,
+  createRecentSignatureConfirmationPromiseFactory
+} from "@solana/transaction-confirmation";
+
+// src/schemes/exact/svm/facilitator/verify.ts
+import {
+  assertIsInstructionWithAccounts,
+  assertIsInstructionWithData,
+  decompileTransactionMessage,
+  fetchEncodedAccounts,
+  getCompiledTransactionMessageDecoder
+} from "@solana/kit";
+import {
+  parseSetComputeUnitLimitInstruction,
+  parseSetComputeUnitPriceInstruction,
+  COMPUTE_BUDGET_PROGRAM_ADDRESS
+} from "@solana-program/compute-budget";
+import {
+  findAssociatedTokenPda,
+  identifyToken2022Instruction,
+  parseCreateAssociatedTokenInstruction,
+  parseTransferCheckedInstruction as parseTransferCheckedInstruction2022,
+  Token2022Instruction,
+  TOKEN_2022_PROGRAM_ADDRESS
+} from "@solana-program/token-2022";
+import {
+  identifyTokenInstruction,
+  parseTransferCheckedInstruction as parseTransferCheckedInstructionToken,
+  TOKEN_PROGRAM_ADDRESS,
+  TokenInstruction
+} from "@solana-program/token";
+async function verify5(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 = getCompiledTransactionMessageDecoder().decode(
+    decodedTransaction.messageBytes
+  );
+  const transactionMessage = 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,
+      {
+        txHasCreateDestATAInstruction: false
+      },
+      rpc
+    );
+  } else {
+    verifyCreateATAInstruction(transactionMessage.instructions[2], paymentRequirements);
+    await verifyTransferInstruction(
+      transactionMessage.instructions[3],
+      paymentRequirements,
+      {
+        txHasCreateDestATAInstruction: true
+      },
+      rpc
+    );
+  }
+}
+function verifyComputeLimitInstruction(instruction) {
+  try {
+    if (instruction.programAddress.toString() !== COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 2) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instructions_compute_limit_instruction`
+      );
+    }
+    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() !== COMPUTE_BUDGET_PROGRAM_ADDRESS.toString() || instruction.data?.[0] !== 3) {
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions_compute_price_instruction`);
+  }
+  const parsedInstruction = 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 {
+    assertIsInstructionWithAccounts(instruction);
+    assertIsInstructionWithData(instruction);
+    createATAInstruction = 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() === TOKEN_PROGRAM_ADDRESS.toString() ? TOKEN_PROGRAM_ADDRESS : TOKEN_2022_PROGRAM_ADDRESS;
+  const payToATA = await 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 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 {
+    assertIsInstructionWithData(instruction);
+    assertIsInstructionWithAccounts(instruction);
+  } catch (error) {
+    console.error(error);
+    throw new Error(`invalid_exact_svm_payload_transaction_instructions`);
+  }
+  let tokenInstruction;
+  if (instruction.programAddress.toString() === TOKEN_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = identifyTokenInstruction(instruction);
+    if (identifiedInstruction !== TokenInstruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_spl_token_transfer_checked`
+      );
+    }
+    tokenInstruction = parseTransferCheckedInstructionToken({
+      ...instruction,
+      data: new Uint8Array(instruction.data)
+    });
+  } else if (instruction.programAddress.toString() === TOKEN_2022_PROGRAM_ADDRESS.toString()) {
+    const identifiedInstruction = identifyToken2022Instruction(instruction);
+    if (identifiedInstruction !== Token2022Instruction.TransferChecked) {
+      throw new Error(
+        `invalid_exact_svm_payload_transaction_instruction_not_token_2022_transfer_checked`
+      );
+    }
+    tokenInstruction = parseTransferCheckedInstruction2022({
+      ...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 settle5(signer, payload, paymentRequirements, config2) {
+  const verifyResponse = await verify5(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 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: getSignatureFromTransaction(signedTransaction),
+      payer
+    };
+  }
+}
+async function sendSignedTransaction(signedTransaction, rpc, sendTxConfig = {
+  skipPreflight: true,
+  encoding: "base64"
+}) {
+  const base64EncodedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+  return await rpc.sendTransaction(base64EncodedTransaction, sendTxConfig).send();
+}
+async function confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions) {
+  const signature = getSignatureFromTransaction(signedTransaction);
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort("Transaction confirmation timed out after 60 seconds");
+  }, 6e4);
+  try {
+    const compiledTransactionMessage = getCompiledTransactionMessageDecoder2().decode(
+      signedTransaction.messageBytes
+    );
+    const decompiledTransactionMessage = await decompileTransactionMessageFetchingLookupTables(
+      compiledTransactionMessage,
+      rpc
+    );
+    assertIsTransactionMessageWithBlockhashLifetime(decompiledTransactionMessage);
+    const signedTransactionWithBlockhashLifetime = {
+      ...signedTransaction,
+      lifetimeConstraint: decompiledTransactionMessage.lifetimeConstraint
+    };
+    const commitment = "confirmed";
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+      rpc,
+      rpcSubscriptions
+    });
+    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+      rpc,
+      rpcSubscriptions
+    });
+    const config2 = {
+      abortSignal: abortController.signal,
+      commitment,
+      getBlockHeightExceedencePromise,
+      getRecentSignatureConfirmationPromise
+    };
+    await waitForRecentTransactionConfirmation({
+      ...config2,
+      transaction: signedTransactionWithBlockhashLifetime
+    });
+    return {
+      success: true,
+      signature
+    };
+  } catch (error) {
+    console.error(error);
+    if (isSolanaError(error, 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";
+
+export {
+  verify5 as verify,
+  settle5 as settle,
+  exact_exports,
+  verify4 as verify2,
+  settle4 as settle2
+};
+//# sourceMappingURL=chunk-57UEJN5U.mjs.map