@unlink-xyz/core 0.1.3-canary.fd5dddf → 0.1.4

package/dist/transactions/note-selection.js

@@ -1,201 +0,0 @@
-import { ValidationError } from "../errors.js";
-import { CIRCUIT_REGISTRY } from "../prover/registry.js";
-/** Maximum inputs supported by available circuits */
-const MAX_CIRCUIT_INPUTS = Math.max(...Object.values(CIRCUIT_REGISTRY).map((c) => c.inputs));
-/** Maximum outputs supported by available circuits */
-const MAX_CIRCUIT_OUTPUTS = Math.max(...Object.values(CIRCUIT_REGISTRY).map((c) => c.outputs));
-/**
- * Get the value of a note as bigint.
- * Handles both bigint and string values for NoteRecord compatibility.
- */
-function getNoteValue(note) {
-    return typeof note.value === "bigint" ? note.value : BigInt(note.value);
-}
-/**
- * Select notes for a transaction with consolidation-first strategy.
- *
- * Priorities:
- * 1. Consolidation - prefer spending more small notes
- * 2. Minimize change - find combinations with less overshoot
- * 3. Respect maxInputs constraint
- *
- * @param notes - Available unspent notes (caller filters by token)
- * @param totalNeeded - Total amount needed for all recipients
- * @param options - Selection options
- * @returns Selection result with notes and amounts
- * @throws ValidationError if insufficient balance or constraints can't be met
- */
-export function selectNotesForAmount(notes, totalNeeded, options) {
-    const maxInputs = options?.maxInputs ?? MAX_CIRCUIT_INPUTS;
-    const maxOutputs = options?.maxOutputs ?? MAX_CIRCUIT_OUTPUTS;
-    const recipientCount = options?.recipientCount ?? 1;
-    // Validate inputs
-    if (totalNeeded <= 0n) {
-        throw new ValidationError("Amount must be positive");
-    }
-    if (!notes.length) {
-        throw new ValidationError("No notes available");
-    }
-    // Validate output constraints: recipients + potential change <= maxOutputs
-    // Change is needed when selected sum > totalNeeded (almost always)
-    // So we conservatively assume change will be needed
-    if (recipientCount + 1 > maxOutputs) {
-        throw new ValidationError(`Too many recipients: ${recipientCount} recipients + change exceeds maxOutputs (${maxOutputs})`);
-    }
-    // Check total balance
-    const totalAvailable = notes.reduce((sum, n) => sum + getNoteValue(n), 0n);
-    if (totalAvailable < totalNeeded) {
-        throw new ValidationError("Insufficient balance");
-    }
-    // Sort ascending for consolidation preference (smallest first)
-    const sortedAsc = [...notes].sort((a, b) => {
-        const aVal = getNoteValue(a);
-        const bVal = getNoteValue(b);
-        return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-    });
-    // Phase 1: Try greedy smallest-first
-    let baseline = greedySelect(sortedAsc, totalNeeded, maxInputs);
-    // Phase 2: If greedy smallest-first didn't work, try largest-first as fallback
-    if (baseline.sum < totalNeeded) {
-        const sortedDesc = [...sortedAsc].reverse();
-        baseline = greedySelect(sortedDesc, totalNeeded, maxInputs);
-    }
-    // Phase 3: If we have a valid baseline, use branch-and-bound to optimize
-    // Only run B&B on a subset of notes to keep it fast
-    let optimized;
-    if (baseline.sum >= totalNeeded) {
-        // Limit B&B to reasonable subset for performance (30 smallest notes)
-        const maxNotesForBnB = Math.min(sortedAsc.length, 30);
-        const notesForBnB = sortedAsc.slice(0, maxNotesForBnB);
-        optimized = findOptimalSelection(notesForBnB, totalNeeded, maxInputs, baseline);
-    }
-    else {
-        optimized = baseline;
-    }
-    // If no valid solution found
-    if (optimized.sum < totalNeeded) {
-        throw new ValidationError("Cannot meet amount within maxInputs constraint");
-    }
-    return {
-        selected: optimized.notes,
-        totalInput: optimized.sum,
-        totalNeeded,
-        change: optimized.sum - totalNeeded,
-    };
-}
-/**
- * Greedy selection: accumulate notes until threshold met.
- * Returns a partial solution if it can't meet the target.
- */
-function greedySelect(sorted, target, maxInputs) {
-    const selected = [];
-    let sum = 0n;
-    for (const note of sorted) {
-        if (sum >= target)
-            break;
-        if (selected.length >= maxInputs)
-            break;
-        selected.push(note);
-        sum += getNoteValue(note);
-    }
-    return { notes: selected, sum };
-}
-/**
- * Compare two solutions.
- * Returns true if (candidate) is better than (best).
- *
- * Priority 0: Prefer valid solutions (sum >= target)
- * Priority 1: Prefer more notes (consolidation)
- * Priority 2: Prefer less change
- */
-function isBetterSolution(candidate, best, target) {
-    const candidateValid = candidate.sum >= target;
-    const bestValid = best.sum >= target;
-    // Priority 0: Prefer valid solutions
-    if (candidateValid && !bestValid)
-        return true;
-    if (!candidateValid && bestValid)
-        return false;
-    if (!candidateValid && !bestValid) {
-        // Neither valid - prefer higher sum (closer to target)
-        return candidate.sum > best.sum;
-    }
-    // Both valid - apply consolidation + change minimization
-    const candidateChange = candidate.sum - target;
-    const bestChange = best.sum - target;
-    // Priority 1: Prefer more notes (consolidation)
-    if (candidate.notes.length > best.notes.length)
-        return true;
-    if (candidate.notes.length < best.notes.length)
-        return false;
-    // Priority 2: Prefer less change
-    return candidateChange < bestChange;
-}
-/**
- * Branch-and-bound search for optimal selection.
- *
- * Explores the solution space with aggressive pruning:
- * - Stop when sum >= target (don't over-select beyond what's needed)
- * - Stop when remaining notes can't reach target
- * - Stop when maxInputs exceeded
- * - Early termination when we find a solution with maxInputs notes and exact match
- */
-function findOptimalSelection(sorted, target, maxInputs, baseline) {
-    let best = baseline;
-    let foundOptimal = false;
-    // Precompute remaining sums for pruning
-    const remainingSums = new Array(sorted.length + 1).fill(0n);
-    for (let i = sorted.length - 1; i >= 0; i--) {
-        const nextSum = remainingSums[i + 1] ?? 0n;
-        const note = sorted[i];
-        const noteValue = note ? getNoteValue(note) : 0n;
-        remainingSums[i] = nextSum + noteValue;
-    }
-    function search(index, selected, sum) {
-        // Early exit if we found optimal solution
-        if (foundOptimal)
-            return;
-        // Pruning: too many notes selected
-        if (selected.length > maxInputs)
-            return;
-        // Found valid solution, now comparing with best
-        if (sum >= target) {
-            const candidate = { notes: selected, sum };
-            if (isBetterSolution(candidate, best, target)) {
-                best = { notes: [...selected], sum };
-                // Check if this is optimal (maxInputs notes with exact match)
-                if (selected.length === maxInputs && sum === target) {
-                    foundOptimal = true;
-                }
-            }
-            // Don't add more notes once target is met
-            return;
-        }
-        // Pruning: can't reach target with remaining notes
-        const remaining = remainingSums[index] ?? 0n;
-        if (sum + remaining < target)
-            return;
-        // Pruning: reached end of notes
-        if (index >= sorted.length)
-            return;
-        // Pruning: can't possibly beat best's note count
-        const remainingSlots = maxInputs - selected.length;
-        const remainingNotes = sorted.length - index;
-        if (selected.length + Math.min(remainingSlots, remainingNotes) <
-            best.notes.length) {
-            // Even selecting all remaining notes won't beat best's count
-            // Only skip if best is already valid
-            if (best.sum >= target)
-                return;
-        }
-        const currentNote = sorted[index];
-        if (!currentNote)
-            return;
-        // Try including current note (explore this branch first for consolidation)
-        search(index + 1, [...selected, currentNote], sum + getNoteValue(currentNote));
-        // Try excluding current note
-        search(index + 1, selected, sum);
-    }
-    search(0, [], 0n);
-    return best;
-}

package/dist/transactions/note-sync.js

@@ -1,485 +0,0 @@
-import { createIndexerClient } from "../clients/indexer.js";
-import { createServiceConfig } from "../config.js";
-import { poseidon } from "../crypto-adapters/index.js";
-import { CoreError, InitializationError } from "../errors.js";
-import { FieldSize, Hex } from "../keys/hex.js";
-import { createMerkleTrees, rebuildTreeFromStore, } from "../state/index.js";
-import { formatUint256, parseHexToBigInt } from "../utils/bigint.js";
-import { decryptNote } from "../utils/crypto.js";
-import { ensureChainId } from "../utils/validators.js";
-const DEFAULT_BATCH_SIZE = 256;
-function buildCiphertext(bytes) {
-    return {
-        data: [
-            parseHexToBigInt(bytes[0]),
-            parseHexToBigInt(bytes[1]),
-            parseHexToBigInt(bytes[2]),
-        ],
-    };
-}
-function encodeCiphertext(ciphertext) {
-    const payload = new Uint8Array(FieldSize.SCALAR * ciphertext.data.length);
-    ciphertext.data.forEach((value, index) => {
-        const start = index * FieldSize.SCALAR;
-        payload.set(Hex.toBytes(formatUint256(value)), start);
-    });
-    return payload;
-}
-export function createNoteSyncService(stateStore, options = {}) {
-    const trees = options.merkleTrees ?? createMerkleTrees();
-    const limit = options.limit ?? DEFAULT_BATCH_SIZE;
-    const status = new Map();
-    // Initialize indexer client
-    let indexerClient = options.indexerClient;
-    if (!indexerClient) {
-        const fetchImpl = options.fetch ?? (typeof fetch === "function" ? fetch : undefined);
-        if (!fetchImpl) {
-            throw new InitializationError("fetch dependency is required to sync indexer commitments");
-        }
-        if (!options.rpcUrl) {
-            throw new InitializationError("rpcUrl is required to sync indexer commitments");
-        }
-        const serviceConfig = createServiceConfig(options.rpcUrl);
-        indexerClient = createIndexerClient(serviceConfig.indexerBaseUrl, {
-            fetch: fetchImpl,
-        });
-    }
-    function createNoteRecord(params) {
-        const { chainId, index, commitment, token, amount, npk, mpk, random, nullifier, createdTxHash, createdEventType, createdAt, spentAt, spentTxHash, } = params;
-        const base = {
-            chainId,
-            index,
-            token,
-            value: amount.toString(),
-            commitment,
-            npk: formatUint256(npk),
-            mpk: formatUint256(mpk),
-            random: formatUint256(random),
-            nullifier,
-            createdTxHash,
-            createdEventType,
-            createdAt,
-            spentTxHash,
-        };
-        return spentAt === undefined ? base : { ...base, spentAt };
-    }
-    // Try to decrypt a note. Returns the note record if successful, null otherwise.
-    function tryDecryptNoteRecord(chainId, record, account) {
-        const ciphertext = buildCiphertext(record.ciphertext);
-        let note;
-        try {
-            note = decryptNote(ciphertext, account.masterPublicKey);
-        }
-        catch (err) {
-            if (err instanceof CoreError) {
-                return null;
-            }
-            throw err;
-        }
-        const random = note.random;
-        const amount = note.amount;
-        const token = note.token;
-        const npk = poseidon([account.masterPublicKey, random]);
-        const commitment = poseidon([npk, BigInt(token), amount]);
-        if (commitment !== parseHexToBigInt(record.commitment)) {
-            return null;
-        }
-        const nullifier = poseidon([account.nullifyingKey, BigInt(record.index)]);
-        const nullifierHex = formatUint256(nullifier);
-        return createNoteRecord({
-            chainId,
-            index: record.index,
-            commitment: record.commitment,
-            token,
-            amount,
-            npk,
-            mpk: account.masterPublicKey,
-            random,
-            nullifier: nullifierHex,
-            createdTxHash: record.txHash,
-            createdEventType: record.eventType,
-            createdAt: record.insertedAt != null ? record.insertedAt * 1000 : undefined,
-        });
-    }
-    // Pulls commitments from the indexer, updating local tree and notes atomically.
-    // Uses batch nullifier check to avoid individual 404-generating queries.
-    async function ingestFrom(chainId, start, account) {
-        let cursor = start;
-        for (;;) {
-            const batch = await indexerClient.fetchCommitmentBatch({
-                chainId,
-                start: cursor,
-                limit,
-            });
-            if (batch.commitments.length === 0) {
-                break;
-            }
-            // Phase 1: Ingest commitments into tree + store
-            const decryptedNotes = [];
-            for (const record of batch.commitments) {
-                const expectedIndex = trees.getLeafCount(chainId);
-                if (record.index !== expectedIndex) {
-                    throw new CoreError(`indexed commitments out of order: expected index ${expectedIndex}, got ${record.index} (cursor=${cursor})`);
-                }
-                const value = Hex.toBigInt(record.commitment);
-                const { index } = trees.addLeaf(chainId, value);
-                if (index !== record.index) {
-                    throw new CoreError("local merkle tree desynchronized");
-                }
-                const noteRecord = tryDecryptNoteRecord(chainId, record, account);
-                const ciphertext = buildCiphertext(record.ciphertext);
-                const ciphertextBytes = encodeCiphertext(ciphertext);
-                await stateStore.syncCommitment({
-                    leaf: {
-                        chainId,
-                        index: record.index,
-                        commitment: record.commitment,
-                        txHash: record.txHash,
-                        eventType: record.eventType,
-                        insertedAt: record.insertedAt,
-                    },
-                    ciphertext: {
-                        chainId,
-                        index: record.index,
-                        payload: ciphertextBytes,
-                    },
-                    root: { chainId, root: record.root },
-                    note: noteRecord ?? undefined,
-                });
-                if (noteRecord) {
-                    decryptedNotes.push(noteRecord);
-                }
-                cursor = record.index + 1;
-            }
-            // Phase 2: Batch nullifier check for decrypted notes
-            if (decryptedNotes.length > 0) {
-                const notesToCheck = [];
-                for (const note of decryptedNotes) {
-                    const existing = await stateStore.getNote(chainId, note.index);
-                    if (existing?.spentAt !== undefined) {
-                        await stateStore.putNullifier({
-                            chainId,
-                            nullifier: note.nullifier,
-                            noteIndex: note.index,
-                        });
-                    }
-                    else {
-                        notesToCheck.push(note);
-                    }
-                }
-                if (notesToCheck.length > 0) {
-                    const spentNullifiers = await indexerClient.checkNullifiers({
-                        chainId,
-                        nullifiers: notesToCheck.map((n) => n.nullifier),
-                    });
-                    const spentMap = new Map(spentNullifiers.map((n) => [n.nullifier, n]));
-                    for (const note of notesToCheck) {
-                        const spent = spentMap.get(note.nullifier);
-                        if (spent) {
-                            const spentAtMs = spent.spentAt * 1000;
-                            await stateStore.putNullifier({
-                                chainId,
-                                nullifier: note.nullifier,
-                                noteIndex: note.index,
-                            });
-                            await stateStore.markNoteSpent(chainId, note.index, spentAtMs, spent.txHash);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    async function diagnoseChainState(chainId, localCount) {
-        // Tier 1: compare first commitment
-        const firstBatch = await indexerClient.fetchCommitmentBatch({
-            chainId,
-            start: 0,
-            limit: 1,
-        });
-        const localFirst = await stateStore.getLeaf(chainId, 0);
-        if (firstBatch.commitments.length === 0 || !localFirst) {
-            return { kind: "full-divergence" };
-        }
-        if (firstBatch.commitments[0].commitment !== localFirst.commitment) {
-            return { kind: "full-divergence" };
-        }
-        // Single-leaf shortcut: first matches and there's only one local leaf.
-        if (localCount === 1) {
-            return { kind: "consistent" };
-        }
-        // Compare last local commitment
-        const lastBatch = await indexerClient.fetchCommitmentBatch({
-            chainId,
-            start: localCount - 1,
-            limit: 1,
-        });
-        const localLast = await stateStore.getLeaf(chainId, localCount - 1);
-        if (lastBatch.commitments.length > 0 &&
-            localLast &&
-            lastBatch.commitments[0].commitment === localLast.commitment) {
-            return { kind: "consistent" };
-        }
-        // Tier 2: binary search for divergence point
-        const divergePoint = await findDivergencePoint(chainId, 1, localCount - 1);
-        return { kind: "partial-divergence", validPrefix: divergePoint };
-    }
-    async function findDivergencePoint(chainId, low, high) {
-        while (low < high) {
-            const mid = Math.floor((low + high) / 2);
-            const batch = await indexerClient.fetchCommitmentBatch({
-                chainId,
-                start: mid,
-                limit: 1,
-            });
-            const localLeaf = await stateStore.getLeaf(chainId, mid);
-            if (batch.commitments.length > 0 &&
-                localLeaf &&
-                batch.commitments[0].commitment === localLeaf.commitment) {
-                low = mid + 1;
-            }
-            else {
-                high = mid;
-            }
-        }
-        return low;
-    }
-    // Clears stale tail data and re-ingests from the divergence point.
-    async function partialResync(chainId, fromIndex, account) {
-        await Promise.all([
-            stateStore.clearChainDataFromIndex(chainId, fromIndex),
-            stateStore.clearNullifiersFromIndex(chainId, fromIndex),
-        ]);
-        trees.reset(chainId);
-        await rebuildTreeFromStore({
-            chainId,
-            trees,
-            loadLeaf: stateStore.getLeaf.bind(stateStore),
-        });
-        await ingestFrom(chainId, fromIndex, account);
-    }
-    // Clears local state for a chain and rehydrates fully from the indexer.
-    async function fullResync(chainId, account) {
-        trees.reset(chainId);
-        await Promise.all([
-            stateStore.clearLeaves(chainId),
-            stateStore.clearNotes(chainId),
-            stateStore.clearCiphertexts(chainId),
-            stateStore.clearNullifiers(chainId),
-        ]);
-        await ingestFrom(chainId, 0, account);
-    }
-    // Decode a stored ciphertext (3 x 32-byte values) into a Ciphertext object
-    function decodeCiphertext(payload) {
-        const data = [];
-        for (let i = 0; i < 3; i++) {
-            const start = i * FieldSize.SCALAR;
-            const end = start + FieldSize.SCALAR;
-            const slice = payload.slice(start, end);
-            data.push(Hex.toBigInt(Hex.fromBytes(slice)));
-        }
-        return { data: data };
-    }
-    // Re-scan stored ciphertexts for a new account, using batch nullifier check.
-    async function rescanCiphertextsForAccount(chainId, account, leafCount) {
-        const accountMpk = formatUint256(account.masterPublicKey);
-        const pendingNotes = [];
-        for (let index = 0; index < leafCount; index++) {
-            const existingNote = await stateStore.getNote(chainId, index);
-            if (existingNote && existingNote.mpk === accountMpk) {
-                continue;
-            }
-            const ciphertextBytes = await stateStore.getCiphertext(chainId, index);
-            if (!ciphertextBytes)
-                continue;
-            const leaf = await stateStore.getLeaf(chainId, index);
-            if (!leaf)
-                continue;
-            const ciphertext = decodeCiphertext(ciphertextBytes);
-            let note;
-            try {
-                note = decryptNote(ciphertext, account.masterPublicKey);
-            }
-            catch (err) {
-                if (err instanceof CoreError)
-                    continue;
-                throw err;
-            }
-            const npk = poseidon([account.masterPublicKey, note.random]);
-            const commitment = poseidon([npk, BigInt(note.token), note.amount]);
-            if (commitment !== parseHexToBigInt(leaf.commitment))
-                continue;
-            const nullifier = poseidon([account.nullifyingKey, BigInt(index)]);
-            const nullifierHex = formatUint256(nullifier);
-            const baseNoteParams = {
-                chainId,
-                index,
-                commitment: leaf.commitment,
-                token: note.token,
-                amount: note.amount,
-                npk,
-                mpk: account.masterPublicKey,
-                random: note.random,
-                nullifier: nullifierHex,
-                createdTxHash: leaf.txHash,
-                createdEventType: leaf.eventType,
-                createdAt: leaf.insertedAt != null ? leaf.insertedAt * 1000 : undefined,
-            };
-            pendingNotes.push({
-                note: createNoteRecord(baseNoteParams),
-                baseParams: baseNoteParams,
-            });
-        }
-        if (pendingNotes.length > 0) {
-            const spentNullifiers = await indexerClient.checkNullifiers({
-                chainId,
-                nullifiers: pendingNotes.map((p) => p.note.nullifier),
-            });
-            const spentMap = new Map(spentNullifiers.map((n) => [n.nullifier, n]));
-            for (const { note, baseParams } of pendingNotes) {
-                const spent = spentMap.get(note.nullifier);
-                if (spent) {
-                    await stateStore.putNullifier({
-                        chainId,
-                        nullifier: note.nullifier,
-                        noteIndex: note.index,
-                    });
-                    await stateStore.putNote(createNoteRecord({
-                        ...baseParams,
-                        spentAt: spent.spentAt * 1000,
-                        spentTxHash: spent.txHash,
-                    }));
-                }
-                else {
-                    await stateStore.putNote(note);
-                }
-            }
-        }
-    }
-    // Check existing unspent notes for nullification using batch check.
-    async function checkExistingNotesForNullification(chainId, account) {
-        const accountMpk = formatUint256(account.masterPublicKey);
-        const unspentNotes = await stateStore.listNotes({
-            chainId,
-            mpk: accountMpk,
-            includeSpent: false,
-        });
-        if (unspentNotes.length === 0)
-            return;
-        const spentNullifiers = await indexerClient.checkNullifiers({
-            chainId,
-            nullifiers: unspentNotes.map((n) => n.nullifier),
-        });
-        const spentMap = new Map(spentNullifiers.map((n) => [n.nullifier, n]));
-        for (const note of unspentNotes) {
-            const spent = spentMap.get(note.nullifier);
-            if (spent) {
-                await stateStore.putNullifier({
-                    chainId,
-                    nullifier: note.nullifier,
-                    noteIndex: note.index,
-                });
-                await stateStore.markNoteSpent(chainId, note.index, spent.spentAt * 1000, spent.txHash);
-            }
-        }
-    }
-    /**
-     * Syncs a single chain into local state, optionally forcing a full rebuild.
-     */
-    async function syncChain(chainId, account, opts = {}) {
-        ensureChainId(chainId);
-        const current = status.get(chainId) ?? {
-            inFlight: false,
-            lastSuccess: null,
-        };
-        if (current.inFlight)
-            return;
-        status.set(chainId, { ...current, inFlight: true, lastError: undefined });
-        try {
-            const start = opts.forceFullResync
-                ? 0
-                : await rebuildTreeFromStore({
-                    chainId,
-                    trees,
-                    loadLeaf: stateStore.getLeaf.bind(stateStore),
-                });
-            if (opts.forceFullResync) {
-                await fullResync(chainId, account);
-            }
-            else if (start > 0) {
-                try {
-                    const diagnosis = await diagnoseChainState(chainId, start);
-                    switch (diagnosis.kind) {
-                        case "consistent":
-                            try {
-                                await ingestFrom(chainId, start, account);
-                            }
-                            catch (err) {
-                                console.warn(`[note-sync] incremental ingest failed for chain ${chainId}, falling back to full resync:`, err);
-                                await fullResync(chainId, account);
-                            }
-                            break;
-                        case "partial-divergence":
-                            await partialResync(chainId, diagnosis.validPrefix, account);
-                            break;
-                        case "full-divergence":
-                            await fullResync(chainId, account);
-                            break;
-                    }
-                }
-                catch (err) {
-                    console.warn(`[note-sync] chain diagnosis failed for chain ${chainId}, falling back to full resync:`, err);
-                    await fullResync(chainId, account);
-                }
-            }
-            else {
-                // start === 0, fresh first sync
-                try {
-                    await ingestFrom(chainId, 0, account);
-                }
-                catch (err) {
-                    console.warn(`[note-sync] initial ingest failed for chain ${chainId}, falling back to full resync:`, err);
-                    await fullResync(chainId, account);
-                }
-            }
-            // Rescan ciphertexts for multi-account support
-            const accountMpk = formatUint256(account.masterPublicKey);
-            const leafCount = trees.getLeafCount(chainId);
-            if (leafCount > 0 && !opts.forceFullResync) {
-                const accountNotes = await stateStore.listNotes({
-                    chainId,
-                    mpk: accountMpk,
-                });
-                if (accountNotes.length < leafCount) {
-                    await rescanCiphertextsForAccount(chainId, account, leafCount);
-                }
-            }
-            // Check if any existing unspent notes have been nullified
-            await checkExistingNotesForNullification(chainId, account);
-            status.set(chainId, { inFlight: false, lastSuccess: Date.now() });
-        }
-        catch (err) {
-            status.set(chainId, {
-                inFlight: false,
-                lastSuccess: current.lastSuccess ?? null,
-                lastError: err instanceof Error ? err.message : String(err),
-            });
-            throw err;
-        }
-    }
-    /**
-     * Syncs multiple chains sequentially.
-     */
-    async function syncChains(chainIds, account, opts) {
-        for (const chainId of chainIds) {
-            await syncChain(chainId, account, opts);
-        }
-    }
-    function getStatus() {
-        return status;
-    }
-    return {
-        syncChain,
-        syncChains,
-        getStatus,
-    };
-}