@introspectivelabs/x402-evm 0.1.0-beta.17 → 0.1.0-beta.19

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

@@ -1,10 +1,10 @@
-import { U as UserOperationSigner, P as PreparedUserOperation } from '../../userOpHash-Bzusu9T7.js';
-export { B as BundlerClient, f as BundlerClientConfig, j as ERC20_TRANSFER_ABI, b as ExactEvmSchemeEIP3009, c as ExactEvmSchemeEIP3009Config, E as ExactEvmSchemeERC4337, a as ExactEvmSchemeERC4337Config, G as GasEstimate, l as PackedUserOp, g as UserOperationCall, V as ViemBundlerClient, h as ViemBundlerClientConfig, i as buildERC20TransferCallData, k as computeUserOpHash, d as createP256SafeMessageSigner, e as createWebAuthnSafeMessageSigner, u as userOpToJson } from '../../userOpHash-Bzusu9T7.js';
+import { U as UserOperationSigner, P as PreparedUserOperation } from '../../userOpHash-qINeS6ay.js';
+export { B as BundlerClient, g as BundlerClientConfig, k as ERC20_TRANSFER_ABI, c as ExactEvmSchemeEIP3009, d as ExactEvmSchemeEIP3009Config, E as ExactEvmSchemeERC4337, a as ExactEvmSchemeERC4337Config, G as GasEstimate, m as PackedUserOp, b as PreparedPayment, h as UserOperationCall, V as ViemBundlerClient, i as ViemBundlerClientConfig, j as buildERC20TransferCallData, l as computeUserOpHash, e as createP256SafeMessageSigner, f as createWebAuthnSafeMessageSigner, u as userOpToJson } from '../../userOpHash-qINeS6ay.js';
 import { SmartAccount } from 'viem/account-abstraction';
 import 'viem';
-import '../../types-Dk5U6Xnw.js';
 import '../../types-lO5B0FRc.js';
 import '@x402/core/types';
+import '../../types-Dk5U6Xnw.js';
 
 /**
  * Adapter to make a SmartAccount (e.g., Safe account) work as a UserOperationSigner.

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

@@ -53,15 +53,13 @@ var import_viem5 = require("viem");
 // src/exact/client/bundler/viem.ts
 var import_viem = require("viem");
 var import_account_abstraction = require("viem/account-abstraction");
+function bigintToHex(n) {
+  return `0x${n.toString(16)}`;
+}
 var ViemBundlerClient = class {
-  /**
-   * Creates a new ViemBundlerClient instance.
-   *
-   * @param config - Configuration for the bundler client
-   */
   constructor(config) {
     this.account = config.account;
-    this.entryPoint = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+    this.usePaymaster = config.paymaster === true;
     this.bundlerClient = (0, import_account_abstraction.createBundlerClient)({
       client: config.publicClient,
       chain: config.chain,
@@ -70,13 +68,91 @@ var ViemBundlerClient = class {
     });
   }
   /**
-   * Prepares an unsigned user operation for the given calls.
+   * Prepares an unsigned user operation using raw RPC calls.
    *
-   * @param calls - Array of calls to execute in the user operation
-   * @param _entryPoint - The entry point address (unused, viem uses the configured entry point)
-   * @returns Promise resolving to a prepared (unsigned) user operation
+   * When paymaster is enabled, uses pm_sponsorUserOperation to get paymaster
+   * data and gas estimates in a single call (Pimlico-compatible).
+   * The returned UserOp has final paymaster data ready for hash computation and signing.
    */
-  async prepareUserOperation(calls, _entryPoint) {
+  async prepareUserOperation(calls, entryPoint) {
+    if (!this.usePaymaster) {
+      return this.prepareWithoutPaymaster(calls);
+    }
+    const callData = await this.account.encodeCalls(
+      calls.map((call) => ({
+        to: call.to,
+        value: call.value,
+        data: call.data
+      }))
+    );
+    const nonce = await this.account.getNonce();
+    const sender = await this.account.getAddress();
+    const gasPriceResult = await this.bundlerClient.request({
+      method: "pimlico_getUserOperationGasPrice",
+      params: []
+    });
+    const maxFeePerGas = BigInt(gasPriceResult.fast.maxFeePerGas);
+    const maxPriorityFeePerGas = BigInt(gasPriceResult.fast.maxPriorityFeePerGas);
+    const stubSignature = await this.account.getStubSignature();
+    {
+      const userOpForEstimation = {
+        sender,
+        nonce: `0x${nonce.toString(16)}`,
+        callData,
+        signature: stubSignature,
+        callGasLimit: bigintToHex(500000n),
+        verificationGasLimit: bigintToHex(500000n),
+        preVerificationGas: bigintToHex(100000n),
+        maxFeePerGas: bigintToHex(maxFeePerGas),
+        maxPriorityFeePerGas: bigintToHex(maxPriorityFeePerGas)
+      };
+      const sponsorResult = await this.bundlerClient.request({
+        method: "pm_sponsorUserOperation",
+        params: [userOpForEstimation, entryPoint]
+      });
+      const callGasLimit = BigInt(sponsorResult.callGasLimit);
+      const verificationGasLimit = BigInt(sponsorResult.verificationGasLimit);
+      const preVerificationGas = BigInt(sponsorResult.preVerificationGas);
+      let paymaster;
+      let paymasterData;
+      let paymasterVerificationGasLimit;
+      let paymasterPostOpGasLimit;
+      if (sponsorResult.paymaster) {
+        paymaster = sponsorResult.paymaster;
+        paymasterData = sponsorResult.paymasterData ?? "0x";
+        paymasterVerificationGasLimit = BigInt(sponsorResult.paymasterVerificationGasLimit ?? "0x0");
+        paymasterPostOpGasLimit = BigInt(sponsorResult.paymasterPostOpGasLimit ?? "0x0");
+      } else if (sponsorResult.paymasterAndData && sponsorResult.paymasterAndData !== "0x") {
+        const packed = sponsorResult.paymasterAndData;
+        paymaster = `0x${packed.slice(2, 42)}`;
+        paymasterVerificationGasLimit = BigInt(`0x${packed.slice(42, 74)}`);
+        paymasterPostOpGasLimit = BigInt(`0x${packed.slice(74, 106)}`);
+        paymasterData = `0x${packed.slice(106)}`;
+      }
+      return {
+        sender,
+        nonce,
+        // Include factory/factoryData keys so that downstream signers (e.g. permissionless
+        // Safe signUserOperation) detect v0.7 format and correctly pack paymasterAndData
+        // from the separate v0.7 fields. Without these keys, permissionless defaults to
+        // paymasterAndData: "0x" causing SafeOp hash mismatch (AA24).
+        factory: void 0,
+        factoryData: void 0,
+        callData,
+        callGasLimit,
+        verificationGasLimit,
+        preVerificationGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        ...paymaster ? { paymaster } : {},
+        ...paymasterData ? { paymasterData } : {},
+        ...paymasterVerificationGasLimit != null ? { paymasterVerificationGasLimit } : {},
+        ...paymasterPostOpGasLimit != null ? { paymasterPostOpGasLimit } : {},
+        signature: stubSignature
+      };
+    }
+  }
+  async prepareWithoutPaymaster(calls) {
     const prepared = await this.bundlerClient.prepareUserOperation({
       account: this.account,
       calls: calls.map((call) => ({
@@ -89,31 +165,20 @@ var ViemBundlerClient = class {
     return {
       sender: prepared.sender,
       nonce: prepared.nonce,
+      // Always include factory/factoryData keys for v0.7 format detection by signers
+      factory: p.factory ?? void 0,
+      factoryData: p.factoryData ?? void 0,
       callData: prepared.callData,
       callGasLimit: prepared.callGasLimit,
       verificationGasLimit: prepared.verificationGasLimit,
       preVerificationGas: prepared.preVerificationGas,
       maxFeePerGas: prepared.maxFeePerGas,
       maxPriorityFeePerGas: prepared.maxPriorityFeePerGas,
-      // v0.7 factory fields (for account deployment)
-      ...p.factory ? { factory: p.factory } : {},
-      ...p.factoryData ? { factoryData: p.factoryData } : {},
-      // v0.7 paymaster fields (separate, not paymasterAndData)
-      ...p.paymaster ? { paymaster: p.paymaster } : {},
-      ...p.paymasterData ? { paymasterData: p.paymasterData } : {},
-      ...p.paymasterVerificationGasLimit != null ? { paymasterVerificationGasLimit: p.paymasterVerificationGasLimit } : {},
-      ...p.paymasterPostOpGasLimit != null ? { paymasterPostOpGasLimit: p.paymasterPostOpGasLimit } : {},
       signature: prepared.signature
     };
   }
   /**
-   * Estimates gas for a user operation.
-   * Note: This is typically done as part of prepareUserOperation,
-   * but is available as a separate method for flexibility.
-   *
-   * @param _userOp - The user operation to estimate gas for
-   * @param _entryPoint - The entry point address
-   * @returns Promise resolving to gas estimates
+   * @deprecated Gas estimation is done as part of prepareUserOperation
    */
   async estimateGas(_userOp, _entryPoint) {
     throw new Error(
@@ -121,26 +186,15 @@ var ViemBundlerClient = class {
     );
   }
   /**
-   * Sends a user operation to the bundler.
+   * Sends a signed user operation to the bundler via raw eth_sendUserOperation RPC.
    *
-   * @param userOp - The signed user operation to send
-   * @param _entryPoint - The entry point address (unused, viem uses the configured entry point)
-   * @returns Promise resolving to the user operation hash
+   * Bypasses viem's middleware to avoid re-calling paymaster RPCs which would
+   * change paymaster fields and invalidate the signature.
    */
-  async sendUserOperation(userOp, _entryPoint) {
-    const hash = await this.bundlerClient.sendUserOperation({
-      account: this.account,
-      sender: userOp.sender,
-      nonce: BigInt(userOp.nonce),
-      callData: userOp.callData,
-      callGasLimit: BigInt(userOp.callGasLimit),
-      verificationGasLimit: BigInt(userOp.verificationGasLimit),
-      preVerificationGas: BigInt(userOp.preVerificationGas),
-      maxFeePerGas: BigInt(userOp.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(userOp.maxPriorityFeePerGas),
-      // Combine paymaster and paymasterData into paymasterAndData
-      paymasterAndData: userOp.paymaster && userOp.paymasterData ? userOp.paymaster + userOp.paymasterData.slice(2) : userOp.paymaster ? userOp.paymaster : "0x",
-      signature: userOp.signature
+  async sendUserOperation(userOp, entryPoint) {
+    const hash = await this.bundlerClient.request({
+      method: "eth_sendUserOperation",
+      params: [userOp, entryPoint]
     });
     return hash;
   }
@@ -253,6 +307,7 @@ function userOpToJson(userOp) {
   const json = {};
   for (const [key, value] of Object.entries(userOp)) {
     if (key === "account") continue;
+    if (value === void 0) continue;
     if (typeof value === "bigint") {
       json[key] = toRpcHex(value);
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -443,7 +498,7 @@ function createDefaultPublicClient(network) {
     transport: (0, import_viem4.http)()
   });
 }
-var ExactEvmSchemeERC4337 = class {
+var ExactEvmSchemeERC4337 = class _ExactEvmSchemeERC4337 {
   /**
    * Creates a new ExactEvmSchemeERC4337 instance.
    *
@@ -458,6 +513,7 @@ var ExactEvmSchemeERC4337 = class {
     this.publicClient = config.publicClient;
     this.entrypoint = config.entrypoint;
     this.bundlerUrl = config.bundlerUrl;
+    this.paymaster = config.paymaster;
     if (!this.bundlerClient && !this.account) {
       throw new Error(
         "Either bundlerClient or account must be provided. If bundlerClient is not provided, account (SmartAccount) is required for dynamic bundlerClient creation."
@@ -479,24 +535,14 @@ var ExactEvmSchemeERC4337 = class {
     }
   }
   /**
-   * Creates a payment payload for the Exact scheme using ERC-4337 UserOperations.
-   *
-   * This method:
-   * 1. Extracts user operation capability from payment requirements
-   * 2. Creates bundlerClient dynamically if not provided (when userOperation.supported is true)
-   * 3. Builds ERC20 transfer call data
-   * 4. Prepares the user operation using the bundler client
-   * 5. Signs the user operation
-   * 6. Converts to JSON-RPC format
-   * 7. Returns the x402 payment payload
-   *
-   * @param x402Version - The x402 protocol version
-   * @param paymentRequirements - The payment requirements
-   * @returns Promise resolving to a payment payload
-   * @throws Error if user operation capability is not found or required fields are missing
+   * Prepares an unsigned payment payload (UserOp) without signing.
+   * Use with `completePaymentPayload()` to attach a signature from any surface.
    */
-  async createPaymentPayload(x402Version, paymentRequirements) {
+  async preparePaymentPayload(x402Version, paymentRequirements) {
     const capability = extractUserOperationCapability(paymentRequirements);
+    const chain = resolveChain(paymentRequirements.network);
+    const configBundlerUrl = typeof this.bundlerUrl === "function" ? this.bundlerUrl(chain.id, paymentRequirements.network) : this.bundlerUrl;
+    const bundlerUrl = configBundlerUrl ?? capability?.bundlerUrl;
     let bundlerClient;
     if (this.bundlerClient) {
       bundlerClient = this.bundlerClient;
@@ -506,8 +552,7 @@ var ExactEvmSchemeERC4337 = class {
           "Account (SmartAccount) is required when bundlerClient is not provided. Either provide bundlerClient in config or account for dynamic creation."
         );
       }
-      const bundlerUrl2 = this.bundlerUrl ?? capability?.bundlerUrl;
-      if (!bundlerUrl2) {
+      if (!bundlerUrl) {
         throw new PaymentCreationError(
           "Bundler URL not provided",
           {
@@ -517,13 +562,14 @@ var ExactEvmSchemeERC4337 = class {
           }
         );
       }
-      const chain = resolveChain(paymentRequirements.network);
       const publicClient = this.publicClient ?? createDefaultPublicClient(paymentRequirements.network);
+      const paymaster = this.paymaster ?? true;
       bundlerClient = new ViemBundlerClient({
         publicClient,
         account: this.account,
         chain,
-        bundlerUrl: bundlerUrl2
+        bundlerUrl,
+        paymaster
       });
     }
     const entryPoint = this.entrypoint ?? capability?.entrypoint;
@@ -537,7 +583,6 @@ var ExactEvmSchemeERC4337 = class {
         }
       );
     }
-    const bundlerUrl = this.bundlerUrl ?? capability?.bundlerUrl;
     if (!bundlerUrl) {
       throw new PaymentCreationError(
         "Bundler URL not provided",
@@ -563,7 +608,6 @@ var ExactEvmSchemeERC4337 = class {
           {
             to: token,
             value: BigInt(0),
-            // ERC20 transfers don't send ETH
             data: callData
           }
         ],
@@ -582,9 +626,43 @@ var ExactEvmSchemeERC4337 = class {
         }
       );
     }
+    return {
+      unsignedUserOp,
+      bundlerClient,
+      entryPoint,
+      bundlerUrl,
+      x402Version,
+      network: paymentRequirements.network,
+      signer: this.signer
+    };
+  }
+  /**
+   * Assembles a signed payment payload from a prepared (unsigned) UserOp and a signature.
+   */
+  static completePaymentPayload(prepared, signature) {
+    const signedUserOp = { ...prepared.unsignedUserOp, signature };
+    const jsonUserOp = userOpToJson(signedUserOp);
+    const payload = {
+      type: "erc4337",
+      entryPoint: prepared.entryPoint,
+      bundlerRpcUrl: prepared.bundlerUrl,
+      userOperation: jsonUserOp
+    };
+    return {
+      x402Version: prepared.x402Version,
+      ...prepared.x402Version === 1 ? { scheme: "exact", network: prepared.network } : {},
+      payload
+    };
+  }
+  /**
+   * Creates a payment payload for the Exact scheme using ERC-4337 UserOperations.
+   * Convenience method that calls `preparePaymentPayload` + signs + `completePaymentPayload`.
+   */
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    const prepared = await this.preparePaymentPayload(x402Version, paymentRequirements);
     let signature;
     try {
-      signature = await this.signer.signUserOperation(unsignedUserOp);
+      signature = await this.signer.signUserOperation(prepared.unsignedUserOp);
     } catch (error) {
       const aaError = parseAAError(error);
       throw new PaymentCreationError(
@@ -598,23 +676,7 @@ var ExactEvmSchemeERC4337 = class {
         }
       );
     }
-    const signedUserOp = {
-      ...unsignedUserOp,
-      signature
-    };
-    const jsonUserOp = userOpToJson(signedUserOp);
-    const payload = {
-      type: "erc4337",
-      entryPoint,
-      bundlerRpcUrl: bundlerUrl,
-      userOperation: jsonUserOp
-    };
-    return {
-      x402Version,
-      // v1 requires scheme and network at top level
-      ...x402Version === 1 ? { scheme: this.scheme, network: paymentRequirements.network } : {},
-      payload
-    };
+    return _ExactEvmSchemeERC4337.completePaymentPayload(prepared, signature);
   }
 };