@privacy-paymasters/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { UserOperationBuilder } from "./src/builder.js";
+export { BundlerClient } from "./src/bundlerClient.js";
+export { PrivacyProtocolBuilder } from "./src/privacyProtocolBuilder.js";
+export { TornadoBuilder, tornadoAbi } from "./src/tornadoBuilder.js";
+export type { EIP1193Provider, GasConfig } from "./src/types.js";
+export type { UserOperationGasPrice, GasPrice } from "./src/bundlerClient.js";

package/dist/index.js

@@ -0,0 +1,274 @@
+// src/builder.ts
+import { createPublicClient, custom } from "viem";
+var entryPointAbi = [
+  {
+    type: "function",
+    name: "getNonce",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "key", type: "uint192" }
+    ],
+    outputs: [{ name: "nonce", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+class UserOperationBuilder {
+  sender;
+  calldata = "0x";
+  authorization;
+  paymaster;
+  paymasterData;
+  signature = "0x";
+  nonceKey = 0n;
+  gas = { type: "auto" };
+  factory;
+  factoryData;
+  constructor(sender) {
+    this.sender = sender;
+  }
+  withCalldata(calldata) {
+    this.calldata = calldata;
+    return this;
+  }
+  withPaymaster(paymaster) {
+    this.paymaster = paymaster;
+    return this;
+  }
+  withPaymasterData(data) {
+    this.paymasterData = data;
+    return this;
+  }
+  withSignature(signature) {
+    this.signature = signature;
+    return this;
+  }
+  withNonceKey(key) {
+    this.nonceKey = key;
+    return this;
+  }
+  withGas(gas) {
+    this.gas = gas;
+    return this;
+  }
+  withFactory(factory, factoryData) {
+    this.factory = factory;
+    this.factoryData = factoryData;
+    return this;
+  }
+  withAuthorization(auth) {
+    this.authorization = auth;
+    return this;
+  }
+  async build(provider, bundlerClient) {
+    const rpcClient = createPublicClient({ transport: custom(provider) });
+    const nonce = await rpcClient.readContract({
+      address: bundlerClient.entryPoint,
+      abi: entryPointAbi,
+      functionName: "getNonce",
+      args: [this.sender, this.nonceKey]
+    });
+    const skeleton = {
+      authorization: this.authorization,
+      sender: this.sender,
+      nonce,
+      factory: this.factory,
+      factoryData: this.factoryData,
+      callData: this.calldata,
+      callGasLimit: 0n,
+      verificationGasLimit: 0n,
+      preVerificationGas: 0n,
+      maxFeePerGas: 0n,
+      maxPriorityFeePerGas: 0n,
+      paymaster: this.paymaster,
+      paymasterVerificationGasLimit: 0n,
+      paymasterPostOpGasLimit: 0n,
+      paymasterData: this.paymasterData,
+      signature: this.signature
+    };
+    if (this.gas.type === "auto") {
+      const [est, gasPrice] = await Promise.all([
+        bundlerClient.estimateUserOperationGas(skeleton),
+        bundlerClient.getUserOperationGasPrice()
+      ]);
+      skeleton.callGasLimit = BigInt(est.callGasLimit);
+      skeleton.verificationGasLimit = BigInt(est.verificationGasLimit);
+      skeleton.preVerificationGas = BigInt(est.preVerificationGas);
+      skeleton.maxFeePerGas = BigInt(gasPrice.fast.maxFeePerGas);
+      skeleton.maxPriorityFeePerGas = BigInt(gasPrice.fast.maxPriorityFeePerGas);
+      skeleton.paymasterVerificationGasLimit = est.paymasterVerificationGasLimit ? BigInt(est.paymasterVerificationGasLimit) : undefined;
+      skeleton.paymasterPostOpGasLimit = est.paymasterPostOpGasLimit ? BigInt(est.paymasterPostOpGasLimit) : undefined;
+    } else {
+      skeleton.callGasLimit = this.gas.callGasLimit;
+      skeleton.verificationGasLimit = this.gas.verificationGasLimit;
+      skeleton.preVerificationGas = this.gas.preVerificationGas;
+      skeleton.maxFeePerGas = this.gas.maxFeePerGas;
+      skeleton.maxPriorityFeePerGas = this.gas.maxPriorityFeePerGas;
+      skeleton.paymasterVerificationGasLimit = this.gas.paymasterVerificationGasLimit;
+      skeleton.paymasterPostOpGasLimit = this.gas.paymasterPostOpGasLimit;
+    }
+    return skeleton;
+  }
+}
+// src/bundlerClient.ts
+import { http, toHex } from "viem";
+import { createBundlerClient as createViemBundlerClient } from "viem/account-abstraction";
+
+class BundlerClient {
+  entryPoint;
+  client;
+  constructor(bundlerUrl, entryPoint) {
+    this.entryPoint = entryPoint;
+    this.client = createViemBundlerClient({ transport: http(bundlerUrl) });
+  }
+  async estimateUserOperationGas(op) {
+    this.client.estimateUserOperationGas;
+    return this.client.request({
+      method: "eth_estimateUserOperationGas",
+      params: [
+        {
+          sender: op.sender,
+          nonce: toHex(op.nonce),
+          callData: op.callData,
+          callGasLimit: toHex(0),
+          verificationGasLimit: toHex(0),
+          preVerificationGas: toHex(0),
+          maxFeePerGas: toHex(0),
+          maxPriorityFeePerGas: toHex(0),
+          paymaster: op.paymaster,
+          paymasterVerificationGasLimit: op.paymaster ? toHex(0) : undefined,
+          paymasterPostOpGasLimit: op.paymaster ? toHex(0) : undefined,
+          paymasterData: op.paymasterData,
+          signature: op.signature,
+          eip7702Auth: op.authorization ? serializeAuth(op.authorization) : undefined
+        },
+        this.entryPoint
+      ]
+    });
+  }
+  async getUserOperationGasPrice() {
+    const result = await this.client.request({
+      method: "pimlico_getUserOperationGasPrice",
+      params: []
+    });
+    const parse = (tier) => ({
+      maxFeePerGas: BigInt(tier.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(tier.maxPriorityFeePerGas)
+    });
+    return {
+      slow: parse(result.slow),
+      standard: parse(result.standard),
+      fast: parse(result.fast)
+    };
+  }
+  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
+      ]
+    });
+  }
+  async waitForUserOperationReceipt(hash) {
+    return this.client.waitForUserOperationReceipt({ hash });
+  }
+}
+function serializeAuth(auth) {
+  return {
+    address: auth.address,
+    chainId: toHex(auth.chainId),
+    nonce: toHex(auth.nonce),
+    r: auth.r,
+    s: auth.s,
+    yParity: toHex(auth.yParity)
+  };
+}
+// src/privacyProtocolBuilder.ts
+import { encodeFunctionData } from "viem";
+var privacyAccountAbi = [
+  {
+    type: "function",
+    name: "execute",
+    inputs: [
+      { name: "feeCalldata", type: "bytes" },
+      {
+        name: "tail",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+
+class PrivacyProtocolBuilder extends UserOperationBuilder {
+  feeCalldata = "0x";
+  tail = [];
+  constructor(sender) {
+    super(sender);
+  }
+  withFeeCalldata(calldata) {
+    this.feeCalldata = calldata;
+    const cd = encodeFunctionData({
+      abi: privacyAccountAbi,
+      functionName: "execute",
+      args: [this.feeCalldata, this.tail]
+    });
+    return this.withCalldata(cd);
+  }
+  withTailCall(target, data) {
+    this.tail.push({ target, data });
+    const cd = encodeFunctionData({
+      abi: privacyAccountAbi,
+      functionName: "execute",
+      args: [this.feeCalldata, this.tail]
+    });
+    return this.withCalldata(cd);
+  }
+}
+// src/tornadoBuilder.ts
+import { encodeFunctionData as encodeFunctionData2, parseAbi } from "viem";
+var tornadoAbi = parseAbi([
+  "function withdraw(bytes proof, bytes32 root, bytes32 nullifierHash, address recipient, address relayer, uint256 fee, uint256 refund)"
+]);
+
+class TornadoBuilder extends PrivacyProtocolBuilder {
+  constructor(sender) {
+    super(sender);
+  }
+  withWithdraw(proof, root, nullifierHash, recipient, relayer, fee) {
+    const calldata = encodeFunctionData2({
+      abi: tornadoAbi,
+      functionName: "withdraw",
+      args: [proof, root, nullifierHash, recipient, relayer, fee, 0n]
+    });
+    return this.withFeeCalldata(calldata);
+  }
+}
+export {
+  tornadoAbi,
+  UserOperationBuilder,
+  TornadoBuilder,
+  PrivacyProtocolBuilder,
+  BundlerClient
+};

package/dist/src/builder.d.ts

@@ -0,0 +1,26 @@
+import { type Address, type Hex, type SignedAuthorization } from 'viem';
+import type { UserOperation } from 'viem';
+import type { EIP1193Provider, GasConfig } from './types.js';
+import type { BundlerClient } from './bundlerClient.js';
+export declare class UserOperationBuilder {
+    private sender;
+    private calldata;
+    private authorization?;
+    private paymaster?;
+    private paymasterData?;
+    private signature;
+    private nonceKey;
+    private gas;
+    private factory?;
+    private factoryData?;
+    constructor(sender: Address);
+    withCalldata(calldata: Hex): this;
+    withPaymaster(paymaster: Address): this;
+    withPaymasterData(data: Hex): this;
+    withSignature(signature: Hex): this;
+    withNonceKey(key: bigint): this;
+    withGas(gas: GasConfig): this;
+    withFactory(factory: Address, factoryData: Hex): this;
+    withAuthorization(auth: SignedAuthorization<number>): this;
+    build(provider: EIP1193Provider, bundlerClient: BundlerClient): Promise<UserOperation>;
+}

package/dist/src/bundlerClient.d.ts

@@ -0,0 +1,20 @@
+import { type Address, type EstimateUserOperationGasReturnType, type Hash } from "viem";
+import type { UserOperation, UserOperationReceipt } from "viem/account-abstraction";
+export type UserOperationGasPrice = {
+    slow: GasPrice;
+    standard: GasPrice;
+    fast: GasPrice;
+};
+export type GasPrice = {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+};
+export declare class BundlerClient {
+    entryPoint: Address;
+    private client;
+    constructor(bundlerUrl: string, entryPoint: Address);
+    estimateUserOperationGas(op: UserOperation): Promise<EstimateUserOperationGasReturnType>;
+    getUserOperationGasPrice(): Promise<UserOperationGasPrice>;
+    sendUserOperation(op: UserOperation): Promise<Hash>;
+    waitForUserOperationReceipt(hash: Hash): Promise<UserOperationReceipt>;
+}

package/dist/src/privacyProtocolBuilder.d.ts

@@ -0,0 +1,9 @@
+import { type Address, type Hex } from "viem";
+import { UserOperationBuilder } from "./builder.js";
+export declare class PrivacyProtocolBuilder extends UserOperationBuilder {
+    private feeCalldata;
+    private tail;
+    constructor(sender: Address);
+    withFeeCalldata(calldata: Hex): this;
+    withTailCall(target: Address, data: Hex): this;
+}

package/dist/src/tornadoBuilder.d.ts

@@ -0,0 +1,34 @@
+import { type Address, type Hex } from "viem";
+import { PrivacyProtocolBuilder } from "./privacyProtocolBuilder.js";
+export declare const tornadoAbi: readonly [{
+    readonly name: "withdraw";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "proof";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "root";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "nullifierHash";
+    }, {
+        readonly type: "address";
+        readonly name: "recipient";
+    }, {
+        readonly type: "address";
+        readonly name: "relayer";
+    }, {
+        readonly type: "uint256";
+        readonly name: "fee";
+    }, {
+        readonly type: "uint256";
+        readonly name: "refund";
+    }];
+    readonly outputs: readonly [];
+}];
+export declare class TornadoBuilder extends PrivacyProtocolBuilder {
+    constructor(sender: Address);
+    withWithdraw(proof: Hex, root: Hex, nullifierHash: Hex, recipient: Address, relayer: Address, fee: bigint): this;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,18 @@
+export interface EIP1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown;
+    }): Promise<unknown>;
+}
+export type GasConfig = {
+    type: 'auto';
+} | {
+    type: 'manual';
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    paymasterVerificationGasLimit?: bigint;
+    paymasterPostOpGasLimit?: bigint;
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@privacy-paymasters/sdk",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "version": "0.0.1",
+  "private": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.0"
+  },
+  "scripts": {
+    "build": "bun build ./index.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "test:e2e": "bun test tests/e2e.test.ts"
+  },
+  "dependencies": {
+    "@pimlico/alto": "^0.0.20",
+    "prool": "^0.2.4",
+    "smol-toml": "^1.6.1",
+    "viem": "2.48.4"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}