@bankofai/x402-evm 1.0.0-beta.0

package/dist/esm/exact/facilitator/index.mjs

@@ -0,0 +1,694 @@
+import {
+  isPermit2Payload
+} from "../../chunk-JK7SLLF7.mjs";
+import "../../chunk-U4HCGTLU.mjs";
+import {
+  ExactEvmSchemeV1,
+  NETWORKS,
+  diagnoseEip3009SimulationFailure,
+  executeTransferWithAuthorization,
+  parseEip3009TransferError,
+  simulateEip3009Transfer
+} from "../../chunk-XG2JLZVJ.mjs";
+import {
+  buildExactPermit2SettleArgs,
+  checkPermit2Prerequisites,
+  diagnosePermit2SimulationFailure,
+  mapSettleError,
+  simulatePermit2Settle,
+  simulatePermit2SettleWithErc20Approval,
+  simulatePermit2SettleWithPermit,
+  splitEip2612Signature,
+  validateEip2612PermitForPayment,
+  validateErc20ApprovalForPayment,
+  waitAndReturnSettleResponse
+} from "../../chunk-H2EYJIZL.mjs";
+import {
+  ErrAssetNotDeployedContract,
+  ErrFactoryNotAllowed,
+  ErrInvalidAuthorizationValue,
+  ErrInvalidScheme,
+  ErrInvalidSignature,
+  ErrMissingEip712Domain,
+  ErrNetworkMismatch,
+  ErrPermit2AmountMismatch,
+  ErrPermit2DeadlineExpired,
+  ErrPermit2InvalidSignature,
+  ErrPermit2InvalidSpender,
+  ErrPermit2NotYetValid,
+  ErrPermit2RecipientMismatch,
+  ErrPermit2TokenMismatch,
+  ErrRecipientMismatch,
+  ErrTransactionFailed,
+  ErrUndeployedSmartWallet,
+  ErrUnsupportedPayloadType,
+  ErrValidAfterInFuture,
+  ErrValidBeforeExpired
+} from "../../chunk-P3QOX3QZ.mjs";
+import {
+  ERC20_APPROVAL_GAS_SPONSORING_KEY,
+  appendDataSuffix,
+  extractEip2612GasSponsoringInfo,
+  extractErc20ApprovalGasSponsoringInfo,
+  resolveDataSuffix,
+  resolveErc20ApprovalExtensionSigner
+} from "../../chunk-JNT7C46S.mjs";
+import {
+  PERMIT2_ADDRESS,
+  authorizationTypes,
+  permit2WitnessTypes,
+  x402ExactPermit2ProxyABI,
+  x402ExactPermit2ProxyAddress
+} from "../../chunk-MACPBXCT.mjs";
+import "../../chunk-VS3RYAYE.mjs";
+import {
+  getEvmChainId
+} from "../../chunk-TW7Z65AO.mjs";
+
+// src/exact/facilitator/eip3009.ts
+import { getAddress, isAddressEqual, parseErc6492Signature } from "viem";
+async function verifyEIP3009(signer, payload, requirements, eip3009Payload, options) {
+  const payer = eip3009Payload.authorization.from;
+  let eip6492Deployment;
+  if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
+    return {
+      isValid: false,
+      invalidReason: ErrInvalidScheme,
+      payer
+    };
+  }
+  if (!requirements.extra?.name || !requirements.extra?.version) {
+    return {
+      isValid: false,
+      invalidReason: ErrMissingEip712Domain,
+      payer
+    };
+  }
+  const { name, version } = requirements.extra;
+  const erc20Address = getAddress(requirements.asset);
+  if (payload.accepted.network !== requirements.network) {
+    return {
+      isValid: false,
+      invalidReason: ErrNetworkMismatch,
+      payer
+    };
+  }
+  const permitTypedData = {
+    types: authorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    domain: {
+      name,
+      version,
+      chainId: getEvmChainId(requirements.network),
+      verifyingContract: erc20Address
+    },
+    message: {
+      from: eip3009Payload.authorization.from,
+      to: eip3009Payload.authorization.to,
+      value: BigInt(eip3009Payload.authorization.value),
+      validAfter: BigInt(eip3009Payload.authorization.validAfter),
+      validBefore: BigInt(eip3009Payload.authorization.validBefore),
+      nonce: eip3009Payload.authorization.nonce
+    }
+  };
+  let isValid = false;
+  try {
+    isValid = await signer.verifyTypedData({
+      address: eip3009Payload.authorization.from,
+      ...permitTypedData,
+      signature: eip3009Payload.signature
+    });
+  } catch {
+    isValid = false;
+  }
+  const signature = eip3009Payload.signature;
+  const sigLen = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+  const erc6492Data = parseErc6492Signature(signature);
+  const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !isAddressEqual(erc6492Data.address, "0x0000000000000000000000000000000000000000");
+  if (hasDeploymentInfo) {
+    eip6492Deployment = {
+      factoryAddress: erc6492Data.address,
+      factoryCalldata: erc6492Data.data
+    };
+  }
+  if (!isValid) {
+    const isSmartWallet = sigLen > 130;
+    if (!isSmartWallet) {
+      return {
+        isValid: false,
+        invalidReason: ErrInvalidSignature,
+        payer
+      };
+    }
+    const bytecode = await signer.getCode({ address: payer });
+    const isDeployed = bytecode && bytecode !== "0x";
+    if (!isDeployed && !hasDeploymentInfo) {
+      return {
+        isValid: false,
+        invalidReason: ErrUndeployedSmartWallet,
+        payer
+      };
+    }
+  }
+  if (getAddress(eip3009Payload.authorization.to) !== getAddress(requirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: ErrRecipientMismatch,
+      payer
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(eip3009Payload.authorization.validBefore) < BigInt(now + 6)) {
+    return {
+      isValid: false,
+      invalidReason: ErrValidBeforeExpired,
+      payer
+    };
+  }
+  if (BigInt(eip3009Payload.authorization.validAfter) > BigInt(now)) {
+    return {
+      isValid: false,
+      invalidReason: ErrValidAfterInFuture,
+      payer
+    };
+  }
+  if (BigInt(eip3009Payload.authorization.value) !== BigInt(requirements.amount)) {
+    return {
+      isValid: false,
+      invalidReason: ErrInvalidAuthorizationValue,
+      payer
+    };
+  }
+  const assetBytecode = await signer.getCode({ address: erc20Address });
+  if (!assetBytecode || assetBytecode === "0x") {
+    return { isValid: false, invalidReason: ErrAssetNotDeployedContract, payer };
+  }
+  if (options?.simulate !== false) {
+    const simulationSucceeded = await simulateEip3009Transfer(
+      signer,
+      erc20Address,
+      eip3009Payload,
+      eip6492Deployment
+    );
+    if (!simulationSucceeded) {
+      return diagnoseEip3009SimulationFailure(
+        signer,
+        erc20Address,
+        eip3009Payload,
+        requirements,
+        requirements.amount
+      );
+    }
+  }
+  return {
+    isValid: true,
+    invalidReason: void 0,
+    payer
+  };
+}
+async function settleEIP3009(signer, payload, requirements, eip3009Payload, config, context) {
+  const payer = eip3009Payload.authorization.from;
+  const valid = await verifyEIP3009(signer, payload, requirements, eip3009Payload, {
+    simulate: config.simulateInSettle ?? false
+  });
+  if (!valid.isValid) {
+    return {
+      success: false,
+      network: payload.accepted.network,
+      transaction: "",
+      errorReason: valid.invalidReason ?? ErrInvalidScheme,
+      payer
+    };
+  }
+  try {
+    const { address: factoryAddress, data: factoryCalldata } = parseErc6492Signature(
+      eip3009Payload.signature
+    );
+    if (factoryAddress && factoryCalldata && !isAddressEqual(factoryAddress, "0x0000000000000000000000000000000000000000")) {
+      const bytecode = await signer.getCode({ address: payer });
+      if (!bytecode || bytecode === "0x") {
+        const normalizedFactory = factoryAddress.toLowerCase();
+        const isAllowed = (config.eip6492AllowedFactories ?? []).some(
+          (allowed) => allowed.toLowerCase() === normalizedFactory
+        );
+        if (!isAllowed) {
+          return {
+            success: false,
+            errorReason: ErrFactoryNotAllowed,
+            transaction: "",
+            network: payload.accepted.network,
+            payer
+          };
+        }
+        const deployTx = await signer.sendTransaction({
+          to: factoryAddress,
+          data: factoryCalldata
+        });
+        await signer.waitForTransactionReceipt({ hash: deployTx });
+      }
+    }
+    const dataSuffix = await resolveDataSuffix(context, {
+      paymentPayload: payload,
+      paymentRequirements: requirements
+    });
+    const tx = await executeTransferWithAuthorization(
+      signer,
+      getAddress(requirements.asset),
+      eip3009Payload,
+      dataSuffix
+    );
+    const receipt = await signer.waitForTransactionReceipt({ hash: tx });
+    if (receipt.status !== "success") {
+      return {
+        success: false,
+        errorReason: ErrTransactionFailed,
+        transaction: tx,
+        network: payload.accepted.network,
+        payer
+      };
+    }
+    return {
+      success: true,
+      transaction: tx,
+      network: payload.accepted.network,
+      payer
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errorReason: parseEip3009TransferError(error),
+      transaction: "",
+      network: payload.accepted.network,
+      payer
+    };
+  }
+}
+
+// src/exact/facilitator/permit2.ts
+import { getAddress as getAddress2, encodeFunctionData } from "viem";
+var exactProxyConfig = {
+  proxyAddress: x402ExactPermit2ProxyAddress,
+  proxyABI: x402ExactPermit2ProxyABI
+};
+async function verifyPermit2(signer, payload, requirements, permit2Payload, context, options) {
+  const payer = permit2Payload.permit2Authorization.from;
+  if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
+    return {
+      isValid: false,
+      invalidReason: ErrUnsupportedPayloadType,
+      payer
+    };
+  }
+  if (payload.accepted.network !== requirements.network) {
+    return {
+      isValid: false,
+      invalidReason: ErrNetworkMismatch,
+      payer
+    };
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = getAddress2(requirements.asset);
+  const assetBytecode = await signer.getCode({ address: tokenAddress });
+  if (!assetBytecode || assetBytecode === "0x") {
+    return { isValid: false, invalidReason: ErrAssetNotDeployedContract, payer };
+  }
+  if (getAddress2(permit2Payload.permit2Authorization.spender) !== getAddress2(x402ExactPermit2ProxyAddress)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2InvalidSpender,
+      payer
+    };
+  }
+  if (getAddress2(permit2Payload.permit2Authorization.witness.to) !== getAddress2(requirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2RecipientMismatch,
+      payer
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(permit2Payload.permit2Authorization.deadline) < BigInt(now + 6)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2DeadlineExpired,
+      payer
+    };
+  }
+  if (BigInt(permit2Payload.permit2Authorization.witness.validAfter) > BigInt(now)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2NotYetValid,
+      payer
+    };
+  }
+  if (BigInt(permit2Payload.permit2Authorization.permitted.amount) !== BigInt(requirements.amount)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2AmountMismatch,
+      payer
+    };
+  }
+  if (getAddress2(permit2Payload.permit2Authorization.permitted.token) !== tokenAddress) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2TokenMismatch,
+      payer
+    };
+  }
+  const permit2TypedData = {
+    types: permit2WitnessTypes,
+    primaryType: "PermitWitnessTransferFrom",
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    message: {
+      permitted: {
+        token: getAddress2(permit2Payload.permit2Authorization.permitted.token),
+        amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
+      },
+      spender: getAddress2(permit2Payload.permit2Authorization.spender),
+      nonce: BigInt(permit2Payload.permit2Authorization.nonce),
+      deadline: BigInt(permit2Payload.permit2Authorization.deadline),
+      witness: {
+        to: getAddress2(permit2Payload.permit2Authorization.witness.to),
+        validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
+      }
+    }
+  };
+  let signatureValid = false;
+  try {
+    signatureValid = await signer.verifyTypedData({
+      address: payer,
+      ...permit2TypedData,
+      signature: permit2Payload.signature
+    });
+  } catch {
+    signatureValid = false;
+  }
+  if (!signatureValid) {
+    const bytecode = await signer.getCode({ address: payer });
+    const isDeployedContract = bytecode && bytecode !== "0x";
+    if (!isDeployedContract) {
+      return {
+        isValid: false,
+        invalidReason: ErrPermit2InvalidSignature,
+        payer
+      };
+    }
+  }
+  if (options?.simulate === false) {
+    return { isValid: true, invalidReason: void 0, payer };
+  }
+  const eip2612Info = extractEip2612GasSponsoringInfo(payload);
+  if (eip2612Info) {
+    const fieldResult = validateEip2612PermitForPayment(eip2612Info, payer, tokenAddress);
+    if (!fieldResult.isValid) {
+      return { isValid: false, invalidReason: fieldResult.invalidReason, payer };
+    }
+    const exactSettleArgs = buildExactPermit2SettleArgs(permit2Payload);
+    const simOk2 = await simulatePermit2SettleWithPermit(
+      exactProxyConfig,
+      signer,
+      exactSettleArgs,
+      eip2612Info
+    );
+    if (!simOk2) {
+      return diagnosePermit2SimulationFailure(
+        exactProxyConfig,
+        signer,
+        tokenAddress,
+        permit2Payload,
+        requirements.amount
+      );
+    }
+    return { isValid: true, invalidReason: void 0, payer };
+  }
+  const erc20GasSponsorshipExtension = context?.getExtension(
+    ERC20_APPROVAL_GAS_SPONSORING_KEY
+  );
+  if (erc20GasSponsorshipExtension) {
+    const erc20Info = extractErc20ApprovalGasSponsoringInfo(payload);
+    if (erc20Info) {
+      const fieldResult = await validateErc20ApprovalForPayment(erc20Info, payer, tokenAddress);
+      if (!fieldResult.isValid) {
+        return { isValid: false, invalidReason: fieldResult.invalidReason, payer };
+      }
+      const extensionSigner = resolveErc20ApprovalExtensionSigner(
+        erc20GasSponsorshipExtension,
+        requirements.network
+      );
+      if (extensionSigner?.simulateTransactions) {
+        const simOk2 = await simulatePermit2SettleWithErc20Approval(
+          exactProxyConfig,
+          extensionSigner,
+          buildExactPermit2SettleArgs(permit2Payload),
+          erc20Info
+        );
+        if (!simOk2) {
+          return diagnosePermit2SimulationFailure(
+            exactProxyConfig,
+            signer,
+            tokenAddress,
+            permit2Payload,
+            requirements.amount
+          );
+        }
+        return { isValid: true, invalidReason: void 0, payer };
+      }
+      return checkPermit2Prerequisites(
+        exactProxyConfig,
+        signer,
+        tokenAddress,
+        payer,
+        requirements.amount
+      );
+    }
+  }
+  const simOk = await simulatePermit2Settle(
+    exactProxyConfig,
+    signer,
+    buildExactPermit2SettleArgs(permit2Payload)
+  );
+  if (!simOk) {
+    return diagnosePermit2SimulationFailure(
+      exactProxyConfig,
+      signer,
+      tokenAddress,
+      permit2Payload,
+      requirements.amount
+    );
+  }
+  return { isValid: true, invalidReason: void 0, payer };
+}
+async function settlePermit2(signer, payload, requirements, permit2Payload, context, config) {
+  const payer = permit2Payload.permit2Authorization.from;
+  const valid = await verifyPermit2(signer, payload, requirements, permit2Payload, context, {
+    simulate: config?.simulateInSettle ?? false
+  });
+  if (!valid.isValid) {
+    return {
+      success: false,
+      network: payload.accepted.network,
+      transaction: "",
+      errorReason: valid.invalidReason ?? ErrInvalidScheme,
+      payer
+    };
+  }
+  const dataSuffix = await resolveDataSuffix(context, {
+    paymentPayload: payload,
+    paymentRequirements: requirements
+  });
+  const eip2612Info = extractEip2612GasSponsoringInfo(payload);
+  if (eip2612Info) {
+    return settlePermit2WithEIP2612(
+      exactProxyConfig,
+      signer,
+      payload,
+      permit2Payload,
+      eip2612Info,
+      dataSuffix
+    );
+  }
+  const erc20Info = extractErc20ApprovalGasSponsoringInfo(payload);
+  if (erc20Info) {
+    const erc20GasSponsorshipExtension = context?.getExtension(
+      ERC20_APPROVAL_GAS_SPONSORING_KEY
+    );
+    const extensionSigner = resolveErc20ApprovalExtensionSigner(
+      erc20GasSponsorshipExtension,
+      payload.accepted.network
+    );
+    if (extensionSigner) {
+      return settlePermit2WithERC20Approval(
+        exactProxyConfig,
+        extensionSigner,
+        payload,
+        permit2Payload,
+        erc20Info,
+        dataSuffix
+      );
+    }
+  }
+  return settlePermit2Direct(exactProxyConfig, signer, payload, permit2Payload, dataSuffix);
+}
+async function settlePermit2WithEIP2612(config, signer, payload, permit2Payload, eip2612Info, dataSuffix) {
+  const payer = permit2Payload.permit2Authorization.from;
+  try {
+    const { v, r, s } = splitEip2612Signature(eip2612Info.signature);
+    const tx = await signer.writeContract({
+      address: config.proxyAddress,
+      abi: config.proxyABI,
+      functionName: "settleWithPermit",
+      args: [
+        {
+          value: BigInt(eip2612Info.amount),
+          deadline: BigInt(eip2612Info.deadline),
+          r,
+          s,
+          v
+        },
+        ...buildExactPermit2SettleArgs(permit2Payload)
+      ],
+      dataSuffix
+    });
+    return waitAndReturnSettleResponse(signer, tx, payload, payer);
+  } catch (error) {
+    return mapSettleError(error, payload, payer);
+  }
+}
+async function settlePermit2WithERC20Approval(config, extensionSigner, payload, permit2Payload, erc20Info, dataSuffix) {
+  const payer = permit2Payload.permit2Authorization.from;
+  try {
+    const settleData = appendDataSuffix(
+      encodeFunctionData({
+        abi: config.proxyABI,
+        functionName: "settle",
+        args: buildExactPermit2SettleArgs(permit2Payload)
+      }),
+      dataSuffix
+    );
+    const txHashes = await extensionSigner.sendTransactions([
+      erc20Info.signedTransaction,
+      { to: config.proxyAddress, data: settleData, gas: BigInt(3e5) }
+    ]);
+    const settleTxHash = txHashes[txHashes.length - 1];
+    return waitAndReturnSettleResponse(extensionSigner, settleTxHash, payload, payer);
+  } catch (error) {
+    return mapSettleError(error, payload, payer);
+  }
+}
+async function settlePermit2Direct(config, signer, payload, permit2Payload, dataSuffix) {
+  const payer = permit2Payload.permit2Authorization.from;
+  try {
+    const tx = await signer.writeContract({
+      address: config.proxyAddress,
+      abi: config.proxyABI,
+      functionName: "settle",
+      args: buildExactPermit2SettleArgs(permit2Payload),
+      dataSuffix
+    });
+    return waitAndReturnSettleResponse(signer, tx, payload, payer);
+  } catch (error) {
+    return mapSettleError(error, payload, payer);
+  }
+}
+
+// src/exact/facilitator/scheme.ts
+var ExactEvmScheme = class {
+  /**
+   * Creates a new ExactEvmScheme facilitator instance.
+   *
+   * @param signer - The EVM signer for facilitator operations
+   * @param config - Optional configuration
+   */
+  constructor(signer, config) {
+    this.signer = signer;
+    this.scheme = "exact";
+    this.caipFamily = "eip155:*";
+    this.config = {
+      eip6492AllowedFactories: config?.eip6492AllowedFactories ?? [],
+      simulateInSettle: config?.simulateInSettle ?? false
+    };
+  }
+  /**
+   * Returns undefined — EVM has no mechanism-specific extra data.
+   *
+   * @param _ - The network identifier (unused)
+   * @returns undefined
+   */
+  getExtra(_) {
+    return void 0;
+  }
+  /**
+   * Returns facilitator wallet addresses for the supported response.
+   *
+   * @param _ - The network identifier (unused, addresses are network-agnostic)
+   * @returns Array of facilitator wallet addresses
+   */
+  getSigners(_) {
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload. Routes to Permit2 or EIP-3009 based on payload type.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @param context - Optional facilitator context for extension capabilities
+   * @param _ - Payment required extensions (unused; reserved for interface parity)
+   * @returns Promise resolving to verification response
+   */
+  async verify(payload, requirements, context, _) {
+    const rawPayload = payload.payload;
+    const isPermit2 = isPermit2Payload(rawPayload);
+    if (isPermit2) {
+      return verifyPermit2(this.signer, payload, requirements, rawPayload, context);
+    }
+    const eip3009Payload = rawPayload;
+    return verifyEIP3009(this.signer, payload, requirements, eip3009Payload);
+  }
+  /**
+   * Settles a payment. Routes to Permit2 or EIP-3009 based on payload type.
+   *
+   * @param payload - The payment payload to settle
+   * @param requirements - The payment requirements
+   * @param context - Optional facilitator context for extension capabilities
+   * @returns Promise resolving to settlement response
+   */
+  async settle(payload, requirements, context) {
+    const rawPayload = payload.payload;
+    const isPermit2 = isPermit2Payload(rawPayload);
+    if (isPermit2) {
+      return settlePermit2(this.signer, payload, requirements, rawPayload, context, {
+        simulateInSettle: this.config.simulateInSettle
+      });
+    }
+    const eip3009Payload = rawPayload;
+    return settleEIP3009(this.signer, payload, requirements, eip3009Payload, this.config, context);
+  }
+};
+
+// src/exact/facilitator/register.ts
+function registerExactEvmScheme(facilitator, config) {
+  facilitator.register(
+    config.networks,
+    new ExactEvmScheme(config.signer, {
+      eip6492AllowedFactories: config.eip6492AllowedFactories,
+      simulateInSettle: config.simulateInSettle
+    })
+  );
+  facilitator.registerV1(
+    NETWORKS,
+    new ExactEvmSchemeV1(config.signer, {
+      eip6492AllowedFactories: config.eip6492AllowedFactories,
+      simulateInSettle: config.simulateInSettle
+    })
+  );
+  return facilitator;
+}
+export {
+  ExactEvmScheme,
+  registerExactEvmScheme
+};
+//# sourceMappingURL=index.mjs.map