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

package/dist/index.d.ts

@@ -42,6 +42,14 @@ interface ISecretManager {
     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$1;
+    }) => Promise<`0x${string}`>;
 }
 interface SecretManagerParams {
     host: Pick<Host, 'keystore'>;
@@ -361,6 +369,18 @@ declare enum DepositStrategy {
     MinFee = 1
 }
 
+type ImportNoteResult = {
+    note: string;
+    status: 'imported';
+    poolAddress: Address;
+} | {
+    note: string;
+    status: 'wrong-chain';
+} | {
+    note: string;
+    status: 'not-found';
+};
+
 /**
  * How the batch delegator for a tail-call paymaster withdrawal is produced.
  * Only honored when `tailCalls` are present (see `paymasterWithdrawThunk`).
@@ -545,6 +565,14 @@ interface IStateManager {
      * @param assets - Optional filter by specific assets
      */
     getNotes: (params: IGetNotesParams) => Promise<TCNote[]>;
+    /**
+     * Parses legacy (pre-SDK) Tornado Cash note strings and, for any that match
+     * a synced on-chain deposit on the current chain, registers them as
+     * importable user secrets.
+     */
+    importNotes: (params: {
+        notes: string[];
+    }) => Promise<ImportNoteResult[]>;
     dumpState: () => Record<StoreStorageKey, PublicRootState>;
 }
 
@@ -558,6 +586,7 @@ interface TCBaseCredential {
     accountIndex: number;
 }
 interface TCPluginParameters extends TCBroadcasterParameters, TCBaseCredential, Pick<TCProtocolParams, 'initialState' | 'minExternalSyncBlocksAmount'> {
+    secretManagerFactory?: TCProtocolParams['secretManagerFactory'];
     protocolConfig: TCProtocolConfig;
     relayerConfig?: IRelayerFeeConfig;
     stateManagerWorkerUrl?: string;
@@ -602,6 +631,7 @@ type TCInstance = PluginInstance<TCAddress, {
         prepareShield(asset: TCAssetAmount, options: TCPrepareShieldOptions): Promise<TCPublicOperation>;
         prepareUnshield(asset: TCAssetAmount, to: Address$1, options: TCRelayerUnshieldOptions): Promise<TCPrivateOperation<'relayer'>>;
         prepareUnshield(asset: TCAssetAmount, to: Address$1, options: TCPaymasterUnshieldOptions): Promise<TCPrivateOperation<'paymaster'>>;
+        importNotes(notes: string | string[]): Promise<ImportNoteResult[]>;
     };
     publicOp: TCPublicOperation;
     privateOp: TCPrivateOperation;
@@ -614,7 +644,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, minExternalSyncBlocksAmount, }: RequireOnly<TCProtocolParams, 'protocolConfig'>);
+    constructor(host: Host, { accountIndex, initialState, protocolConfig, artifactsLoader, stateManagerWorkerUrl, relayerConfig, paymasterConfig, relayerClientFactory, minExternalSyncBlocksAmount, secretManagerFactory, }: RequireOnly<TCProtocolParams, 'protocolConfig'>);
     instanceId: () => Promise<"0x1">;
     /**
      * Only process supported assets or error out?
@@ -628,6 +658,11 @@ declare class TornadoCashProtocol implements TCInstance {
      * @param includeSpent - Include notes with zero balance (default: false)
      */
     notes(assets?: ERC20AssetId[], includeSpent?: boolean): Promise<TCNote[]>;
+    /**
+     * Parses legacy (pre-SDK) Tornado Cash note strings and registers any that
+     * match a synced on-chain deposit on the current chain as user secrets.
+     */
+    importNotes(notes: string | string[]): Promise<ImportNoteResult[]>;
     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'>>;
@@ -717,4 +752,4 @@ declare const TornadoCashConfigs: {
     };
 };
 
-export { type Commitment, DepositStrategy, E_ADDRESS, type ISecretManager, type Nullifier, SecretManager, type SecretManagerParams, type TCAddress, type TCAssetAmount, type TCAssetBalance, type TCBroadcaster, type TCBroadcasterParameters, type TCInstance, type TCNote, type TCPaymasterUnshieldOptions, type TCPluginParameters, type TCPrepareShieldOptions, type TCPrepareUnshieldOptions, type TCRelayerUnshieldOptions, TornadoCashConfigs, TornadoCashProtocol, TornadoPaymasterConfigs, createTCBroadcaster, createTCPlugin };
+export { type Commitment, DepositStrategy, E_ADDRESS, type ISecretManager, type ImportNoteResult, type Nullifier, SecretManager, type SecretManagerParams, type TCAddress, type TCAssetAmount, type TCAssetBalance, type TCBroadcaster, type TCBroadcasterParameters, type TCInstance, type TCNote, type TCPaymasterUnshieldOptions, type TCPluginParameters, type TCPrepareShieldOptions, type TCPrepareUnshieldOptions, type TCRelayerUnshieldOptions, TornadoCashConfigs, TornadoCashProtocol, TornadoPaymasterConfigs, createTCBroadcaster, createTCPlugin };

package/dist/index.js

@@ -5,7 +5,7 @@ import { proxy } from 'comlink';
 import { loadStateManagerWorker } from '#worker-loader';
 import 'viem/accounts';
 import { createBundlerClient } from 'viem/account-abstraction';
-import { numberToBytesLE, bytesToNumberLE, concatBytes } from '@noble/curves/utils.js';
+import { asciiToBytes, numberToBytesLE, concatBytes, bytesToHex, bytesToNumberLE } 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';
 
@@ -216,10 +216,29 @@ createSelector(
     ([, relayer]) => deserialize(relayer, { ensName: true, hostname: true })
   )
 );
-var userSecretsSelector = selectEntityMap(
+var derivedUserSecretsSelector = selectEntityMap(
   (s) => s.userSecrets.byPool,
   deserialize
 );
+var legacyUserSecretsSelector = selectEntityMap(
+  (s) => s.legacySecrets.byPool,
+  deserialize
+);
+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/thunks/getDepositPayloadThunk.ts
 var DepositStrategy = /* @__PURE__ */ ((DepositStrategy2) => {
@@ -266,7 +285,7 @@ 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);
@@ -456,7 +475,8 @@ var TornadoCashProtocol = class {
     relayerConfig,
     paymasterConfig = TornadoPaymasterConfigs,
     relayerClientFactory = () => new RelayerClient(host),
-    minExternalSyncBlocksAmount
+    minExternalSyncBlocksAmount,
+    secretManagerFactory
   }) {
     this.host = host;
     this.stateManager = (async () => {
@@ -479,6 +499,7 @@ var TornadoCashProtocol = class {
         firstCoveredBlock: (params) => externalSyncProvider.firstCoveredBlock(params),
         lastCoveredBlock: (params) => externalSyncProvider.lastCoveredBlock(params)
       };
+      const resolvedSecretManager = secretManagerFactory ? await secretManagerFactory({ host: { keystore: host.keystore }, accountIndex }) : void 0;
       await Promise.race([
         remote.init(
           proxy(host.provider),
@@ -487,6 +508,7 @@ var TornadoCashProtocol = class {
           proxy(host.storage),
           proxy(initialState),
           proxy(artifactsLoader),
+          resolvedSecretManager ? proxy(resolvedSecretManager) : void 0,
           externalSyncClient ? proxy(externalSyncClient) : void 0,
           { protocolConfig, accountIndex, relayerConfig, paymasterConfig, minExternalSyncBlocksAmount }
         ),
@@ -497,6 +519,7 @@ var TornadoCashProtocol = class {
         getBalances: ((assets) => remote.getBalances(assets)),
         getNotes: (params) => remote.getNotes(params),
         getDepositPayload: (params) => remote.getDepositPayload(params),
+        importNotes: (params) => remote.importNotes(params),
         getWithdrawalPayloads: (params) => {
           if (params.mode === "paymaster") {
             const { tailCalls, ...rest } = params;
@@ -560,6 +583,15 @@ var TornadoCashProtocol = class {
       assets: assetAddresses.length > 0 ? assetAddresses : void 0
     });
   }
+  /**
+   * Parses legacy (pre-SDK) Tornado Cash note strings and registers any that
+   * match a synced on-chain deposit on the current chain as user secrets.
+   */
+  async importNotes(notes) {
+    const stateManager = await this.stateManager;
+    await stateManager.sync();
+    return stateManager.importNotes({ notes: Array.isArray(notes) ? notes : [notes] });
+  }
   async prepareShield(assets, options) {
     const { asset, amount } = assets;
     const strategy = typeof options === "string" ? 1 /* MinFee */ : options?.strategy || 1 /* MinFee */;
@@ -768,10 +800,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 hash = keccak_256(concatBytes(numberToBytesLE(nullifier, 31), LEGACY_EPHEMERAL_SALT));
+    return `0x${bytesToHex(hash)}`;
+  };
   return {
     getDepositSecrets: (params) => deriveSecrets(params),
     deriveEphemeralSigner,
-    deriveDelegatorSigner
+    deriveDelegatorSigner,
+    deriveLegacyEphemeralSigner
   };
 }
 function tcPath({ accountIndex, secretType, depositIndex }) {