@privacy-paymasters/sdk 0.0.1 → 0.0.2

package/dist/index.js

@@ -111,7 +111,8 @@ class UserOperationBuilder {
   }
 }
 // src/bundlerClient.ts
-import { http, toHex } from "viem";
+import { decodeErrorResult, http, toHex } from "viem";
+import { entryPoint08Abi } from "viem/account-abstraction";
 import { createBundlerClient as createViemBundlerClient } from "viem/account-abstraction";
 
 class BundlerClient {
@@ -119,7 +120,9 @@ class BundlerClient {
   client;
   constructor(bundlerUrl, entryPoint) {
     this.entryPoint = entryPoint;
-    this.client = createViemBundlerClient({ transport: http(bundlerUrl) });
+    this.client = createViemBundlerClient({
+      transport: http(bundlerUrl)
+    });
   }
   async estimateUserOperationGas(op) {
     this.client.estimateUserOperationGas;
@@ -162,28 +165,42 @@ class BundlerClient {
     };
   }
   async sendUserOperation(op) {
-    return this.client.request({
-      method: "eth_sendUserOperation",
-      params: [
-        {
-          sender: op.sender,
-          nonce: toHex(op.nonce),
-          callData: op.callData,
-          callGasLimit: toHex(op.callGasLimit),
-          verificationGasLimit: toHex(op.verificationGasLimit),
-          preVerificationGas: toHex(op.preVerificationGas),
-          maxFeePerGas: toHex(op.maxFeePerGas),
-          maxPriorityFeePerGas: toHex(op.maxPriorityFeePerGas),
-          paymaster: op.paymaster,
-          paymasterVerificationGasLimit: op.paymasterVerificationGasLimit ? toHex(op.paymasterVerificationGasLimit) : undefined,
-          paymasterPostOpGasLimit: op.paymasterPostOpGasLimit ? toHex(op.paymasterPostOpGasLimit) : undefined,
-          paymasterData: op.paymasterData,
-          signature: op.signature,
-          eip7702Auth: op.authorization ? serializeAuth(op.authorization) : undefined
-        },
-        this.entryPoint
-      ]
-    });
+    try {
+      const _r = await this.client.request({
+        method: "eth_sendUserOperation",
+        params: [
+          {
+            sender: op.sender,
+            nonce: toHex(op.nonce),
+            callData: op.callData,
+            callGasLimit: toHex(op.callGasLimit),
+            verificationGasLimit: toHex(op.verificationGasLimit),
+            preVerificationGas: toHex(op.preVerificationGas),
+            maxFeePerGas: toHex(op.maxFeePerGas),
+            maxPriorityFeePerGas: toHex(op.maxPriorityFeePerGas),
+            paymaster: op.paymaster,
+            paymasterVerificationGasLimit: op.paymasterVerificationGasLimit ? toHex(op.paymasterVerificationGasLimit) : undefined,
+            paymasterPostOpGasLimit: op.paymasterPostOpGasLimit ? toHex(op.paymasterPostOpGasLimit) : undefined,
+            paymasterData: op.paymasterData,
+            signature: op.signature,
+            eip7702Auth: op.authorization ? serializeAuth(op.authorization) : undefined
+          },
+          this.entryPoint
+        ]
+      });
+      return _r;
+    } catch (error) {
+      console.error(error);
+      let _error = error;
+      if (_error?.data) {
+        const parsedError = decodeErrorResult({
+          abi: entryPoint08Abi,
+          data: _error.data
+        });
+        throw parsedError;
+      }
+      throw error;
+    }
   }
   async waitForUserOperationReceipt(hash) {
     return this.client.waitForUserOperationReceipt({ hash });

package/dist/src/bundler-server.d.ts

@@ -0,0 +1,18 @@
+import type { Address, Hex } from "viem";
+export interface StartServersOptions {
+    execRpcUrl?: string;
+    forkUrl?: string;
+    forkBlockNumber?: bigint | number;
+    entrypoint: Address;
+    executorPrivateKey?: Hex;
+    utilityPrivateKey?: Hex;
+    port?: number;
+    fundedPrivateKeys?: Hex[];
+    safeMode?: boolean;
+}
+export interface ServersResult {
+    execRpcUrl: string;
+    bundlerRpcUrl: string;
+    stop: () => Promise<void>;
+}
+export declare function startServers(options: StartServersOptions): Promise<ServersResult>;

package/dist/src/bundler-server.js

@@ -0,0 +1,61 @@
+// src/bundler-server.ts
+import { Instance } from "prool";
+import { createTestClient, http, parseEther } from "viem";
+import { privateKeyToAddress } from "viem/accounts";
+import { anvil } from "viem/chains";
+var DEFAULT_EXECUTOR_PK = "0x4a3a02862ddcb260ed52d40ef03f8e3d78fa3d174b0ef333afdf1ffb4a648cd5";
+var DEFAULT_UTILITY_PK = "0xdd4b2564c83ff7de602c39ffda1146055dc1814b07c083d7971722384f1f01a6";
+async function startServers(options) {
+  const {
+    forkUrl,
+    forkBlockNumber,
+    entrypoint,
+    executorPrivateKey = DEFAULT_EXECUTOR_PK,
+    utilityPrivateKey = DEFAULT_UTILITY_PK,
+    fundedPrivateKeys = [],
+    safeMode = false,
+    port = 8545
+  } = options;
+  if (!options.execRpcUrl && !forkUrl)
+    throw new Error("Either execRpcUrl or forkUrl must be provided");
+  let execRpcUrl;
+  let stopExec;
+  if (options.execRpcUrl) {
+    execRpcUrl = options.execRpcUrl;
+  } else {
+    const execServer = Instance.anvil({
+      forkUrl,
+      forkBlockNumber,
+      chainId: anvil.id,
+      port
+    });
+    await execServer.start();
+    execRpcUrl = `http://localhost:${execServer.port}`;
+    stopExec = () => execServer.stop();
+    const allPks = [executorPrivateKey, utilityPrivateKey, ...fundedPrivateKeys];
+    const testClient = createTestClient({ chain: anvil, mode: "anvil", transport: http(execRpcUrl) });
+    for (const pk of allPks) {
+      await testClient.setBalance({ address: privateKeyToAddress(pk), value: parseEther("1000") });
+    }
+  }
+  const bundlerServer = Instance.alto({
+    rpcUrl: execRpcUrl,
+    entrypoints: [entrypoint],
+    executorPrivateKeys: [executorPrivateKey],
+    utilityPrivateKey,
+    safeMode
+  });
+  await bundlerServer.start();
+  const bundlerRpcUrl = `http://127.0.0.1:${bundlerServer.port}`;
+  return {
+    execRpcUrl,
+    bundlerRpcUrl,
+    stop: async () => {
+      await stopExec?.();
+      await bundlerServer.stop();
+    }
+  };
+}
+export {
+  startServers
+};

package/dist/src/deploy-paymaster.d.ts

@@ -0,0 +1,14 @@
+import type { Hex } from "viem";
+export interface DeployPaymasterOptions {
+    forkUrl: string;
+    privateKey: Hex;
+    deployEnv?: string;
+    stakeAmount?: string;
+    unstakeDelay?: string;
+    depositAmount?: string;
+}
+export interface DeploymentResult {
+    paymasterAddress: `0x${string}`;
+    tornadoAccountAddress: `0x${string}`;
+}
+export declare function deployPaymaster(options: DeployPaymasterOptions): Promise<DeploymentResult>;

package/dist/src/deploy-paymaster.js

@@ -0,0 +1,64 @@
+// src/deploy-paymaster.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(join(dir, "foundry.toml")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      throw new Error("Could not find foundry.toml — run from inside the privacy-paymaster project");
+    dir = parent;
+  }
+}
+function forge(args, env, cwd) {
+  return new Promise((resolve, reject) => {
+    console.log(`Running: forge ${args.join(" ")}`);
+    const proc = spawn("forge", args, { env, cwd, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0)
+        reject(new Error(`forge ${args.join(" ")} failed:
+${stderr}`));
+      else
+        resolve();
+    });
+  });
+}
+async function deployPaymaster(options) {
+  const {
+    forkUrl,
+    privateKey,
+    deployEnv = "anvil-test",
+    stakeAmount = "100000000000000000",
+    unstakeDelay = "3600",
+    depositAmount = "100000000000000000"
+  } = options;
+  const projectRoot = findProjectRoot(dirname(fileURLToPath(import.meta.url)));
+  const deploymentsPath = join(projectRoot, `config/deployments/${deployEnv}.json`);
+  await writeFile(deploymentsPath, "{}");
+  const env = { ...process.env, DEPLOY_ENV: deployEnv, PRIVATE_KEY: privateKey };
+  await forge(["script", "DeployPaymaster", "--fork-url", forkUrl, "--broadcast"], env, projectRoot);
+  await forge(["script", "StakePaymaster", "--fork-url", forkUrl, "--broadcast"], {
+    ...env,
+    STAKE_AMOUNT: stakeAmount,
+    UNSTAKE_DELAY: unstakeDelay,
+    DEPOSIT_AMOUNT: depositAmount
+  }, projectRoot);
+  await forge(["script", "DeployTornado", "--fork-url", forkUrl, "--broadcast"], env, projectRoot);
+  const deployments = JSON.parse(await readFile(deploymentsPath, "utf-8"));
+  return {
+    paymasterAddress: deployments.paymaster.address,
+    tornadoAccountAddress: deployments.tornado_eth_1.tornadoAccount
+  };
+}
+export {
+  deployPaymaster
+};

package/package.json

@@ -3,25 +3,36 @@
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "private": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./bundler-server": {
+      "types": "./dist/src/bundler-server.d.ts",
+      "import": "./dist/src/bundler-server.js"
+    },
+    "./deploy-paymaster": {
+      "types": "./dist/src/deploy-paymaster.d.ts",
+      "import": "./dist/src/deploy-paymaster.js"
     }
   },
   "files": [
     "dist"
   ],
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "@types/node": "^25.8.0"
   },
   "peerDependencies": {
     "typescript": "^5.9.0"
   },
   "scripts": {
-    "build": "bun build ./index.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "build": "bun build ./index.ts ./src/bundler-server.ts ./src/deploy-paymaster.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "serve-bundler": "bun scripts/start-bundler.ts",
+    "deploy": "bun scripts/deploy-paymaster.ts",
     "test": "bun test",
     "test:e2e": "bun test tests/e2e.test.ts"
   },