@x402/evm 2.2.0 → 2.3.0

package/dist/cjs/exact/client/index.d.ts

@@ -1,5 +1,5 @@
-export { ExactEvmScheme } from '../../index.js';
-import { x402Client, SelectPaymentRequirements, PaymentPolicy } from '@x402/core/client';
+export { E as ExactEvmScheme, P as Permit2AllowanceParams, c as createPermit2ApprovalTx, e as erc20AllowanceAbi, g as getPermit2AllowanceReadParams } from '../../permit2-BYv82va2.js';
+import { SelectPaymentRequirements, PaymentPolicy, x402Client } from '@x402/core/client';
 import { Network } from '@x402/core/types';
 import { C as ClientEvmSigner } from '../../signer-5OVDxViv.js';
 

package/dist/cjs/exact/client/index.js

@@ -21,12 +21,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var client_exports = {};
 __export(client_exports, {
   ExactEvmScheme: () => ExactEvmScheme,
+  createPermit2ApprovalTx: () => createPermit2ApprovalTx,
+  erc20AllowanceAbi: () => erc20AllowanceAbi,
+  getPermit2AllowanceReadParams: () => getPermit2AllowanceReadParams,
   registerExactEvmScheme: () => registerExactEvmScheme
 });
 module.exports = __toCommonJS(client_exports);
 
-// src/exact/client/scheme.ts
-var import_viem2 = require("viem");
+// src/exact/client/eip3009.ts
+var import_viem4 = require("viem");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -39,32 +42,35 @@ var authorizationTypes = {
     { name: "nonce", type: "bytes32" }
   ]
 };
+var permit2WitnessTypes = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Witness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  Witness: [
+    { name: "to", type: "address" },
+    { name: "validAfter", type: "uint256" },
+    { name: "extra", type: "bytes" }
+  ]
+};
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var x402ExactPermit2ProxyAddress = "0x4020615294c913F045dc10f0a5cdEbd86c280001";
 
 // src/utils.ts
-var import_viem = require("viem");
-function getEvmChainId(network) {
-  const networkMap = {
-    base: 8453,
-    "base-sepolia": 84532,
-    ethereum: 1,
-    sepolia: 11155111,
-    polygon: 137,
-    "polygon-amoy": 80002
-  };
-  return networkMap[network] || 1;
-}
-function createNonce() {
-  const cryptoObj = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : globalThis.crypto;
-  if (!cryptoObj) {
-    throw new Error("Crypto API not available");
-  }
-  return (0, import_viem.toHex)(cryptoObj.getRandomValues(new Uint8Array(32)));
-}
+var import_viem3 = require("viem");
 
-// src/exact/client/scheme.ts
-var ExactEvmScheme = class {
+// src/exact/v1/client/scheme.ts
+var import_viem = require("viem");
+var ExactEvmSchemeV1 = class {
   /**
-   * Creates a new ExactEvmClient instance.
+   * Creates a new ExactEvmClientV1 instance.
    *
    * @param signer - The EVM signer for client operations
    */
@@ -73,31 +79,34 @@ var ExactEvmScheme = class {
     this.scheme = "exact";
   }
   /**
-   * Creates a payment payload for the Exact scheme.
+   * Creates a payment payload for the Exact scheme (V1).
    *
    * @param x402Version - The x402 protocol version
    * @param paymentRequirements - The payment requirements
    * @returns Promise resolving to a payment payload
    */
   async createPaymentPayload(x402Version, paymentRequirements) {
+    const selectedV1 = paymentRequirements;
     const nonce = createNonce();
     const now = Math.floor(Date.now() / 1e3);
     const authorization = {
       from: this.signer.address,
-      to: (0, import_viem2.getAddress)(paymentRequirements.payTo),
-      value: paymentRequirements.amount,
+      to: (0, import_viem.getAddress)(selectedV1.payTo),
+      value: selectedV1.maxAmountRequired,
       validAfter: (now - 600).toString(),
       // 10 minutes before
-      validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+      validBefore: (now + selectedV1.maxTimeoutSeconds).toString(),
       nonce
     };
-    const signature = await this.signAuthorization(authorization, paymentRequirements);
+    const signature = await this.signAuthorization(authorization, selectedV1);
     const payload = {
       authorization,
       signature
     };
     return {
       x402Version,
+      scheme: selectedV1.scheme,
+      network: selectedV1.network,
       payload
     };
   }
@@ -109,7 +118,7 @@ var ExactEvmScheme = class {
    * @returns Promise resolving to the signature
    */
   async signAuthorization(authorization, requirements) {
-    const chainId = parseInt(requirements.network.split(":")[1]);
+    const chainId = getEvmChainId(requirements.network);
     if (!requirements.extra?.name || !requirements.extra?.version) {
       throw new Error(
         `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${requirements.asset}`
@@ -120,11 +129,11 @@ var ExactEvmScheme = class {
       name,
       version,
       chainId,
-      verifyingContract: (0, import_viem2.getAddress)(requirements.asset)
+      verifyingContract: (0, import_viem.getAddress)(requirements.asset)
     };
     const message = {
-      from: (0, import_viem2.getAddress)(authorization.from),
-      to: (0, import_viem2.getAddress)(authorization.to),
+      from: (0, import_viem.getAddress)(authorization.from),
+      to: (0, import_viem.getAddress)(authorization.to),
       value: BigInt(authorization.value),
       validAfter: BigInt(authorization.validAfter),
       validBefore: BigInt(authorization.validBefore),
@@ -139,11 +148,219 @@ var ExactEvmScheme = class {
   }
 };
 
-// src/exact/v1/client/scheme.ts
-var import_viem3 = require("viem");
-var ExactEvmSchemeV1 = class {
+// src/exact/v1/facilitator/scheme.ts
+var import_viem2 = require("viem");
+
+// src/v1/index.ts
+var EVM_NETWORK_CHAIN_ID_MAP = {
+  ethereum: 1,
+  sepolia: 11155111,
+  abstract: 2741,
+  "abstract-testnet": 11124,
+  "base-sepolia": 84532,
+  base: 8453,
+  "avalanche-fuji": 43113,
+  avalanche: 43114,
+  iotex: 4689,
+  sei: 1329,
+  "sei-testnet": 1328,
+  polygon: 137,
+  "polygon-amoy": 80002,
+  peaq: 3338,
+  story: 1514,
+  educhain: 41923,
+  "skale-base-sepolia": 324705682
+};
+var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
+
+// src/utils.ts
+function getEvmChainId(network) {
+  const chainId = EVM_NETWORK_CHAIN_ID_MAP[network];
+  if (!chainId) {
+    throw new Error(`Unsupported network: ${network}`);
+  }
+  return chainId;
+}
+function getCrypto() {
+  const cryptoObj = globalThis.crypto;
+  if (!cryptoObj) {
+    throw new Error("Crypto API not available");
+  }
+  return cryptoObj;
+}
+function createNonce() {
+  return (0, import_viem3.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
+}
+function createPermit2Nonce() {
+  const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
+  return BigInt((0, import_viem3.toHex)(randomBytes)).toString();
+}
+
+// src/exact/client/eip3009.ts
+async function createEIP3009Payload(signer, x402Version, paymentRequirements) {
+  const nonce = createNonce();
+  const now = Math.floor(Date.now() / 1e3);
+  const authorization = {
+    from: signer.address,
+    to: (0, import_viem4.getAddress)(paymentRequirements.payTo),
+    value: paymentRequirements.amount,
+    validAfter: (now - 600).toString(),
+    validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+    nonce
+  };
+  const signature = await signEIP3009Authorization(signer, authorization, paymentRequirements);
+  const payload = {
+    authorization,
+    signature
+  };
+  return {
+    x402Version,
+    payload
+  };
+}
+async function signEIP3009Authorization(signer, authorization, requirements) {
+  const chainId = parseInt(requirements.network.split(":")[1]);
+  if (!requirements.extra?.name || !requirements.extra?.version) {
+    throw new Error(
+      `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${requirements.asset}`
+    );
+  }
+  const { name, version } = requirements.extra;
+  const domain = {
+    name,
+    version,
+    chainId,
+    verifyingContract: (0, import_viem4.getAddress)(requirements.asset)
+  };
+  const message = {
+    from: (0, import_viem4.getAddress)(authorization.from),
+    to: (0, import_viem4.getAddress)(authorization.to),
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: authorization.nonce
+  };
+  return await signer.signTypedData({
+    domain,
+    types: authorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    message
+  });
+}
+
+// src/exact/client/permit2.ts
+var import_viem5 = require("viem");
+var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+async function createPermit2Payload(signer, x402Version, paymentRequirements) {
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = createPermit2Nonce();
+  const validAfter = (now - 600).toString();
+  const deadline = (now + paymentRequirements.maxTimeoutSeconds).toString();
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: (0, import_viem5.getAddress)(paymentRequirements.asset),
+      amount: paymentRequirements.amount
+    },
+    spender: x402ExactPermit2ProxyAddress,
+    nonce,
+    deadline,
+    witness: {
+      to: (0, import_viem5.getAddress)(paymentRequirements.payTo),
+      validAfter,
+      extra: "0x"
+    }
+  };
+  const signature = await signPermit2Authorization(
+    signer,
+    permit2Authorization,
+    paymentRequirements
+  );
+  const payload = {
+    signature,
+    permit2Authorization
+  };
+  return {
+    x402Version,
+    payload
+  };
+}
+async function signPermit2Authorization(signer, permit2Authorization, requirements) {
+  const chainId = parseInt(requirements.network.split(":")[1]);
+  const domain = {
+    name: "Permit2",
+    chainId,
+    verifyingContract: PERMIT2_ADDRESS
+  };
+  const message = {
+    permitted: {
+      token: (0, import_viem5.getAddress)(permit2Authorization.permitted.token),
+      amount: BigInt(permit2Authorization.permitted.amount)
+    },
+    spender: (0, import_viem5.getAddress)(permit2Authorization.spender),
+    nonce: BigInt(permit2Authorization.nonce),
+    deadline: BigInt(permit2Authorization.deadline),
+    witness: {
+      to: (0, import_viem5.getAddress)(permit2Authorization.witness.to),
+      validAfter: BigInt(permit2Authorization.witness.validAfter),
+      extra: permit2Authorization.witness.extra
+    }
+  };
+  return await signer.signTypedData({
+    domain,
+    types: permit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message
+  });
+}
+var erc20ApproveAbi = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+var erc20AllowanceAbi = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+function createPermit2ApprovalTx(tokenAddress) {
+  const data = (0, import_viem5.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [PERMIT2_ADDRESS, MAX_UINT256]
+  });
+  return {
+    to: (0, import_viem5.getAddress)(tokenAddress),
+    data
+  };
+}
+function getPermit2AllowanceReadParams(params) {
+  return {
+    address: (0, import_viem5.getAddress)(params.tokenAddress),
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [(0, import_viem5.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+  };
+}
+
+// src/exact/client/scheme.ts
+var ExactEvmScheme = class {
   /**
-   * Creates a new ExactEvmClientV1 instance.
+   * Creates a new ExactEvmClient instance.
    *
    * @param signer - The EVM signer for client operations
    */
@@ -152,97 +369,22 @@ var ExactEvmSchemeV1 = class {
     this.scheme = "exact";
   }
   /**
-   * Creates a payment payload for the Exact scheme (V1).
+   * Creates a payment payload for the Exact scheme.
+   * Routes to EIP-3009 or Permit2 based on requirements.extra.assetTransferMethod.
    *
    * @param x402Version - The x402 protocol version
    * @param paymentRequirements - The payment requirements
-   * @returns Promise resolving to a payment payload
+   * @returns Promise resolving to a payment payload result
    */
   async createPaymentPayload(x402Version, paymentRequirements) {
-    const selectedV1 = paymentRequirements;
-    const nonce = createNonce();
-    const now = Math.floor(Date.now() / 1e3);
-    const authorization = {
-      from: this.signer.address,
-      to: (0, import_viem3.getAddress)(selectedV1.payTo),
-      value: selectedV1.maxAmountRequired,
-      validAfter: (now - 600).toString(),
-      // 10 minutes before
-      validBefore: (now + selectedV1.maxTimeoutSeconds).toString(),
-      nonce
-    };
-    const signature = await this.signAuthorization(authorization, selectedV1);
-    const payload = {
-      authorization,
-      signature
-    };
-    return {
-      x402Version,
-      scheme: selectedV1.scheme,
-      network: selectedV1.network,
-      payload
-    };
-  }
-  /**
-   * Sign the EIP-3009 authorization using EIP-712
-   *
-   * @param authorization - The authorization to sign
-   * @param requirements - The payment requirements
-   * @returns Promise resolving to the signature
-   */
-  async signAuthorization(authorization, requirements) {
-    const chainId = getEvmChainId(requirements.network);
-    if (!requirements.extra?.name || !requirements.extra?.version) {
-      throw new Error(
-        `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${requirements.asset}`
-      );
+    const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
+    if (assetTransferMethod === "permit2") {
+      return createPermit2Payload(this.signer, x402Version, paymentRequirements);
     }
-    const { name, version } = requirements.extra;
-    const domain = {
-      name,
-      version,
-      chainId,
-      verifyingContract: (0, import_viem3.getAddress)(requirements.asset)
-    };
-    const message = {
-      from: (0, import_viem3.getAddress)(authorization.from),
-      to: (0, import_viem3.getAddress)(authorization.to),
-      value: BigInt(authorization.value),
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-      nonce: authorization.nonce
-    };
-    return await this.signer.signTypedData({
-      domain,
-      types: authorizationTypes,
-      primaryType: "TransferWithAuthorization",
-      message
-    });
+    return createEIP3009Payload(this.signer, x402Version, paymentRequirements);
   }
 };
 
-// src/exact/v1/facilitator/scheme.ts
-var import_viem4 = require("viem");
-
-// src/v1/index.ts
-var NETWORKS = [
-  "abstract",
-  "abstract-testnet",
-  "base-sepolia",
-  "base",
-  "avalanche-fuji",
-  "avalanche",
-  "iotex",
-  "sei",
-  "sei-testnet",
-  "polygon",
-  "polygon-amoy",
-  "peaq",
-  "story",
-  "educhain",
-  "skale-base-sepolia"
-];
-
 // src/exact/client/register.ts
 function registerExactEvmScheme(client, config) {
   if (config.networks && config.networks.length > 0) {
@@ -265,6 +407,9 @@ function registerExactEvmScheme(client, config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ExactEvmScheme,
+  createPermit2ApprovalTx,
+  erc20AllowanceAbi,
+  getPermit2AllowanceReadParams,
   registerExactEvmScheme
 });
 //# sourceMappingURL=index.js.map