@payai/x402-evm 2.2.3 → 2.3.0

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

@@ -28,8 +28,8 @@ __export(client_exports, {
 });
 module.exports = __toCommonJS(client_exports);
 
-// src/exact/client/eip3009.ts
-var import_viem4 = require("viem");
+// src/exact/client/scheme.ts
+var import_extensions2 = require("@x402/extensions");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -56,130 +56,72 @@ var permit2WitnessTypes = {
   ],
   Witness: [
     { name: "to", type: "address" },
-    { name: "validAfter", type: "uint256" },
-    { name: "extra", type: "bytes" }
+    { name: "validAfter", type: "uint256" }
   ]
 };
-var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var x402ExactPermit2ProxyAddress = "0x4020615294c913F045dc10f0a5cdEbd86c280001";
-
-// src/utils.ts
-var import_viem3 = require("viem");
-
-// src/exact/v1/client/scheme.ts
-var import_viem = require("viem");
-var ExactEvmSchemeV1 = class {
-  /**
-   * Creates a new ExactEvmClientV1 instance.
-   *
-   * @param signer - The EVM signer for client operations
-   */
-  constructor(signer) {
-    this.signer = signer;
-    this.scheme = "exact";
+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"
   }
-  /**
-   * 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_viem.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
-    };
+];
+var erc20ApproveAbi = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
   }
-  /**
-   * 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: (0, import_viem.getAddress)(requirements.asset)
-    };
-    const message = {
-      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),
-      nonce: authorization.nonce
-    };
-    return await this.signer.signTypedData({
-      domain,
-      types: authorizationTypes,
-      primaryType: "TransferWithAuthorization",
-      message
-    });
+];
+var erc20AllowanceAbi = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
   }
-};
-
-// src/exact/v1/facilitator/scheme.ts
-var import_viem2 = require("viem");
+];
+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 x402ExactPermit2ProxyAddress = "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
 
-// 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/exact/client/scheme.ts
+var import_viem6 = require("viem");
 
 // src/utils.ts
+var import_viem = require("viem");
 function getEvmChainId(network) {
-  const chainId = EVM_NETWORK_CHAIN_ID_MAP[network];
-  if (!chainId) {
-    throw new Error(`Unsupported network: ${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;
   }
-  return chainId;
+  throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
 }
 function getCrypto() {
   const cryptoObj = globalThis.crypto;
@@ -189,20 +131,21 @@ function getCrypto() {
   return cryptoObj;
 }
 function createNonce() {
-  return (0, import_viem3.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
+  return (0, import_viem.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
 }
 function createPermit2Nonce() {
   const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
-  return BigInt((0, import_viem3.toHex)(randomBytes)).toString();
+  return BigInt((0, import_viem.toHex)(randomBytes)).toString();
 }
 
 // src/exact/client/eip3009.ts
+var import_viem2 = require("viem");
 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),
+    to: (0, import_viem2.getAddress)(paymentRequirements.payTo),
     value: paymentRequirements.amount,
     validAfter: (now - 600).toString(),
     validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
@@ -219,7 +162,7 @@ async function createEIP3009Payload(signer, x402Version, paymentRequirements) {
   };
 }
 async function signEIP3009Authorization(signer, 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}`
@@ -230,11 +173,11 @@ async function signEIP3009Authorization(signer, authorization, requirements) {
     name,
     version,
     chainId,
-    verifyingContract: (0, import_viem4.getAddress)(requirements.asset)
+    verifyingContract: (0, import_viem2.getAddress)(requirements.asset)
   };
   const message = {
-    from: (0, import_viem4.getAddress)(authorization.from),
-    to: (0, import_viem4.getAddress)(authorization.to),
+    from: (0, import_viem2.getAddress)(authorization.from),
+    to: (0, import_viem2.getAddress)(authorization.to),
     value: BigInt(authorization.value),
     validAfter: BigInt(authorization.validAfter),
     validBefore: BigInt(authorization.validBefore),
@@ -249,7 +192,7 @@ async function signEIP3009Authorization(signer, authorization, requirements) {
 }
 
 // src/exact/client/permit2.ts
-var import_viem5 = require("viem");
+var import_viem3 = require("viem");
 var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   const now = Math.floor(Date.now() / 1e3);
@@ -259,16 +202,15 @@ async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   const permit2Authorization = {
     from: signer.address,
     permitted: {
-      token: (0, import_viem5.getAddress)(paymentRequirements.asset),
+      token: (0, import_viem3.getAddress)(paymentRequirements.asset),
       amount: paymentRequirements.amount
     },
     spender: x402ExactPermit2ProxyAddress,
     nonce,
     deadline,
     witness: {
-      to: (0, import_viem5.getAddress)(paymentRequirements.payTo),
-      validAfter,
-      extra: "0x"
+      to: (0, import_viem3.getAddress)(paymentRequirements.payTo),
+      validAfter
     }
   };
   const signature = await signPermit2Authorization(
@@ -286,7 +228,7 @@ async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   };
 }
 async function signPermit2Authorization(signer, permit2Authorization, requirements) {
-  const chainId = parseInt(requirements.network.split(":")[1]);
+  const chainId = getEvmChainId(requirements.network);
   const domain = {
     name: "Permit2",
     chainId,
@@ -294,16 +236,15 @@ async function signPermit2Authorization(signer, permit2Authorization, requiremen
   };
   const message = {
     permitted: {
-      token: (0, import_viem5.getAddress)(permit2Authorization.permitted.token),
+      token: (0, import_viem3.getAddress)(permit2Authorization.permitted.token),
       amount: BigInt(permit2Authorization.permitted.amount)
     },
-    spender: (0, import_viem5.getAddress)(permit2Authorization.spender),
+    spender: (0, import_viem3.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
+      to: (0, import_viem3.getAddress)(permit2Authorization.witness.to),
+      validAfter: BigInt(permit2Authorization.witness.validAfter)
     }
   };
   return await signer.signTypedData({
@@ -313,47 +254,107 @@ async function signPermit2Authorization(signer, permit2Authorization, requiremen
     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)({
+  const data = (0, import_viem3.encodeFunctionData)({
     abi: erc20ApproveAbi,
     functionName: "approve",
     args: [PERMIT2_ADDRESS, MAX_UINT256]
   });
   return {
-    to: (0, import_viem5.getAddress)(tokenAddress),
+    to: (0, import_viem3.getAddress)(tokenAddress),
     data
   };
 }
 function getPermit2AllowanceReadParams(params) {
   return {
-    address: (0, import_viem5.getAddress)(params.tokenAddress),
+    address: (0, import_viem3.getAddress)(params.tokenAddress),
     abi: erc20AllowanceAbi,
     functionName: "allowance",
-    args: [(0, import_viem5.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+    args: [(0, import_viem3.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+  };
+}
+
+// src/exact/client/eip2612.ts
+var import_viem4 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
+  const owner = signer.address;
+  const spender = (0, import_viem4.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_viem5 = require("viem");
+var import_extensions = require("@x402/extensions");
+async function signErc20ApprovalTransaction(signer, tokenAddress, chainId) {
+  const from = signer.address;
+  const spender = (0, import_viem5.getAddress)(PERMIT2_ADDRESS);
+  const data = (0, import_viem5.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [spender, import_viem5.maxUint256]
+  });
+  const nonce = await signer.getTransactionCount({ address: from });
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  try {
+    const fees = await signer.estimateFeesPerGas();
+    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_viem5.maxUint256.toString(),
+    signedTransaction,
+    version: import_extensions.ERC20_APPROVAL_GAS_SPONSORING_VERSION
   };
 }
 
@@ -362,7 +363,9 @@ var ExactEvmScheme = class {
   /**
    * Creates a new ExactEvmClient instance.
    *
-   * @param signer - The EVM signer for client operations
+   * @param signer - The EVM signer for client operations.
+   *   Must support `readContract` for EIP-2612 gas sponsoring.
+   *   Use `createWalletClient(...).extend(publicActions)` or `toClientEvmSigner(account, publicClient)`.
    */
   constructor(signer) {
     this.signer = signer;
@@ -372,27 +375,268 @@ var ExactEvmScheme = class {
    * Creates a payment payload for the Exact scheme.
    * Routes to EIP-3009 or Permit2 based on requirements.extra.assetTransferMethod.
    *
+   * For Permit2 flows, if the server advertises `eip2612GasSponsoring` and the
+   * signer supports `readContract`, automatically signs an EIP-2612 permit
+   * when Permit2 allowance is insufficient.
+   *
    * @param x402Version - The x402 protocol version
    * @param paymentRequirements - The payment requirements
-   * @returns Promise resolving to a payment payload result
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result (with optional extensions)
    */
-  async createPaymentPayload(x402Version, paymentRequirements) {
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
     const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
     if (assetTransferMethod === "permit2") {
-      return createPermit2Payload(this.signer, x402Version, paymentRequirements);
+      const result = await createPermit2Payload(this.signer, x402Version, paymentRequirements);
+      const eip2612Extensions = await this.trySignEip2612Permit(
+        paymentRequirements,
+        result,
+        context
+      );
+      if (eip2612Extensions) {
+        return {
+          ...result,
+          extensions: eip2612Extensions
+        };
+      }
+      const erc20Extensions = await this.trySignErc20Approval(paymentRequirements, result, context);
+      if (erc20Extensions) {
+        return {
+          ...result,
+          extensions: erc20Extensions
+        };
+      }
+      return result;
     }
     return createEIP3009Payload(this.signer, x402Version, paymentRequirements);
   }
+  /**
+   * Attempts to sign an EIP-2612 permit for gasless Permit2 approval.
+   *
+   * Returns extension data if:
+   * 1. Server advertises eip2612GasSponsoring
+   * 2. Signer has readContract capability
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param result - The payment payload result from the scheme
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for EIP-2612 gas sponsoring, or undefined if not applicable
+   */
+  async trySignEip2612Permit(requirements, result, context) {
+    if (!context?.extensions?.[import_extensions2.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_viem6.getAddress)(requirements.asset);
+    try {
+      const allowance = await this.signer.readContract({
+        address: tokenAddress,
+        abi: erc20AllowanceAbi,
+        functionName: "allowance",
+        args: [this.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(
+      this.signer,
+      tokenAddress,
+      tokenName,
+      tokenVersion,
+      chainId,
+      deadline,
+      requirements.amount
+    );
+    return {
+      [import_extensions2.EIP2612_GAS_SPONSORING.key]: { info }
+    };
+  }
+  /**
+   * Attempts to sign an ERC-20 approval transaction for gasless Permit2 approval.
+   *
+   * This is the fallback path when the token does not support EIP-2612. The client
+   * signs (but does not broadcast) a raw `approve(Permit2, MaxUint256)` transaction.
+   * The facilitator broadcasts it atomically before settling.
+   *
+   * Returns extension data if:
+   * 1. Server advertises erc20ApprovalGasSponsoring
+   * 2. Signer has signTransaction + getTransactionCount capabilities
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param _result - The payment payload result from the scheme (unused)
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for ERC-20 approval gas sponsoring, or undefined if not applicable
+   */
+  async trySignErc20Approval(requirements, _result, context) {
+    if (!context?.extensions?.[import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key]) {
+      return void 0;
+    }
+    if (!this.signer.signTransaction || !this.signer.getTransactionCount) {
+      return void 0;
+    }
+    const chainId = getEvmChainId(requirements.network);
+    const tokenAddress = (0, import_viem6.getAddress)(requirements.asset);
+    try {
+      const allowance = await this.signer.readContract({
+        address: tokenAddress,
+        abi: erc20AllowanceAbi,
+        functionName: "allowance",
+        args: [this.signer.address, PERMIT2_ADDRESS]
+      });
+      if (allowance >= BigInt(requirements.amount)) {
+        return void 0;
+      }
+    } catch {
+    }
+    const info = await signErc20ApprovalTransaction(this.signer, tokenAddress, chainId);
+    return {
+      [import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key]: { info }
+    };
+  }
+};
+
+// src/exact/v1/client/scheme.ts
+var import_viem8 = require("viem");
+
+// src/exact/v1/facilitator/scheme.ts
+var import_viem7 = 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,
+  megaeth: 4326,
+  monad: 143
+};
+var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
+function getEvmChainIdV1(network) {
+  const chainId = EVM_NETWORK_CHAIN_ID_MAP[network];
+  if (!chainId) {
+    throw new Error(`Unsupported v1 network: ${network}`);
+  }
+  return chainId;
+}
+
+// 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: (0, import_viem8.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 = getEvmChainIdV1(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: (0, import_viem8.getAddress)(requirements.asset)
+    };
+    const message = {
+      from: (0, import_viem8.getAddress)(authorization.from),
+      to: (0, import_viem8.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/client/register.ts
 function registerExactEvmScheme(client, config) {
+  const evmScheme = new ExactEvmScheme(config.signer);
   if (config.networks && config.networks.length > 0) {
     config.networks.forEach((network) => {
-      client.register(network, new ExactEvmScheme(config.signer));
+      client.register(network, evmScheme);
     });
   } else {
-    client.register("eip155:*", new ExactEvmScheme(config.signer));
+    client.register("eip155:*", evmScheme);
   }
   NETWORKS.forEach((network) => {
     client.registerV1(network, new ExactEvmSchemeV1(config.signer));