@x402/evm 2.2.0 → 2.3.0

package/dist/esm/chunk-DSSJHWGT.mjs

@@ -0,0 +1,658 @@
+// src/exact/v1/client/scheme.ts
+import { getAddress } from "viem";
+
+// src/constants.ts
+var authorizationTypes = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { 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 eip3009ABI = [
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var x402ExactPermit2ProxyAddress = "0x4020615294c913F045dc10f0a5cdEbd86c280001";
+var x402UptoPermit2ProxyAddress = "0x4020633461b2895a48930Ff97eE8fCdE8E520002";
+var x402ExactPermit2ProxyABI = [
+  {
+    type: "function",
+    name: "PERMIT2",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "contract ISignatureTransfer" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPEHASH",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WITNESS_TYPE_STRING",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [{ name: "_permit2", type: "address", internalType: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settle",
+    inputs: [
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402BasePermit2Proxy.Witness",
+        components: [
+          { name: "to", type: "address", internalType: "address" },
+          { name: "validAfter", type: "uint256", internalType: "uint256" },
+          { name: "extra", type: "bytes", internalType: "bytes" }
+        ]
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settleWithPermit",
+    inputs: [
+      {
+        name: "permit2612",
+        type: "tuple",
+        internalType: "struct x402BasePermit2Proxy.EIP2612Permit",
+        components: [
+          { name: "value", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" },
+          { name: "r", type: "bytes32", internalType: "bytes32" },
+          { name: "s", type: "bytes32", internalType: "bytes32" },
+          { name: "v", type: "uint8", internalType: "uint8" }
+        ]
+      },
+      {
+        name: "permit",
+        type: "tuple",
+        internalType: "struct ISignatureTransfer.PermitTransferFrom",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            internalType: "struct ISignatureTransfer.TokenPermissions",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256", internalType: "uint256" },
+          { name: "deadline", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        internalType: "struct x402BasePermit2Proxy.Witness",
+        components: [
+          { name: "to", type: "address", internalType: "address" },
+          { name: "validAfter", type: "uint256", internalType: "uint256" },
+          { name: "extra", type: "bytes", internalType: "bytes" }
+        ]
+      },
+      { name: "signature", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  { type: "event", name: "Settled", inputs: [], anonymous: false },
+  { type: "event", name: "SettledWithPermit", inputs: [], anonymous: false },
+  { type: "error", name: "AlreadyInitialized", inputs: [] },
+  { type: "error", name: "InvalidDestination", inputs: [] },
+  { type: "error", name: "InvalidOwner", inputs: [] },
+  { type: "error", name: "InvalidPermit2Address", inputs: [] },
+  { type: "error", name: "PaymentTooEarly", inputs: [] },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] }
+];
+
+// src/utils.ts
+import { toHex } from "viem";
+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 toHex(getCrypto().getRandomValues(new Uint8Array(32)));
+}
+function createPermit2Nonce() {
+  const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
+  return BigInt(toHex(randomBytes)).toString();
+}
+
+// src/exact/v1/client/scheme.ts
+var ExactEvmSchemeV1 = class {
+  /**
+   * Creates a new ExactEvmClientV1 instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    this.scheme = "exact";
+  }
+  /**
+   * 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: 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 { name, version } = requirements.extra;
+    const domain = {
+      name,
+      version,
+      chainId,
+      verifyingContract: getAddress(requirements.asset)
+    };
+    const message = {
+      from: getAddress(authorization.from),
+      to: 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
+    });
+  }
+};
+
+// src/exact/v1/facilitator/scheme.ts
+import { getAddress as getAddress2, isAddressEqual, parseErc6492Signature, parseSignature } from "viem";
+var ExactEvmSchemeV12 = class {
+  /**
+   * Creates a new ExactEvmFacilitatorV1 instance.
+   *
+   * @param signer - The EVM signer for facilitator operations
+   * @param config - Optional configuration for the facilitator
+   */
+  constructor(signer, config) {
+    this.signer = signer;
+    this.scheme = "exact";
+    this.caipFamily = "eip155:*";
+    this.config = {
+      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false
+    };
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   * For EVM, no extra data is needed.
+   *
+   * @param _ - The network identifier (unused for EVM)
+   * @returns undefined (EVM has no extra data)
+   */
+  getExtra(_) {
+    return void 0;
+  }
+  /**
+   * Get signer addresses used by this facilitator.
+   * Returns all addresses this facilitator can use for signing/settling transactions.
+   *
+   * @param _ - The network identifier (unused for EVM, addresses are network-agnostic)
+   * @returns Array of facilitator wallet addresses
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload (V1).
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to verification response
+   */
+  async verify(payload, requirements) {
+    const requirementsV1 = requirements;
+    const payloadV1 = payload;
+    const exactEvmPayload = payload.payload;
+    if (payloadV1.scheme !== "exact" || requirements.scheme !== "exact") {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    let chainId;
+    try {
+      chainId = getEvmChainId(payloadV1.network);
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: `invalid_network`,
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    if (!requirements.extra?.name || !requirements.extra?.version) {
+      return {
+        isValid: false,
+        invalidReason: "missing_eip712_domain",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    const { name, version } = requirements.extra;
+    const erc20Address = getAddress2(requirements.asset);
+    if (payloadV1.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        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: BigInt(exactEvmPayload.authorization.value),
+        validAfter: BigInt(exactEvmPayload.authorization.validAfter),
+        validBefore: BigInt(exactEvmPayload.authorization.validBefore),
+        nonce: exactEvmPayload.authorization.nonce
+      }
+    };
+    try {
+      const recoveredAddress = await this.signer.verifyTypedData({
+        address: exactEvmPayload.authorization.from,
+        ...permitTypedData,
+        signature: exactEvmPayload.signature
+      });
+      if (!recoveredAddress) {
+        return {
+          isValid: false,
+          invalidReason: "invalid_exact_evm_payload_signature",
+          payer: exactEvmPayload.authorization.from
+        };
+      }
+    } catch {
+      const signature = exactEvmPayload.signature;
+      const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+      const isSmartWallet = signatureLength > 130;
+      if (isSmartWallet) {
+        const payerAddress = exactEvmPayload.authorization.from;
+        const bytecode = await this.signer.getCode({ address: payerAddress });
+        if (!bytecode || bytecode === "0x") {
+          const erc6492Data = parseErc6492Signature(signature);
+          const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !isAddressEqual(erc6492Data.address, "0x0000000000000000000000000000000000000000");
+          if (!hasDeploymentInfo) {
+            return {
+              isValid: false,
+              invalidReason: "invalid_exact_evm_payload_undeployed_smart_wallet",
+              payer: payerAddress
+            };
+          }
+        } else {
+          return {
+            isValid: false,
+            invalidReason: "invalid_exact_evm_payload_signature",
+            payer: exactEvmPayload.authorization.from
+          };
+        }
+      } else {
+        return {
+          isValid: false,
+          invalidReason: "invalid_exact_evm_payload_signature",
+          payer: exactEvmPayload.authorization.from
+        };
+      }
+    }
+    if (getAddress2(exactEvmPayload.authorization.to) !== getAddress2(requirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (BigInt(exactEvmPayload.authorization.validBefore) < BigInt(now + 6)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_exact_evm_payload_authorization_valid_before",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    if (BigInt(exactEvmPayload.authorization.validAfter) > BigInt(now)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_exact_evm_payload_authorization_valid_after",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    try {
+      const balance = await this.signer.readContract({
+        address: erc20Address,
+        abi: eip3009ABI,
+        functionName: "balanceOf",
+        args: [exactEvmPayload.authorization.from]
+      });
+      if (BigInt(balance) < BigInt(requirementsV1.maxAmountRequired)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_funds",
+          invalidMessage: `Insufficient funds to complete the payment. Required: ${requirementsV1.maxAmountRequired} ${requirements.asset}, Available: ${balance.toString()} ${requirements.asset}. Please add funds to your wallet and try again.`,
+          payer: exactEvmPayload.authorization.from
+        };
+      }
+    } catch {
+    }
+    if (BigInt(exactEvmPayload.authorization.value) < BigInt(requirementsV1.maxAmountRequired)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_exact_evm_payload_authorization_value",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: exactEvmPayload.authorization.from
+    };
+  }
+  /**
+   * Settles a payment by executing the transfer (V1).
+   *
+   * @param payload - The payment payload to settle
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to settlement response
+   */
+  async settle(payload, requirements) {
+    const payloadV1 = payload;
+    const exactEvmPayload = payload.payload;
+    const valid = await this.verify(payload, requirements);
+    if (!valid.isValid) {
+      return {
+        success: false,
+        network: payloadV1.network,
+        transaction: "",
+        errorReason: valid.invalidReason ?? "invalid_scheme",
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    try {
+      const parseResult = parseErc6492Signature(exactEvmPayload.signature);
+      const { signature, address: factoryAddress, data: factoryCalldata } = parseResult;
+      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !isAddressEqual(factoryAddress, "0x0000000000000000000000000000000000000000")) {
+        const payerAddress = exactEvmPayload.authorization.from;
+        const bytecode = await this.signer.getCode({ address: payerAddress });
+        if (!bytecode || bytecode === "0x") {
+          try {
+            console.log(`Deploying ERC-4337 smart wallet for ${payerAddress} via EIP-6492`);
+            const deployTx = await this.signer.sendTransaction({
+              to: factoryAddress,
+              data: factoryCalldata
+            });
+            await this.signer.waitForTransactionReceipt({ hash: deployTx });
+            console.log(`Successfully deployed smart wallet for ${payerAddress}`);
+          } catch (deployError) {
+            console.error("Smart wallet deployment failed:", deployError);
+            throw deployError;
+          }
+        } else {
+          console.log(`Smart wallet for ${payerAddress} already deployed, skipping deployment`);
+        }
+      }
+      const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+      const isECDSA = signatureLength === 130;
+      let tx;
+      if (isECDSA) {
+        const parsedSig = parseSignature(signature);
+        tx = await this.signer.writeContract({
+          address: getAddress2(requirements.asset),
+          abi: eip3009ABI,
+          functionName: "transferWithAuthorization",
+          args: [
+            getAddress2(exactEvmPayload.authorization.from),
+            getAddress2(exactEvmPayload.authorization.to),
+            BigInt(exactEvmPayload.authorization.value),
+            BigInt(exactEvmPayload.authorization.validAfter),
+            BigInt(exactEvmPayload.authorization.validBefore),
+            exactEvmPayload.authorization.nonce,
+            parsedSig.v || parsedSig.yParity,
+            parsedSig.r,
+            parsedSig.s
+          ]
+        });
+      } else {
+        tx = await this.signer.writeContract({
+          address: getAddress2(requirements.asset),
+          abi: eip3009ABI,
+          functionName: "transferWithAuthorization",
+          args: [
+            getAddress2(exactEvmPayload.authorization.from),
+            getAddress2(exactEvmPayload.authorization.to),
+            BigInt(exactEvmPayload.authorization.value),
+            BigInt(exactEvmPayload.authorization.validAfter),
+            BigInt(exactEvmPayload.authorization.validBefore),
+            exactEvmPayload.authorization.nonce,
+            signature
+          ]
+        });
+      }
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: "invalid_transaction_state",
+          transaction: tx,
+          network: payloadV1.network,
+          payer: exactEvmPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: tx,
+        network: payloadV1.network,
+        payer: exactEvmPayload.authorization.from
+      };
+    } catch (error) {
+      console.error("Failed to settle transaction:", error);
+      return {
+        success: false,
+        errorReason: "transaction_failed",
+        transaction: "",
+        network: payloadV1.network,
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+  }
+};
+
+// 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);
+
+export {
+  authorizationTypes,
+  permit2WitnessTypes,
+  eip3009ABI,
+  PERMIT2_ADDRESS,
+  x402ExactPermit2ProxyAddress,
+  x402UptoPermit2ProxyAddress,
+  x402ExactPermit2ProxyABI,
+  ExactEvmSchemeV1,
+  ExactEvmSchemeV12,
+  EVM_NETWORK_CHAIN_ID_MAP,
+  NETWORKS,
+  createNonce,
+  createPermit2Nonce
+};
+//# sourceMappingURL=chunk-DSSJHWGT.mjs.map