@kohaku-eth/tornado-cash 0.0.2-alpha.19 → 0.0.2-alpha.21

package/dist/state-manager.worker.node.js

@@ -16856,10 +16856,16 @@ async function SecretManager({
   const deriveDelegatorSigner = async ({ path }) => {
     return Promise.resolve(keystore.deriveAt(path));
   };
+  const LEGACY_EPHEMERAL_SALT = asciiToBytes("KOHAKU7702");
+  const deriveLegacyEphemeralSigner = async ({ nullifier }) => {
+    const hash2 = keccak_256(concatBytes2(numberToBytesLE(nullifier, 31), LEGACY_EPHEMERAL_SALT));
+    return `0x${bytesToHex2(hash2)}`;
+  };
   return {
     getDepositSecrets: (params) => deriveSecrets(params),
     deriveEphemeralSigner,
-    deriveDelegatorSigner
+    deriveDelegatorSigner,
+    deriveLegacyEphemeralSigner
   };
 }
 function tcPath({ accountIndex, secretType, depositIndex }) {
@@ -17898,10 +17904,10 @@ function getUnexpectedStateShapeWarningMessage(inputState, reducers2, action, un
 function assertReducerShape(reducers2) {
   Object.keys(reducers2).forEach((key) => {
     const reducer = reducers2[key];
-    const initialState9 = reducer(void 0, {
+    const initialState10 = reducer(void 0, {
       type: actionTypes_default.INIT
     });
-    if (typeof initialState9 === "undefined") {
+    if (typeof initialState10 === "undefined") {
       throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : `The slice reducer for key "${key}" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
     }
     if (typeof reducer(void 0, {
@@ -19142,7 +19148,7 @@ function createThunkMiddleware(extraArgument) {
 var thunk = createThunkMiddleware();
 var withExtraArgument = createThunkMiddleware;
 
-// ../../node_modules/.pnpm/@reduxjs+toolkit@2.12.0_react@19.2.7/node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
+// ../../node_modules/.pnpm/@reduxjs+toolkit@2.12.0_react@19.2.8/node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
 var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
   if (arguments.length === 0) return void 0;
   if (typeof arguments[0] === "object") return compose;
@@ -19763,7 +19769,7 @@ function executeReducerBuilderCallback(builderCallback) {
 function isStateFunction(x) {
   return typeof x === "function";
 }
-function createReducer(initialState9, mapOrBuilderCallback) {
+function createReducer(initialState10, mapOrBuilderCallback) {
   if (process.env.NODE_ENV !== "production") {
     if (typeof mapOrBuilderCallback === "object") {
       throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
@@ -19771,10 +19777,10 @@ function createReducer(initialState9, mapOrBuilderCallback) {
   }
   let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
   let getInitialState;
-  if (isStateFunction(initialState9)) {
-    getInitialState = () => freezeDraftable(initialState9());
+  if (isStateFunction(initialState10)) {
+    getInitialState = () => freezeDraftable(initialState10());
   } else {
-    const frozenInitialState = freezeDraftable(initialState9);
+    const frozenInitialState = freezeDraftable(initialState10);
     getInitialState = () => frozenInitialState;
   }
   function reducer(state = getInitialState(), action) {
@@ -20429,10 +20435,29 @@ var relayersSelector = createSelector(
   )
 );
 var relayerFeeConfigSelector = (state) => state.relayers.feeConfig;
-var userSecretsSelector = selectEntityMap(
+var derivedUserSecretsSelector = selectEntityMap(
   (s) => s.userSecrets.byPool,
   deserialize
 );
+var legacyUserSecretsSelector = selectEntityMap(
+  (s) => s.legacySecrets.byPool,
+  deserialize
+);
+var userSecretsSelector = createSelector(
+  [derivedUserSecretsSelector, legacyUserSecretsSelector],
+  (derived, legacy) => {
+    const result = /* @__PURE__ */ new Map();
+    for (const [poolAddress, records] of legacy) {
+      const existing = result.get(poolAddress) ?? [];
+      result.set(poolAddress, [...existing, ...records.map((record) => ({ kind: "legacy", ...record }))]);
+    }
+    for (const [poolAddress, records] of derived) {
+      const existing = result.get(poolAddress) ?? [];
+      result.set(poolAddress, [...existing, ...records.map((record) => ({ kind: "derived", ...record }))]);
+    }
+    return result;
+  }
+);
 
 // src/state/selectors/deposits.selector.ts
 var myDepositsSelector = createSelector(
@@ -20446,7 +20471,7 @@ var myDepositsSelector = createSelector(
         const commitment = BigInt(r.commitment);
         const deposit = poolDeposits.get(commitment);
         if (deposit) {
-          result.set(commitment, { ...deposit, index: r.depositIndex });
+          result.set(commitment, { ...deposit, index: r.kind === "derived" ? r.depositIndex : -1 });
         }
       }
     }
@@ -20827,6 +20852,28 @@ var userSecretsSlice = createSlice({
 var { addUserSecret } = userSecretsSlice.actions;
 var userSecretsReducer = userSecretsSlice.reducer;
 
+// src/state/slices/legacySecretsSlice.ts
+var initialState9 = {
+  byPool: []
+};
+var legacySecretsSlice = createSlice({
+  name: "legacySecrets",
+  initialState: initialState9,
+  reducers: {
+    addLegacyUserSecret: ({ byPool }, { payload: { poolAddress, record } }) => {
+      const map = new Map(deserialize(byPool));
+      const records = map.get(poolAddress) || [];
+      if (!records.some((r) => r.commitment === record.commitment)) {
+        records.push(record);
+      }
+      map.set(poolAddress, records);
+      return serialize({ byPool: [...map] });
+    }
+  }
+});
+var { addLegacyUserSecret } = legacySecretsSlice.actions;
+var legacySecretsReducer = legacySecretsSlice.reducer;
+
 // src/state/store.ts
 var reducers = {
   deposits: depositsReducer,
@@ -20836,7 +20883,8 @@ var reducers = {
   relayers: relayersReducer,
   instanceRegistryInfo: protocolConfigReducer,
   sync: syncReducer,
-  userSecrets: userSecretsReducer
+  userSecrets: userSecretsReducer,
+  legacySecrets: legacySecretsReducer
 };
 var loggerFactory = (logLevel) => (api) => (next) => (action) => {
   const result = next(action);
@@ -20866,11 +20914,11 @@ var loggerFactory = (logLevel) => (api) => (next) => (action) => {
 };
 var storeFactory = ({
   protocolConfig,
-  initialState: initialState9,
+  initialState: initialState10,
   logLevel = "error"
 }) => {
   const store = configureStore({
-    preloadedState: initialState9,
+    preloadedState: initialState10,
     reducer: reducers,
     middleware: (getDefaultMiddleware) => {
       const defaultMiddleware = getDefaultMiddleware({
@@ -21229,7 +21277,7 @@ var discoverUserEventsThunk = createAsyncThunk(
     const deposits = depositsSelector(state);
     const pools = poolsSelector(state);
     const { chainId } = instanceRegistryInfoSelector(state);
-    const userSecrets = userSecretsSelector(state);
+    const userSecrets = derivedUserSecretsSelector(state);
     for (const [poolAddress] of pools) {
       const startIndex = userSecrets.get(poolAddress)?.length ?? 0;
       const poolDeposits = deposits.get(poolAddress);
@@ -21433,7 +21481,7 @@ var createTx = (address, payload, value = BigInt(0)) => {
 init_exports();
 init_encodeAbiParameters2();
 
-// ../../node_modules/.pnpm/@privacy-paymasters+sdk@0.0.4_typescript@5.9.3_zod@4.4.3/node_modules/@privacy-paymasters/sdk/dist/index.js
+// ../../node_modules/.pnpm/@privacy-paymasters+sdk@0.0.5_typescript@5.9.3_zod@4.4.3/node_modules/@privacy-paymasters/sdk/dist/index.js
 function encodePaymasterData(adapter, adapterData) {
   return encodeAbiParameters2(parseAbiParameters("(address adapter, bytes adapterData)"), [{ adapter, adapterData }]);
 }
@@ -21615,7 +21663,7 @@ var baseGasUnits = {
   preVerificationGas: 100000n,
   verificationGasLimit: 50000n,
   callGasLimit: 300000n,
-  paymasterVerificationGasLimit: 350000n,
+  paymasterVerificationGasLimit: 450000n,
   paymasterPostOpGasLimit: 50000n
 };
 function reasonableGasUnits(isERC20) {
@@ -23481,6 +23529,22 @@ var paymasterWithdrawThunk = createAsyncThunk("withdraw/executePaymasterWithdraw
   );
   const bundlerClient = createPaymasterBundlerClient(bundlerUrl);
   const { standard: { maxFeePerGas, maxPriorityFeePerGas } } = await getUserOperationGasPrice(bundlerClient);
+  const refineGasWithBundler = async (baselineGas2, provisionalUserOperation) => {
+    try {
+      const estimated = await estimateUserOperationGas2(bundlerClient, provisionalUserOperation, entryPointAddress);
+      const buffer2 = (x) => x * 12n / 10n;
+      const orBaseline = (e, b) => e > 0n ? buffer2(e) : b;
+      return {
+        callGasLimit: orBaseline(estimated.callGasLimit, baselineGas2.callGasLimit),
+        verificationGasLimit: orBaseline(estimated.verificationGasLimit, baselineGas2.verificationGasLimit),
+        preVerificationGas: orBaseline(estimated.preVerificationGas, baselineGas2.preVerificationGas),
+        paymasterVerificationGasLimit: orBaseline(estimated.paymasterVerificationGasLimit, baselineGas2.paymasterVerificationGasLimit),
+        paymasterPostOpGasLimit: orBaseline(estimated.paymasterPostOpGasLimit, baselineGas2.paymasterPostOpGasLimit)
+      };
+    } catch {
+      return baselineGas2;
+    }
+  };
   const relayerAddress = BigInt(paymasterAddress);
   const bigintChainId = await dataService.getChainId();
   const { recipient: originalRecipient, ...restWithoutRecipient } = rest;
@@ -23507,11 +23571,13 @@ var paymasterWithdrawThunk = createAsyncThunk("withdraw/executePaymasterWithdraw
       )
     );
   };
-  const ephemeralSigner = async (deposit) => privateKeyToAccount(await secretManager.deriveEphemeralSigner({
-    depositIndex: deposit.index,
-    chainId: bigintChainId,
-    poolAddress: deposit.pool
-  }));
+  const ephemeralSigner = async (deposit) => privateKeyToAccount(
+    deposit.kind === "legacy" ? await secretManager.deriveLegacyEphemeralSigner({ nullifier: deposit.nullifier }) : await secretManager.deriveEphemeralSigner({
+      depositIndex: deposit.depositIndex,
+      chainId: bigintChainId,
+      poolAddress: deposit.pool
+    })
+  );
   const resolveBatchDelegator = async () => {
     if (delegation?.mode === "random") return privateKeyToAccount(generatePrivateKey());
     if (delegation?.mode === "deterministic" && delegation.path) {
@@ -23525,19 +23591,36 @@ var paymasterWithdrawThunk = createAsyncThunk("withdraw/executePaymasterWithdraw
   if (!needsConsolidation) {
     const deposit = deposits[0];
     const signer2 = await resolveIndependentSigner(deposit);
-    const gasUnits = reasonableGasUnits(poolInfo.isERC20);
-    const fee2 = await quoteFee(computeMinimumViableFee(gasUnits, maxFeePerGas));
-    const proof = await prove(deposit, originalRecipient, relayerAddress, fee2);
-    const userOperation2 = await buildSignedTornadoUserOp({
+    const baselineGas2 = { ...reasonableGasUnits(poolInfo.isERC20), callGasLimit: 0n };
+    let fee2 = await quoteFee(computeMinimumViableFee(baselineGas2, maxFeePerGas));
+    let gas2 = baselineGas2;
+    let proof = await prove(deposit, originalRecipient, relayerAddress, fee2);
+    let userOperation2 = await buildSignedTornadoUserOp({
       signer: signer2,
       chainId,
       paymasterAddress,
       paymasterData: buildPaymasterData(deposit.pool, proof),
-      gas: { ...gasUnits, callGasLimit: 0n },
+      gas: gas2,
       maxFeePerGas,
       maxPriorityFeePerGas,
       nonce: 0n
     });
+    const estimatedGas = await refineGasWithBundler(baselineGas2, userOperation2);
+    if (estimatedGas !== baselineGas2) {
+      gas2 = { ...estimatedGas, callGasLimit: 0n };
+      fee2 = await quoteFee(computeMinimumViableFee(gas2, maxFeePerGas));
+      proof = await prove(deposit, originalRecipient, relayerAddress, fee2);
+      userOperation2 = await buildSignedTornadoUserOp({
+        signer: signer2,
+        chainId,
+        paymasterAddress,
+        paymasterData: buildPaymasterData(deposit.pool, proof),
+        gas: gas2,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: 0n
+      });
+    }
     return [{
       mode: "paymaster",
       proof,
@@ -23606,22 +23689,12 @@ var paymasterWithdrawThunk = createAsyncThunk("withdraw/executePaymasterWithdraw
   let gas = baselineGas;
   let sponsoringProof = await prove(sponsoringDeposit, senderAddress, relayerAddress, fee);
   let userOperation = await buildOp(gas, fee, buildPaymasterData(sponsoringDeposit.pool, sponsoringProof));
-  try {
-    const estimated = await estimateUserOperationGas2(bundlerClient, userOperation, entryPointAddress);
-    const buffer2 = (x) => x * 12n / 10n;
-    const orBaseline = (e, b) => e > 0n ? buffer2(e) : b;
-    const refinedGas = {
-      callGasLimit: orBaseline(estimated.callGasLimit, baselineGas.callGasLimit),
-      verificationGasLimit: orBaseline(estimated.verificationGasLimit, baselineGas.verificationGasLimit),
-      preVerificationGas: orBaseline(estimated.preVerificationGas, baselineGas.preVerificationGas),
-      paymasterVerificationGasLimit: orBaseline(estimated.paymasterVerificationGasLimit, baselineGas.paymasterVerificationGasLimit),
-      paymasterPostOpGasLimit: orBaseline(estimated.paymasterPostOpGasLimit, baselineGas.paymasterPostOpGasLimit)
-    };
-    fee = await quoteFee(computeMinimumViableFee(refinedGas, maxFeePerGas));
+  const refinedGas = await refineGasWithBundler(baselineGas, userOperation);
+  if (refinedGas !== baselineGas) {
     gas = refinedGas;
+    fee = await quoteFee(computeMinimumViableFee(gas, maxFeePerGas));
     sponsoringProof = await prove(sponsoringDeposit, senderAddress, relayerAddress, fee);
     userOperation = await buildOp(gas, fee, buildPaymasterData(sponsoringDeposit.pool, sponsoringProof));
-  } catch {
   }
   return [{
     mode: "paymaster",
@@ -23703,7 +23776,7 @@ var getDepositPayloadThunk = createAsyncThunk(
     const state = getState();
     const pools = poolsSelector(state);
     const { chainId } = instanceRegistryInfoSelector(state);
-    const userSecrets = userSecretsSelector(state);
+    const userSecrets = derivedUserSecretsSelector(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);
@@ -23752,6 +23825,62 @@ var getDepositPayloadThunk = createAsyncThunk(
   }
 );
 
+// src/account/legacyNote.ts
+init_utils2();
+var NOTE_REGEX = /^tornado-([a-zA-Z0-9]+)-([0-9.]+)-(\d+)-0x([0-9a-fA-F]+)$/;
+function parseLegacyNote(note) {
+  const match = NOTE_REGEX.exec(note.trim());
+  if (!match) {
+    throw new Error(`Invalid tornado cash note: ${note}`);
+  }
+  const [, currency, denomination, chainId, preimageHex] = match;
+  const preimageBytes = hexToBytes2(preimageHex);
+  if (preimageBytes.length !== 62) {
+    throw new Error(`Invalid tornado cash note preimage length: ${note}`);
+  }
+  const nullifierBytes = preimageBytes.subarray(0, 31);
+  const saltBytes = preimageBytes.subarray(31, 62);
+  return {
+    currency,
+    denomination,
+    chainId: BigInt(chainId),
+    nullifier: bytesToNumberLE(nullifierBytes),
+    salt: bytesToNumberLE(saltBytes),
+    commitment: pedersenHash2(preimageBytes),
+    nullifierHash: pedersenHash2(nullifierBytes)
+  };
+}
+
+// src/state/thunks/importLegacyNotesThunk.ts
+var importLegacyNotesThunk = createAsyncThunk(
+  "userSecrets/importLegacy",
+  async ({ notes }, { getState, dispatch }) => {
+    const state = getState();
+    const deposits = depositsSelector(state);
+    const { chainId } = instanceRegistryInfoSelector(state);
+    return notes.map((note) => {
+      const parsed = parseLegacyNote(note);
+      if (parsed.chainId !== chainId) {
+        return { note, status: "wrong-chain" };
+      }
+      const matchedPool = [...deposits].find(([, poolDeposits]) => poolDeposits.has(parsed.commitment))?.[0];
+      if (!matchedPool) {
+        return { note, status: "not-found" };
+      }
+      dispatch(addLegacyUserSecret({
+        poolAddress: matchedPool,
+        record: {
+          commitment: parsed.commitment,
+          nullifierHash: parsed.nullifierHash,
+          nullifier: parsed.nullifier,
+          salt: parsed.salt
+        }
+      }));
+      return { note, status: "imported", poolAddress: matchedPool };
+    });
+  }
+);
+
 // src/state/state-manager.ts
 var ETH_SEPOLIA_CHAIN_ID = 11155111n;
 var getStoreKey = ({
@@ -23766,6 +23895,10 @@ var initializeSelectors = (store) => ({
     getAllNotes: () => allNotesSelector(store.getState())
   },
   getPublicState: () => {
+    const { userSecrets, legacySecrets, ...publicState } = store.getState();
+    return publicState;
+  },
+  getPrivateState: () => {
     const { userSecrets, ...publicState } = store.getState();
     return publicState;
   }
@@ -23795,13 +23928,13 @@ var storeByChainAndEntrypoint = ({
         const rawStoredState = storageToSyncTo ? await storageToSyncTo.get(storageKey) : void 0;
         const storedState = rawStoredState ? JSON.parse(rawStoredState) : void 0;
         const snapshotInitialState = storedState || !resolveInitialState ? void 0 : (await resolveInitialState())[storageKey];
-        let initialState9 = storedState || snapshotInitialState;
-        if (!initialState9 && getChainStoreParams.chainId === ETH_SEPOLIA_CHAIN_ID) {
-          initialState9 = await Promise.resolve().then(() => __toESM(require_state_11155111_minimal(), 1)).then((a) => a["tornado-cash-state-11155111-447664927873626138772898946646079239273904189887"]);
+        let initialState10 = storedState || snapshotInitialState;
+        if (!initialState10 && getChainStoreParams.chainId === ETH_SEPOLIA_CHAIN_ID) {
+          initialState10 = await Promise.resolve().then(() => __toESM(require_state_11155111_minimal(), 1)).then((a) => a["tornado-cash-state-11155111-447664927873626138772898946646079239273904189887"]);
         }
         const store = storeFactory({
           protocolConfig,
-          initialState: initialState9
+          initialState: initialState10
         });
         store.dispatch(setRelayerFeeConfig(relayerConfig));
         storeWithSelectors = initializeSelectors(store);
@@ -23830,14 +23963,14 @@ var storeStateManager = async ({
   paymasterConfig,
   proverFactory,
   storageToSyncTo,
-  initialState: initialState9,
+  initialState: initialState10,
   protocolConfig,
   relayerConfig
 }) => {
   const secretManager = await secretManagerFactory();
   const { getChainStore, getAllStores } = storeByChainAndEntrypoint({
     storageToSyncTo,
-    initialState: initialState9
+    initialState: initialState10
   });
   const getChainInfo = async () => {
     const chainId = await dataService.getChainId();
@@ -23851,6 +23984,14 @@ var storeStateManager = async ({
       }
     };
   };
+  const persistStateIfAvailable = async (chainInfo, store) => {
+    if (storageToSyncTo) {
+      await storageToSyncTo.set(
+        getStoreStorageKey(chainInfo),
+        JSON.stringify(store.getPrivateState())
+      );
+    }
+  };
   return {
     sync: async () => {
       const chainInfo = await getChainInfo();
@@ -23866,12 +24007,7 @@ var storeStateManager = async ({
           })
         )
       );
-      if (storageToSyncTo) {
-        await storageToSyncTo.set(
-          getStoreStorageKey(chainInfo),
-          JSON.stringify(store.getPublicState())
-        );
-      }
+      await persistStateIfAvailable(chainInfo, store);
     },
     getBalances: async (assets) => {
       const { selectors: { specificAssetsBalanceSelector: specificAssetsBalanceSelector2 } } = await getChainStore(await getChainInfo());
@@ -23937,6 +24073,15 @@ var storeStateManager = async ({
         )
       );
     },
+    importNotes: async ({ notes }) => {
+      const chainInfo = await getChainInfo();
+      const store = await getChainStore(chainInfo);
+      const result = unwrapResult(
+        await store.dispatch(importLegacyNotesThunk({ notes }))
+      );
+      await persistStateIfAvailable(chainInfo, store);
+      return result;
+    },
     dumpState: () => getAllStores()
   };
 };
@@ -23948,12 +24093,12 @@ function getStateManager() {
   return _stateManager;
 }
 var workerApi = {
-  async init(provider, relayerClient, keystore, rawStorage, initialState9, artifactsLoader, externalSyncProvider, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }) {
+  async init(provider, relayerClient, keystore, rawStorage, initialState10, artifactsLoader, secretManager, externalSyncProvider, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }) {
     const storage = rawStorage;
     const dataService = new DataService({ provider });
     _stateManager = await storeStateManager({
       paymasterConfig,
-      secretManagerFactory: () => SecretManager({ host: { keystore }, accountIndex }),
+      secretManagerFactory: () => secretManager ? Promise.resolve(secretManager) : SecretManager({ host: { keystore }, accountIndex }),
       dataService,
       syncService: new SyncService({ dataService, externalSyncProvider, minExternalSyncBlocksAmount }),
       relayerClient,
@@ -23961,7 +24106,7 @@ var workerApi = {
       storageToSyncTo: storage,
       protocolConfig,
       relayerConfig,
-      initialState: initialState9
+      initialState: initialState10
     });
   },
   sync() {
@@ -23976,6 +24121,9 @@ var workerApi = {
   getDepositPayload(params) {
     return getStateManager().getDepositPayload(params);
   },
+  importNotes(params) {
+    return getStateManager().importNotes(params);
+  },
   getWithdrawalPayloads(params, tailCalls) {
     const fullParams = params.mode === "paymaster" && tailCalls ? { ...params, tailCalls } : params;
     return getStateManager().getWithdrawalPayloads(fullParams);

package/dist/worker-loader.browser.d.ts

@@ -7,6 +7,8 @@ import * as _kohaku_eth_provider from '@kohaku-eth/provider';
 import { TxData } from '@kohaku-eth/provider';
 import { Address as Address$1 } from 'ox/Address';
 
+type Nullifier = bigint & {};
+type NullifierHash = bigint & {};
 type Address = bigint & {};
 type Commitment = bigint & {};
 interface IContract {
@@ -30,6 +32,41 @@ interface ProtocolConfigState {
 type RootState = ReturnType<ReturnType<typeof combineReducers<typeof reducers>>>;
 type PublicRootState = Omit<RootState, 'userSecrets'>;
 
+interface Secret {
+    nullifier: Nullifier;
+    salt: bigint;
+    commitment: Commitment;
+    nullifierHash: NullifierHash;
+}
+type BaseDeriveSecretParams = {
+    poolAddress: bigint;
+    chainId: bigint;
+};
+type DeriveDepositSecretParams = BaseDeriveSecretParams & {
+    depositIndex: number;
+};
+interface ISecretManager {
+    getDepositSecrets: (params: DeriveDepositSecretParams) => Promise<Secret>;
+    deriveEphemeralSigner: (params: DeriveDepositSecretParams) => Promise<`0x${string}`>;
+    /**
+     * Derives a delegator key from a classical wallet BIP-32 `path`, WITHOUT the
+     * `coalesceSecret` privacy transform, so it resolves to a recoverable,
+     * classical Ethereum address. Used for the tail-call batch delegator when the
+     * integrator supplies a wallet path (see `paymasterWithdrawThunk`).
+     */
+    deriveDelegatorSigner: (params: {
+        path: string;
+    }) => Promise<`0x${string}`>;
+    /**
+     * Derives the ephemeral signer for an imported legacy note. Legacy secrets
+     * have no keystore-derived `depositIndex`, so this is a pure function of
+     * the note's own nullifier instead of a BIP-32 derivation.
+     */
+    deriveLegacyEphemeralSigner: (params: {
+        nullifier: Nullifier;
+    }) => Promise<`0x${string}`>;
+}
+
 interface IBaseEvent {
     blockNumber: bigint;
     transactionHash: bigint;
@@ -91,6 +128,18 @@ interface IRelayerClient {
     withdraw(relayerUrl: string, body: ITornadoWithdrawRequest): Promise<ITornadoWithdrawResponse>;
 }
 
+type ImportNoteResult = {
+    note: string;
+    status: 'imported';
+    poolAddress: Address;
+} | {
+    note: string;
+    status: 'wrong-chain';
+} | {
+    note: string;
+    status: 'not-found';
+};
+
 interface TornadoProveOutput {
     proof: `0x${string}`;
     args: [
@@ -241,11 +290,14 @@ interface WorkerInitOptions {
 
 declare function loadStateManagerWorker(workerUrl?: string | URL): {
     remote: comlink.Remote<{
-        init(provider: _kohaku_eth_provider.EthereumProvider, relayerClient: IRelayerClient, keystore: _kohaku_eth_plugins.Keystore, rawStorage: Omit<_kohaku_eth_plugins.Storage, "_brand">, initialState: () => Promise<Record<string, PublicRootState>>, artifactsLoader: () => Promise<ITornadoArtifacts>, externalSyncProvider: ExternalSyncClient | undefined, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }: WorkerInitOptions): Promise<void>;
+        init(provider: _kohaku_eth_provider.EthereumProvider, relayerClient: IRelayerClient, keystore: _kohaku_eth_plugins.Keystore, rawStorage: Omit<_kohaku_eth_plugins.Storage, "_brand">, initialState: () => Promise<Record<string, PublicRootState>>, artifactsLoader: () => Promise<ITornadoArtifacts>, secretManager: ISecretManager | undefined, externalSyncProvider: ExternalSyncClient | undefined, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }: WorkerInitOptions): Promise<void>;
         sync(): Promise<void>;
         getBalances(assets?: Address[]): Promise<Map<Address, bigint>>;
         getNotes(params: IGetNotesParams): Promise<TCNote[]>;
         getDepositPayload(params: IDepositOperationParams): Promise<_kohaku_eth_provider.TxData[]>;
+        importNotes(params: {
+            notes: string[];
+        }): Promise<ImportNoteResult[]>;
         getWithdrawalPayloads(params: IWithdrawapOperationParams, tailCalls?: IPaymasterWithdrawParams["tailCalls"]): Promise<IWithdrawalPayload[]>;
         dumpState(): Record<StoreStorageKey, Omit<RootState, "userSecrets">>;
     }>;

package/dist/worker-loader.node.d.ts

@@ -8,6 +8,8 @@ import { TxData } from '@kohaku-eth/provider';
 import { Address as Address$1 } from 'ox/Address';
 import { Worker } from 'worker_threads';
 
+type Nullifier = bigint & {};
+type NullifierHash = bigint & {};
 type Address = bigint & {};
 type Commitment = bigint & {};
 interface IContract {
@@ -31,6 +33,41 @@ interface ProtocolConfigState {
 type RootState = ReturnType<ReturnType<typeof combineReducers<typeof reducers>>>;
 type PublicRootState = Omit<RootState, 'userSecrets'>;
 
+interface Secret {
+    nullifier: Nullifier;
+    salt: bigint;
+    commitment: Commitment;
+    nullifierHash: NullifierHash;
+}
+type BaseDeriveSecretParams = {
+    poolAddress: bigint;
+    chainId: bigint;
+};
+type DeriveDepositSecretParams = BaseDeriveSecretParams & {
+    depositIndex: number;
+};
+interface ISecretManager {
+    getDepositSecrets: (params: DeriveDepositSecretParams) => Promise<Secret>;
+    deriveEphemeralSigner: (params: DeriveDepositSecretParams) => Promise<`0x${string}`>;
+    /**
+     * Derives a delegator key from a classical wallet BIP-32 `path`, WITHOUT the
+     * `coalesceSecret` privacy transform, so it resolves to a recoverable,
+     * classical Ethereum address. Used for the tail-call batch delegator when the
+     * integrator supplies a wallet path (see `paymasterWithdrawThunk`).
+     */
+    deriveDelegatorSigner: (params: {
+        path: string;
+    }) => Promise<`0x${string}`>;
+    /**
+     * Derives the ephemeral signer for an imported legacy note. Legacy secrets
+     * have no keystore-derived `depositIndex`, so this is a pure function of
+     * the note's own nullifier instead of a BIP-32 derivation.
+     */
+    deriveLegacyEphemeralSigner: (params: {
+        nullifier: Nullifier;
+    }) => Promise<`0x${string}`>;
+}
+
 interface IBaseEvent {
     blockNumber: bigint;
     transactionHash: bigint;
@@ -92,6 +129,18 @@ interface IRelayerClient {
     withdraw(relayerUrl: string, body: ITornadoWithdrawRequest): Promise<ITornadoWithdrawResponse>;
 }
 
+type ImportNoteResult = {
+    note: string;
+    status: 'imported';
+    poolAddress: Address;
+} | {
+    note: string;
+    status: 'wrong-chain';
+} | {
+    note: string;
+    status: 'not-found';
+};
+
 interface TornadoProveOutput {
     proof: `0x${string}`;
     args: [
@@ -242,11 +291,14 @@ interface WorkerInitOptions {
 
 declare function loadStateManagerWorker(workerUrl?: string | URL): {
     remote: comlink.Remote<{
-        init(provider: _kohaku_eth_provider.EthereumProvider, relayerClient: IRelayerClient, keystore: _kohaku_eth_plugins.Keystore, rawStorage: Omit<_kohaku_eth_plugins.Storage, "_brand">, initialState: () => Promise<Record<string, PublicRootState>>, artifactsLoader: () => Promise<ITornadoArtifacts>, externalSyncProvider: ExternalSyncClient | undefined, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }: WorkerInitOptions): Promise<void>;
+        init(provider: _kohaku_eth_provider.EthereumProvider, relayerClient: IRelayerClient, keystore: _kohaku_eth_plugins.Keystore, rawStorage: Omit<_kohaku_eth_plugins.Storage, "_brand">, initialState: () => Promise<Record<string, PublicRootState>>, artifactsLoader: () => Promise<ITornadoArtifacts>, secretManager: ISecretManager | undefined, externalSyncProvider: ExternalSyncClient | undefined, { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }: WorkerInitOptions): Promise<void>;
         sync(): Promise<void>;
         getBalances(assets?: Address[]): Promise<Map<Address, bigint>>;
         getNotes(params: IGetNotesParams): Promise<TCNote[]>;
         getDepositPayload(params: IDepositOperationParams): Promise<_kohaku_eth_provider.TxData[]>;
+        importNotes(params: {
+            notes: string[];
+        }): Promise<ImportNoteResult[]>;
         getWithdrawalPayloads(params: IWithdrawapOperationParams, tailCalls?: IPaymasterWithdrawParams["tailCalls"]): Promise<IWithdrawalPayload[]>;
         dumpState(): Record<StoreStorageKey, Omit<RootState, "userSecrets">>;
     }>;