@kohaku-eth/tornado-cash 0.0.2-alpha.11 → 0.0.2-alpha.13

package/dist/index.js

@@ -1,15 +1,13 @@
 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';
-import 'micro-zk-proofs/mimcsponge.js';
-import 'fixed-merkle-tree';
 
 // src/state/thunks/getDepositPayloadThunk.ts
 
@@ -350,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: {}
@@ -373,8 +372,7 @@ var TornadoCashConfigs = {
     aggregator: {
       address: 0xE8F47A78A6D52D317D0D2FFFac56739fE14D1b49n
     },
-    weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2n,
-    uniswapQuoterV2: 0x61fFE014bA17989E743c5F6cB21bF9697530B21en
+    weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2n
   },
   11155111: {
     ensSubdomainKey: "sepolia-tornado",
@@ -389,8 +387,7 @@ var TornadoCashConfigs = {
     aggregator: {
       address: 0x4088712AC9fad39ea133cdb9130E465d235e9642n
     },
-    weth: 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14n,
-    uniswapQuoterV2: 0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3n
+    weth: 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14n
   }
 };
 
@@ -423,7 +420,7 @@ var TornadoCashProtocol = class {
     relayerConfig,
     paymasterConfig = TornadoPaymasterConfigs,
     relayerClientFactory = () => new RelayerClient(host),
-    proverVersion
+    minExternalSyncBlocksAmount
   }) {
     this.host = host;
     this.stateManager = (async () => {
@@ -434,6 +431,17 @@ 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;
+        },
+        lastCoveredBlock: (params) => externalSyncProvider.lastCoveredBlock(params)
+      };
       await Promise.race([
         remote.init(
           proxy(host.provider),
@@ -442,15 +450,26 @@ var TornadoCashProtocol = class {
           proxy(host.storage),
           proxy(initialState),
           proxy(artifactsLoader),
-          { protocolConfig, accountIndex, relayerConfig, paymasterConfig, proverVersion }
+          externalSyncClient ? proxy(externalSyncClient) : void 0,
+          { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }
         ),
         workerReady
       ]);
       return {
         sync: () => remote.sync(),
         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())
       };
     })();
@@ -487,6 +506,23 @@ var TornadoCashProtocol = class {
       };
     });
   }
+  /**
+   * Returns all notes for the account.
+   * @param assets - Filter by specific assets (optional, if empty returns all)
+   * @param includeSpent - Include notes with zero balance (default: false)
+   */
+  async notes(assets = [], includeSpent = false) {
+    const stateManager = await this.stateManager;
+    await stateManager.sync();
+    const assetAddresses = assets.map(({ contract }) => {
+      const parsedAddress = BigInt(contract);
+      return parsedAddress === E_ADDRESS_BIGINT ? 0n : parsedAddress;
+    });
+    return stateManager.getNotes({
+      includeSpent,
+      assets: assetAddresses.length > 0 ? assetAddresses : void 0
+    });
+  }
   async prepareShield(assets, options) {
     const { asset, amount } = assets;
     const strategy = typeof options === "string" ? 1 /* MinFee */ : options?.strategy || 1 /* MinFee */;
@@ -500,7 +536,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;
@@ -515,7 +554,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({
@@ -538,120 +578,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
@@ -663,7 +634,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();