@permissionless-technologies/upp-sdk 0.1.0

package/dist/react/index.js

@@ -0,0 +1,2598 @@
+import { NoteStore, init_stealth, stealth_exports, SWAP_ORDER_PLACED_EVENT, filterOrdersByTokenPair, filterOrdersByASP, generateCancelSecret, computeCancelKeyHash, computeGiveAmount } from '../chunk-NUIQHTSA.js';
+import { computeSingleOriginASPRoot } from '../chunk-P37MRZ73.js';
+export { ASP_TREE_DEPTH, buildASPTree, computeMultiOriginASPRoot, computeSingleOriginASPRoot, generateASPProof, generateMultiOriginASPProof, generateSingleOriginASPProof } from '../chunk-P37MRZ73.js';
+import { createAutoAdapter } from '../chunk-XV72HNHN.js';
+import '../chunk-W77GRBO4.js';
+import { init_poseidon, BABYJUBJUB_SUBORDER } from '../chunk-V23OSL25.js';
+import { __toCommonJS } from '../chunk-Z6ZWNWWR.js';
+import { createContext, useState, useRef, useEffect, useCallback, useMemo, useContext } from 'react';
+import { toHex, keccak256, toBytes, getAddress, encodePacked } from 'viem';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { createPortal } from 'react-dom';
+import { ASP_REGISTRY_HUB_ABI } from '@permissionless-technologies/upc-sdk';
+
+var UPP_EIP712_DOMAIN = {
+  name: "UPP Stealth Account",
+  version: "2"
+};
+var UPP_EIP712_TYPES = {
+  Connect: [
+    { name: "info", type: "string" },
+    { name: "warning", type: "string" },
+    { name: "passwordHash", type: "bytes32" }
+  ]
+};
+var UPPAccountContext = createContext(null);
+var sdkPromise = null;
+async function loadSDK() {
+  if (!sdkPromise) {
+    sdkPromise = import('../index.js');
+  }
+  return sdkPromise;
+}
+function getStorageKey(ethAddress) {
+  return `upp_pq_account_${ethAddress.toLowerCase()}`;
+}
+function getNotesStorageKey(chainId, ownerHashPrefix) {
+  return `upp_pq_notes_${chainId}_${ownerHashPrefix}`;
+}
+function getChainFingerprintKey(chainId) {
+  return `upp_chain_fp_${chainId}`;
+}
+async function checkChainFingerprint(chainId, publicClient) {
+  if (typeof window === "undefined" || !publicClient) return true;
+  const fpKey = getChainFingerprintKey(chainId);
+  const stored = localStorage.getItem(fpKey);
+  try {
+    const [currentBlock, genesisBlock] = await Promise.all([
+      publicClient.getBlockNumber(),
+      publicClient.getBlock({ blockNumber: 0n })
+    ]);
+    const currentGenesisHash = genesisBlock.hash;
+    const currentBlockNum = Number(currentBlock);
+    if (stored) {
+      const fp = JSON.parse(stored);
+      if (fp.genesisHash !== currentGenesisHash || currentBlockNum < fp.blockNumber) {
+        localStorage.removeItem(fpKey);
+        return false;
+      }
+    }
+    const newFp = {
+      genesisHash: currentGenesisHash,
+      blockNumber: currentBlockNum
+    };
+    localStorage.setItem(fpKey, JSON.stringify(newFp));
+    return true;
+  } catch (e) {
+    console.warn("[UPPAccount] Chain fingerprint check failed:", e);
+    return true;
+  }
+}
+function UPPAccountProvider({
+  children,
+  ethAddress,
+  chainId = 1,
+  indexerConfig,
+  signTypedData,
+  publicClient: publicClientProp,
+  activeProofSystem
+}) {
+  const [masterKeys, setMasterKeys] = useState(null);
+  const [starkMasterKeys, setStarkMasterKeys] = useState(null);
+  const [notes, setNotes] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isConnecting, setIsConnecting] = useState(false);
+  const [cryptoReady, setCryptoReady] = useState(false);
+  const [isSyncing, setIsSyncing] = useState(false);
+  const [lastSyncedBlock, _setLastSyncedBlock] = useState(0);
+  const [liveSyncInterval, setLiveSyncInterval] = useState(null);
+  const unwatchRef = useRef(null);
+  const syncPromiseRef = useRef(null);
+  const noteStoreRef = useRef(null);
+  useEffect(() => {
+    loadSDK().then(() => setCryptoReady(true));
+  }, []);
+  useEffect(() => {
+    let noteStoreUnsub = null;
+    if (typeof window === "undefined") return;
+    if (!ethAddress || !cryptoReady) {
+      setMasterKeys(null);
+      setStarkMasterKeys(null);
+      setNotes([]);
+      noteStoreRef.current = null;
+      return;
+    }
+    const saved = localStorage.getItem(getStorageKey(ethAddress));
+    if (saved) {
+      try {
+        const parsed = JSON.parse(saved);
+        if (!parsed.starkSecret || !parsed.spendingSecret) {
+          console.log("[UPPAccount] Invalid account data, clearing...");
+          localStorage.removeItem(getStorageKey(ethAddress));
+          setMasterKeys(null);
+          setStarkMasterKeys(null);
+          setNotes([]);
+          return;
+        }
+        const keys = {
+          spendingSecret: BigInt(parsed.spendingSecret),
+          ownerHash: BigInt(parsed.ownerHash),
+          viewingSecret: BigInt(parsed.viewingSecret),
+          viewingHash: BigInt(parsed.viewingHash)
+        };
+        setMasterKeys(keys);
+        if (parsed.starkSecret) {
+          const starkKeys = {
+            starkSecret: parsed.starkSecret.map((s) => BigInt(s)),
+            starkOwnerHash: parsed.starkOwnerHash.map((s) => BigInt(s)),
+            starkViewingSecret: parsed.starkViewingSecret.map((s) => BigInt(s)),
+            starkViewingHash: parsed.starkViewingHash.map((s) => BigInt(s))
+          };
+          setStarkMasterKeys(starkKeys);
+        }
+        const ownerHashHex2 = toHex(keys.ownerHash, { size: 32 });
+        const storagePrefix = `upp_${chainId}_${ownerHashHex2.slice(0, 12)}`;
+        const storage = createAutoAdapter(storagePrefix);
+        const store = new NoteStore(storage, "notes");
+        noteStoreRef.current = store;
+        noteStoreUnsub = store.onChange(() => {
+          setNotes([...store.getNotes()]);
+        });
+        store.load().then(() => {
+          if (store.getNotes().length === 0) {
+            const legacyKey = getNotesStorageKey(chainId, ownerHashHex2.slice(0, 12));
+            const legacyNotes = localStorage.getItem(legacyKey);
+            if (legacyNotes) {
+              try {
+                const parsed2 = JSON.parse(legacyNotes);
+                const migrated = parsed2.map((n) => ({
+                  ...n,
+                  amount: BigInt(n.amount),
+                  blinding: BigInt(n.blinding),
+                  origin: n.origin ?? "0x0000000000000000000000000000000000000000",
+                  token: n.token ?? "0x0000000000000000000000000000000000000000",
+                  proofSystem: n.proofSystem ?? "snark"
+                }));
+                store.addNotes(migrated);
+                store.persist();
+                console.log(`[NoteStore] Migrated ${migrated.length} legacy notes`);
+              } catch {
+              }
+            }
+          }
+          setNotes([...store.getNotes()]);
+        });
+        if (publicClientProp) {
+          checkChainFingerprint(chainId, publicClientProp).then((valid) => {
+            if (!valid) {
+              console.log(`[UPPAccount] Chain ${chainId} was reset \u2014 clearing stale notes`);
+              store.clear();
+              const legacyKey = getNotesStorageKey(chainId, ownerHashHex2.slice(0, 12));
+              localStorage.removeItem(legacyKey);
+            }
+          });
+        }
+      } catch (e) {
+        console.error("Failed to load saved account:", e);
+      }
+    } else {
+      setMasterKeys(null);
+      setStarkMasterKeys(null);
+      setNotes([]);
+    }
+    return () => {
+      if (noteStoreUnsub) noteStoreUnsub();
+    };
+  }, [ethAddress, cryptoReady, chainId, publicClientProp]);
+  const persistNotes = useCallback(
+    (_notesToSave) => {
+      noteStoreRef.current?.persist().catch(console.error);
+    },
+    []
+  );
+  const setupAccount = useCallback(
+    async (signature) => {
+      if (!ethAddress || !cryptoReady) {
+        throw new Error("Not ready to setup account");
+      }
+      setIsLoading(true);
+      try {
+        const sdk = await loadSDK();
+        const keys = await sdk.deriveKeysFromSignature(signature);
+        const starkKeys = sdk.deriveStarkKeysFromSignature(signature);
+        setMasterKeys(keys);
+        setStarkMasterKeys(starkKeys);
+        setNotes([]);
+        const serialized = {
+          version: 3,
+          spendingSecret: toHex(keys.spendingSecret, { size: 32 }),
+          ownerHash: toHex(keys.ownerHash, { size: 32 }),
+          viewingSecret: toHex(keys.viewingSecret, { size: 32 }),
+          viewingHash: toHex(keys.viewingHash, { size: 32 }),
+          starkSecret: starkKeys.starkSecret.map((v) => v.toString()),
+          starkOwnerHash: starkKeys.starkOwnerHash.map((v) => v.toString()),
+          starkViewingSecret: starkKeys.starkViewingSecret.map((v) => v.toString()),
+          starkViewingHash: starkKeys.starkViewingHash.map((v) => v.toString())
+        };
+        localStorage.setItem(getStorageKey(ethAddress), JSON.stringify(serialized));
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [ethAddress, cryptoReady]
+  );
+  const connect = useCallback(
+    async (password) => {
+      if (!signTypedData) {
+        throw new Error("signTypedData not provided to UPPAccountProvider. Pass signTypedDataAsync from wagmi.");
+      }
+      if (!ethAddress) {
+        throw new Error("Wallet not connected");
+      }
+      setIsConnecting(true);
+      try {
+        const passwordHash = password ? keccak256(toBytes(password)) : keccak256(toBytes(""));
+        const signature = await signTypedData({
+          domain: { ...UPP_EIP712_DOMAIN, chainId },
+          types: UPP_EIP712_TYPES,
+          primaryType: "Connect",
+          message: {
+            info: "Setup UPP Private Account (SNARK + STARK)",
+            warning: "This signature derives your private keys. Never share it.",
+            passwordHash
+          }
+        });
+        await setupAccount(signature);
+      } finally {
+        setIsConnecting(false);
+      }
+    },
+    [signTypedData, ethAddress, chainId, setupAccount]
+  );
+  const logout = useCallback(() => {
+    noteStoreRef.current?.clear().catch(console.error);
+    noteStoreRef.current = null;
+    if (masterKeys) {
+      const ownerHashHex2 = toHex(masterKeys.ownerHash, { size: 32 });
+      const notesKey = getNotesStorageKey(chainId, ownerHashHex2.slice(0, 12));
+      localStorage.removeItem(notesKey);
+    }
+    if (ethAddress) {
+      localStorage.removeItem(getStorageKey(ethAddress));
+    }
+    setMasterKeys(null);
+    setStarkMasterKeys(null);
+    setNotes([]);
+  }, [masterKeys, ethAddress, chainId]);
+  const addNote = useCallback(
+    (note) => {
+      const store = noteStoreRef.current;
+      if (store) {
+        store.addNote(note);
+        store.persist().catch(console.error);
+      } else {
+        setNotes((prev) => [...prev, note]);
+      }
+    },
+    []
+  );
+  const markNoteSpent = useCallback(
+    (commitment) => {
+      const store = noteStoreRef.current;
+      if (store) {
+        store.markSpent(commitment);
+        store.persist().catch(console.error);
+      } else {
+        setNotes(
+          (prev) => prev.map(
+            (n) => n.commitment.toLowerCase() === commitment.toLowerCase() ? { ...n, status: "spent" } : n
+          )
+        );
+      }
+    },
+    []
+  );
+  const createNoteForSelf = useCallback(
+    async (amount, origin, token) => {
+      if (!masterKeys || !cryptoReady) throw new Error("Account not ready");
+      const sdk = await loadSDK();
+      return createHashBasedNote(sdk, amount, masterKeys.spendingSecret, masterKeys.ownerHash, masterKeys.viewingSecret, origin, token);
+    },
+    [masterKeys, cryptoReady]
+  );
+  const getOwnerHash = useCallback(() => {
+    return masterKeys?.ownerHash ?? null;
+  }, [masterKeys]);
+  const unspentNotes = useMemo(() => {
+    const unspent = notes.filter((n) => n.status !== "spent");
+    if (!activeProofSystem) return unspent;
+    return unspent.filter((n) => (n.proofSystem ?? "snark") === activeProofSystem);
+  }, [notes, activeProofSystem]);
+  const balance = useMemo(
+    () => unspentNotes.reduce((acc, n) => acc + n.amount, 0n),
+    [unspentNotes]
+  );
+  const selectOptimalCircuit = 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 syncNotes = useCallback(
+    async (contractAddress, client) => {
+      if (!masterKeys || !cryptoReady) return 0;
+      if (syncPromiseRef.current) {
+        return syncPromiseRef.current;
+      }
+      const syncPromise = (async () => {
+        setIsSyncing(true);
+        try {
+          const sdk = await loadSDK();
+          const viewingSecret = masterKeys.viewingSecret;
+          const spendingSecret = masterKeys.spendingSecret;
+          const aesKeyHex = keccak256(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 existingCommitments = new Set(
+            notes.map((n) => n.commitment.toLowerCase())
+          );
+          const candidates = [];
+          console.log("[syncNotes] Scanning contract:", contractAddress, "\u2014 existing:", existingCommitments.size, "notes");
+          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: 0n,
+              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: 0n,
+              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: 0n,
+                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);
+          }
+          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) {
+                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 = getAddress(originRaw);
+              const token = getAddress(tokenRaw);
+              const pubkey = await sdk.privateToPublic(spendingSecret);
+              const expectedCommitment = await sdk.poseidon([
+                amount,
+                pubkey.x,
+                pubkey.y,
+                blinding,
+                BigInt(origin),
+                BigInt(token)
+              ]);
+              const expectedHex = toHex(expectedCommitment, { size: 32 });
+              if (expectedHex.toLowerCase() !== candidate.commitment.toLowerCase()) {
+                console.warn("[syncNotes] Commitment mismatch, skipping");
+                continue;
+              }
+              const newNote = {
+                commitment: candidate.commitment,
+                amount,
+                blinding,
+                ownerSecret: toHex(spendingSecret, { size: 32 }),
+                ownerHash: 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: 0n,
+                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 spentSnarkNotes = currentNotes.filter((n) => n.status === "spent" && n.proofSystem !== "stark");
+            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 % 2736030358979909402780800718157159386076813972158567259200215660948447373041n,
+                  BigInt(correctLeaf),
+                  commitment
+                ]);
+                const nullifierHex = 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();
+          }
+          return discovered + repaired;
+        } finally {
+          setIsSyncing(false);
+          syncPromiseRef.current = null;
+        }
+      })();
+      syncPromiseRef.current = syncPromise;
+      return syncPromise;
+    },
+    [masterKeys, cryptoReady, notes, persistNotes]
+  );
+  const startLiveSync = 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);
+    },
+    [syncNotes, liveSyncInterval, indexerConfig?.liveSyncIntervalMs]
+  );
+  const stopLiveSync = useCallback(() => {
+    if (liveSyncInterval) {
+      clearInterval(liveSyncInterval);
+      setLiveSyncInterval(null);
+    }
+    if (unwatchRef.current) {
+      unwatchRef.current();
+      unwatchRef.current = null;
+    }
+  }, [liveSyncInterval]);
+  useEffect(() => {
+    return () => {
+      if (liveSyncInterval) clearInterval(liveSyncInterval);
+      if (unwatchRef.current) {
+        unwatchRef.current();
+        unwatchRef.current = null;
+      }
+    };
+  }, [liveSyncInterval]);
+  const ownerHashHex = masterKeys ? toHex(masterKeys.ownerHash, { size: 32 }) : null;
+  const stealthAddress = useMemo(() => {
+    if (!masterKeys) return null;
+    try {
+      const { encodeStealthAddress } = (init_stealth(), __toCommonJS(stealth_exports));
+      return encodeStealthAddress(masterKeys.ownerHash, masterKeys.viewingHash);
+    } catch {
+      return null;
+    }
+  }, [masterKeys]);
+  const starkStealthAddress = useMemo(() => {
+    if (!starkMasterKeys) return null;
+    try {
+      const { encodeStarkStealthAddress } = (init_stealth(), __toCommonJS(stealth_exports));
+      return encodeStarkStealthAddress(starkMasterKeys.starkOwnerHash, starkMasterKeys.starkViewingHash);
+    } catch {
+      return null;
+    }
+  }, [starkMasterKeys]);
+  return /* @__PURE__ */ jsx(
+    UPPAccountContext.Provider,
+    {
+      value: {
+        masterKeys,
+        starkMasterKeys,
+        ethAddress: ethAddress ?? null,
+        ownerHash: ownerHashHex,
+        stealthAddress,
+        starkStealthAddress,
+        notes,
+        unspentNotes,
+        balance,
+        isSetup: !!masterKeys,
+        isLoading,
+        isConnecting,
+        cryptoReady,
+        isSyncing,
+        lastSyncedBlock,
+        setupAccount,
+        connect,
+        logout,
+        disconnect: logout,
+        addNote,
+        markNoteSpent,
+        createNoteForSelf,
+        getOwnerHash,
+        selectOptimalCircuit,
+        syncNotes,
+        startLiveSync,
+        stopLiveSync,
+        isLiveSyncing: liveSyncInterval !== null
+      },
+      children
+    }
+  );
+}
+function useUPPAccount() {
+  const context = useContext(UPPAccountContext);
+  if (!context) {
+    throw new Error("useUPPAccount must be used within a UPPAccountProvider");
+  }
+  return context;
+}
+async function createHashBasedNote(sdk, amount, spendingSecret, ownerHash, viewingSecret, origin, token) {
+  const blinding = await sdk.randomFieldElement();
+  const pubkey = await sdk.privateToPublic(spendingSecret);
+  const commitment = await sdk.poseidon([
+    amount,
+    pubkey.x,
+    pubkey.y,
+    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,
+    pubkeyX: pubkey.x,
+    pubkeyY: pubkey.y,
+    blinding,
+    encryptedNote,
+    searchTag,
+    amount,
+    origin,
+    token
+  };
+}
+async function encryptNoteData(amount, blinding, origin, token, viewingSecret) {
+  const keyMaterial = keccak256(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 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) {
+  const bytes = new Array(32).fill(0);
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    bytes[i % 32] = bytes[i % 32] * 31 + c & 255;
+  }
+  for (let round = 0; round < 3; round++) {
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = bytes[i] + bytes[(i + 7) % 32] * 17 + round * 53 & 255;
+    }
+  }
+  return bytes;
+}
+function byteToHex(r, g, b) {
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function adjustBrightness(r, g, b, minBrightness, maxBrightness) {
+  const brightness = (r * 299 + g * 587 + b * 114) / 1e3;
+  if (brightness < minBrightness) {
+    const factor = minBrightness / Math.max(brightness, 1);
+    return [
+      Math.min(255, Math.round(r * factor)),
+      Math.min(255, Math.round(g * factor)),
+      Math.min(255, Math.round(b * factor))
+    ];
+  }
+  if (brightness > maxBrightness) {
+    const factor = maxBrightness / brightness;
+    return [
+      Math.round(r * factor),
+      Math.round(g * factor),
+      Math.round(b * factor)
+    ];
+  }
+  return [r, g, b];
+}
+var SHAPE_TYPES = ["circle", "rect", "triangle"];
+function generateAvatarData(address) {
+  const bytes = hashBytes(address);
+  const [bgR, bgG, bgB] = adjustBrightness(bytes[0], bytes[1], bytes[2], 30, 80);
+  const background = byteToHex(bgR, bgG, bgB);
+  const shapeCount = 3 + bytes[3] % 2;
+  const shapes = [];
+  for (let i = 0; i < shapeCount; i++) {
+    const offset = 4 + i * 6;
+    const [sr, sg, sb] = adjustBrightness(
+      bytes[offset % 32],
+      bytes[(offset + 1) % 32],
+      bytes[(offset + 2) % 32],
+      100,
+      240
+    );
+    shapes.push({
+      type: SHAPE_TYPES[bytes[(offset + 3) % 32] % 3],
+      x: 10 + bytes[(offset + 4) % 32] % 80,
+      y: 10 + bytes[(offset + 5) % 32] % 80,
+      size: 20 + bytes[(offset + 3) % 32] % 40,
+      color: byteToHex(sr, sg, sb),
+      opacity: 0.5 + bytes[(offset + 2) % 32] % 50 / 100,
+      rotation: bytes[(offset + 1) % 32] * 360 / 256
+    });
+  }
+  return { background, shapes };
+}
+function renderAvatarSVG(data, size = 32) {
+  const shapes = data.shapes.map((s) => {
+    const transform = `transform="rotate(${s.rotation} ${s.x} ${s.y})"`;
+    const style = `fill="${s.color}" opacity="${s.opacity}"`;
+    switch (s.type) {
+      case "circle":
+        return `<circle cx="${s.x}" cy="${s.y}" r="${s.size / 2}" ${style} />`;
+      case "rect":
+        return `<rect x="${s.x - s.size / 2}" y="${s.y - s.size / 2}" width="${s.size}" height="${s.size * 0.7}" rx="4" ${style} ${transform} />`;
+      case "triangle": {
+        const h = s.size * 0.866;
+        const points = `${s.x},${s.y - h / 2} ${s.x - s.size / 2},${s.y + h / 2} ${s.x + s.size / 2},${s.y + h / 2}`;
+        return `<polygon points="${points}" ${style} ${transform} />`;
+      }
+    }
+  }).join("\n  ");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="${size}" height="${size}">
+  <rect width="100" height="100" rx="20" fill="${data.background}" />
+  ${shapes}
+</svg>`;
+}
+function ShapeSVG({ shape }) {
+  const transform = `rotate(${shape.rotation} ${shape.x} ${shape.y})`;
+  const fill = shape.color;
+  const opacity = shape.opacity;
+  switch (shape.type) {
+    case "circle":
+      return /* @__PURE__ */ jsx("circle", { cx: shape.x, cy: shape.y, r: shape.size / 2, fill, opacity });
+    case "rect":
+      return /* @__PURE__ */ jsx(
+        "rect",
+        {
+          x: shape.x - shape.size / 2,
+          y: shape.y - shape.size / 2,
+          width: shape.size,
+          height: shape.size * 0.7,
+          rx: 4,
+          fill,
+          opacity,
+          transform
+        }
+      );
+    case "triangle": {
+      const h = shape.size * 0.866;
+      const points = `${shape.x},${shape.y - h / 2} ${shape.x - shape.size / 2},${shape.y + h / 2} ${shape.x + shape.size / 2},${shape.y + h / 2}`;
+      return /* @__PURE__ */ jsx("polygon", { points, fill, opacity, transform });
+    }
+  }
+}
+function UPPAvatar({ address, size = 32, className, style }) {
+  const data = useMemo(() => generateAvatarData(address), [address]);
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 100 100",
+      width: size,
+      height: size,
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsx("rect", { width: "100", height: "100", rx: "20", fill: data.background }),
+        data.shapes.map((shape, i) => /* @__PURE__ */ jsx(ShapeSVG, { shape }, i))
+      ]
+    }
+  );
+}
+
+// src/react/components/styles.ts
+var colors = {
+  backdrop: "rgba(0, 0, 0, 0.5)",
+  modalBg: "var(--upp-modal-bg, rgba(0, 0, 0, 0.85))",
+  border: "var(--upp-border, rgba(255, 255, 255, 0.1))",
+  textPrimary: "var(--upp-text-primary, #ffffff)",
+  textSecondary: "var(--upp-text-secondary, rgba(255, 255, 255, 0.6))",
+  textTertiary: "var(--upp-text-tertiary, rgba(255, 255, 255, 0.4))",
+  textMuted: "var(--upp-text-muted, rgba(255, 255, 255, 0.25))",
+  hoverBg: "var(--upp-hover-bg, rgba(255, 255, 255, 0.05))",
+  pillBg: "var(--upp-pill-bg, rgba(255, 255, 255, 0.05))",
+  pillBorder: "var(--upp-pill-border, rgba(255, 255, 255, 0.1))",
+  pillBorderDashed: "var(--upp-pill-border-dashed, rgba(255, 255, 255, 0.15))",
+  emeraldBg: "rgba(16, 185, 129, 0.1)",
+  emeraldBorder: "rgba(16, 185, 129, 0.2)",
+  emeraldBorderHover: "rgba(16, 185, 129, 0.3)",
+  indigo: "#6366f1",
+  indigoBg: "rgba(99, 102, 241, 0.15)",
+  indigoBorder: "rgba(99, 102, 241, 0.3)",
+  indigoRing: "rgba(99, 102, 241, 0.5)",
+  indigoHoverBg: "rgba(99, 102, 241, 0.15)",
+  indigoHoverBorder: "rgba(99, 102, 241, 0.3)",
+  redBg: "rgba(239, 68, 68, 0.2)",
+  redBorder: "rgba(239, 68, 68, 0.3)",
+  redText: "#fca5a5",
+  inputBg: "var(--upp-input-bg, rgba(0, 0, 0, 0.3))"
+};
+var backdrop = {
+  position: "fixed",
+  inset: 0,
+  zIndex: 50,
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  background: colors.backdrop,
+  backdropFilter: "blur(4px)",
+  WebkitBackdropFilter: "blur(4px)"
+};
+var modalContainer = {
+  width: "100%",
+  maxWidth: "28rem",
+  margin: "0 1rem",
+  background: colors.modalBg,
+  backdropFilter: "blur(24px)",
+  WebkitBackdropFilter: "blur(24px)",
+  border: `1px solid ${colors.border}`,
+  borderRadius: "1rem",
+  boxShadow: "0 25px 50px -12px rgba(0, 0, 0, 0.5)"
+};
+var pillBase = {
+  display: "flex",
+  alignItems: "center",
+  gap: "8px",
+  height: "40px",
+  padding: "0 14px",
+  borderRadius: "12px",
+  border: `1px solid ${colors.pillBorder}`,
+  background: colors.pillBg,
+  cursor: "pointer",
+  transition: "all 150ms ease",
+  outline: "none",
+  boxSizing: "border-box"
+};
+var pillDisconnected = {
+  ...pillBase,
+  border: `1px dashed ${colors.pillBorderDashed}`
+};
+var pillConnected = {
+  ...pillBase,
+  background: colors.emeraldBg,
+  border: `1px solid ${colors.emeraldBorder}`
+};
+var primaryButton = {
+  width: "100%",
+  height: "40px",
+  background: colors.indigo,
+  color: colors.textPrimary,
+  borderRadius: "0.75rem",
+  fontSize: "14px",
+  fontWeight: 500,
+  border: "none",
+  cursor: "pointer",
+  transition: "all 150ms ease",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  gap: "8px"
+};
+var secondaryButton = {
+  width: "100%",
+  height: "40px",
+  background: colors.hoverBg,
+  color: colors.textSecondary,
+  borderRadius: "0.75rem",
+  fontSize: "14px",
+  fontWeight: 500,
+  border: `1px solid ${colors.border}`,
+  cursor: "pointer",
+  transition: "all 150ms ease"
+};
+var textInput = {
+  width: "100%",
+  height: "40px",
+  background: colors.inputBg,
+  border: `1px solid ${colors.border}`,
+  borderRadius: "0.75rem",
+  padding: "0 12px",
+  fontSize: "14px",
+  color: colors.textPrimary,
+  fontFamily: "monospace",
+  outline: "none",
+  transition: "all 150ms ease",
+  boxSizing: "border-box"
+};
+var UPP_KEYFRAMES = `
+@keyframes upp-spin {
+  to { transform: rotate(360deg); }
+}
+@keyframes upp-fade-in {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+@keyframes upp-zoom-in {
+  from { opacity: 0; transform: scale(0.95); }
+  to { opacity: 1; transform: scale(1); }
+}
+`;
+function UPPModal({ isOpen, onClose, settingsSlot }) {
+  const { isSetup, connect, disconnect, isConnecting } = useUPPAccount();
+  const [password, setPassword] = useState("");
+  const [error, setError] = useState(null);
+  const backdropRef = useRef(null);
+  const [closeHover, setCloseHover] = useState(false);
+  const [primaryHover, setPrimaryHover] = useState(false);
+  const [disconnectHover, setDisconnectHover] = useState(false);
+  const [inputFocused, setInputFocused] = useState(false);
+  useEffect(() => {
+    if (isOpen) {
+      setPassword("");
+      setError(null);
+    }
+  }, [isOpen]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handler = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [isOpen, onClose]);
+  const handleActivate = useCallback(async () => {
+    setError(null);
+    try {
+      await connect(password || void 0);
+      onClose();
+    } catch (e) {
+      if (e?.message?.includes("User rejected")) {
+        setError("Signature rejected");
+      } else {
+        setError(e?.message || "Setup failed");
+      }
+    }
+  }, [connect, password, onClose]);
+  const handleDisconnect = useCallback(() => {
+    disconnect();
+    onClose();
+  }, [disconnect, onClose]);
+  const handleBackdropClick = useCallback(
+    (e) => {
+      if (e.target === backdropRef.current) onClose();
+    },
+    [onClose]
+  );
+  if (!isOpen) return null;
+  if (typeof document === "undefined") return null;
+  const closeButtonStyle = {
+    padding: "6px",
+    color: closeHover ? "rgba(255,255,255,0.6)" : "rgba(255,255,255,0.3)",
+    background: closeHover ? "rgba(255,255,255,0.05)" : "transparent",
+    border: "none",
+    borderRadius: "8px",
+    cursor: "pointer",
+    transition: "all 150ms ease",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+  };
+  const inputStyle = {
+    ...textInput,
+    ...inputFocused && {
+      boxShadow: `0 0 0 1px ${colors.indigoRing}`,
+      border: `1px solid ${colors.indigoRing}`
+    }
+  };
+  const activateStyle = {
+    ...primaryButton,
+    ...primaryHover && !isConnecting && {
+      background: "#4f46e5"
+    },
+    ...isConnecting && {
+      background: "rgba(99, 102, 241, 0.5)",
+      cursor: "not-allowed"
+    }
+  };
+  const disconnectStyle = {
+    ...secondaryButton,
+    ...disconnectHover && {
+      background: colors.redBg,
+      color: colors.redText,
+      border: `1px solid ${colors.redBorder}`
+    }
+  };
+  return createPortal(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("style", { children: UPP_KEYFRAMES }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: backdropRef,
+          onClick: handleBackdropClick,
+          style: { ...backdrop, animation: "upp-fade-in 150ms ease" },
+          children: /* @__PURE__ */ jsxs("div", { style: { ...modalContainer, animation: "upp-zoom-in 200ms ease" }, children: [
+            /* @__PURE__ */ jsx("div", { style: { display: "flex", justifyContent: "flex-end", padding: "12px 12px 0" }, children: /* @__PURE__ */ jsx(
+              "button",
+              {
+                onClick: onClose,
+                onMouseEnter: () => setCloseHover(true),
+                onMouseLeave: () => setCloseHover(false),
+                style: closeButtonStyle,
+                children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", children: /* @__PURE__ */ jsx("path", { d: "M4 4l8 8M12 4l-8 8" }) })
+              }
+            ) }),
+            isSetup ? (
+              /* ============ Account Mode ============ */
+              /* @__PURE__ */ jsxs("div", { style: { padding: "0 24px 24px", display: "flex", flexDirection: "column", gap: "16px" }, children: [
+                /* @__PURE__ */ jsx("h3", { style: { fontSize: "14px", fontWeight: 600, color: colors.textPrimary, margin: 0, textAlign: "center" }, children: "Private Account" }),
+                settingsSlot,
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: handleDisconnect,
+                    onMouseEnter: () => setDisconnectHover(true),
+                    onMouseLeave: () => setDisconnectHover(false),
+                    style: disconnectStyle,
+                    children: "Disconnect"
+                  }
+                )
+              ] })
+            ) : (
+              /* ============ Setup Mode ============ */
+              /* @__PURE__ */ jsxs("div", { style: { padding: "0 24px 24px", display: "flex", flexDirection: "column", gap: "16px" }, children: [
+                /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", alignItems: "center", gap: "12px" }, children: [
+                  /* @__PURE__ */ jsx("div", { style: {
+                    padding: "12px",
+                    background: colors.indigoBg,
+                    borderRadius: "1rem",
+                    border: `1px solid ${colors.indigoBorder}`
+                  }, children: /* @__PURE__ */ jsx("svg", { width: "28", height: "28", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", style: { color: "#818cf8" }, children: /* @__PURE__ */ jsx("path", { d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" }) }) }),
+                  /* @__PURE__ */ jsxs("div", { style: { textAlign: "center" }, children: [
+                    /* @__PURE__ */ jsx("h3", { style: { fontSize: "16px", fontWeight: 600, color: colors.textPrimary, margin: "0 0 4px" }, children: "Activate Private Account" }),
+                    /* @__PURE__ */ jsx("p", { style: { fontSize: "12px", color: colors.textTertiary, maxWidth: "20rem", margin: 0 }, children: "Sign once with your wallet to derive your private keys. The optional password creates a unique account." })
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "password",
+                    placeholder: "Password (optional)",
+                    value: password,
+                    onChange: (e) => setPassword(e.target.value),
+                    onKeyDown: (e) => {
+                      if (e.key === "Enter" && !isConnecting) handleActivate();
+                    },
+                    onFocus: () => setInputFocused(true),
+                    onBlur: () => setInputFocused(false),
+                    style: inputStyle
+                  }
+                ),
+                error && /* @__PURE__ */ jsx("p", { style: { fontSize: "12px", color: "#f87171", textAlign: "center", margin: 0 }, children: error }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: handleActivate,
+                    disabled: isConnecting,
+                    onMouseEnter: () => setPrimaryHover(true),
+                    onMouseLeave: () => setPrimaryHover(false),
+                    style: activateStyle,
+                    children: isConnecting ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                      /* @__PURE__ */ jsx(
+                        "svg",
+                        {
+                          width: "16",
+                          height: "16",
+                          viewBox: "0 0 24 24",
+                          fill: "none",
+                          stroke: "currentColor",
+                          strokeWidth: "2",
+                          style: { animation: "upp-spin 1s linear infinite" },
+                          children: /* @__PURE__ */ jsx("path", { d: "M12 2v4M12 18v4M4.93 4.93l2.83 2.83M16.24 16.24l2.83 2.83M2 12h4M18 12h4M4.93 19.07l2.83-2.83M16.24 7.76l2.83-2.83" })
+                        }
+                      ),
+                      "Signing..."
+                    ] }) : "Activate"
+                  }
+                ),
+                /* @__PURE__ */ jsx("p", { style: { fontSize: "9px", color: colors.textMuted, textAlign: "center", margin: 0 }, children: "Your private key is derived from a wallet signature. No seed phrase needed." })
+              ] })
+            )
+          ] })
+        }
+      )
+    ] }),
+    document.body
+  );
+}
+function UPPPrivateButton({
+  style: externalStyle,
+  label = "Private Account",
+  settingsSlot
+}) {
+  const { isSetup, stealthAddress } = useUPPAccount();
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [isHovered, setIsHovered] = useState(false);
+  const openModal = useCallback(() => setIsModalOpen(true), []);
+  const closeModal = useCallback(() => setIsModalOpen(false), []);
+  if (isSetup && stealthAddress) {
+    const connectedStyle = {
+      ...pillConnected,
+      ...isHovered && {
+        background: "rgba(16, 185, 129, 0.2)",
+        border: `1px solid ${colors.emeraldBorderHover}`
+      },
+      ...externalStyle
+    };
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: openModal,
+          onMouseEnter: () => setIsHovered(true),
+          onMouseLeave: () => setIsHovered(false),
+          style: connectedStyle,
+          title: "Private Account",
+          children: [
+            /* @__PURE__ */ jsx(UPPAvatar, { address: stealthAddress, size: 22, style: { borderRadius: "5px", flexShrink: 0 } }),
+            /* @__PURE__ */ jsx("svg", { width: "10", height: "6", viewBox: "0 0 10 6", fill: "none", style: { color: "rgba(110, 231, 183, 0.4)" }, children: /* @__PURE__ */ jsx("path", { d: "M1 1l4 4 4-4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(UPPModal, { isOpen: isModalOpen, onClose: closeModal, settingsSlot })
+    ] });
+  }
+  const disconnectedStyle = {
+    ...pillDisconnected,
+    ...isHovered && {
+      background: colors.indigoHoverBg,
+      border: `1px dashed ${colors.indigoHoverBorder}`
+    },
+    ...externalStyle
+  };
+  const iconColor = isHovered ? colors.indigo : "rgba(255, 255, 255, 0.25)";
+  const textColor = isHovered ? "rgba(255, 255, 255, 0.7)" : colors.textTertiary;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: openModal,
+        onMouseEnter: () => setIsHovered(true),
+        onMouseLeave: () => setIsHovered(false),
+        style: disconnectedStyle,
+        title: "Activate Private Account",
+        children: [
+          /* @__PURE__ */ jsx(
+            "svg",
+            {
+              width: "18",
+              height: "18",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "1.5",
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              style: { color: iconColor, transition: "color 150ms ease", flexShrink: 0 },
+              children: /* @__PURE__ */ jsx("path", { d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" })
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { style: {
+            fontSize: "13px",
+            fontWeight: 500,
+            color: textColor,
+            transition: "color 150ms ease"
+          }, children: label })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(UPPModal, { isOpen: isModalOpen, onClose: closeModal, settingsSlot })
+  ] });
+}
+var sdkPromise2 = null;
+function useUPPCrypto() {
+  const [isReady, setIsReady] = useState(false);
+  const loadSDK2 = useCallback(async () => {
+    if (!sdkPromise2) {
+      sdkPromise2 = import('../index.js');
+    }
+    return sdkPromise2;
+  }, []);
+  useEffect(() => {
+    loadSDK2().then(() => setIsReady(true));
+  }, [loadSDK2]);
+  const poseidon = useCallback(
+    async (inputs) => {
+      const sdk = await loadSDK2();
+      return sdk.poseidon(inputs);
+    },
+    [loadSDK2]
+  );
+  const randomFieldElement = useCallback(async () => {
+    const sdk = await loadSDK2();
+    return sdk.randomFieldElement();
+  }, [loadSDK2]);
+  const computeSharedSecret = useCallback(
+    async (privateKey, publicKey) => {
+      const sdk = await loadSDK2();
+      return sdk.computeSharedSecret(privateKey, publicKey);
+    },
+    [loadSDK2]
+  );
+  const privateToPublic = useCallback(
+    async (privateKey) => {
+      const sdk = await loadSDK2();
+      return sdk.privateToPublic(privateKey);
+    },
+    [loadSDK2]
+  );
+  const addPoints = useCallback(
+    async (p1, p2) => {
+      const sdk = await loadSDK2();
+      return sdk.addPoints(p1, p2);
+    },
+    [loadSDK2]
+  );
+  const mulPointScalar = useCallback(
+    async (point, scalar) => {
+      const sdk = await loadSDK2();
+      return sdk.mulPointScalar(point, scalar);
+    },
+    [loadSDK2]
+  );
+  const getSubOrder = useCallback(async () => {
+    const sdk = await loadSDK2();
+    return sdk.getSubOrder();
+  }, [loadSDK2]);
+  const init = useCallback(async () => {
+    await loadSDK2();
+    setIsReady(true);
+  }, [loadSDK2]);
+  return {
+    isReady,
+    init,
+    poseidon,
+    randomFieldElement,
+    computeSharedSecret,
+    privateToPublic,
+    addPoints,
+    mulPointScalar,
+    getSubOrder
+  };
+}
+function packNoteData(note) {
+  return encodePacked(
+    ["uint64", "uint256", "bytes"],
+    [note.searchTag, note.ownerHash, note.encryptedNote]
+  );
+}
+function useShield(config) {
+  const { createNoteForSelf, isSetup, masterKeys } = useUPPAccount();
+  const [isPending, setIsPending] = useState(false);
+  const [stage, setStage] = useState(null);
+  const [error, setError] = useState(null);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const reset = useCallback(() => {
+    setError(null);
+    setStage(null);
+  }, []);
+  const build = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const { amount, originAddress } = params;
+        const cfg = configRef.current;
+        if (amount <= 0n) {
+          throw new Error("Amount must be positive");
+        }
+        const origin = BigInt(originAddress);
+        const token = BigInt(cfg.tokenAddress);
+        setStage("creating_note");
+        const noteData = await createNoteForSelf(amount, origin, token);
+        const commitment = toHex(noteData.commitment, { size: 32 });
+        const encryptedNote = packNoteData(noteData);
+        return {
+          amount,
+          token: cfg.tokenAddress,
+          commitment,
+          encryptedNote,
+          noteData
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, createNoteForSelf]
+  );
+  return {
+    build,
+    isPending,
+    stage,
+    error,
+    reset
+  };
+}
+function packNoteData2(note) {
+  return encodePacked(
+    ["uint64", "uint256", "bytes"],
+    [note.searchTag, note.ownerHash, note.encryptedNote]
+  );
+}
+function usePoolTransfer(config) {
+  const {
+    unspentNotes,
+    createNoteForSelf,
+    isSetup,
+    masterKeys
+  } = useUPPAccount();
+  const [isPending, setIsPending] = useState(false);
+  const [stage, setStage] = useState(null);
+  const [error, setError] = useState(null);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const reset = useCallback(() => {
+    setError(null);
+    setStage(null);
+  }, []);
+  const build = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const { amount, recipient: _recipient } = params;
+        const cfg = configRef.current;
+        setStage("selecting_notes");
+        const confirmedNotes = unspentNotes.filter(
+          (n) => n.status === "confirmed" && n.token?.toLowerCase() === cfg.tokenAddress.toLowerCase()
+        );
+        const sortedNotes = [...confirmedNotes].sort((a, b) => {
+          const diff = b.amount - a.amount;
+          return diff > 0n ? 1 : diff < 0n ? -1 : 0;
+        });
+        const selectedNote = sortedNotes.find((n) => n.amount >= amount);
+        if (!selectedNote) {
+          const totalBalance = confirmedNotes.reduce((sum, n) => sum + n.amount, 0n);
+          if (totalBalance >= amount) {
+            throw new Error(
+              "No single note is large enough. Please merge notes first, or shield a larger amount."
+            );
+          }
+          throw new Error("Insufficient shielded balance");
+        }
+        const changeAmount = selectedNote.amount - amount;
+        const origin = BigInt(selectedNote.origin);
+        const token = BigInt(selectedNote.token);
+        setStage("creating_outputs");
+        const recipientNote = await createNoteForSelf(amount, origin, token);
+        const changeNote = await createNoteForSelf(changeAmount, origin, token);
+        const [transferModule, proofModule, aspModule] = await Promise.all([
+          import('../transfer-KTCXKHS4.js'),
+          import('../proof-C4YBP6RY.js'),
+          import('../asp-ZA3RGN7G.js')
+        ]);
+        const {
+          syncMerkleTree,
+          getMerkleProofsForNotes,
+          buildUPPTransferCircuitInputs
+        } = transferModule;
+        const { generateUPPProof, formatProofForContract } = proofModule;
+        const { generateASPProof: generateASPProof2, DEMO_ASP_ID } = aspModule;
+        setStage("syncing_merkle");
+        const { tree, leaves } = await syncMerkleTree(cfg.publicClient, cfg.poolAddress);
+        const spendableNote = {
+          amount: selectedNote.amount,
+          blinding: selectedNote.blinding,
+          commitment: selectedNote.commitment,
+          ownerSecret: selectedNote.ownerSecret,
+          ownerHash: selectedNote.ownerHash,
+          leafIndex: selectedNote.leafIndex,
+          origin,
+          token
+        };
+        const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
+        const aspProof = await generateASPProof2(
+          cfg.aspId ?? DEMO_ASP_ID,
+          origin,
+          cfg.aspApprovedOrigins
+        );
+        setStage("generating_proof");
+        const recipientNoteWithAmount = { ...recipientNote, amount };
+        const changeNoteWithAmount = { ...changeNote, amount: changeAmount };
+        const circuitInputs = await buildUPPTransferCircuitInputs(
+          noteProof,
+          aspProof,
+          recipientNoteWithAmount,
+          changeNoteWithAmount
+        );
+        const { proof } = await generateUPPProof(
+          "transfer",
+          circuitInputs,
+          cfg.circuitBaseUrl ?? "/circuits/"
+        );
+        const formattedProof = formatProofForContract(proof);
+        const proofArray = [
+          formattedProof.a[0],
+          formattedProof.a[1],
+          formattedProof.b[0][0],
+          formattedProof.b[0][1],
+          formattedProof.b[1][0],
+          formattedProof.b[1][1],
+          formattedProof.c[0],
+          formattedProof.c[1]
+        ];
+        return {
+          circuit: "transfer",
+          proof: proofArray,
+          nullifier: toHex(BigInt(circuitInputs.nullifier), { size: 32 }),
+          stateRoot: BigInt(circuitInputs.stateRoot),
+          aspRoot: BigInt(circuitInputs.aspRoot),
+          token: cfg.tokenAddress,
+          outputCommitment1: toHex(recipientNote.commitment, { size: 32 }),
+          outputCommitment2: toHex(changeNote.commitment, { size: 32 }),
+          encryptedNote1: packNoteData2(recipientNote),
+          encryptedNote2: packNoteData2(changeNote),
+          spentNote: selectedNote,
+          recipientNoteData: recipientNote,
+          changeNoteData: changeNote
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, unspentNotes, createNoteForSelf]
+  );
+  return {
+    build,
+    isPending,
+    stage,
+    error,
+    reset
+  };
+}
+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,
+    masterKeys,
+    unspentNotes
+  } = useUPPAccount();
+  const [isPending, setIsPending] = useState(false);
+  const [stage, setStage] = useState(null);
+  const [error, setError] = useState(null);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const reset = useCallback(() => {
+    setError(null);
+    setStage(null);
+  }, []);
+  const build = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const {
+          amount,
+          recipient,
+          aspId = 0n,
+          aspRoot = 0n,
+          isRagequit = false
+        } = params;
+        const cfg = configRef.current;
+        setStage("selecting_notes");
+        console.log(`[useWithdraw] === NOTE SELECTION DEBUG ===`);
+        console.log(`  Requested amount: ${amount}`);
+        console.log(`  Available unspent notes (${unspentNotes.length}):`);
+        unspentNotes.forEach((n, i) => {
+          console.log(`    [${i}] amount=${n.amount}, status=${n.status}, leafIndex=${n.leafIndex}, commitment=${n.commitment.slice(0, 18)}...`);
+        });
+        const tokenFilteredNotes = unspentNotes.filter(
+          (n) => n.token?.toLowerCase() === cfg.tokenAddress.toLowerCase() && n.proofSystem !== "stark"
+        );
+        const sortedNotes = [...tokenFilteredNotes].sort(
+          (a, b) => a.amount > b.amount ? 1 : -1
+        );
+        console.log(`  Sorted notes (ascending by amount):`);
+        sortedNotes.forEach((n, i) => {
+          console.log(`    [${i}] amount=${n.amount}, commitment=${n.commitment.slice(0, 18)}...`);
+        });
+        const selectedNote = sortedNotes.find((n) => n.amount >= amount);
+        console.log(`  Selected note: ${selectedNote ? `amount=${selectedNote.amount}, commitment=${selectedNote.commitment.slice(0, 18)}...` : "NONE"}`);
+        if (!selectedNote) {
+          throw new Error(`Insufficient balance. Need ${amount}, have ${tokenFilteredNotes.reduce((s, n) => s + n.amount, 0n)}`);
+        }
+        if (selectedNote.amount !== amount) {
+          throw new Error(
+            `Withdraw circuit requires exact note amount. Note has ${selectedNote.amount}, requested ${amount}. Use private transfer to split the note first.`
+          );
+        }
+        const origin = BigInt(selectedNote.origin);
+        const token = BigInt(selectedNote.token);
+        setStage("creating_outputs");
+        const [transferModule, proofModule, sdk] = await Promise.all([
+          import('../transfer-KTCXKHS4.js'),
+          import('../proof-C4YBP6RY.js'),
+          import('../index.js')
+        ]);
+        const { syncMerkleTree, getMerkleProofsForNotes } = transferModule;
+        const { generateUPPProof, formatProofForContract } = proofModule;
+        setStage("syncing_merkle");
+        const { tree, leaves } = await syncMerkleTree(cfg.publicClient, cfg.poolAddress);
+        const spendableNote = {
+          amount: selectedNote.amount,
+          blinding: selectedNote.blinding,
+          commitment: selectedNote.commitment,
+          ownerSecret: selectedNote.ownerSecret,
+          ownerHash: selectedNote.ownerHash,
+          leafIndex: selectedNote.leafIndex,
+          origin,
+          token
+        };
+        const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
+        setStage("generating_proof");
+        const merkleProof = noteProof.proof;
+        const stateRootBI = merkleProof.root;
+        const actualLeafIndex = merkleProof.leafIndex;
+        const inputPubkey = await sdk.privateToPublic(BigInt(selectedNote.ownerSecret));
+        const localCommitment = await sdk.poseidon([
+          selectedNote.amount,
+          inputPubkey.x,
+          inputPubkey.y,
+          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) % BABYJUBJUB_SUBORDER,
+          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) % BABYJUBJUB_SUBORDER).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 { proof } = await generateUPPProof(
+          "withdraw",
+          circuitInputs,
+          cfg.circuitBaseUrl ?? "/circuits/"
+        );
+        const formattedProof = formatProofForContract(proof);
+        const stateRoot = stateRootBI;
+        const proofArray = [
+          formattedProof.a[0],
+          formattedProof.a[1],
+          formattedProof.b[0][0],
+          formattedProof.b[0][1],
+          formattedProof.b[1][0],
+          formattedProof.b[1][1],
+          formattedProof.c[0],
+          formattedProof.c[1]
+        ];
+        return {
+          proof: proofArray,
+          nullifier: toHex(nullifier, { size: 32 }),
+          stateRoot,
+          aspRoot,
+          aspId,
+          token: cfg.tokenAddress,
+          amount,
+          recipient,
+          isRagequit,
+          spentNote: selectedNote,
+          changeNoteData: null,
+          changeCommitment: null,
+          changeEncryptedNote: null
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, unspentNotes]
+  );
+  return {
+    build,
+    isPending,
+    stage,
+    error,
+    reset
+  };
+}
+var STORAGE_KEY_PREFIX = "upp_personal_asp_";
+function getStorageKey2(chainId, address) {
+  return `${STORAGE_KEY_PREFIX}${chainId}_${address.toLowerCase()}`;
+}
+function loadStoredASPId(chainId, address) {
+  if (typeof window === "undefined") return null;
+  try {
+    const key = getStorageKey2(chainId, address);
+    const stored = localStorage.getItem(key);
+    return stored ? BigInt(stored) : null;
+  } catch {
+    return null;
+  }
+}
+function storeASPId(chainId, address, aspId) {
+  if (typeof window === "undefined") return;
+  try {
+    const key = getStorageKey2(chainId, address);
+    localStorage.setItem(key, aspId.toString());
+  } catch {
+  }
+}
+function usePersonalASP(config) {
+  const { aspHubAddress, publicClient, userAddress } = config;
+  const [aspInfo, setAspInfo] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!userAddress || !publicClient) {
+      setAspInfo(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const chainId = await publicClient.getChainId();
+      const storedAspId = loadStoredASPId(chainId, userAddress);
+      if (storedAspId) {
+        const aspData = await publicClient.readContract({
+          address: aspHubAddress,
+          abi: ASP_REGISTRY_HUB_ABI,
+          functionName: "getASP",
+          args: [storedAspId]
+        });
+        if (aspData.operator.toLowerCase() === userAddress.toLowerCase()) {
+          const userOrigin = BigInt(userAddress);
+          const expectedRoot = await computeSingleOriginASPRoot(userOrigin);
+          const isApproved = aspData.currentRoot === expectedRoot;
+          setAspInfo({
+            aspId: storedAspId,
+            currentRoot: aspData.currentRoot,
+            isRegistered: true,
+            isApproved
+          });
+          setIsLoading(false);
+          return;
+        }
+      }
+      setAspInfo({
+        aspId: 0n,
+        currentRoot: 0n,
+        isRegistered: false,
+        isApproved: false
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setAspInfo(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [aspHubAddress, publicClient, userAddress]);
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+  const isOriginApproved = useCallback(async (origin) => {
+    if (!aspInfo?.isRegistered || !publicClient) return false;
+    try {
+      const expectedRoot = await computeSingleOriginASPRoot(origin);
+      const isValid = await publicClient.readContract({
+        address: aspHubAddress,
+        abi: ASP_REGISTRY_HUB_ABI,
+        functionName: "isValidASPRoot",
+        args: [aspInfo.aspId, expectedRoot]
+      });
+      return isValid;
+    } catch {
+      return false;
+    }
+  }, [aspInfo, aspHubAddress, publicClient]);
+  const getASPId = useCallback(() => {
+    return aspInfo?.isRegistered ? aspInfo.aspId : null;
+  }, [aspInfo]);
+  const getASPRootForOrigin = useCallback(async (origin) => {
+    return computeSingleOriginASPRoot(origin);
+  }, []);
+  return {
+    aspInfo,
+    isLoading,
+    error,
+    isOriginApproved,
+    getASPId,
+    getASPRootForOrigin,
+    refresh
+  };
+}
+function storePersonalASPId(chainId, address, aspId) {
+  storeASPId(chainId, address, aspId);
+}
+init_poseidon();
+var STATE_TREE_DEPTH2 = 32;
+function padToDepth2(arr, padValue, depth) {
+  if (arr.length >= depth) return arr.slice(0, depth);
+  return [...arr, ...Array(depth - arr.length).fill(padValue)];
+}
+var SWAP_ORDERS_ABI = [{
+  type: "function",
+  name: "swapOrders",
+  inputs: [{ name: "", type: "bytes32" }],
+  outputs: [
+    { name: "sellToken", type: "address" },
+    { name: "sellAmount", type: "uint256" },
+    { name: "remainingSellAmount", type: "uint256" },
+    { name: "buyToken", type: "address" },
+    { name: "rate", type: "uint256" },
+    { name: "accumulatedBuyAmount", type: "uint256" },
+    { name: "makerAspId", type: "uint256" },
+    { name: "requiredFillerAspId", type: "uint256" },
+    { name: "cancelKeyHash", type: "bytes32" },
+    { name: "expiry", type: "uint256" },
+    { name: "claimed", type: "bool" },
+    { name: "cancelled", type: "bool" }
+  ],
+  stateMutability: "view"
+}];
+function useSwapOrderBook(config) {
+  const [orders, setOrders] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const intervalRef = useRef(null);
+  const refresh = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const logs = await config.publicClient.getLogs({
+        address: config.poolAddress,
+        event: SWAP_ORDER_PLACED_EVENT,
+        fromBlock: config.fromBlock ?? 0n,
+        toBlock: "latest"
+      });
+      let parsedOrders = logs.map((log) => ({
+        orderId: log.args.orderId,
+        sellToken: log.args.sellToken,
+        buyToken: log.args.buyToken,
+        sellAmount: log.args.sellAmount,
+        rate: log.args.rate,
+        makerAspId: log.args.makerAspId,
+        requiredFillerAspId: log.args.requiredFillerAspId,
+        expiry: log.args.expiry,
+        blockNumber: log.blockNumber ?? 0n
+      }));
+      if (config.sellToken && config.buyToken) {
+        parsedOrders = filterOrdersByTokenPair(parsedOrders, config.sellToken, config.buyToken);
+      }
+      if (config.acceptableAspIds && config.acceptableAspIds.length > 0) {
+        parsedOrders = filterOrdersByASP(parsedOrders, config.acceptableAspIds);
+      }
+      const enriched = [];
+      for (const order of parsedOrders) {
+        try {
+          const result = await config.publicClient.readContract({
+            address: config.poolAddress,
+            abi: SWAP_ORDERS_ABI,
+            functionName: "swapOrders",
+            args: [order.orderId]
+          });
+          const claimed = result[10];
+          const cancelled = result[11];
+          const remainingSellAmount = result[2];
+          enriched.push({
+            ...order,
+            remainingSellAmount,
+            claimed,
+            cancelled
+          });
+        } catch {
+          enriched.push(order);
+        }
+      }
+      setOrders(enriched);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch order book");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [config.publicClient, config.poolAddress, config.sellToken, config.buyToken, config.acceptableAspIds, config.fromBlock]);
+  useEffect(() => {
+    refresh();
+    const interval = config.pollInterval ?? 15e3;
+    intervalRef.current = setInterval(refresh, interval);
+    return () => {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+    };
+  }, [refresh, config.pollInterval]);
+  return { orders, isLoading, error, refresh };
+}
+function useSwap(config) {
+  const {
+    isSetup,
+    masterKeys,
+    unspentNotes,
+    createNoteForSelf,
+    ethAddress
+  } = useUPPAccount();
+  const [isPending, setIsPending] = useState(false);
+  const [stage, setStage] = useState(null);
+  const [error, setError] = useState(null);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const reset = useCallback(() => {
+    setError(null);
+    setStage(null);
+  }, []);
+  const buildPlaceOrder = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const {
+          sellToken,
+          sellAmount,
+          buyToken,
+          rate,
+          requiredFillerAspId = 0n,
+          expiryBlocks,
+          aspId,
+          noteOverride
+        } = params;
+        const cfg = configRef.current;
+        setStage("selecting_notes");
+        let selectedNote;
+        if (noteOverride) {
+          selectedNote = noteOverride;
+        } else {
+          const sortedNotes = [...unspentNotes].filter((n) => n.token?.toLowerCase() === sellToken.toLowerCase() && n.proofSystem !== "stark").sort((a, b) => a.amount > b.amount ? 1 : -1);
+          const exactNote = sortedNotes.find((n) => n.amount === sellAmount);
+          if (!exactNote) {
+            const largerNote = sortedNotes.find((n) => n.amount > sellAmount);
+            if (largerNote) {
+              throw new Error(`SPLIT_REQUIRED:${largerNote.commitment}`);
+            }
+            throw new Error(
+              `Insufficient ${sellToken} balance for swap. Need ${sellAmount}, have ${sortedNotes.reduce((s, n) => s + n.amount, 0n)}`
+            );
+          }
+          selectedNote = exactNote;
+        }
+        setStage("creating_outputs");
+        const [transferModule, proofModule, sdk, aspModule] = await Promise.all([
+          import('../transfer-KTCXKHS4.js'),
+          import('../proof-C4YBP6RY.js'),
+          import('../index.js'),
+          import('../asp-ZA3RGN7G.js')
+        ]);
+        const { syncMerkleTree, getMerkleProofsForNotes } = transferModule;
+        const { generateUPPProof, formatProofForContract } = proofModule;
+        const { generateASPProof: generateASPProof2 } = aspModule;
+        setStage("syncing_merkle");
+        const { tree, leaves } = await syncMerkleTree(cfg.publicClient, cfg.poolAddress);
+        const origin = BigInt(selectedNote.origin);
+        const token = BigInt(selectedNote.token);
+        const spendableNote = {
+          amount: selectedNote.amount,
+          blinding: selectedNote.blinding,
+          commitment: selectedNote.commitment,
+          ownerSecret: selectedNote.ownerSecret,
+          ownerHash: selectedNote.ownerHash,
+          leafIndex: selectedNote.leafIndex,
+          origin,
+          token
+        };
+        const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
+        const merkleProof = noteProof.proof;
+        const stateRootBI = merkleProof.root;
+        const actualLeafIndex = merkleProof.leafIndex;
+        setStage("generating_proof");
+        const inputPubkey = await sdk.privateToPublic(BigInt(selectedNote.ownerSecret));
+        const localCommitment = await sdk.poseidon([
+          selectedNote.amount,
+          inputPubkey.x,
+          inputPubkey.y,
+          selectedNote.blinding,
+          origin,
+          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) % BABYJUBJUB_SUBORDER,
+          BigInt(actualLeafIndex),
+          storedCommitment
+        ]);
+        const aspProofData = await generateASPProof2(aspId, origin, cfg.aspApprovedOrigins);
+        const circuitInputs = {
+          stateRoot: stateRootBI.toString(),
+          aspRoot: aspProofData.aspRoot.toString(),
+          nullifier: nullifier.toString(),
+          amount: selectedNote.amount.toString(),
+          recipient: BigInt(cfg.poolAddress).toString(),
+          token: token.toString(),
+          isRagequit: "0",
+          inputAmount: selectedNote.amount.toString(),
+          inputOneTimeSecret: (BigInt(selectedNote.ownerSecret) % BABYJUBJUB_SUBORDER).toString(),
+          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: aspProofData.aspPathElements.map(String),
+          aspPathIndices: aspProofData.aspPathIndices.map(String)
+        };
+        const { proof } = await generateUPPProof(
+          "withdraw",
+          circuitInputs,
+          cfg.circuitBaseUrl ?? "/circuits/"
+        );
+        const formattedProof = formatProofForContract(proof);
+        const proofArray = [
+          formattedProof.a[0],
+          formattedProof.a[1],
+          formattedProof.b[0][0],
+          formattedProof.b[0][1],
+          formattedProof.b[1][0],
+          formattedProof.b[1][1],
+          formattedProof.c[0],
+          formattedProof.c[1]
+        ];
+        const cancelSecret = generateCancelSecret();
+        const cancelKeyHash = computeCancelKeyHash(cancelSecret);
+        const currentBlock = await cfg.publicClient.getBlockNumber();
+        const expiry = currentBlock + expiryBlocks;
+        return {
+          proof: proofArray,
+          nullifier: toHex(nullifier, { size: 32 }),
+          stateRoot: stateRootBI,
+          aspRoot: aspProofData.aspRoot,
+          aspId,
+          sellToken,
+          sellAmount,
+          buyToken,
+          rate,
+          cancelKeyHash,
+          cancelSecret,
+          requiredFillerAspId,
+          expiry,
+          spentNote: selectedNote
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, unspentNotes]
+  );
+  const buildFillOrder = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const {
+          orderId,
+          takeAmount,
+          rate,
+          sellToken,
+          buyToken,
+          aspId,
+          noteOverride
+        } = params;
+        const cfg = configRef.current;
+        const giveAmount = computeGiveAmount(takeAmount, rate);
+        setStage("selecting_notes");
+        let selectedNote;
+        if (noteOverride) {
+          selectedNote = noteOverride;
+        } else {
+          const sortedNotes = [...unspentNotes].filter((n) => n.token?.toLowerCase() === buyToken.toLowerCase() && n.proofSystem !== "stark").sort((a, b) => a.amount > b.amount ? 1 : -1);
+          const exactNote = sortedNotes.find((n) => n.amount === giveAmount);
+          if (!exactNote) {
+            const largerNote = sortedNotes.find((n) => n.amount > giveAmount);
+            if (largerNote) {
+              throw new Error(`SPLIT_REQUIRED:${largerNote.commitment}`);
+            }
+            throw new Error(
+              `Insufficient ${buyToken} balance. Need ${giveAmount} to fill order, have ${sortedNotes.reduce((s, n) => s + n.amount, 0n)}`
+            );
+          }
+          selectedNote = exactNote;
+        }
+        setStage("creating_outputs");
+        const [transferModule, proofModule, sdk, aspModule] = await Promise.all([
+          import('../transfer-KTCXKHS4.js'),
+          import('../proof-C4YBP6RY.js'),
+          import('../index.js'),
+          import('../asp-ZA3RGN7G.js')
+        ]);
+        const { syncMerkleTree, getMerkleProofsForNotes } = transferModule;
+        const { generateUPPProof, formatProofForContract } = proofModule;
+        const { generateASPProof: generateASPProof2 } = aspModule;
+        const fillerOrigin = ethAddress ? BigInt(ethAddress) : BigInt(masterKeys.ownerHash);
+        const fillerNoteData = await createNoteForSelf(
+          takeAmount,
+          fillerOrigin,
+          BigInt(sellToken)
+        );
+        setStage("syncing_merkle");
+        const { tree, leaves } = await syncMerkleTree(cfg.publicClient, cfg.poolAddress);
+        const origin = BigInt(selectedNote.origin);
+        const token = BigInt(selectedNote.token);
+        const spendableNote = {
+          amount: selectedNote.amount,
+          blinding: selectedNote.blinding,
+          commitment: selectedNote.commitment,
+          ownerSecret: selectedNote.ownerSecret,
+          ownerHash: selectedNote.ownerHash,
+          leafIndex: selectedNote.leafIndex,
+          origin,
+          token
+        };
+        const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
+        const merkleProof = noteProof.proof;
+        const stateRootBI = merkleProof.root;
+        const actualLeafIndex = merkleProof.leafIndex;
+        setStage("generating_proof");
+        const inputPubkeyF = await sdk.privateToPublic(BigInt(selectedNote.ownerSecret));
+        const localCommitmentF = await sdk.poseidon([
+          selectedNote.amount,
+          inputPubkeyF.x,
+          inputPubkeyF.y,
+          selectedNote.blinding,
+          origin,
+          token
+        ]);
+        const storedCommitmentF = BigInt(selectedNote.commitment);
+        if (localCommitmentF !== storedCommitmentF) {
+          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) % BABYJUBJUB_SUBORDER,
+          BigInt(actualLeafIndex),
+          storedCommitmentF
+        ]);
+        const aspProofData = await generateASPProof2(aspId, origin, cfg.aspApprovedOrigins);
+        const circuitInputs = {
+          stateRoot: stateRootBI.toString(),
+          aspRoot: aspProofData.aspRoot.toString(),
+          nullifier: nullifier.toString(),
+          amount: selectedNote.amount.toString(),
+          recipient: BigInt(cfg.poolAddress).toString(),
+          token: token.toString(),
+          isRagequit: "0",
+          inputAmount: selectedNote.amount.toString(),
+          inputOneTimeSecret: (BigInt(selectedNote.ownerSecret) % BABYJUBJUB_SUBORDER).toString(),
+          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: aspProofData.aspPathElements.map(String),
+          aspPathIndices: aspProofData.aspPathIndices.map(String)
+        };
+        const { proof } = await generateUPPProof(
+          "withdraw",
+          circuitInputs,
+          cfg.circuitBaseUrl ?? "/circuits/"
+        );
+        const formattedProof = formatProofForContract(proof);
+        const proofArray = [
+          formattedProof.a[0],
+          formattedProof.a[1],
+          formattedProof.b[0][0],
+          formattedProof.b[0][1],
+          formattedProof.b[1][0],
+          formattedProof.b[1][1],
+          formattedProof.c[0],
+          formattedProof.c[1]
+        ];
+        const { encodePacked: encodePacked3 } = await import('viem');
+        const packedFillerNote = encodePacked3(
+          ["uint64", "uint256", "bytes"],
+          [fillerNoteData.searchTag, fillerNoteData.ownerHash, fillerNoteData.encryptedNote]
+        );
+        return {
+          proof: proofArray,
+          nullifier: toHex(nullifier, { size: 32 }),
+          stateRoot: stateRootBI,
+          aspRoot: aspProofData.aspRoot,
+          aspId,
+          orderId,
+          takeAmount,
+          fillerOutputCommitment: toHex(fillerNoteData.commitment, { size: 32 }),
+          fillerEncryptedNote: packedFillerNote,
+          spentNote: selectedNote,
+          fillerNoteData
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, unspentNotes, createNoteForSelf]
+  );
+  const buildClaimOrder = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const {
+          orderId,
+          cancelSecret,
+          remainingSellAmount,
+          accumulatedBuyAmount,
+          sellToken,
+          buyToken
+        } = params;
+        let buyNoteData = null;
+        let refundNoteData = null;
+        const originAddr = ethAddress ? BigInt(ethAddress) : BigInt(masterKeys.ownerHash);
+        if (accumulatedBuyAmount > 0n) {
+          buyNoteData = await createNoteForSelf(
+            accumulatedBuyAmount,
+            originAddr,
+            BigInt(buyToken)
+          );
+        }
+        if (remainingSellAmount > 0n) {
+          refundNoteData = await createNoteForSelf(
+            remainingSellAmount,
+            originAddr,
+            BigInt(sellToken)
+          );
+        }
+        const zeroHex = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        return {
+          orderId,
+          cancelSecret,
+          buyOutputCommitment: buyNoteData ? toHex(buyNoteData.commitment, { size: 32 }) : zeroHex,
+          refundCommitment: refundNoteData ? toHex(refundNoteData.commitment, { size: 32 }) : zeroHex,
+          buyEncryptedNote: buyNoteData ? buyNoteData.encryptedNote : "0x",
+          refundEncryptedNote: refundNoteData ? refundNoteData.encryptedNote : "0x",
+          buyNoteData,
+          refundNoteData
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, createNoteForSelf]
+  );
+  const buildCancelOrder = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const { orderId, cancelSecret, sellAmount, sellToken } = params;
+        const cancelOrigin = ethAddress ? BigInt(ethAddress) : BigInt(masterKeys.ownerHash);
+        const refundNoteData = await createNoteForSelf(
+          sellAmount,
+          cancelOrigin,
+          BigInt(sellToken)
+        );
+        return {
+          orderId,
+          cancelSecret,
+          refundCommitment: toHex(refundNoteData.commitment, { size: 32 }),
+          refundEncryptedNote: refundNoteData.encryptedNote,
+          refundNoteData
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, createNoteForSelf]
+  );
+  const buildNoteSplit = useCallback(
+    async (params) => {
+      if (!isSetup || !masterKeys) {
+        throw new Error("Account not set up. Call setupAccount() first.");
+      }
+      setIsPending(true);
+      setError(null);
+      try {
+        const { note, targetAmount, aspId: splitAspId } = params;
+        const cfg = configRef.current;
+        if (targetAmount >= note.amount) {
+          throw new Error("Target amount must be less than note amount");
+        }
+        if (targetAmount <= 0n) {
+          throw new Error("Target amount must be positive");
+        }
+        const changeAmount = note.amount - targetAmount;
+        const origin = BigInt(note.origin);
+        const token = BigInt(note.token);
+        setStage("creating_outputs");
+        const [exactNoteData, changeNoteData] = await Promise.all([
+          createNoteForSelf(targetAmount, origin, token),
+          createNoteForSelf(changeAmount, origin, token)
+        ]);
+        const [transferModule, proofModule, aspModule] = await Promise.all([
+          import('../transfer-KTCXKHS4.js'),
+          import('../proof-C4YBP6RY.js'),
+          import('../asp-ZA3RGN7G.js')
+        ]);
+        const { syncMerkleTree, getMerkleProofsForNotes, buildUPPTransferCircuitInputs } = transferModule;
+        const { generateUPPProof, formatProofForContract } = proofModule;
+        const { generateASPProof: generateASPProof2, DEMO_ASP_ID } = aspModule;
+        setStage("syncing_merkle");
+        const { tree, leaves } = await syncMerkleTree(cfg.publicClient, cfg.poolAddress);
+        const spendableNote = {
+          amount: note.amount,
+          blinding: note.blinding,
+          commitment: note.commitment,
+          ownerSecret: note.ownerSecret,
+          ownerHash: note.ownerHash,
+          leafIndex: note.leafIndex,
+          origin,
+          token
+        };
+        const [noteProof] = await getMerkleProofsForNotes([spendableNote], leaves, tree);
+        const aspProof = await generateASPProof2(splitAspId ?? DEMO_ASP_ID, origin, cfg.aspApprovedOrigins);
+        setStage("generating_proof");
+        const exactNoteWithAmount = { ...exactNoteData, amount: targetAmount };
+        const changeNoteWithAmount = { ...changeNoteData, amount: changeAmount };
+        const circuitInputs = await buildUPPTransferCircuitInputs(
+          noteProof,
+          aspProof,
+          exactNoteWithAmount,
+          changeNoteWithAmount
+        );
+        const { proof } = await generateUPPProof(
+          "transfer",
+          circuitInputs,
+          cfg.circuitBaseUrl ?? "/circuits/"
+        );
+        const formattedProof = formatProofForContract(proof);
+        const proofArray = [
+          formattedProof.a[0],
+          formattedProof.a[1],
+          formattedProof.b[0][0],
+          formattedProof.b[0][1],
+          formattedProof.b[1][0],
+          formattedProof.b[1][1],
+          formattedProof.c[0],
+          formattedProof.c[1]
+        ];
+        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,
+          blinding: exactNoteData.blinding,
+          commitment: toHex(exactNoteData.commitment, { size: 32 }),
+          ownerSecret: toHex(exactNoteData.ownerSecret, { size: 32 }),
+          ownerHash: toHex(exactNoteData.ownerHash, { size: 32 }),
+          leafIndex: 0,
+          origin: note.origin,
+          token: note.token,
+          status: "confirmed",
+          proofSystem,
+          timestamp: Date.now()
+        };
+        const changeShieldedNote = {
+          amount: changeAmount,
+          blinding: changeNoteData.blinding,
+          commitment: toHex(changeNoteData.commitment, { size: 32 }),
+          ownerSecret: toHex(changeNoteData.ownerSecret, { size: 32 }),
+          ownerHash: toHex(changeNoteData.ownerHash, { size: 32 }),
+          leafIndex: 0,
+          origin: note.origin,
+          token: note.token,
+          status: "confirmed",
+          proofSystem,
+          timestamp: Date.now()
+        };
+        return {
+          proof: proofArray,
+          nullifier: toHex(BigInt(circuitInputs.nullifier), { size: 32 }),
+          stateRoot: BigInt(circuitInputs.stateRoot),
+          aspRoot: BigInt(circuitInputs.aspRoot),
+          token: note.token,
+          outputCommitment1: toHex(exactNoteData.commitment, { size: 32 }),
+          outputCommitment2: toHex(changeNoteData.commitment, { size: 32 }),
+          encryptedNote1: packNote(exactNoteData),
+          encryptedNote2: packNote(changeNoteData),
+          exactNote: exactShieldedNote,
+          changeNote: changeShieldedNote,
+          spentNote: note,
+          exactNoteData,
+          changeNoteData
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        setStage(null);
+      }
+    },
+    [isSetup, masterKeys, createNoteForSelf]
+  );
+  return {
+    stage,
+    isPending,
+    error,
+    buildNoteSplit,
+    buildPlaceOrder,
+    buildFillOrder,
+    buildClaimOrder,
+    buildCancelOrder,
+    reset
+  };
+}
+
+export { UPPAccountProvider, UPPAvatar, UPPModal, UPPPrivateButton, generateAvatarData, renderAvatarSVG, storePersonalASPId, usePersonalASP, usePoolTransfer, useShield, useSwap, useSwapOrderBook, useUPPAccount, useUPPCrypto, useWithdraw };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map