@payai/x402-evm 2.3.6 → 2.4.0

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

@@ -0,0 +1,507 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/upto/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  UptoEvmScheme: () => UptoEvmScheme,
+  createPermit2ApprovalTx: () => createPermit2ApprovalTx,
+  erc20AllowanceAbi: () => erc20AllowanceAbi,
+  getPermit2AllowanceReadParams: () => getPermit2AllowanceReadParams
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/constants.ts
+var uptoPermit2WitnessTypes = {
+  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: "facilitator", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var eip2612PermitTypes = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var eip2612NoncesAbi = [
+  {
+    type: "function",
+    name: "nonces",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+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"
+  }
+];
+var ERC20_APPROVE_GAS_LIMIT = 70000n;
+var DEFAULT_MAX_FEE_PER_GAS = 1000000000n;
+var DEFAULT_MAX_PRIORITY_FEE_PER_GAS = 100000000n;
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var x402UptoPermit2ProxyAddress = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+
+// src/utils.ts
+var import_viem = require("viem");
+function getEvmChainId(network) {
+  if (network.startsWith("eip155:")) {
+    const idStr = network.split(":")[1];
+    const chainId = parseInt(idStr, 10);
+    if (isNaN(chainId)) {
+      throw new Error(`Invalid CAIP-2 chain ID: ${network}`);
+    }
+    return chainId;
+  }
+  throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
+}
+function getCrypto() {
+  const cryptoObj = globalThis.crypto;
+  if (!cryptoObj) {
+    throw new Error("Crypto API not available");
+  }
+  return cryptoObj;
+}
+function createPermit2Nonce() {
+  const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
+  return BigInt((0, import_viem.toHex)(randomBytes)).toString();
+}
+
+// src/upto/client/permit2.ts
+var import_viem6 = require("viem");
+
+// src/exact/client/permit2.ts
+var import_viem5 = require("viem");
+
+// src/exact/extensions.ts
+var EIP2612_GAS_SPONSORING_KEY = "eip2612GasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_KEY = "erc20ApprovalGasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_VERSION = "1";
+
+// src/shared/permit2.ts
+var import_viem4 = require("viem");
+
+// src/multicall.ts
+var import_viem2 = require("viem");
+
+// src/shared/erc20approval.ts
+var import_viem3 = require("viem");
+
+// src/exact/client/permit2.ts
+var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+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/upto/client/permit2.ts
+async function createUptoPermit2Payload(signer, x402Version, paymentRequirements) {
+  const facilitatorAddress = paymentRequirements.extra?.facilitatorAddress;
+  if (!facilitatorAddress) {
+    throw new Error(
+      "upto scheme requires facilitatorAddress in paymentRequirements.extra. Ensure the server is configured with an upto facilitator that provides getExtra()."
+    );
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = createPermit2Nonce();
+  const validAfter = (now - 600).toString();
+  const deadline = (now + paymentRequirements.maxTimeoutSeconds).toString();
+  if (BigInt(deadline) <= BigInt(validAfter)) {
+    throw new Error(
+      `Invalid time window: deadline (${deadline}) must be after validAfter (${validAfter}). Check that maxTimeoutSeconds (${paymentRequirements.maxTimeoutSeconds}) is positive.`
+    );
+  }
+  const permit2Authorization = {
+    from: signer.address,
+    permitted: {
+      token: (0, import_viem6.getAddress)(paymentRequirements.asset),
+      amount: paymentRequirements.amount
+    },
+    spender: x402UptoPermit2ProxyAddress,
+    nonce,
+    deadline,
+    witness: {
+      to: (0, import_viem6.getAddress)(paymentRequirements.payTo),
+      facilitator: (0, import_viem6.getAddress)(facilitatorAddress),
+      validAfter
+    }
+  };
+  const chainId = getEvmChainId(paymentRequirements.network);
+  const signature = await signer.signTypedData({
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: uptoPermit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: {
+        token: (0, import_viem6.getAddress)(permit2Authorization.permitted.token),
+        amount: BigInt(permit2Authorization.permitted.amount)
+      },
+      spender: (0, import_viem6.getAddress)(permit2Authorization.spender),
+      nonce: BigInt(permit2Authorization.nonce),
+      deadline: BigInt(permit2Authorization.deadline),
+      witness: {
+        to: (0, import_viem6.getAddress)(permit2Authorization.witness.to),
+        facilitator: (0, import_viem6.getAddress)(permit2Authorization.witness.facilitator),
+        validAfter: BigInt(permit2Authorization.witness.validAfter)
+      }
+    }
+  });
+  return {
+    x402Version,
+    payload: { signature, permit2Authorization }
+  };
+}
+
+// src/shared/extensions.ts
+var import_viem10 = require("viem");
+
+// src/exact/client/eip2612.ts
+var import_viem7 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
+  const owner = signer.address;
+  const spender = (0, import_viem7.getAddress)(PERMIT2_ADDRESS);
+  const nonce = await signer.readContract({
+    address: tokenAddress,
+    abi: eip2612NoncesAbi,
+    functionName: "nonces",
+    args: [owner]
+  });
+  const domain = {
+    name: tokenName,
+    version: tokenVersion,
+    chainId,
+    verifyingContract: tokenAddress
+  };
+  const approvalAmount = BigInt(permittedAmount);
+  const message = {
+    owner,
+    spender,
+    value: approvalAmount,
+    nonce,
+    deadline: BigInt(deadline)
+  };
+  const signature = await signer.signTypedData({
+    domain,
+    types: eip2612PermitTypes,
+    primaryType: "Permit",
+    message
+  });
+  return {
+    from: owner,
+    asset: tokenAddress,
+    spender,
+    amount: approvalAmount.toString(),
+    nonce: nonce.toString(),
+    deadline,
+    signature,
+    version: "1"
+  };
+}
+
+// src/exact/client/erc20approval.ts
+var import_viem8 = require("viem");
+async function signErc20ApprovalTransaction(signer, tokenAddress, chainId) {
+  const from = signer.address;
+  const spender = (0, import_viem8.getAddress)(PERMIT2_ADDRESS);
+  const data = (0, import_viem8.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [spender, import_viem8.maxUint256]
+  });
+  const nonce = await signer.getTransactionCount({ address: from });
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  try {
+    const fees = await signer.estimateFeesPerGas?.();
+    if (!fees) {
+      throw new Error("no fee estimates available");
+    }
+    maxFeePerGas = fees.maxFeePerGas;
+    maxPriorityFeePerGas = fees.maxPriorityFeePerGas;
+  } catch {
+    maxFeePerGas = DEFAULT_MAX_FEE_PER_GAS;
+    maxPriorityFeePerGas = DEFAULT_MAX_PRIORITY_FEE_PER_GAS;
+  }
+  const signedTransaction = await signer.signTransaction({
+    to: tokenAddress,
+    data,
+    nonce,
+    gas: ERC20_APPROVE_GAS_LIMIT,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    chainId
+  });
+  return {
+    from,
+    asset: tokenAddress,
+    spender,
+    amount: import_viem8.maxUint256.toString(),
+    signedTransaction,
+    version: ERC20_APPROVAL_GAS_SPONSORING_VERSION
+  };
+}
+
+// src/shared/rpc.ts
+var import_viem9 = require("viem");
+var rpcClientCache = /* @__PURE__ */ new Map();
+function isConfigByChainId(options) {
+  const keys = Object.keys(options);
+  return keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+}
+function getRpcClient(rpcUrl) {
+  const existing = rpcClientCache.get(rpcUrl);
+  if (existing) {
+    return existing;
+  }
+  const client = (0, import_viem9.createPublicClient)({
+    transport: (0, import_viem9.http)(rpcUrl)
+  });
+  rpcClientCache.set(rpcUrl, client);
+  return client;
+}
+function resolveRpcUrl(network, options) {
+  if (!options) {
+    return void 0;
+  }
+  if (isConfigByChainId(options)) {
+    const chainId = getEvmChainId(network);
+    const optionsByChainId = options;
+    return optionsByChainId[chainId]?.rpcUrl;
+  }
+  return options.rpcUrl;
+}
+function resolveExtensionRpcCapabilities(network, signer, options) {
+  const capabilities = {
+    signTransaction: signer.signTransaction,
+    readContract: signer.readContract,
+    getTransactionCount: signer.getTransactionCount,
+    estimateFeesPerGas: signer.estimateFeesPerGas
+  };
+  const needsRpcBackfill = !capabilities.readContract || !capabilities.getTransactionCount || !capabilities.estimateFeesPerGas;
+  if (!needsRpcBackfill) {
+    return capabilities;
+  }
+  const rpcUrl = resolveRpcUrl(network, options);
+  if (!rpcUrl) {
+    return capabilities;
+  }
+  const rpcClient = getRpcClient(rpcUrl);
+  if (!capabilities.readContract) {
+    capabilities.readContract = (args) => rpcClient.readContract(args);
+  }
+  if (!capabilities.getTransactionCount) {
+    capabilities.getTransactionCount = async (args) => rpcClient.getTransactionCount({ address: args.address });
+  }
+  if (!capabilities.estimateFeesPerGas) {
+    capabilities.estimateFeesPerGas = async () => rpcClient.estimateFeesPerGas();
+  }
+  return capabilities;
+}
+
+// src/shared/extensions.ts
+async function trySignEip2612PermitExtension(signer, options, requirements, result, context) {
+  const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
+  if (!capabilities.readContract) {
+    return void 0;
+  }
+  if (!context?.extensions?.[EIP2612_GAS_SPONSORING_KEY]) {
+    return void 0;
+  }
+  const tokenName = requirements.extra?.name;
+  const tokenVersion = requirements.extra?.version;
+  if (!tokenName || !tokenVersion) {
+    return void 0;
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = (0, import_viem10.getAddress)(requirements.asset);
+  try {
+    const allowance = await capabilities.readContract({
+      address: tokenAddress,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [signer.address, PERMIT2_ADDRESS]
+    });
+    if (allowance >= BigInt(requirements.amount)) {
+      return void 0;
+    }
+  } catch {
+  }
+  const permit2Auth = result.payload?.permit2Authorization;
+  const deadline = permit2Auth?.deadline ?? Math.floor(Date.now() / 1e3 + requirements.maxTimeoutSeconds).toString();
+  const info = await signEip2612Permit(
+    {
+      address: signer.address,
+      signTypedData: (msg) => signer.signTypedData(msg),
+      readContract: capabilities.readContract
+    },
+    tokenAddress,
+    tokenName,
+    tokenVersion,
+    chainId,
+    deadline,
+    requirements.amount
+  );
+  return {
+    [EIP2612_GAS_SPONSORING_KEY]: { info }
+  };
+}
+async function trySignErc20ApprovalExtension(signer, options, requirements, context) {
+  const capabilities = resolveExtensionRpcCapabilities(requirements.network, signer, options);
+  if (!capabilities.readContract) {
+    return void 0;
+  }
+  if (!context?.extensions?.[ERC20_APPROVAL_GAS_SPONSORING_KEY]) {
+    return void 0;
+  }
+  if (!capabilities.signTransaction || !capabilities.getTransactionCount) {
+    return void 0;
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = (0, import_viem10.getAddress)(requirements.asset);
+  try {
+    const allowance = await capabilities.readContract({
+      address: tokenAddress,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [signer.address, PERMIT2_ADDRESS]
+    });
+    if (allowance >= BigInt(requirements.amount)) {
+      return void 0;
+    }
+  } catch {
+  }
+  const info = await signErc20ApprovalTransaction(
+    {
+      address: signer.address,
+      signTransaction: capabilities.signTransaction,
+      getTransactionCount: capabilities.getTransactionCount,
+      estimateFeesPerGas: capabilities.estimateFeesPerGas
+    },
+    tokenAddress,
+    chainId
+  );
+  return {
+    [ERC20_APPROVAL_GAS_SPONSORING_KEY]: { info }
+  };
+}
+
+// src/upto/client/scheme.ts
+var UptoEvmScheme = class {
+  /**
+   * Creates a new UptoEvmScheme instance.
+   *
+   * @param signer - The EVM signer for client operations
+   * @param options - Optional RPC configuration
+   */
+  constructor(signer, options) {
+    this.signer = signer;
+    this.options = options;
+    this.scheme = "upto";
+  }
+  /**
+   * Creates a payment payload for the Upto scheme using Permit2.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result
+   */
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
+    const result = await createUptoPermit2Payload(this.signer, x402Version, paymentRequirements);
+    const eip2612Extensions = await trySignEip2612PermitExtension(
+      this.signer,
+      this.options,
+      paymentRequirements,
+      result,
+      context
+    );
+    if (eip2612Extensions) {
+      return { ...result, extensions: eip2612Extensions };
+    }
+    const erc20Extensions = await trySignErc20ApprovalExtension(
+      this.signer,
+      this.options,
+      paymentRequirements,
+      context
+    );
+    if (erc20Extensions) {
+      return { ...result, extensions: erc20Extensions };
+    }
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UptoEvmScheme,
+  createPermit2ApprovalTx,
+  erc20AllowanceAbi,
+  getPermit2AllowanceReadParams
+});
+//# sourceMappingURL=index.js.map