@permissionless-technologies/upp-sdk 0.5.5 → 0.5.7

package/dist/react/index.cjs

@@ -1,10 +1,14 @@
 'use strict';
 
-var chunkIYRCJAME_cjs = require('../chunk-IYRCJAME.cjs');
+var chunkC3HXJ5A6_cjs = require('../chunk-C3HXJ5A6.cjs');
+var chunkY3VL3LOE_cjs = require('../chunk-Y3VL3LOE.cjs');
+require('../chunk-IX7HV5TE.cjs');
 var chunkXVIICZKW_cjs = require('../chunk-XVIICZKW.cjs');
 var chunkVVW5VVY3_cjs = require('../chunk-VVW5VVY3.cjs');
+require('../chunk-IIUKM5VE.cjs');
+var chunkPGIV2GDM_cjs = require('../chunk-PGIV2GDM.cjs');
 var chunkARH2SJM3_cjs = require('../chunk-ARH2SJM3.cjs');
-require('../chunk-UFEDJJSH.cjs');
+var chunkBCSMUH4L_cjs = require('../chunk-BCSMUH4L.cjs');
 var chunkHEHXSV47_cjs = require('../chunk-HEHXSV47.cjs');
 var chunkG7VZBCD6_cjs = require('../chunk-G7VZBCD6.cjs');
 var react = require('react');
@@ -13,6 +17,7 @@ var jsxRuntime = require('react/jsx-runtime');
 var reactDom = require('react-dom');
 var upcSdk = require('@permissionless-technologies/upc-sdk');
 
+// src/core/eip712.ts
 var UPP_EIP712_DOMAIN = {
   name: "UPP Stealth Account",
   version: "2"
@@ -24,14 +29,8 @@ var UPP_EIP712_TYPES = {
     { name: "passwordHash", type: "bytes32" }
   ]
 };
-var UPPAccountContext = react.createContext(null);
-var sdkPromise = null;
-async function loadSDK() {
-  if (!sdkPromise) {
-    sdkPromise = import('../index.cjs');
-  }
-  return sdkPromise;
-}
+
+// src/core/storage-keys.ts
 function getStorageKey(ethAddress) {
   return `upp_pq_account_${ethAddress.toLowerCase()}`;
 }
@@ -41,6 +40,8 @@ function getNotesStorageKey(chainId, ownerHashPrefix) {
 function getChainFingerprintKey(chainId) {
   return `upp_chain_fp_${chainId}`;
 }
+
+// src/core/chain-fingerprint.ts
 async function checkChainFingerprint(chainId, publicClient) {
   if (typeof window === "undefined" || !publicClient) return true;
   const fpKey = getChainFingerprintKey(chainId);
@@ -70,6 +71,99 @@ async function checkChainFingerprint(chainId, publicClient) {
     return true;
   }
 }
+
+// src/core/circuit-selector.ts
+function selectOptimalCircuit(unspentNotes, requiredAmount, tokenAddress) {
+  let candidates = unspentNotes;
+  if (tokenAddress) {
+    candidates = candidates.filter(
+      (n) => n.token?.toLowerCase() === tokenAddress.toLowerCase()
+    );
+  }
+  const sortedNotes = [...candidates].sort((a, b) => a.amount > b.amount ? 1 : -1);
+  const singleNote = sortedNotes.find((n) => n.amount >= requiredAmount);
+  if (singleNote) {
+    return { circuit: "1x2", selectedNotes: [singleNote] };
+  }
+  for (let i = 0; i < sortedNotes.length; i++) {
+    for (let j = i + 1; j < sortedNotes.length; j++) {
+      const combined = sortedNotes[i].amount + sortedNotes[j].amount;
+      if (combined >= requiredAmount) {
+        return { circuit: "2x2", selectedNotes: [sortedNotes[i], sortedNotes[j]] };
+      }
+    }
+  }
+  const candidateBalance = candidates.reduce((acc, n) => acc + n.amount, 0n);
+  if (candidateBalance >= requiredAmount) {
+    return {
+      circuit: null,
+      selectedNotes: [],
+      error: "Requires more than 2 notes. Please consolidate first."
+    };
+  }
+  return { circuit: null, selectedNotes: [], error: "Insufficient balance" };
+}
+
+// src/core/note-crypto.ts
+chunkBCSMUH4L_cjs.init_crypto();
+async function createHashBasedNote(sdk, amount, spendingSecret, ownerHash, viewingSecret, origin, token) {
+  const blinding = await Promise.resolve(sdk.randomFieldElement());
+  const commitment = await sdk.poseidon([
+    amount,
+    ownerHash,
+    blinding,
+    origin,
+    token
+  ]);
+  const searchTagHash = await sdk.poseidon([viewingSecret, commitment]);
+  const searchTag = searchTagHash & (1n << 64n) - 1n;
+  const encryptedNote = await encryptNoteData(amount, blinding, origin, token, viewingSecret);
+  return {
+    commitment,
+    ownerSecret: spendingSecret,
+    ownerHash,
+    blinding,
+    encryptedNote,
+    searchTag,
+    amount,
+    origin,
+    token
+  };
+}
+async function encryptNoteData(amount, blinding, origin, token, viewingSecret) {
+  const keyMaterial = viem.keccak256(viem.toHex(viewingSecret, { size: 32 }));
+  const keyBytes = chunkBCSMUH4L_cjs.hexToBytes(keyMaterial);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer.slice(keyBytes.byteOffset, keyBytes.byteOffset + keyBytes.byteLength),
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt"]
+  );
+  const plaintext = new Uint8Array(104);
+  plaintext.set(chunkBCSMUH4L_cjs.bigintToBytes(amount, 32), 0);
+  plaintext.set(chunkBCSMUH4L_cjs.bigintToBytes(blinding, 32), 32);
+  plaintext.set(chunkBCSMUH4L_cjs.bigintToBytes(origin, 20), 64);
+  plaintext.set(chunkBCSMUH4L_cjs.bigintToBytes(token, 20), 84);
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: nonce },
+    cryptoKey,
+    plaintext
+  );
+  const result = new Uint8Array(12 + ciphertext.byteLength);
+  result.set(nonce, 0);
+  result.set(new Uint8Array(ciphertext), 12);
+  return viem.toHex(result);
+}
+var UPPAccountContext = react.createContext(null);
+var sdkPromise = null;
+async function loadSDK() {
+  if (!sdkPromise) {
+    sdkPromise = import('../index.cjs');
+  }
+  return sdkPromise;
+}
 function UPPAccountProvider({
   children,
   ethAddress,
@@ -88,10 +182,10 @@ function UPPAccountProvider({
   const [isSyncing, setIsSyncing] = react.useState(false);
   const [lastSyncedBlock, _setLastSyncedBlock] = react.useState(0);
   const [liveSyncInterval, setLiveSyncInterval] = react.useState(null);
-  const unwatchRef = react.useRef(null);
-  const syncPromiseRef = react.useRef(null);
   const noteStoreRef = react.useRef(null);
+  const [noteStoreReady, setNoteStoreReady] = react.useState(false);
   const accountAdapterRef = react.useRef(null);
+  const [initNonce, setInitNonce] = react.useState(0);
   react.useEffect(() => {
     loadSDK().then(() => setCryptoReady(true));
   }, []);
@@ -104,11 +198,12 @@ function UPPAccountProvider({
       setStarkMasterKeys(null);
       setNotes([]);
       noteStoreRef.current = null;
+      setNoteStoreReady(false);
       accountAdapterRef.current = null;
       return;
     }
     const accountStorage = chunkARH2SJM3_cjs.createIndexedDBAdapter(`upp_account`);
-    const adapter = new chunkIYRCJAME_cjs.StorableAccountAdapter(accountStorage, ethAddress);
+    const adapter = new chunkC3HXJ5A6_cjs.StorableAccountAdapter(accountStorage, ethAddress);
     accountAdapterRef.current = adapter;
     const legacyKey = getStorageKey(ethAddress);
     const legacySaved = typeof window !== "undefined" ? localStorage.getItem(legacyKey) : null;
@@ -149,8 +244,9 @@ function UPPAccountProvider({
       const ownerHashHex2 = viem.toHex(account.keys.ownerHash, { size: 32 });
       const storagePrefix = `upp_${chainId}_${ownerHashHex2.slice(0, 12)}`;
       const noteStorage = chunkARH2SJM3_cjs.createIndexedDBAdapter(storagePrefix);
-      const store = new chunkIYRCJAME_cjs.NoteStore(noteStorage, "notes");
+      const store = new chunkC3HXJ5A6_cjs.NoteStore(noteStorage, "notes");
       noteStoreRef.current = store;
+      setNoteStoreReady(true);
       noteStoreUnsub = store.onChange(() => {
         if (!cancelled) setNotes([...store.getNotes()]);
       });
@@ -189,15 +285,8 @@ function UPPAccountProvider({
     return () => {
       cancelled = true;
       if (noteStoreUnsub) noteStoreUnsub();
-      syncPromiseRef.current = null;
     };
-  }, [ethAddress, cryptoReady, chainId, publicClientProp]);
-  const persistNotes = react.useCallback(
-    (_notesToSave) => {
-      noteStoreRef.current?.persist().catch(console.error);
-    },
-    []
-  );
+  }, [ethAddress, cryptoReady, chainId, publicClientProp, initNonce]);
   const setupAccount = react.useCallback(
     async (signature) => {
       if (!ethAddress || !cryptoReady) {
@@ -215,6 +304,7 @@ function UPPAccountProvider({
         if (adapter) {
           await adapter.save(keys, starkKeys);
         }
+        setInitNonce((n) => n + 1);
       } finally {
         setIsLoading(false);
       }
@@ -252,8 +342,8 @@ function UPPAccountProvider({
   const logout = react.useCallback(() => {
     noteStoreRef.current?.clear().catch(console.error);
     noteStoreRef.current = null;
+    setNoteStoreReady(false);
     accountAdapterRef.current?.clear().catch(console.error);
-    accountAdapterRef.current = null;
     if (masterKeys) {
       const ownerHashHex2 = viem.toHex(masterKeys.ownerHash, { size: 32 });
       const notesKey = getNotesStorageKey(chainId, ownerHashHex2.slice(0, 12));
@@ -320,546 +410,87 @@ function UPPAccountProvider({
     () => unspentNotes.reduce((acc, n) => acc + n.amount, 0n),
     [unspentNotes]
   );
-  const selectOptimalCircuit = react.useCallback(
-    (requiredAmount, tokenAddress) => {
-      let candidates = unspentNotes;
-      if (tokenAddress) {
-        candidates = candidates.filter(
-          (n) => n.token?.toLowerCase() === tokenAddress.toLowerCase()
-        );
-      }
-      const sortedNotes = [...candidates].sort((a, b) => a.amount > b.amount ? 1 : -1);
-      const singleNote = sortedNotes.find((n) => n.amount >= requiredAmount);
-      if (singleNote) {
-        return { circuit: "1x2", selectedNotes: [singleNote] };
-      }
-      for (let i = 0; i < sortedNotes.length; i++) {
-        for (let j = i + 1; j < sortedNotes.length; j++) {
-          const combined = sortedNotes[i].amount + sortedNotes[j].amount;
-          if (combined >= requiredAmount) {
-            return { circuit: "2x2", selectedNotes: [sortedNotes[i], sortedNotes[j]] };
-          }
-        }
-      }
-      const candidateBalance = candidates.reduce((acc, n) => acc + n.amount, 0n);
-      if (candidateBalance >= requiredAmount) {
-        return {
-          circuit: null,
-          selectedNotes: [],
-          error: "Requires more than 2 notes. Please consolidate first."
-        };
-      }
-      return { circuit: null, selectedNotes: [], error: "Insufficient balance" };
-    },
-    [unspentNotes, balance]
+  const selectOptimalCircuitCb = react.useCallback(
+    (requiredAmount, tokenAddress) => selectOptimalCircuit(unspentNotes, requiredAmount, tokenAddress),
+    [unspentNotes]
   );
+  const syncEngineRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!masterKeys || !cryptoReady || !publicClientProp || !indexerConfig?.contractAddress || !noteStoreReady) {
+      syncEngineRef.current = null;
+      return;
+    }
+    let cancelled = false;
+    loadSDK().then((sdk) => {
+      if (cancelled) return;
+      const store = noteStoreRef.current;
+      if (!store) return;
+      syncEngineRef.current = chunkPGIV2GDM_cjs.createSyncEngine({
+        client: publicClientProp,
+        contractAddress: indexerConfig.contractAddress,
+        swapModuleAddress: indexerConfig.swapModuleAddress,
+        ownerHash: masterKeys.ownerHash,
+        spendingSecret: masterKeys.spendingSecret,
+        viewingSecret: masterKeys.viewingSecret,
+        noteStore: store,
+        fromBlock: indexerConfig.fromBlock,
+        poseidonFn: (inputs) => sdk.poseidon(inputs)
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [masterKeys, cryptoReady, publicClientProp, noteStoreReady, indexerConfig?.contractAddress, indexerConfig?.swapModuleAddress, indexerConfig?.fromBlock]);
   const syncNotes = react.useCallback(
-    async (contractAddress, client) => {
-      if (!masterKeys || !cryptoReady) return 0;
-      if (syncPromiseRef.current) {
-        return syncPromiseRef.current;
+    async (_contractAddress, _client) => {
+      const engine = syncEngineRef.current;
+      if (!engine) return 0;
+      setIsSyncing(true);
+      try {
+        const result = await engine.sync();
+        return result.discovered + result.repaired;
+      } finally {
+        setIsSyncing(false);
       }
-      const syncPromise = (async () => {
-        setIsSyncing(true);
-        try {
-          const sdk = await loadSDK();
-          const viewingSecret = masterKeys.viewingSecret;
-          const spendingSecret = masterKeys.spendingSecret;
-          const scanFromBlock = BigInt(indexerConfig?.fromBlock ?? 0);
-          const swapModuleAddr = indexerConfig?.swapModuleAddress;
-          const aesKeyHex = viem.keccak256(viem.toHex(viewingSecret, { size: 32 }));
-          const aesKeyBytes = hexToBytes(aesKeyHex);
-          const cryptoKey = await crypto.subtle.importKey(
-            "raw",
-            aesKeyBytes.buffer.slice(aesKeyBytes.byteOffset, aesKeyBytes.byteOffset + aesKeyBytes.byteLength),
-            { name: "AES-GCM", length: 256 },
-            false,
-            ["decrypt"]
-          );
-          const currentStore = noteStoreRef.current;
-          const existingCommitments = new Set(
-            (currentStore ? currentStore.getNotes() : notes).map((n) => n.commitment.toLowerCase())
-          );
-          const candidates = [];
-          console.log("[syncNotes] Scanning contract:", contractAddress, "\u2014 existing:", existingCommitments.size, "notes", "\u2014 store:", currentStore ? "ready" : "NULL");
-          try {
-            const shieldedLogs = await client.getLogs({
-              address: contractAddress,
-              event: {
-                type: "event",
-                name: "Shielded",
-                inputs: [
-                  { name: "token", type: "address", indexed: true },
-                  { name: "depositor", type: "address", indexed: true },
-                  { name: "commitment", type: "bytes32", indexed: true },
-                  { name: "leafIndex", type: "uint256", indexed: false },
-                  { name: "encryptedNote", type: "bytes", indexed: false }
-                ]
-              },
-              fromBlock: scanFromBlock,
-              toBlock: "latest"
-            });
-            for (const log of shieldedLogs) {
-              const commitment = log.args.commitment;
-              if (existingCommitments.has(commitment.toLowerCase())) continue;
-              candidates.push({
-                commitment,
-                leafIndex: Number(log.args.leafIndex),
-                packedData: log.args.encryptedNote,
-                txHash: log.transactionHash
-              });
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Failed to scan Shielded events:", e?.message ?? e);
-          }
-          const commitmentLeafMap = /* @__PURE__ */ new Map();
-          try {
-            const transferredLogs = await client.getLogs({
-              address: contractAddress,
-              event: {
-                type: "event",
-                name: "Transferred",
-                inputs: [
-                  { name: "nullifier", type: "bytes32", indexed: true },
-                  { name: "outputCommitment1", type: "bytes32", indexed: true },
-                  { name: "outputCommitment2", type: "bytes32", indexed: true },
-                  { name: "encryptedNote1", type: "bytes", indexed: false },
-                  { name: "encryptedNote2", type: "bytes", indexed: false }
-                ]
-              },
-              fromBlock: scanFromBlock,
-              toBlock: "latest"
-            });
-            try {
-              const ciLogs = await client.getLogs({
-                address: contractAddress,
-                event: {
-                  type: "event",
-                  name: "CommitmentInserted",
-                  inputs: [
-                    { name: "commitment", type: "bytes32", indexed: true },
-                    { name: "leafIndex", type: "uint256", indexed: false },
-                    { name: "timestamp", type: "uint256", indexed: false }
-                  ]
-                },
-                fromBlock: scanFromBlock,
-                toBlock: "latest"
-              });
-              for (const log of ciLogs) {
-                commitmentLeafMap.set(
-                  log.args.commitment.toLowerCase(),
-                  Number(log.args.leafIndex)
-                );
-              }
-            } catch (e) {
-              console.warn("[syncNotes] Failed to scan CommitmentInserted events:", e);
-            }
-            for (const log of transferredLogs) {
-              const c1 = log.args.outputCommitment1;
-              const c2 = log.args.outputCommitment2;
-              const txHash = log.transactionHash;
-              if (!existingCommitments.has(c1.toLowerCase())) {
-                candidates.push({
-                  commitment: c1,
-                  leafIndex: commitmentLeafMap.get(c1.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedNote1,
-                  txHash
-                });
-              }
-              if (!existingCommitments.has(c2.toLowerCase())) {
-                candidates.push({
-                  commitment: c2,
-                  leafIndex: commitmentLeafMap.get(c2.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedNote2,
-                  txHash
-                });
-              }
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Failed to scan Transferred events:", e);
-          }
-          if (swapModuleAddr) try {
-            const filledLogs = await client.getLogs({
-              address: swapModuleAddr,
-              event: {
-                type: "event",
-                name: "SwapOrderFilled",
-                inputs: [
-                  { name: "orderId", type: "bytes32", indexed: true },
-                  { name: "fillerNullifier", type: "bytes32", indexed: true },
-                  { name: "fillerOutputCommitment", type: "bytes32", indexed: true },
-                  { name: "takeAmount", type: "uint256", indexed: false },
-                  { name: "giveAmount", type: "uint256", indexed: false },
-                  { name: "fillerAspId", type: "uint256", indexed: false },
-                  { name: "remainingSellAmount", type: "uint256", indexed: false },
-                  { name: "encryptedFillerNote", type: "bytes", indexed: false }
-                ]
-              },
-              fromBlock: scanFromBlock,
-              toBlock: "latest"
-            });
-            for (const log of filledLogs) {
-              const c = log.args.fillerOutputCommitment;
-              if (!existingCommitments.has(c.toLowerCase())) {
-                candidates.push({
-                  commitment: c,
-                  leafIndex: commitmentLeafMap.get(c.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedFillerNote,
-                  txHash: log.transactionHash
-                });
-              }
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Failed to scan SwapOrderFilled events:", e);
-          }
-          if (swapModuleAddr) try {
-            const claimedLogs = await client.getLogs({
-              address: swapModuleAddr,
-              event: {
-                type: "event",
-                name: "SwapOrderClaimed",
-                inputs: [
-                  { name: "orderId", type: "bytes32", indexed: true },
-                  { name: "accumulatedBuyAmount", type: "uint256", indexed: false },
-                  { name: "refundedSellAmount", type: "uint256", indexed: false },
-                  { name: "buyOutputCommitment", type: "bytes32", indexed: false },
-                  { name: "encryptedBuyNote", type: "bytes", indexed: false },
-                  { name: "refundCommitment", type: "bytes32", indexed: false },
-                  { name: "encryptedRefundNote", type: "bytes", indexed: false }
-                ]
-              },
-              fromBlock: scanFromBlock,
-              toBlock: "latest"
-            });
-            for (const log of claimedLogs) {
-              const buyC = log.args.buyOutputCommitment;
-              const refundC = log.args.refundCommitment;
-              const txHash = log.transactionHash;
-              if (buyC && !existingCommitments.has(buyC.toLowerCase())) {
-                candidates.push({
-                  commitment: buyC,
-                  leafIndex: commitmentLeafMap.get(buyC.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedBuyNote,
-                  txHash
-                });
-              }
-              if (refundC && !existingCommitments.has(refundC.toLowerCase())) {
-                candidates.push({
-                  commitment: refundC,
-                  leafIndex: commitmentLeafMap.get(refundC.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedRefundNote,
-                  txHash
-                });
-              }
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Failed to scan SwapOrderClaimed events:", e);
-          }
-          if (swapModuleAddr) try {
-            const cancelledLogs = await client.getLogs({
-              address: swapModuleAddr,
-              event: {
-                type: "event",
-                name: "SwapOrderCancelled",
-                inputs: [
-                  { name: "orderId", type: "bytes32", indexed: true },
-                  { name: "refundedSellAmount", type: "uint256", indexed: false },
-                  { name: "refundCommitment", type: "bytes32", indexed: false },
-                  { name: "encryptedRefundNote", type: "bytes", indexed: false }
-                ]
-              },
-              fromBlock: scanFromBlock,
-              toBlock: "latest"
-            });
-            for (const log of cancelledLogs) {
-              const c = log.args.refundCommitment;
-              if (c && !existingCommitments.has(c.toLowerCase())) {
-                candidates.push({
-                  commitment: c,
-                  leafIndex: commitmentLeafMap.get(c.toLowerCase()) ?? -1,
-                  packedData: log.args.encryptedRefundNote,
-                  txHash: log.transactionHash
-                });
-              }
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Failed to scan SwapOrderCancelled events:", e);
-          }
-          let discovered = 0;
-          let skippedEmpty = 0, skippedOwner = 0;
-          for (const candidate of candidates) {
-            try {
-              const packed = candidate.packedData;
-              if (!packed || packed === "0x" || packed.length < 82) {
-                skippedEmpty++;
-                continue;
-              }
-              const raw = packed.startsWith("0x") ? packed.slice(2) : packed;
-              const noteOwnerHash = BigInt("0x" + raw.slice(16, 80));
-              const encryptedPayload = raw.slice(80);
-              if (noteOwnerHash !== masterKeys.ownerHash) {
-                console.log(`[syncNotes] ownerHash mismatch: note=${noteOwnerHash.toString(16).slice(0, 16)}\u2026 ours=${masterKeys.ownerHash.toString(16).slice(0, 16)}\u2026`);
-                skippedOwner++;
-                continue;
-              }
-              const encBytes = hexToBytes("0x" + encryptedPayload);
-              if (encBytes.length < 12) continue;
-              const nonce = encBytes.slice(0, 12);
-              const ciphertext = encBytes.slice(12);
-              let plaintext;
-              try {
-                plaintext = await crypto.subtle.decrypt(
-                  { name: "AES-GCM", iv: nonce },
-                  cryptoKey,
-                  ciphertext
-                );
-              } catch {
-                continue;
-              }
-              const ptBytes = new Uint8Array(plaintext);
-              if (ptBytes.length !== 104) continue;
-              const amount = bytesToBigint(ptBytes.slice(0, 32));
-              const blinding = bytesToBigint(ptBytes.slice(32, 64));
-              const originRaw = "0x" + Array.from(ptBytes.slice(64, 84)).map((b) => b.toString(16).padStart(2, "0")).join("");
-              const tokenRaw = "0x" + Array.from(ptBytes.slice(84, 104)).map((b) => b.toString(16).padStart(2, "0")).join("");
-              const origin = viem.getAddress(originRaw);
-              const token = viem.getAddress(tokenRaw);
-              const ownerHash = await sdk.poseidon([spendingSecret]);
-              const expectedCommitment = await sdk.poseidon([
-                amount,
-                ownerHash,
-                blinding,
-                BigInt(origin),
-                BigInt(token)
-              ]);
-              const expectedHex = viem.toHex(expectedCommitment, { size: 32 });
-              if (expectedHex.toLowerCase() !== candidate.commitment.toLowerCase()) {
-                console.warn(`[syncNotes] Commitment mismatch: expected=${expectedHex.slice(0, 16)}\u2026 got=${candidate.commitment.slice(0, 16)}\u2026`);
-                continue;
-              }
-              const newNote = {
-                commitment: candidate.commitment,
-                amount,
-                blinding,
-                ownerSecret: viem.toHex(spendingSecret, { size: 32 }),
-                ownerHash: viem.toHex(masterKeys.ownerHash, { size: 32 }),
-                origin,
-                token,
-                leafIndex: candidate.leafIndex,
-                status: "confirmed",
-                timestamp: Math.floor(Date.now() / 1e3),
-                txHash: candidate.txHash,
-                proofSystem: "snark"
-              };
-              const store2 = noteStoreRef.current;
-              if (store2) {
-                if (store2.addNote(newNote)) discovered++;
-              } else {
-                setNotes((prev) => {
-                  if (prev.some((n) => n.commitment.toLowerCase() === newNote.commitment.toLowerCase())) return prev;
-                  return [...prev, newNote];
-                });
-                discovered++;
-              }
-            } catch (e) {
-              console.warn("[syncNotes] Failed to process candidate:", e);
-            }
-          }
-          if (discovered > 0 || candidates.length > 0) {
-            console.log(`[syncNotes] Discovered ${discovered} new notes from ${candidates.length} candidates`);
-          }
-          if (commitmentLeafMap.size === 0) {
-            try {
-              const ciLogs = await client.getLogs({
-                address: contractAddress,
-                event: {
-                  type: "event",
-                  name: "CommitmentInserted",
-                  inputs: [
-                    { name: "commitment", type: "bytes32", indexed: true },
-                    { name: "leafIndex", type: "uint256", indexed: false },
-                    { name: "timestamp", type: "uint256", indexed: false }
-                  ]
-                },
-                fromBlock: scanFromBlock,
-                toBlock: "latest"
-              });
-              for (const log of ciLogs) {
-                commitmentLeafMap.set(
-                  log.args.commitment.toLowerCase(),
-                  Number(log.args.leafIndex)
-                );
-              }
-            } catch {
-            }
-          }
-          let repaired = 0;
-          const store = noteStoreRef.current;
-          if (store) {
-            for (const note of store.getNotes()) {
-              const correctLeafIndex = commitmentLeafMap.get(note.commitment.toLowerCase());
-              if (correctLeafIndex !== void 0 && note.leafIndex !== correctLeafIndex) {
-                store.updateLeafIndex(note.commitment, correctLeafIndex);
-                repaired++;
-              }
-            }
-          }
-          try {
-            const currentNotes = store ? store.getNotes() : notes;
-            const snarkNotes = currentNotes.filter((n) => n.proofSystem !== "stark");
-            const unspentSnarkNotes = snarkNotes.filter((n) => n.status !== "spent");
-            if (unspentSnarkNotes.length > 0) {
-              const sdk2 = await loadSDK();
-              for (const note of unspentSnarkNotes) {
-                const correctLeaf = commitmentLeafMap.get(note.commitment.toLowerCase());
-                if (correctLeaf === void 0) continue;
-                const ownerSecret = BigInt(note.ownerSecret);
-                const commitment = BigInt(note.commitment);
-                const nullifier = await sdk2.poseidon([
-                  ownerSecret,
-                  BigInt(correctLeaf),
-                  commitment
-                ]);
-                const nullifierHex = viem.toHex(nullifier, { size: 32 });
-                const isUsed = await client.readContract({
-                  address: contractAddress,
-                  abi: [{
-                    type: "function",
-                    name: "nullifierUsed",
-                    inputs: [{ name: "", type: "bytes32" }],
-                    outputs: [{ name: "", type: "bool" }],
-                    stateMutability: "view"
-                  }],
-                  functionName: "nullifierUsed",
-                  args: [nullifierHex]
-                });
-                if (isUsed) {
-                  console.log(`[syncNotes] Marking note ${note.commitment.slice(0, 12)} as spent \u2014 nullifier found on-chain`);
-                  if (store) store.markSpent(note.commitment);
-                  repaired++;
-                }
-              }
-            }
-            const spentSnarkNotes = snarkNotes.filter((n) => n.status === "spent");
-            if (spentSnarkNotes.length > 0) {
-              const sdk2 = await loadSDK();
-              for (const note of spentSnarkNotes) {
-                const correctLeaf = commitmentLeafMap.get(note.commitment.toLowerCase());
-                if (correctLeaf === void 0) continue;
-                const ownerSecret = BigInt(note.ownerSecret);
-                const commitment = BigInt(note.commitment);
-                const nullifier = await sdk2.poseidon([
-                  ownerSecret,
-                  BigInt(correctLeaf),
-                  commitment
-                ]);
-                const nullifierHex = viem.toHex(nullifier, { size: 32 });
-                const isUsed = await client.readContract({
-                  address: contractAddress,
-                  abi: [{
-                    type: "function",
-                    name: "nullifierUsed",
-                    inputs: [{ name: "", type: "bytes32" }],
-                    outputs: [{ name: "", type: "bool" }],
-                    stateMutability: "view"
-                  }],
-                  functionName: "nullifierUsed",
-                  args: [nullifierHex]
-                });
-                if (!isUsed) {
-                  console.log(`[syncNotes] Un-spending note ${note.commitment.slice(0, 12)} \u2014 nullifier not used on-chain`);
-                  if (store) {
-                    store.unmarkSpent(note.commitment);
-                    store.updateLeafIndex(note.commitment, correctLeaf);
-                  }
-                  repaired++;
-                }
-              }
-            }
-          } catch (e) {
-            console.warn("[syncNotes] Nullifier verification failed:", e);
-          }
-          if (repaired > 0) {
-            console.log(`[syncNotes] Repaired ${repaired} existing notes`);
-          }
-          if (store && (discovered > 0 || repaired > 0)) {
-            await store.persist();
-            console.log(`[syncNotes] Persisted ${store.getNotes().length} notes to IndexedDB`);
-          } else if (!store) {
-            console.warn("[syncNotes] No NoteStore \u2014 notes NOT persisted");
-          }
-          return discovered + repaired;
-        } finally {
-          setIsSyncing(false);
-          syncPromiseRef.current = null;
-        }
-      })();
-      syncPromiseRef.current = syncPromise;
-      return syncPromise;
     },
-    // Note: `notes` is intentionally NOT in the dependency array to prevent
-    // sync loops. The callback reads notes from noteStoreRef.current directly.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [masterKeys, cryptoReady, persistNotes, indexerConfig?.fromBlock]
+    []
   );
   const startLiveSync = react.useCallback(
-    (contractAddress, client) => {
-      if (liveSyncInterval) clearInterval(liveSyncInterval);
-      if (unwatchRef.current) {
-        unwatchRef.current();
-        unwatchRef.current = null;
-      }
-      syncNotes(contractAddress, client).catch(console.error);
-      try {
-        const unwatch = client.watchContractEvent({
-          address: contractAddress,
-          eventName: "CommitmentInserted",
-          onLogs: () => {
-            syncNotes(contractAddress, client).catch(console.error);
-          }
-        });
-        unwatchRef.current = unwatch;
-      } catch (e) {
-        console.warn("[liveSync] watchContractEvent not available, using polling only:", e);
-      }
-      const fallbackMs = indexerConfig?.liveSyncIntervalMs ?? 6e4;
-      const interval = setInterval(() => {
-        syncNotes(contractAddress, client).catch(console.error);
-      }, fallbackMs);
-      setLiveSyncInterval(interval);
+    (_contractAddress, _client) => {
+      const engine = syncEngineRef.current;
+      if (!engine) return;
+      engine.startLiveSync({
+        intervalMs: indexerConfig?.liveSyncIntervalMs ?? 6e4
+      });
+      setLiveSyncInterval(true);
     },
-    [syncNotes, liveSyncInterval, indexerConfig?.liveSyncIntervalMs]
+    [indexerConfig?.liveSyncIntervalMs]
   );
   const stopLiveSync = react.useCallback(() => {
-    if (liveSyncInterval) {
-      clearInterval(liveSyncInterval);
-      setLiveSyncInterval(null);
-    }
-    if (unwatchRef.current) {
-      unwatchRef.current();
-      unwatchRef.current = null;
-    }
-  }, [liveSyncInterval]);
+    syncEngineRef.current?.stopLiveSync();
+    setLiveSyncInterval(null);
+  }, []);
   react.useEffect(() => {
     return () => {
-      if (liveSyncInterval) clearInterval(liveSyncInterval);
-      if (unwatchRef.current) {
-        unwatchRef.current();
-        unwatchRef.current = null;
-      }
+      syncEngineRef.current?.stopLiveSync();
     };
-  }, [liveSyncInterval]);
+  }, []);
   react.useEffect(() => {
-    const contractAddr = indexerConfig?.contractAddress;
-    if (!masterKeys || !publicClientProp || !contractAddr) return;
-    startLiveSync(contractAddr, publicClientProp);
-    return () => stopLiveSync();
+    if (!syncEngineRef.current) return;
+    syncEngineRef.current.startLiveSync({
+      intervalMs: indexerConfig?.liveSyncIntervalMs ?? 6e4
+    });
+    setLiveSyncInterval(true);
+    return () => {
+      syncEngineRef.current?.stopLiveSync();
+      setLiveSyncInterval(null);
+    };
   }, [masterKeys, publicClientProp, indexerConfig?.contractAddress]);
   const ownerHashHex = masterKeys ? viem.toHex(masterKeys.ownerHash, { size: 32 }) : null;
   const stealthAddress = react.useMemo(() => {
     if (!masterKeys) return null;
     try {
-      const { encodeStealthAddress } = (chunkIYRCJAME_cjs.init_stealth(), chunkG7VZBCD6_cjs.__toCommonJS(chunkIYRCJAME_cjs.stealth_exports));
+      const { encodeStealthAddress } = (chunkC3HXJ5A6_cjs.init_stealth(), chunkG7VZBCD6_cjs.__toCommonJS(chunkC3HXJ5A6_cjs.stealth_exports));
       return encodeStealthAddress(masterKeys.ownerHash, masterKeys.viewingHash);
     } catch {
       return null;
@@ -868,7 +499,7 @@ function UPPAccountProvider({
   const starkStealthAddress = react.useMemo(() => {
     if (!starkMasterKeys) return null;
     try {
-      const { encodeStarkStealthAddress } = (chunkIYRCJAME_cjs.init_stealth(), chunkG7VZBCD6_cjs.__toCommonJS(chunkIYRCJAME_cjs.stealth_exports));
+      const { encodeStarkStealthAddress } = (chunkC3HXJ5A6_cjs.init_stealth(), chunkG7VZBCD6_cjs.__toCommonJS(chunkC3HXJ5A6_cjs.stealth_exports));
       return encodeStarkStealthAddress(starkMasterKeys.starkOwnerHash, starkMasterKeys.starkViewingHash);
     } catch {
       return null;
@@ -901,7 +532,7 @@ function UPPAccountProvider({
         markNoteSpent,
         createNoteForSelf,
         getOwnerHash,
-        selectOptimalCircuit,
+        selectOptimalCircuit: selectOptimalCircuitCb,
         syncNotes,
         startLiveSync,
         stopLiveSync,
@@ -918,80 +549,6 @@ function useUPPAccount() {
   }
   return context;
 }
-async function createHashBasedNote(sdk, amount, spendingSecret, ownerHash, viewingSecret, origin, token) {
-  const blinding = await sdk.randomFieldElement();
-  const commitment = await sdk.poseidon([
-    amount,
-    ownerHash,
-    blinding,
-    origin,
-    token
-  ]);
-  const searchTagHash = await sdk.poseidon([viewingSecret, commitment]);
-  const searchTag = searchTagHash & (1n << 64n) - 1n;
-  const encryptedNote = await encryptNoteData(amount, blinding, origin, token, viewingSecret);
-  return {
-    commitment,
-    ownerSecret: spendingSecret,
-    ownerHash,
-    blinding,
-    encryptedNote,
-    searchTag,
-    amount,
-    origin,
-    token
-  };
-}
-async function encryptNoteData(amount, blinding, origin, token, viewingSecret) {
-  const keyMaterial = viem.keccak256(viem.toHex(viewingSecret, { size: 32 }));
-  const keyBytes = hexToBytes(keyMaterial);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    keyBytes.buffer.slice(keyBytes.byteOffset, keyBytes.byteOffset + keyBytes.byteLength),
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt"]
-  );
-  const plaintext = new Uint8Array(104);
-  plaintext.set(bigintToBytes(amount, 32), 0);
-  plaintext.set(bigintToBytes(blinding, 32), 32);
-  plaintext.set(bigintToBytes(origin, 20), 64);
-  plaintext.set(bigintToBytes(token, 20), 84);
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const ciphertext = await crypto.subtle.encrypt(
-    { name: "AES-GCM", iv: nonce },
-    cryptoKey,
-    plaintext
-  );
-  const result = new Uint8Array(12 + ciphertext.byteLength);
-  result.set(nonce, 0);
-  result.set(new Uint8Array(ciphertext), 12);
-  return viem.toHex(result);
-}
-function hexToBytes(hex) {
-  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(h.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(h.substr(i * 2, 2), 16);
-  }
-  return bytes;
-}
-function bigintToBytes(n, length) {
-  const bytes = new Uint8Array(length);
-  let temp = n;
-  for (let i = length - 1; i >= 0; i--) {
-    bytes[i] = Number(temp & 0xffn);
-    temp >>= 8n;
-  }
-  return bytes;
-}
-function bytesToBigint(bytes) {
-  let result = 0n;
-  for (const b of bytes) {
-    result = result << 8n | BigInt(b);
-  }
-  return result;
-}
 
 // src/react/utils/avatar.ts
 function hashBytes(input) {
@@ -1596,12 +1153,6 @@ function useUPPCrypto() {
     getSubOrder
   };
 }
-function packNoteData(note) {
-  return viem.encodePacked(
-    ["uint64", "uint256", "bytes"],
-    [note.searchTag, note.ownerHash, note.encryptedNote]
-  );
-}
 function useShield(config) {
   const { createNoteForSelf, isSetup, masterKeys } = useUPPAccount();
   const [isPending, setIsPending] = react.useState(false);
@@ -1631,7 +1182,7 @@ function useShield(config) {
         setStage("creating_note");
         const noteData = await createNoteForSelf(amount, origin, token);
         const commitment = viem.toHex(noteData.commitment, { size: 32 });
-        const encryptedNote = packNoteData(noteData);
+        const encryptedNote = chunkY3VL3LOE_cjs.packNoteData(noteData);
         return {
           amount,
           token: cfg.tokenAddress,
@@ -1658,12 +1209,6 @@ function useShield(config) {
     reset
   };
 }
-function packNoteData2(note) {
-  return viem.encodePacked(
-    ["uint64", "uint256", "bytes"],
-    [note.searchTag, note.ownerHash, note.encryptedNote]
-  );
-}
 function usePoolTransfer(config) {
   const {
     unspentNotes,
@@ -1716,7 +1261,7 @@ function usePoolTransfer(config) {
         const recipientNote = await createNoteForSelf(amount, origin, token);
         const changeNote = await createNoteForSelf(changeAmount, origin, token);
         const [transferModule, proofModule, aspModule] = await Promise.all([
-          import('../transfer-ZD76R7XF.cjs'),
+          import('../transfer-TJNDCZF2.cjs'),
           import('../proof-X3MVQFFZ.cjs'),
           import('../asp-CUE3NMBN.cjs')
         ]);
@@ -1755,7 +1300,7 @@ function usePoolTransfer(config) {
           changeNoteWithAmount
         );
         setProvingProgress(null);
-        const { proof } = await chunkIYRCJAME_cjs.generateUPPProofAsync(
+        const { proof } = await chunkC3HXJ5A6_cjs.generateUPPProofAsync(
           "transfer",
           circuitInputs,
           cfg.circuitBaseUrl,
@@ -1775,8 +1320,8 @@ function usePoolTransfer(config) {
           token: cfg.tokenAddress,
           outputCommitment1: viem.toHex(recipientNote.commitment, { size: 32 }),
           outputCommitment2: viem.toHex(changeNote.commitment, { size: 32 }),
-          encryptedNote1: packNoteData2(recipientNote),
-          encryptedNote2: packNoteData2(changeNote),
+          encryptedNote1: chunkY3VL3LOE_cjs.packNoteData(recipientNote),
+          encryptedNote2: chunkY3VL3LOE_cjs.packNoteData(changeNote),
           spentNote: selectedNote,
           recipientNoteData: recipientNote,
           changeNoteData: changeNote
@@ -1802,15 +1347,6 @@ function usePoolTransfer(config) {
     reset
   };
 }
-chunkHEHXSV47_cjs.init_poseidon();
-var STATE_TREE_DEPTH = 32;
-var ASP_TREE_DEPTH2 = 20;
-function padToDepth(arr, padValue, depth) {
-  if (arr.length >= depth) {
-    return arr.slice(0, depth);
-  }
-  return [...arr, ...Array(depth - arr.length).fill(padValue)];
-}
 function useWithdraw(config) {
   const {
     isSetup,
@@ -1840,6 +1376,8 @@ function useWithdraw(config) {
           recipient,
           aspId = 0n,
           aspRoot = 0n,
+          aspPathElements,
+          aspPathIndices,
           isRagequit = false
         } = params;
         const cfg = configRef.current;
@@ -1873,10 +1411,9 @@ function useWithdraw(config) {
         const origin = BigInt(selectedNote.origin);
         const token = BigInt(selectedNote.token);
         setStage("creating_outputs");
-        const [transferModule, proofModule, sdk] = await Promise.all([
-          import('../transfer-ZD76R7XF.cjs'),
-          import('../proof-X3MVQFFZ.cjs'),
-          import('../index.cjs')
+        const [transferModule, proofModule] = await Promise.all([
+          import('../transfer-TJNDCZF2.cjs'),
+          import('../proof-X3MVQFFZ.cjs')
         ]);
         const { syncMerkleTree, getMerkleProofsForNotes } = transferModule;
         const { formatPlonkProofForContract } = proofModule;
@@ -1894,52 +1431,20 @@ function useWithdraw(config) {
         };
         const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
         setStage("generating_proof");
-        const merkleProof = noteProof.proof;
-        const stateRootBI = merkleProof.root;
-        const actualLeafIndex = merkleProof.leafIndex;
-        const inputOwnerHash = chunkHEHXSV47_cjs.computeOwnerHash(BigInt(selectedNote.ownerSecret));
-        const localCommitment = await sdk.poseidon([
-          selectedNote.amount,
-          inputOwnerHash,
-          selectedNote.blinding,
-          BigInt(selectedNote.origin),
-          BigInt(selectedNote.token)
-        ]);
-        const storedCommitment = BigInt(selectedNote.commitment);
-        if (localCommitment !== storedCommitment) {
-          throw new Error(
-            `Note commitment mismatch \u2014 this note was created with an outdated commitment formula. Clear your shielded account (localStorage) and re-shield tokens.`
-          );
-        }
-        const nullifier = await sdk.poseidon([
-          BigInt(selectedNote.ownerSecret),
-          BigInt(actualLeafIndex),
-          storedCommitment
-        ]);
-        const circuitInputs = {
-          // Public inputs
-          stateRoot: stateRootBI.toString(),
-          aspRoot: aspRoot.toString(),
-          nullifier: nullifier.toString(),
-          amount: selectedNote.amount.toString(),
-          recipient: BigInt(recipient).toString(),
-          token: BigInt(cfg.tokenAddress).toString(),
-          isRagequit: isRagequit ? "1" : "0",
-          // Private inputs - Input Note
-          // IMPORTANT: Use actualLeafIndex from Merkle proof, not stored leafIndex
-          inputAmount: selectedNote.amount.toString(),
-          inputOneTimeSecret: BigInt(selectedNote.ownerSecret).toString(),
-          inputBlinding: selectedNote.blinding.toString(),
-          inputOrigin: origin.toString(),
-          inputLeafIndex: actualLeafIndex.toString(),
-          inputPathElements: padToDepth(merkleProof.pathElements.map(String), "0", STATE_TREE_DEPTH),
-          inputPathIndices: padToDepth(merkleProof.pathIndices.map(String), "0", STATE_TREE_DEPTH),
-          // ASP membership proof (zeros for ragequit)
-          aspPathElements: Array(ASP_TREE_DEPTH2).fill("0"),
-          aspPathIndices: Array(ASP_TREE_DEPTH2).fill("0")
-        };
+        const circuitInputs = await chunkY3VL3LOE_cjs.buildWithdrawCircuitInputs({
+          selectedNote: spendableNote,
+          merkleProof: noteProof.proof,
+          recipient: BigInt(recipient),
+          tokenAddress: BigInt(cfg.tokenAddress),
+          aspRoot,
+          aspPathElements,
+          aspPathIndices,
+          isRagequit
+        });
+        const stateRootBI = noteProof.proof.root;
+        const nullifier = BigInt(circuitInputs.nullifier);
         setProvingProgress(null);
-        const { proof } = await chunkIYRCJAME_cjs.generateUPPProofAsync(
+        const { proof } = await chunkC3HXJ5A6_cjs.generateUPPProofAsync(
           "withdraw",
           circuitInputs,
           cfg.circuitBaseUrl,
@@ -2098,12 +1603,8 @@ function storePersonalASPId(chainId, address, aspId) {
   storeASPId(chainId, address, aspId);
 }
 chunkHEHXSV47_cjs.init_poseidon();
-var STATE_TREE_DEPTH2 = 32;
-var ASP_TREE_DEPTH3 = 20;
-function padToDepth2(arr, padValue, depth) {
-  if (arr.length >= depth) return arr.slice(0, depth);
-  return [...arr, ...Array(depth - arr.length).fill(padValue)];
-}
+var STATE_TREE_DEPTH = 32;
+var ASP_TREE_DEPTH2 = 20;
 var SWAP_ORDERS_ABI = [{
   type: "function",
   name: "swapOrders",
@@ -2135,7 +1636,7 @@ function useSwapOrderBook(config) {
     try {
       const logs = await config.publicClient.getLogs({
         address: config.swapModuleAddress,
-        event: chunkIYRCJAME_cjs.SWAP_ORDER_PLACED_EVENT,
+        event: chunkC3HXJ5A6_cjs.SWAP_ORDER_PLACED_EVENT,
         fromBlock: config.fromBlock ?? 0n,
         toBlock: "latest"
       });
@@ -2151,10 +1652,10 @@ function useSwapOrderBook(config) {
         blockNumber: log.blockNumber ?? 0n
       }));
       if (config.sellToken && config.buyToken) {
-        parsedOrders = chunkIYRCJAME_cjs.filterOrdersByTokenPair(parsedOrders, config.sellToken, config.buyToken);
+        parsedOrders = chunkC3HXJ5A6_cjs.filterOrdersByTokenPair(parsedOrders, config.sellToken, config.buyToken);
       }
       if (config.acceptableAspIds && config.acceptableAspIds.length > 0) {
-        parsedOrders = chunkIYRCJAME_cjs.filterOrdersByASP(parsedOrders, config.acceptableAspIds);
+        parsedOrders = chunkC3HXJ5A6_cjs.filterOrdersByASP(parsedOrders, config.acceptableAspIds);
       }
       const enriched = [];
       for (const order of parsedOrders) {
@@ -2252,7 +1753,7 @@ function useSwap(config) {
         }
         setStage("creating_outputs");
         const [transferModule, proofModule, sdk, aspModule] = await Promise.all([
-          import('../transfer-ZD76R7XF.cjs'),
+          import('../transfer-TJNDCZF2.cjs'),
           import('../proof-X3MVQFFZ.cjs'),
           import('../index.cjs'),
           import('../asp-CUE3NMBN.cjs')
@@ -2312,13 +1813,13 @@ function useSwap(config) {
           inputBlinding: selectedNote.blinding.toString(),
           inputOrigin: origin.toString(),
           inputLeafIndex: actualLeafIndex.toString(),
-          inputPathElements: padToDepth2(merkleProof.pathElements.map(String), "0", STATE_TREE_DEPTH2),
-          inputPathIndices: padToDepth2(merkleProof.pathIndices.map(String), "0", STATE_TREE_DEPTH2),
-          aspPathElements: padToDepth2(aspProofData.aspPathElements.map(String), "0", ASP_TREE_DEPTH3),
-          aspPathIndices: padToDepth2(aspProofData.aspPathIndices.map(String), "0", ASP_TREE_DEPTH3)
+          inputPathElements: chunkY3VL3LOE_cjs.padToDepth(merkleProof.pathElements.map(String), "0", STATE_TREE_DEPTH),
+          inputPathIndices: chunkY3VL3LOE_cjs.padToDepth(merkleProof.pathIndices.map(String), "0", STATE_TREE_DEPTH),
+          aspPathElements: chunkY3VL3LOE_cjs.padToDepth(aspProofData.aspPathElements.map(String), "0", ASP_TREE_DEPTH2),
+          aspPathIndices: chunkY3VL3LOE_cjs.padToDepth(aspProofData.aspPathIndices.map(String), "0", ASP_TREE_DEPTH2)
         };
         setProvingProgress(null);
-        const { proof } = await chunkIYRCJAME_cjs.generateUPPProofAsync(
+        const { proof } = await chunkC3HXJ5A6_cjs.generateUPPProofAsync(
           "withdraw",
           circuitInputs,
           cfg.circuitBaseUrl,
@@ -2329,8 +1830,8 @@ function useSwap(config) {
           }
         );
         const formattedProof = await formatPlonkProofForContract(proof);
-        const cancelSecret = chunkIYRCJAME_cjs.generateCancelSecret();
-        const cancelKeyHash = chunkIYRCJAME_cjs.computeCancelKeyHash(cancelSecret);
+        const cancelSecret = chunkC3HXJ5A6_cjs.generateCancelSecret();
+        const cancelKeyHash = chunkC3HXJ5A6_cjs.computeCancelKeyHash(cancelSecret);
         const currentBlock = await cfg.publicClient.getBlockNumber();
         const expiry = currentBlock + expiryBlocks;
         return {
@@ -2379,7 +1880,7 @@ function useSwap(config) {
           noteOverride
         } = params;
         const cfg = configRef.current;
-        const giveAmount = chunkIYRCJAME_cjs.computeGiveAmount(takeAmount, rate);
+        const giveAmount = chunkC3HXJ5A6_cjs.computeGiveAmount(takeAmount, rate);
         setStage("selecting_notes");
         let selectedNote;
         if (noteOverride) {
@@ -2400,7 +1901,7 @@ function useSwap(config) {
         }
         setStage("creating_outputs");
         const [transferModule, proofModule, sdk, aspModule] = await Promise.all([
-          import('../transfer-ZD76R7XF.cjs'),
+          import('../transfer-TJNDCZF2.cjs'),
           import('../proof-X3MVQFFZ.cjs'),
           import('../index.cjs'),
           import('../asp-CUE3NMBN.cjs')
@@ -2466,13 +1967,13 @@ function useSwap(config) {
           inputBlinding: selectedNote.blinding.toString(),
           inputOrigin: origin.toString(),
           inputLeafIndex: actualLeafIndex.toString(),
-          inputPathElements: padToDepth2(merkleProof.pathElements.map(String), "0", STATE_TREE_DEPTH2),
-          inputPathIndices: padToDepth2(merkleProof.pathIndices.map(String), "0", STATE_TREE_DEPTH2),
-          aspPathElements: padToDepth2(aspProofData.aspPathElements.map(String), "0", ASP_TREE_DEPTH3),
-          aspPathIndices: padToDepth2(aspProofData.aspPathIndices.map(String), "0", ASP_TREE_DEPTH3)
+          inputPathElements: chunkY3VL3LOE_cjs.padToDepth(merkleProof.pathElements.map(String), "0", STATE_TREE_DEPTH),
+          inputPathIndices: chunkY3VL3LOE_cjs.padToDepth(merkleProof.pathIndices.map(String), "0", STATE_TREE_DEPTH),
+          aspPathElements: chunkY3VL3LOE_cjs.padToDepth(aspProofData.aspPathElements.map(String), "0", ASP_TREE_DEPTH2),
+          aspPathIndices: chunkY3VL3LOE_cjs.padToDepth(aspProofData.aspPathIndices.map(String), "0", ASP_TREE_DEPTH2)
         };
         setProvingProgress(null);
-        const { proof } = await chunkIYRCJAME_cjs.generateUPPProofAsync(
+        const { proof } = await chunkC3HXJ5A6_cjs.generateUPPProofAsync(
           "withdraw",
           circuitInputs,
           cfg.circuitBaseUrl,
@@ -2483,11 +1984,7 @@ function useSwap(config) {
           }
         );
         const formattedProof = await formatPlonkProofForContract(proof);
-        const { encodePacked: encodePacked3 } = await import('viem');
-        const packedFillerNote = encodePacked3(
-          ["uint64", "uint256", "bytes"],
-          [fillerNoteData.searchTag, fillerNoteData.ownerHash, fillerNoteData.encryptedNote]
-        );
+        const packedFillerNote = chunkY3VL3LOE_cjs.packNoteData(fillerNoteData);
         return {
           proof: formattedProof,
           nullifier: viem.toHex(nullifier, { size: 32 }),
@@ -2547,18 +2044,13 @@ function useSwap(config) {
           );
         }
         const zeroHex = "0x0000000000000000000000000000000000000000000000000000000000000000";
-        const { encodePacked: encodePacked3 } = await import('viem');
-        const packNote = (note) => encodePacked3(
-          ["uint64", "uint256", "bytes"],
-          [note.searchTag, note.ownerHash, note.encryptedNote]
-        );
         return {
           orderId,
           cancelSecret,
           buyOutputCommitment: buyNoteData ? viem.toHex(buyNoteData.commitment, { size: 32 }) : zeroHex,
           refundCommitment: refundNoteData ? viem.toHex(refundNoteData.commitment, { size: 32 }) : zeroHex,
-          buyEncryptedNote: buyNoteData ? packNote(buyNoteData) : "0x",
-          refundEncryptedNote: refundNoteData ? packNote(refundNoteData) : "0x",
+          buyEncryptedNote: buyNoteData ? chunkY3VL3LOE_cjs.packNoteData(buyNoteData) : "0x",
+          refundEncryptedNote: refundNoteData ? chunkY3VL3LOE_cjs.packNoteData(refundNoteData) : "0x",
           buyNoteData,
           refundNoteData
         };
@@ -2589,11 +2081,7 @@ function useSwap(config) {
           cancelOrigin,
           BigInt(sellToken)
         );
-        const { encodePacked: encodePacked3 } = await import('viem');
-        const packedRefund = encodePacked3(
-          ["uint64", "uint256", "bytes"],
-          [refundNoteData.searchTag, refundNoteData.ownerHash, refundNoteData.encryptedNote]
-        );
+        const packedRefund = chunkY3VL3LOE_cjs.packNoteData(refundNoteData);
         return {
           orderId,
           cancelSecret,
@@ -2638,7 +2126,7 @@ function useSwap(config) {
           createNoteForSelf(changeAmount, origin, token)
         ]);
         const [transferModule, proofModule, aspModule] = await Promise.all([
-          import('../transfer-ZD76R7XF.cjs'),
+          import('../transfer-TJNDCZF2.cjs'),
           import('../proof-X3MVQFFZ.cjs'),
           import('../asp-CUE3NMBN.cjs')
         ]);
@@ -2669,7 +2157,7 @@ function useSwap(config) {
           changeNoteWithAmount
         );
         setProvingProgress(null);
-        const { proof } = await chunkIYRCJAME_cjs.generateUPPProofAsync(
+        const { proof } = await chunkC3HXJ5A6_cjs.generateUPPProofAsync(
           "transfer",
           circuitInputs,
           cfg.circuitBaseUrl,
@@ -2680,11 +2168,6 @@ function useSwap(config) {
           }
         );
         const formattedProof = await formatPlonkProofForContract(proof);
-        const { encodePacked: encodePacked3 } = await import('viem');
-        const packNote = (n) => encodePacked3(
-          ["uint64", "uint256", "bytes"],
-          [n.searchTag, n.ownerHash, n.encryptedNote]
-        );
         const proofSystem = note.proofSystem ?? "snark";
         const exactShieldedNote = {
           amount: targetAmount,
@@ -2720,8 +2203,8 @@ function useSwap(config) {
           token: note.token,
           outputCommitment1: viem.toHex(exactNoteData.commitment, { size: 32 }),
           outputCommitment2: viem.toHex(changeNoteData.commitment, { size: 32 }),
-          encryptedNote1: packNote(exactNoteData),
-          encryptedNote2: packNote(changeNoteData),
+          encryptedNote1: chunkY3VL3LOE_cjs.packNoteData(exactNoteData),
+          encryptedNote2: chunkY3VL3LOE_cjs.packNoteData(changeNoteData),
           exactNote: exactShieldedNote,
           changeNote: changeShieldedNote,
           spentNote: note,
@@ -2760,7 +2243,7 @@ function useProofWorker(worker) {
       setManager(null);
       return;
     }
-    const m = new chunkIYRCJAME_cjs.ProofWorkerManager(worker);
+    const m = new chunkC3HXJ5A6_cjs.ProofWorkerManager(worker);
     setManager(m);
     return () => {
       m.terminate();
@@ -2848,7 +2331,7 @@ function usePrivateBalance(config) {
     try {
       const placedLogs = await publicClient.getLogs({
         address: swapModuleAddress,
-        event: chunkIYRCJAME_cjs.SWAP_ORDER_PLACED_EVENT,
+        event: chunkC3HXJ5A6_cjs.SWAP_ORDER_PLACED_EVENT,
         fromBlock,
         toBlock: "latest"
       });
@@ -2856,7 +2339,7 @@ function usePrivateBalance(config) {
       for (const log of placedLogs) {
         const args = log.args;
         const orderId = args.orderId;
-        if (walletAddress && !chunkIYRCJAME_cjs.getCancelSecret(orderId, walletAddress)) continue;
+        if (walletAddress && !chunkC3HXJ5A6_cjs.getCancelSecret(orderId, walletAddress)) continue;
         orders.set(orderId.toLowerCase(), {
           sellToken: args.sellToken,
           sellAmount: BigInt(args.sellAmount),
@@ -2865,7 +2348,7 @@ function usePrivateBalance(config) {
       }
       const filledLogs = await publicClient.getLogs({
         address: swapModuleAddress,
-        event: chunkIYRCJAME_cjs.SWAP_ORDER_FILLED_EVENT,
+        event: chunkC3HXJ5A6_cjs.SWAP_ORDER_FILLED_EVENT,
         fromBlock,
         toBlock: "latest"
       });
@@ -2884,7 +2367,7 @@ function usePrivateBalance(config) {
       }
       const claimedLogs = await publicClient.getLogs({
         address: swapModuleAddress,
-        event: chunkIYRCJAME_cjs.SWAP_ORDER_CLAIMED_EVENT,
+        event: chunkC3HXJ5A6_cjs.SWAP_ORDER_CLAIMED_EVENT,
         fromBlock,
         toBlock: "latest"
       });
@@ -2893,7 +2376,7 @@ function usePrivateBalance(config) {
       }
       const cancelledLogs = await publicClient.getLogs({
         address: swapModuleAddress,
-        event: chunkIYRCJAME_cjs.SWAP_ORDER_CANCELLED_EVENT,
+        event: chunkC3HXJ5A6_cjs.SWAP_ORDER_CANCELLED_EVENT,
         fromBlock,
         toBlock: "latest"
       });
@@ -2985,11 +2468,11 @@ function usePrivateBalance(config) {
 
 Object.defineProperty(exports, "ProofWorkerManager", {
   enumerable: true,
-  get: function () { return chunkIYRCJAME_cjs.ProofWorkerManager; }
+  get: function () { return chunkC3HXJ5A6_cjs.ProofWorkerManager; }
 });
 Object.defineProperty(exports, "generateUPPProofAsync", {
   enumerable: true,
-  get: function () { return chunkIYRCJAME_cjs.generateUPPProofAsync; }
+  get: function () { return chunkC3HXJ5A6_cjs.generateUPPProofAsync; }
 });
 Object.defineProperty(exports, "ASP_TREE_DEPTH", {
   enumerable: true,