@kohaku-eth/tornado-cash 0.0.1 → 0.0.2-alpha.9

package/dist/index.js

@@ -0,0 +1,778 @@
+import { createSelector, createAsyncThunk } from '@reduxjs/toolkit';
+import { createTx } from '@kohaku-eth/provider';
+import { encodeFunctionData, toHex, erc20Abi } 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 { 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
+
+// src/data/abis/pool.abi.ts
+var poolAbi = [
+  {
+    type: "function",
+    name: "getLastRoot",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "currentRootIndex",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint32",
+        internalType: "uint32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "roots",
+    inputs: [{
+      type: "uint256"
+    }],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "denomination",
+    inputs: [],
+    outputs: [
+      {
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [
+      {
+        name: "_commitment",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    inputs: [
+      { name: "_proof", type: "bytes", internalType: "bytes" },
+      { name: "_root", type: "bytes32", internalType: "bytes32" },
+      { name: "_nullifierHash", type: "bytes32", internalType: "bytes32" },
+      { name: "_recipient", type: "address", internalType: "address" },
+      { name: "_relayer", type: "address", internalType: "address" },
+      { name: "_fee", type: "uint256", internalType: "uint256" },
+      { name: "_refund", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "ROOT_HISTORY_SIZE",
+    inputs: [],
+    outputs: [{
+      type: "uint32"
+    }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isKnownRoot",
+    inputs: [{
+      name: "_root",
+      type: "bytes32"
+    }],
+    outputs: [{
+      type: "bool"
+    }],
+    stateMutability: "view"
+  }
+];
+function prepareNativeShield({ commitment, poolAddress, poolDenomination }) {
+  const data = encodeFunctionData({
+    abi: poolAbi,
+    functionName: "deposit",
+    args: [toHex(commitment, { size: 32 })]
+  });
+  return createTx(poolAddress, data, poolDenomination);
+}
+function prepareErc20Shield({ commitment, tokenAddress, poolAddress, denomination }) {
+  const approveData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [poolAddress, denomination]
+  });
+  const depositData = encodeFunctionData({
+    abi: poolAbi,
+    functionName: "deposit",
+    args: [toHex(commitment, { size: 32 })]
+  });
+  return [
+    createTx(tokenAddress, approveData),
+    createTx(poolAddress, depositData)
+  ];
+}
+function addressToHex(address, padding = 40) {
+  return `0x${address.toString(16).padStart(padding, "0")}`;
+}
+
+// src/state/utils/serialize.utils.ts
+var deserialize = (data, strings) => {
+  switch (typeof data) {
+    case "object": {
+      if (data === null) {
+        return data;
+      }
+      if (data instanceof Array) {
+        if (data.length === 2) {
+          const stringsData = strings || [];
+          return [
+            deserialize(data[0], stringsData[0]),
+            deserialize(data[1], stringsData[1])
+          ];
+        }
+        return data.map(
+          (d) => deserialize(d, strings)
+        );
+      }
+      return Object.entries(data).reduce(
+        (deserializedObject, [key, value]) => {
+          deserializedObject[key] = deserialize(
+            value,
+            (strings || {})[key]
+          );
+          return deserializedObject;
+        },
+        {}
+      );
+    }
+    case "string":
+      return strings === true ? data : BigInt(data);
+    default:
+      return data;
+  }
+};
+
+// src/state/utils/selectors.utils.ts
+var selectEntityMap = (mapFn, transform = deserialize) => createSelector([mapFn], (tuple) => new Map(tuple.map(transform)));
+createSelector(
+  [(s) => s.deposits.depositsTuples],
+  (tuples) => {
+    const deserialized = deserialize(tuples);
+    return new Map(
+      deserialized.map(
+        ([poolAddress, innerTuples]) => [poolAddress, new Map(innerTuples)]
+      )
+    );
+  }
+);
+var instanceRegistryInfoSelector = createSelector(
+  [(state) => state.instanceRegistryInfo],
+  (poolInfo) => deserialize(poolInfo, { ensSubdomainKey: true })
+);
+var poolsSelector = selectEntityMap(
+  (s) => s.pools.poolsTuples,
+  deserialize
+);
+selectEntityMap(
+  (s) => s.withdrawals.withdrawalsTuples,
+  deserialize
+);
+selectEntityMap(
+  (s) => s.assets.assetsTuples,
+  (assetsTuple) => deserialize(assetsTuple, [void 0, { name: true, symbol: true }])
+);
+createSelector(
+  [(state) => state.relayers.relayersTuples],
+  (tuples) => tuples.map(
+    ([, relayer]) => deserialize(relayer, { ensName: true, hostname: true })
+  )
+);
+var userSecretsSelector = selectEntityMap(
+  (s) => s.userSecrets.byPool,
+  deserialize
+);
+
+// src/state/thunks/getDepositPayloadThunk.ts
+var DepositStrategy = /* @__PURE__ */ ((DepositStrategy2) => {
+  DepositStrategy2[DepositStrategy2["MaxAnonimitySet"] = 0] = "MaxAnonimitySet";
+  DepositStrategy2[DepositStrategy2["MinFee"] = 1] = "MinFee";
+  return DepositStrategy2;
+})(DepositStrategy || {});
+var calculatePoolsDeposits = (pools, value, strategy) => {
+  if (!pools.length) {
+    throw new Error("No pools to deposit into");
+  }
+  const poolsToDepositInto = [];
+  switch (strategy) {
+    case 0 /* MaxAnonimitySet */: {
+      const lowToHighDenominationPools = pools.sort((a, b) => Number(a.denomination - b.denomination));
+      const lowestDenominationPool = lowToHighDenominationPools[0];
+      const depositsCount = Number(value / lowestDenominationPool.denomination);
+      poolsToDepositInto.push({
+        ...lowestDenominationPool,
+        depositsCount
+      });
+      break;
+    }
+    case 1 /* MinFee */: {
+      const highToLowDenominationPools = pools.sort((a, b) => Number(b.denomination - a.denomination));
+      highToLowDenominationPools.reduce((remainingAmount, pool) => {
+        const depositsForThisPool = remainingAmount / pool.denomination;
+        if (depositsForThisPool > 0n) {
+          poolsToDepositInto.push({
+            ...pool,
+            depositsCount: Number(depositsForThisPool)
+          });
+        }
+        return remainingAmount - depositsForThisPool * pool.denomination;
+      }, value);
+      break;
+    }
+  }
+  return poolsToDepositInto;
+};
+createAsyncThunk(
+  "deposits/getPayload",
+  async ({ secretManager, asset, amount, strategy }, { getState }) => {
+    const state = getState();
+    const pools = poolsSelector(state);
+    const { chainId } = instanceRegistryInfoSelector(state);
+    const userSecrets = userSecretsSelector(state);
+    const poolsCandidates = Array.from(pools.values()).filter((p) => p.asset === asset);
+    if (poolsCandidates.length === 0) throw new Error(`No pools available for asset ${addressToHex(asset)}`);
+    const poolsToDepositInto = calculatePoolsDeposits(poolsCandidates, amount, strategy);
+    const depositInfo = await Promise.all(poolsToDepositInto.map(async (pool) => {
+      const startIndex = userSecrets.get(pool.address)?.length ?? 0;
+      const count = pool.depositsCount;
+      const secrets = await Promise.all(
+        Array.from(
+          { length: count },
+          (_, i) => secretManager.getDepositSecrets({
+            chainId,
+            depositIndex: startIndex + i,
+            poolAddress: pool.address
+          })
+        )
+      );
+      return {
+        ...pool,
+        secrets
+      };
+    }));
+    const newDeposits = depositInfo.reduce((txData, { secrets, ...pool }) => {
+      const poolAddressHex = addressToHex(pool.address);
+      if (!pool.isERC20) {
+        const newDeposits3 = secrets.map(
+          ({ commitment }) => prepareNativeShield({
+            commitment,
+            poolAddress: poolAddressHex,
+            poolDenomination: pool.denomination
+          })
+        );
+        return txData.concat(newDeposits3);
+      }
+      const assetHex = addressToHex(pool.asset);
+      const newDeposits2 = secrets.flatMap(
+        ({ commitment }) => prepareErc20Shield({
+          commitment,
+          tokenAddress: assetHex,
+          poolAddress: poolAddressHex,
+          denomination: pool.denomination
+        })
+      );
+      return txData.concat(newDeposits2);
+    }, []);
+    return newDeposits;
+  }
+);
+
+// src/relayer/relayer-client.ts
+var RelayerError = class extends Error {
+};
+var RelayerClient = class {
+  fetch;
+  constructor({ network: { fetch: fetch2 } }) {
+    this.fetch = fetch2;
+  }
+  async getStatus(hostname) {
+    const statusResponse = await this.fetch(`https://${hostname}/status`);
+    return statusResponse.json();
+  }
+  async withdraw(relayerUrl, body) {
+    const response = await this.fetch(`${relayerUrl}v1/tornadoWithdraw`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const { error } = await response.json();
+      throw new RelayerError(error);
+    }
+    return response.json();
+  }
+};
+
+// src/config.ts
+var E_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var E_ADDRESS_BIGINT = BigInt(E_ADDRESS);
+var TornadoPaymasterConfigs = {
+  11155111: {
+    bundlerUrl: "https://public.pimlico.io/v2/11155111/rpc",
+    entryPointAddress: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+    paymasterAddress: "0xA0e2667AcdECb9bCDa6Fcf87638a962e2E9dB20D",
+    poolsAccountsMap: {
+      "0x8c4a04d872a6c1be37964a21ba3a138525dff50b": "0x8A70E3dE493B8599447013f08d8b35719C8ED0ec",
+      "0x8cc930096b4df705a007c4a039bdfa1320ed2508": "0x191e3De3cF7f61de7EbEf4Bf45cfBA4f652d1C6e",
+      "0x6921fd1a97441dd603a997ed6ddf388658daf754": "0x060d053A6595630851ab873d6C95401b0C964d26"
+    }
+  },
+  1: {}
+};
+var TornadoCashConfigs = {
+  1: {
+    ensSubdomainKey: "mainnet-tornado",
+    instanceRegistry: {
+      address: 0xB20c66C4DE72433F3cE747b58B86830c459CA911n,
+      deploymentBlock: 14173395n
+    },
+    relayerRegistry: {
+      address: 0x58E8dCC13BE9780fC42E8723D8EaD4CF46943dF2n,
+      deploymentBlock: 14173129n
+    },
+    aggregator: {
+      address: 0xE8F47A78A6D52D317D0D2FFFac56739fE14D1b49n
+    },
+    weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2n,
+    uniswapQuoterV2: 0x61fFE014bA17989E743c5F6cB21bF9697530B21en
+  },
+  11155111: {
+    ensSubdomainKey: "sepolia-tornado",
+    instanceRegistry: {
+      address: 0x4e69fD587118dFb64957d18654E3894118E9B1BFn,
+      deploymentBlock: 5594611n
+    },
+    relayerRegistry: {
+      address: 0xD6663593E71e4916eCb6f6606e1A6FbfA1634ffAn,
+      deploymentBlock: 5594660n
+    },
+    aggregator: {
+      address: 0x4088712AC9fad39ea133cdb9130E465d235e9642n
+    },
+    weth: 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14n,
+    uniswapQuoterV2: 0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3n
+  }
+};
+
+// src/utils/circuit-loader.ts
+async function loadCircuitFiles(circuitUrl, provingKeyUrl) {
+  const [circuitRes, provingKeyRes] = await Promise.all([
+    fetch(circuitUrl),
+    fetch(provingKeyUrl)
+  ]);
+  const [circuitText, provingKey] = await Promise.all([
+    circuitRes.text(),
+    provingKeyRes.arrayBuffer()
+  ]);
+  return { circuitText, provingKey };
+}
+
+// src/utils/default-artifacts-loader.ts
+var TC_CIRCUIT_URL = "https://raw.githubusercontent.com/tornadocash/tornado-cli/refs/heads/master/build/circuits/tornado.json";
+var TC_PROVING_KEY_URL = "https://github.com/tornadocash/tornado-cli/raw/refs/heads/master/build/circuits/tornadoProvingKey.bin";
+var defaultArtifactsLoader = () => loadCircuitFiles(TC_CIRCUIT_URL, TC_PROVING_KEY_URL);
+
+// src/plugin/base.ts
+var TornadoCashProtocol = class {
+  constructor(host, {
+    accountIndex = 0,
+    initialState = async () => ({}),
+    protocolConfig,
+    artifactsLoader = defaultArtifactsLoader,
+    stateManagerWorkerUrl,
+    relayerConfig,
+    paymasterConfig = TornadoPaymasterConfigs,
+    relayerClientFactory = () => new RelayerClient(host)
+  }) {
+    this.host = host;
+    this.stateManager = (async () => {
+      const { remote, onError } = loadStateManagerWorker(stateManagerWorkerUrl);
+      const workerReady = new Promise((_resolve, reject) => {
+        onError((err) => {
+          console.error("[worker crash]", err);
+          reject(err);
+        });
+      });
+      await Promise.race([
+        remote.init(
+          proxy(host.provider),
+          proxy(relayerClientFactory()),
+          proxy(host.keystore),
+          proxy(host.storage),
+          proxy(initialState),
+          proxy(artifactsLoader),
+          { protocolConfig, accountIndex, relayerConfig, paymasterConfig }
+        ),
+        workerReady
+      ]);
+      return {
+        sync: () => remote.sync(),
+        getBalances: ((assets) => remote.getBalances(assets)),
+        getDepositPayload: (params) => remote.getDepositPayload(params),
+        getWithdrawalPayloads: (params) => remote.getWithdrawalPayloads(params),
+        dumpState: (() => remote.dumpState())
+      };
+    })();
+  }
+  host;
+  stateManager;
+  instanceId = () => Promise.resolve("0x1");
+  /**
+   * Only process supported assets or error out?
+   * Returns the balances of the requested assets.
+   * The assets retain the provided order. If an asset is not supported its balance will be 0
+   */
+  async balance(assets = []) {
+    const stateManager = await this.stateManager;
+    await stateManager.sync();
+    const parsedDesiredAssets = assets.map(({ contract }) => {
+      const parsedAddress = BigInt(contract);
+      return parsedAddress === E_ADDRESS_BIGINT ? 0n : parsedAddress;
+    });
+    const balances = await stateManager.getBalances(
+      assets.length > 0 ? parsedDesiredAssets : void 0
+    );
+    const actuallySelectedAssets = assets.length > 0 ? assets.map((a) => a.contract) : [...balances.keys()].map((a) => addressToHex(a));
+    return actuallySelectedAssets.map((assetAddress, index) => {
+      const parsedSelectedAsset = BigInt(actuallySelectedAssets[index]);
+      const balance = balances.get(parsedSelectedAsset === E_ADDRESS_BIGINT ? 0n : parsedSelectedAsset) || 0n;
+      const asset = {
+        contract: assetAddress,
+        __type: "erc20"
+      };
+      return {
+        asset,
+        amount: balance
+      };
+    });
+  }
+  async prepareShield(assets, options) {
+    const { asset, amount } = assets;
+    const strategy = typeof options === "string" ? 1 /* MinFee */ : options?.strategy || 1 /* MinFee */;
+    const stateManager = await this.stateManager;
+    await stateManager.sync();
+    const parsedAsset = BigInt(asset.contract);
+    const tx = await stateManager.getDepositPayload({
+      asset: parsedAsset === E_ADDRESS_BIGINT ? 0n : parsedAsset,
+      amount,
+      strategy
+    });
+    return { txns: tx };
+  }
+  async prepareUnshield(assets, to, options) {
+    const { asset, amount } = assets;
+    const parsedAsset = BigInt(asset.contract || E_ADDRESS_BIGINT);
+    const stateManager = await this.stateManager;
+    await stateManager.sync();
+    const baseParams = {
+      asset: parsedAsset === E_ADDRESS_BIGINT ? 0n : parsedAsset,
+      amount,
+      recipient: BigInt(to)
+    };
+    let withdrawals;
+    if (options && options.mode === "paymaster") {
+      withdrawals = await stateManager.getWithdrawalPayloads({
+        ...baseParams,
+        mode: "paymaster",
+        delegation: options.delegation
+      });
+    } else {
+      withdrawals = await stateManager.getWithdrawalPayloads({
+        ...baseParams,
+        mode: "relayer",
+        preferredRelayersEns: options?.preferredRelayersEns
+      });
+    }
+    return {
+      __type: "privateOperation",
+      withdrawals
+    };
+  }
+  async sync() {
+    const stateManager = await this.stateManager;
+    return stateManager.sync();
+  }
+  async dumpState() {
+    const stateManager = await this.stateManager;
+    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
+  };
+}
+async function signDelegationAuthorization({
+  privateKey,
+  accountAddress,
+  chainId,
+  nonce
+}) {
+  const account = privateKeyToAccount(privateKey);
+  const authorization = await account.signAuthorization({
+    contractAddress: accountAddress,
+    chainId,
+    nonce
+  });
+  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,
+      bundlerUrl,
+      paymasterAddress,
+      entryPointAddress
+    } = 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,
+        bundlerUrl,
+        paymasterAddress,
+        entryPointAddress,
+        accountAddress: poolAcountsMap.get(w.poolAddress)
+      }, this.provider))
+    );
+    const failed = results.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);
+  }
+  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);
+    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
+var TornadoCashBroadcaster = class {
+  relayerClient;
+  provider;
+  paymasterBroadcaster;
+  constructor({
+    host,
+    relayerClientFactory = () => new RelayerClient({ network: host.network }),
+    paymasterConfig,
+    paymasterClientFactory = () => new PaymasterBroadcaster(host.provider, paymasterConfig)
+  }) {
+    this.provider = host.provider;
+    this.relayerClient = relayerClientFactory();
+    this.paymasterBroadcaster = paymasterClientFactory();
+  }
+  async broadcast({
+    withdrawals
+  }) {
+    const relayerWithdrawals = withdrawals.filter((w) => w.mode === "relayer");
+    const paymasterWithdrawals = withdrawals.filter((w) => w.mode === "paymaster");
+    const [relayerResults, paymasterResults] = await Promise.all([
+      this.broadcastViaRelayer(relayerWithdrawals),
+      paymasterWithdrawals.length > 0 ? this.broadcastViaPaymaster(paymasterWithdrawals) : Promise.resolve([])
+    ]);
+    const normalizedPaymasterResults = paymasterResults.map(
+      ({ userOpHash }) => ({ id: userOpHash })
+    );
+    return [...relayerResults, ...normalizedPaymasterResults];
+  }
+  async broadcastViaRelayer(withdrawals) {
+    if (withdrawals.length === 0) return [];
+    const successes = [];
+    const failures = [];
+    for (const { proof: { args, proof }, poolAddress, relayerUrl } of withdrawals) {
+      try {
+        successes.push(await this.relayerClient.withdraw(relayerUrl, {
+          proof,
+          args,
+          contract: addressToHex(poolAddress)
+        }));
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length > 0) {
+      console.warn(`Some withdrawals failed.`, failures.map((e) => e.message).join("\n"));
+    }
+    return successes;
+  }
+  async broadcastViaPaymaster(withdrawals) {
+    return this.paymasterBroadcaster.broadcast(withdrawals);
+  }
+};
+
+// src/v1/factory.ts
+var createTCBroadcaster = (host, params) => {
+  const paymasterConfig = params?.paymasterConfig || TornadoPaymasterConfigs;
+  return new TornadoCashBroadcaster({ host, ...params, paymasterConfig });
+};
+var createTCPlugin = ((host, params) => new TornadoCashProtocol(host, params));
+function pedersenHash(msg) {
+  const hash = pedersenHash$1(msg);
+  return Point.decode(hash).x;
+}
+
+// src/account/keys.ts
+var TORNADO_CASH_PATH = "m/29795'/1'";
+var MASK_248 = (1n << 248n) - 1n;
+function coalesceSecret({ secret, chainId, poolAddress }) {
+  return bytesToNumberLE(
+    keccak_256(
+      concatBytes(
+        numberToBytesLE(BigInt(secret), 32),
+        numberToBytesLE(chainId, 8),
+        numberToBytesLE(poolAddress, 20)
+      )
+    )
+  );
+}
+async function SecretManager({
+  host: { keystore },
+  accountIndex = 0
+}) {
+  const deriveSecrets = async ({ chainId, poolAddress, depositIndex }) => {
+    const saltSecretRaw = await Promise.resolve(keystore.deriveAt(tcPath({ accountIndex, secretType: "salt", depositIndex })));
+    const nullifierSecretRaw = await Promise.resolve(keystore.deriveAt(tcPath({ accountIndex, secretType: "nullifier", depositIndex })));
+    const salt = coalesceSecret({ secret: saltSecretRaw, chainId, poolAddress }) & MASK_248;
+    const nullifier = coalesceSecret({ secret: nullifierSecretRaw, chainId, poolAddress }) & MASK_248;
+    const nullifierBytes = numberToBytesLE(nullifier, 31);
+    const preimage = new Uint8Array(62);
+    preimage.set(nullifierBytes, 0);
+    preimage.set(numberToBytesLE(salt, 31), 31);
+    const commitment = pedersenHash(preimage);
+    const nullifierHash = pedersenHash(nullifierBytes);
+    return { nullifier, salt, commitment, nullifierHash };
+  };
+  const deriveEphemeralSigner = async ({ chainId, poolAddress, depositIndex }) => {
+    const path = tcPath({ accountIndex, secretType: "signer", depositIndex });
+    const raw = await Promise.resolve(keystore.deriveAt(path));
+    const coalesced = coalesceSecret({ secret: raw, chainId, poolAddress });
+    return `0x${coalesced.toString(16).padStart(64, "0")}`;
+  };
+  return {
+    getDepositSecrets: (params) => deriveSecrets(params),
+    deriveEphemeralSigner
+  };
+}
+function tcPath({ accountIndex, secretType, depositIndex }) {
+  const _secretType = {
+    "nullifier": 0,
+    "salt": 1,
+    "signer": 2
+  }[secretType];
+  return `${TORNADO_CASH_PATH}/${accountIndex}'/${_secretType}'/${depositIndex}'`;
+}
+
+export { DepositStrategy, E_ADDRESS, SecretManager, TornadoCashConfigs, TornadoCashProtocol, createTCBroadcaster, createTCPlugin };