@kohaku-eth/tornado-cash 0.0.2-alpha.12 → 0.0.2-alpha.14

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { Broadcaster } from '@kohaku-eth/plugins/broadcaster';
-import { Host, ChainId, Storage, PrivateOperation, PublicOperation, AssetAmount, ERC20AssetId, PluginInstance, AccountId } from '@kohaku-eth/plugins';
+import { Host, ExternalRawEvent, ChainId, Storage, PrivateOperation, PublicOperation, AccountId, AssetAmount, ERC20AssetId, PluginInstance, UnshieldOptions } from '@kohaku-eth/plugins';
+import { TxData } from '@kohaku-eth/provider';
 import { combineReducers } from '@reduxjs/toolkit';
 import { ParseAbiItem, SignedAuthorization, Hash, Address as Address$2 } from 'viem';
-import { TxData } from '@kohaku-eth/provider';
 import { Address as Address$1 } from 'ox/Address';
+import { Hex } from 'ox/Hex';
 
 type Nullifier$1 = bigint & {};
 type NullifierHash = bigint & {};
@@ -190,7 +191,7 @@ declare const INSTANCE_REGISTRY_EVENT_SIGNATURES: {
 };
 
 type IEventsMap = Record<string, ParseAbiItem<string>>;
-interface IGetEventsParams<T> {
+interface IGetEventsParams$1<T> {
     events: T | T[];
     fromBlock: bigint;
     toBlock?: bigint;
@@ -211,7 +212,7 @@ type IGroupedEvents<NamesTable extends Record<string, unknown>> = {
 };
 type GetEventsFn<EventsMap extends IEventsMap, ParsedEvents extends {
     [key in keyof EventsMap]: unknown;
-}> = <const T extends keyof ParsedEvents = never>(params: IGetEventsParams<T>) => Promise<Pick<IGroupedEvents<ParsedEvents>, T> & {
+}> = <const T extends keyof ParsedEvents = never>(params: IGetEventsParams$1<T>) => Promise<Pick<IGroupedEvents<ParsedEvents>, T> & {
     fromBlock: bigint;
     toBlock: bigint;
 }>;
@@ -220,7 +221,6 @@ interface IPoolConfig {
     isERC20: boolean;
     token: Address;
     state: 0 | 1;
-    uniswapPoolSwappingFee: number;
     protocolFeePercentage: number;
     denomination: bigint;
     rootHistorySize: number;
@@ -233,6 +233,14 @@ interface IRelayerAggregatorData {
 }
 interface IDataService {
     getPoolEvents: GetEventsFn<typeof POOL_EVENTS_SIGNATURES, IPoolEvents>;
+    getBlockNumber(): Promise<bigint>;
+    parsePoolEvents(events: ExternalRawEvent[]): {
+        Deposited: IRawDepositEvent[];
+        Withdrawn: IRawWithdrawalEvent[];
+    };
+    parseRelayerRegistryEvents(events: ExternalRawEvent[]): {
+        RelayerRegistered: IRelayerRegisteredEvent[];
+    };
     getRelayerRegistryEvents: GetEventsFn<typeof RELAYER_REGISTRY_EVENTS_SIGNATURES, IRelayerRegistryEvents>;
     getInstanceRegistryEvents: GetEventsFn<typeof INSTANCE_REGISTRY_EVENT_SIGNATURES, IInstanceRegistryEvents>;
     getAsset(assetAddress: Address): Promise<IAsset>;
@@ -249,7 +257,47 @@ interface IDataService {
     getLatestBlockTimestamp(): Promise<bigint>;
     getRelayerData(aggregatorAddress: Address, relayerNameHashes: bigint[], subdomains: string[]): Promise<IRelayerAggregatorData[]>;
     getAccountNonce(accountAddress: Address): Promise<number>;
-    quoteEthToToken(amountInWei: bigint, tokenAddress: Address, poolFee: number): Promise<bigint>;
+    quoteWeiInToken(paymasterAddress: Address, feeToken: Address, weiAmount: bigint): Promise<bigint>;
+}
+
+/** Identifies one contract to sync from a given block. */
+interface IGetEventsParams {
+    chainId: bigint;
+    address: Address;
+    fromBlock: bigint;
+}
+interface IGetPoolEventsResult {
+    Deposited: IRawDepositEvent[];
+    Withdrawn: IRawWithdrawalEvent[];
+    /** Highest block the returned events are synced up to. */
+    toBlock: bigint;
+}
+interface IGetRelayerRegistryEventsResult {
+    RelayerRegistered: IRelayerRegisteredEvent[];
+    /** Highest block the returned events are synced up to. */
+    toBlock: bigint;
+}
+interface ISyncService {
+    /**
+     * Fetches a single pool's `Deposited`/`Withdrawn` events from `fromBlock`.
+     * Uses the external sync provider for the bulk of a large range and the chain
+     * for the remaining tail; falls back to a chain-only fetch otherwise.
+     */
+    getPoolEvents(params: IGetEventsParams): Promise<IGetPoolEventsResult>;
+    /**
+     * Fetches the relayer registry's `RelayerRegistered` events from `fromBlock`,
+     * with the same external-then-chain strategy as {@link getPoolEvents}.
+     */
+    getRelayerRegistryEvents(params: IGetEventsParams): Promise<IGetRelayerRegistryEventsResult>;
+    /**
+     * Resolves a pool's scan-start block. Uses the external provider's first
+     * covered block when available (an O(1) lookup), else falls back to the
+     * on-chain deployment-block binary search.
+     */
+    getPoolDeploymentBlock(params: {
+        chainId: bigint;
+        address: Address;
+    }): Promise<bigint>;
 }
 
 type SpecificAssetBalanceFn<isAsync extends boolean = false> = <const Adresses extends Address | Address[] = Address[], ReturnType = Adresses extends unknown[] ? Map<Address, bigint> : bigint>(assetAddress?: Adresses) => isAsync extends true ? Promise<ReturnType> : ReturnType;
@@ -289,6 +337,7 @@ interface IRelayerFeeConfig {
 interface StoreFactoryParams {
     secretManagerFactory: () => Promise<ISecretManager>;
     dataService: IDataService;
+    syncService: ISyncService;
     relayerClient: IRelayerClient;
     paymasterConfig: IChainsPaymastersConfig;
     storageToSyncTo?: Storage;
@@ -303,6 +352,36 @@ declare enum DepositStrategy {
     MinFee = 1
 }
 
+interface SerializedAuth {
+    address: Address$1;
+    chainId: Hex;
+    nonce: Hex;
+    r: Hex;
+    s: Hex;
+    yParity: Hex;
+}
+/**
+ * A userOp serialized to the hex shape expected by `eth_sendUserOperation`, so
+ * it can be carried as plain (JSON-serializable) data from the prepare phase
+ * (thunk) to the broadcast phase.
+ */
+interface SerializedUserOperation {
+    sender: `0x${string}`;
+    nonce: `0x${string}`;
+    callData: `0x${string}`;
+    callGasLimit: `0x${string}`;
+    verificationGasLimit: `0x${string}`;
+    preVerificationGas: `0x${string}`;
+    maxFeePerGas: `0x${string}`;
+    maxPriorityFeePerGas: `0x${string}`;
+    paymaster?: `0x${string}`;
+    paymasterVerificationGasLimit?: `0x${string}`;
+    paymasterPostOpGasLimit?: `0x${string}`;
+    paymasterData?: `0x${string}`;
+    signature: `0x${string}`;
+    eip7702Auth?: SerializedAuth;
+}
+
 interface SignedDelegation {
     senderAddress: `0x${string}`;
     authorization: SignedAuthorization;
@@ -322,8 +401,7 @@ interface IGenericPaymasterWithdrawalPayload {
     paymasterAddress: `0x${string}`;
     entryPointAddress: `0x${string}`;
     bundlerUrl: string;
-    accountAddress: `0x${string}`;
-    delegation?: SignedDelegation;
+    userOperation: SerializedUserOperation;
 }
 interface PaymasterBroadcastResult {
     userOpHash: Hash;
@@ -377,6 +455,12 @@ interface TCProtocolParams {
     artifactsLoader?: () => Promise<ITornadoArtifacts>;
     initialState?: () => Promise<Record<string, PublicRootState>>;
     stateManagerWorkerUrl?: string;
+    /**
+     * When a pool is at least this many blocks behind, use the host's
+     * `externalSyncProvider` (if any) for the bulk of the sync instead of the
+     * chain. Omit to always sync from the chain.
+     */
+    minExternalSyncBlocksAmount?: number;
 }
 interface IBaseOperationParams {
 }
@@ -396,6 +480,7 @@ interface IRelayerWithdrawParams extends IWithdrawBaseParams {
 interface IPaymasterWithdrawParams extends IWithdrawBaseParams {
     mode: 'paymaster';
     delegation?: DelegationConfig;
+    tailCalls?: (address: AccountId) => Promise<TxData[]>;
 }
 type IWithdrawapOperationParams = IRelayerWithdrawParams | IPaymasterWithdrawParams;
 interface IGetNotesParams extends IBaseOperationParams {
@@ -445,7 +530,7 @@ type TCBroadcaster = Broadcaster<TCPrivateOperation, ITornadoWithdrawResponse[]>
 interface TCBaseCredential {
     accountIndex: number;
 }
-interface TCPluginParameters extends TCBroadcasterParameters, TCBaseCredential, Pick<TCProtocolParams, 'initialState'> {
+interface TCPluginParameters extends TCBroadcasterParameters, TCBaseCredential, Pick<TCProtocolParams, 'initialState' | 'minExternalSyncBlocksAmount'> {
     protocolConfig: TCProtocolConfig;
     relayerConfig?: IRelayerFeeConfig;
     stateManagerWorkerUrl?: string;
@@ -454,11 +539,11 @@ interface TCPluginParameters extends TCBroadcasterParameters, TCBaseCredential,
 type TCAddress = Address$1;
 type TCAssetAmount<Tag extends string | undefined = undefined> = AssetAmount<ERC20AssetId, bigint, Tag>;
 type TCAssetBalance = TCAssetAmount;
-interface TCRelayerUnshieldOptions {
+interface TCRelayerUnshieldOptions extends UnshieldOptions {
     mode: 'relayer';
     preferredRelayersEns?: string[];
 }
-interface TCPaymasterUnshieldOptions {
+interface TCPaymasterUnshieldOptions extends UnshieldOptions {
     mode: 'paymaster';
     delegation?: DelegationConfig;
 }
@@ -495,7 +580,7 @@ type RequireOnly<T, Keys extends keyof T> = Partial<T> & Pick<T, Keys>;
 declare class TornadoCashProtocol implements TCInstance {
     readonly host: Host;
     private stateManager;
-    constructor(host: Host, { accountIndex, initialState, protocolConfig, artifactsLoader, stateManagerWorkerUrl, relayerConfig, paymasterConfig, relayerClientFactory, }: RequireOnly<TCProtocolParams, 'protocolConfig'>);
+    constructor(host: Host, { accountIndex, initialState, protocolConfig, artifactsLoader, stateManagerWorkerUrl, relayerConfig, paymasterConfig, relayerClientFactory, minExternalSyncBlocksAmount, }: RequireOnly<TCProtocolParams, 'protocolConfig'>);
     instanceId: () => Promise<"0x1">;
     /**
      * Only process supported assets or error out?
@@ -510,6 +595,7 @@ declare class TornadoCashProtocol implements TCInstance {
      */
     notes(assets?: ERC20AssetId[], includeSpent?: boolean): Promise<TCNote[]>;
     prepareShield(assets: TCAssetAmount, options?: TCPrepareShieldOptions | `0x${string}`): Promise<TCPublicOperation>;
+    prepareUnshield(assets: AssetAmount, to: AccountId): Promise<TCPrivateOperation<'relayer'>>;
     prepareUnshield(assets: AssetAmount, to: AccountId, options?: TCRelayerUnshieldOptions): Promise<TCPrivateOperation<'relayer'>>;
     prepareUnshield(assets: AssetAmount, to: AccountId, options?: TCPaymasterUnshieldOptions): Promise<TCPrivateOperation<'paymaster'>>;
     sync(): Promise<void>;
@@ -534,11 +620,11 @@ declare const TornadoPaymasterConfigs: {
     readonly 11155111: {
         readonly bundlerUrl: "https://public.pimlico.io/v2/11155111/rpc";
         readonly entryPointAddress: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
-        readonly paymasterAddress: "0xA0e2667AcdECb9bCDa6Fcf87638a962e2E9dB20D";
+        readonly paymasterAddress: "0x1c5aCCb9c09D72945b79EC986776136bE01d7B2F";
         readonly poolsAccountsMap: {
-            readonly '0x8c4a04d872a6c1be37964a21ba3a138525dff50b': "0x8A70E3dE493B8599447013f08d8b35719C8ED0ec";
-            readonly '0x8cc930096b4df705a007c4a039bdfa1320ed2508': "0x191e3De3cF7f61de7EbEf4Bf45cfBA4f652d1C6e";
-            readonly '0x6921fd1a97441dd603a997ed6ddf388658daf754': "0x060d053A6595630851ab873d6C95401b0C964d26";
+            readonly '0x8c4a04d872a6c1be37964a21ba3a138525dff50b': "0xa616aAE443FCCABfc2F1EA2Afe001E5046FFDCe0";
+            readonly '0x8cc930096b4df705a007c4a039bdfa1320ed2508': "0x67a898343F32641206d0f30CB3367944a8919A3A";
+            readonly '0x6921fd1a97441dd603a997ed6ddf388658daf754': "0xbF0a7969dacF8337716d0F283df0574dF56b0479";
         };
     };
     readonly 1: never;
@@ -558,7 +644,6 @@ declare const TornadoCashConfigs: {
             readonly address: 1329937909414098670091808248270266272594403334985n;
         };
         readonly weth: 1097077688018008265106216665536940668749033598146n;
-        readonly uniswapQuoterV2: 559478315000592720989748010348495519536007655966n;
     };
     readonly 11155111: {
         readonly ensSubdomainKey: "sepolia-tornado";
@@ -574,7 +659,6 @@ declare const TornadoCashConfigs: {
             readonly address: 368418168928372787409224158240737522620871644738n;
         };
         readonly weth: 1461358721292675304620367034492138750323989506836n;
-        readonly uniswapQuoterV2: 1353730886217084326490181093487957540173111046067n;
     };
 };
 

package/dist/index.js

@@ -1,10 +1,10 @@
 import { createSelector, createAsyncThunk } from '@reduxjs/toolkit';
 import { createTx } from '@kohaku-eth/provider';
-import { encodeFunctionData, toHex, erc20Abi } from 'viem';
+import { encodeFunctionData, toHex, erc20Abi, http } from 'viem';
 import { proxy } from 'comlink';
 import { loadStateManagerWorker } from '#worker-loader';
-import { BundlerClient, TornadoBuilder } from '@privacy-paymasters/sdk';
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import 'viem/accounts';
+import { createBundlerClient } from 'viem/account-abstraction';
 import { numberToBytesLE, bytesToNumberLE, concatBytes } from '@noble/curves/utils.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { pedersenHash as pedersenHash$1, Point } from 'micro-zk-proofs/pedersen.js';
@@ -348,11 +348,12 @@ var TornadoPaymasterConfigs = {
   11155111: {
     bundlerUrl: "https://public.pimlico.io/v2/11155111/rpc",
     entryPointAddress: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-    paymasterAddress: "0xA0e2667AcdECb9bCDa6Fcf87638a962e2E9dB20D",
+    paymasterAddress: "0x1c5aCCb9c09D72945b79EC986776136bE01d7B2F",
     poolsAccountsMap: {
-      "0x8c4a04d872a6c1be37964a21ba3a138525dff50b": "0x8A70E3dE493B8599447013f08d8b35719C8ED0ec",
-      "0x8cc930096b4df705a007c4a039bdfa1320ed2508": "0x191e3De3cF7f61de7EbEf4Bf45cfBA4f652d1C6e",
-      "0x6921fd1a97441dd603a997ed6ddf388658daf754": "0x060d053A6595630851ab873d6C95401b0C964d26"
+      // pool -> per-pool TornadoFeeAdapter (eth_0_1, eth_1, dai_100)
+      "0x8c4a04d872a6c1be37964a21ba3a138525dff50b": "0xa616aAE443FCCABfc2F1EA2Afe001E5046FFDCe0",
+      "0x8cc930096b4df705a007c4a039bdfa1320ed2508": "0x67a898343F32641206d0f30CB3367944a8919A3A",
+      "0x6921fd1a97441dd603a997ed6ddf388658daf754": "0xbF0a7969dacF8337716d0F283df0574dF56b0479"
     }
   },
   1: {}
@@ -371,8 +372,7 @@ var TornadoCashConfigs = {
     aggregator: {
       address: 0xE8F47A78A6D52D317D0D2FFFac56739fE14D1b49n
     },
-    weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2n,
-    uniswapQuoterV2: 0x61fFE014bA17989E743c5F6cB21bF9697530B21en
+    weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2n
   },
   11155111: {
     ensSubdomainKey: "sepolia-tornado",
@@ -387,8 +387,7 @@ var TornadoCashConfigs = {
     aggregator: {
       address: 0x4088712AC9fad39ea133cdb9130E465d235e9642n
     },
-    weth: 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14n,
-    uniswapQuoterV2: 0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3n
+    weth: 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14n
   }
 };
 
@@ -420,7 +419,8 @@ var TornadoCashProtocol = class {
     stateManagerWorkerUrl,
     relayerConfig,
     paymasterConfig = TornadoPaymasterConfigs,
-    relayerClientFactory = () => new RelayerClient(host)
+    relayerClientFactory = () => new RelayerClient(host),
+    minExternalSyncBlocksAmount
   }) {
     this.host = host;
     this.stateManager = (async () => {
@@ -431,6 +431,18 @@ var TornadoCashProtocol = class {
           reject(err);
         });
       });
+      const { externalSyncProvider } = host;
+      const externalSyncClient = externalSyncProvider && {
+        getEvents: async (params) => {
+          const events = [];
+          for await (const event of externalSyncProvider.streamEvents(params)) {
+            events.push(event);
+          }
+          return events;
+        },
+        firstCoveredBlock: (params) => externalSyncProvider.firstCoveredBlock(params),
+        lastCoveredBlock: (params) => externalSyncProvider.lastCoveredBlock(params)
+      };
       await Promise.race([
         remote.init(
           proxy(host.provider),
@@ -439,7 +451,8 @@ var TornadoCashProtocol = class {
           proxy(host.storage),
           proxy(initialState),
           proxy(artifactsLoader),
-          { protocolConfig, accountIndex, relayerConfig, paymasterConfig }
+          externalSyncClient ? proxy(externalSyncClient) : void 0,
+          { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }
         ),
         workerReady
       ]);
@@ -448,7 +461,16 @@ var TornadoCashProtocol = class {
         getBalances: ((assets) => remote.getBalances(assets)),
         getNotes: (params) => remote.getNotes(params),
         getDepositPayload: (params) => remote.getDepositPayload(params),
-        getWithdrawalPayloads: (params) => remote.getWithdrawalPayloads(params),
+        getWithdrawalPayloads: (params) => {
+          if (params.mode === "paymaster") {
+            const { tailCalls, ...rest } = params;
+            return remote.getWithdrawalPayloads(
+              rest,
+              tailCalls ? proxy(tailCalls) : void 0
+            );
+          }
+          return remote.getWithdrawalPayloads(params);
+        },
         dumpState: (() => remote.dumpState())
       };
     })();
@@ -515,7 +537,10 @@ var TornadoCashProtocol = class {
     });
     return { txns: tx };
   }
-  async prepareUnshield(assets, to, options) {
+  async prepareUnshield(assets, to, options = { mode: "relayer" }) {
+    if (options.mode === "relayer" && options.tailCalls !== void 0) {
+      throw new Error("Tail Calls are only supported when using paymaster mode.");
+    }
     const { asset, amount } = assets;
     const parsedAsset = BigInt(asset.contract || E_ADDRESS_BIGINT);
     const stateManager = await this.stateManager;
@@ -530,7 +555,8 @@ var TornadoCashProtocol = class {
       withdrawals = await stateManager.getWithdrawalPayloads({
         ...baseParams,
         mode: "paymaster",
-        delegation: options.delegation
+        delegation: options.delegation,
+        tailCalls: options.tailCalls
       });
     } else {
       withdrawals = await stateManager.getWithdrawalPayloads({
@@ -553,120 +579,51 @@ var TornadoCashProtocol = class {
     return stateManager.dumpState();
   }
 };
-
-// src/paymaster/fee.ts
-var ERC20_TRANSFER_GAS = 100000n;
-var baseGasUnits = {
-  preVerificationGas: 80000n,
-  verificationGasLimit: 50000n,
-  callGasLimit: 300000n,
-  paymasterVerificationGasLimit: 350000n,
-  paymasterPostOpGasLimit: 10000n
-};
-function reasonableGasUnits(isERC20) {
-  if (!isERC20) return baseGasUnits;
-  return {
-    ...baseGasUnits,
-    callGasLimit: baseGasUnits.callGasLimit + ERC20_TRANSFER_GAS
-  };
+function createPaymasterBundlerClient(bundlerUrl) {
+  return createBundlerClient({ transport: http(bundlerUrl) });
 }
-async function signDelegationAuthorization({
-  privateKey,
-  accountAddress,
-  chainId,
-  nonce
-}) {
-  const account = privateKeyToAccount(privateKey);
-  const authorization = await account.signAuthorization({
-    contractAddress: accountAddress,
-    chainId,
-    nonce
+async function sendSerializedUserOperation(client, op, entryPoint) {
+  return client.request({
+    method: "eth_sendUserOperation",
+    params: [op, entryPoint]
   });
-  return { authorization, senderAddress: account.address };
 }
 
 // src/paymaster/paymaster-broadcaster.ts
 var PaymasterBroadcaster = class _PaymasterBroadcaster {
-  constructor(provider, options) {
-    this.provider = provider;
-    this.options = options;
-  }
-  provider;
-  options;
   async broadcast(withdrawals) {
-    const chainId = Number(await this.provider.getChainId());
-    const {
-      poolsAccountsMap: rawPoolsAccountsMap
-    } = this.options[chainId];
-    const poolAcountsMap = new Map(
-      Object.entries(rawPoolsAccountsMap).map(([poolAccount, tornadoAccount]) => [
-        BigInt(poolAccount),
-        tornadoAccount
-      ])
-    );
-    const results = await Promise.allSettled(
-      withdrawals.map((w) => _PaymasterBroadcaster.broadcastOne({
-        ...w,
-        accountAddress: poolAcountsMap.get(w.poolAddress)
-      }, this.provider))
+    const bySender = /* @__PURE__ */ new Map();
+    for (const w of withdrawals) {
+      const key = w.userOperation.sender.toLowerCase();
+      const group = bySender.get(key) ?? [];
+      group.push(w);
+      bySender.set(key, group);
+    }
+    const groupResults = await Promise.allSettled(
+      [...bySender.values()].map(async (group) => {
+        const out = [];
+        for (const w of group) {
+          out.push(await _PaymasterBroadcaster.broadcastOne(w));
+        }
+        return out;
+      })
     );
-    const failed = results.filter((r) => r.status === "rejected");
+    const failed = groupResults.filter((r) => r.status === "rejected");
     if (failed.length > 0) {
       console.warn(
         `Some paymaster withdrawals failed.`,
         failed.map((e) => e.reason).join("\n")
       );
     }
-    return results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    return groupResults.filter((r) => r.status === "fulfilled").flatMap((r) => r.value);
   }
-  static async broadcastOne(withdrawal, provider) {
-    const {
-      proof: { proof: proofHex, args: proofArgs },
-      paymasterAddress,
-      entryPointAddress,
-      bundlerUrl,
-      accountAddress,
-      isERC20
-    } = withdrawal;
-    const [root, nullifierHash, recipient, _paymasterAddress, feeHex] = proofArgs;
-    if (BigInt(paymasterAddress) !== BigInt(_paymasterAddress)) {
-      throw new Error(`relayer must be paymaster when using the 4337 paymaster flow: ${paymasterAddress} != ${_paymasterAddress}`);
-    }
-    const delegation = withdrawal.delegation ?? await _PaymasterBroadcaster.generateRandomDelegation(accountAddress, provider);
-    const { senderAddress, authorization } = delegation;
-    const bundlerClient = new BundlerClient(bundlerUrl, entryPointAddress);
-    const { standard: { maxFeePerGas, maxPriorityFeePerGas } } = await bundlerClient.getUserOperationGasPrice();
-    let gas;
-    {
-      gas = {
-        type: "manual",
-        ...reasonableGasUnits(isERC20),
-        maxFeePerGas,
-        maxPriorityFeePerGas
-      };
-    }
-    const op = await new TornadoBuilder(senderAddress).withPaymaster(paymasterAddress).withAuthorization(authorization).withWithdraw(
-      proofHex,
-      root,
-      nullifierHash,
-      recipient,
-      _paymasterAddress,
-      BigInt(feeHex)
-    ).withGas(gas).build(provider, bundlerClient);
-    const userOpHash = await bundlerClient.sendUserOperation(op);
-    await bundlerClient.waitForUserOperationReceipt(userOpHash);
+  static async broadcastOne(withdrawal) {
+    const { bundlerUrl, entryPointAddress, userOperation } = withdrawal;
+    const bundlerClient = createPaymasterBundlerClient(bundlerUrl);
+    const userOpHash = await sendSerializedUserOperation(bundlerClient, userOperation, entryPointAddress);
+    await bundlerClient.waitForUserOperationReceipt({ hash: userOpHash });
     return { userOpHash };
   }
-  static async generateRandomDelegation(accountAddress, provider) {
-    const privateKey = generatePrivateKey();
-    const chainId = Number(await provider.getChainId());
-    return signDelegationAuthorization({
-      privateKey,
-      accountAddress,
-      chainId,
-      nonce: 0
-    });
-  }
 };
 
 // src/plugin/broadcaster.ts
@@ -678,7 +635,7 @@ var TornadoCashBroadcaster = class {
     host,
     relayerClientFactory = () => new RelayerClient({ network: host.network }),
     paymasterConfig,
-    paymasterClientFactory = () => new PaymasterBroadcaster(host.provider, paymasterConfig)
+    paymasterClientFactory = () => new PaymasterBroadcaster()
   }) {
     this.provider = host.provider;
     this.relayerClient = relayerClientFactory();

package/dist/merkle-tree.browser.js

@@ -1,5 +1,5 @@
 // src/utils/merkle-tree/merkle-tree.util.browser.ts
-import { generateMimcMerkleProof, createMimcMerkleTreeParallel } from "mimc-tree";
+import { generateMimcMerkleProof, createMimcMerkleTreeParallel } from "@kohaku-eth/mimc-tree";
 var buildTree = async (leaves) => {
   return createMimcMerkleTreeParallel(leaves, { workerUrl: "./merkle-tree-worker.browser.js" });
 };

package/dist/merkle-tree.node.js

@@ -1,5 +1,5 @@
 // src/utils/merkle-tree/merkle-tree.util.node.ts
-import { generateMimcMerkleProof, createMimcMerkleTreeNodejsParallel } from "mimc-tree";
+import { generateMimcMerkleProof, createMimcMerkleTreeNodejsParallel } from "@kohaku-eth/mimc-tree";
 var buildTree = async (leaves) => {
   return createMimcMerkleTreeNodejsParallel(leaves);
 };