@shielded-x402/client 0.2.4 → 0.4.0

package/dist/walletState.js

@@ -1,16 +1,16 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { normalizeHex } from '@shielded-x402/shared-types';
 import { createPublicClient, http, parseAbiItem } from 'viem';
 import { deriveWitness } from './merkle.js';
+import { postJson } from './http.js';
 const ZERO_BYTES32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
 const depositedEvent = parseAbiItem('event Deposited(bytes32 indexed commitment, uint256 indexed leafIndex, bytes32 indexed root, uint256 amount)');
 const spentEvent = parseAbiItem('event Spent(bytes32 indexed nullifier, bytes32 indexed merchantCommitment, bytes32 indexed changeCommitment, uint256 amount, bytes32 challengeHash, uint256 merchantLeafIndex, uint256 changeLeafIndex, bytes32 newRoot)');
-function normalizeHex(value) {
-    return value.toLowerCase();
-}
+const INDEXER_PAGE_SIZE = 500;
 function serialize(state, poolAddress) {
     return {
-        version: 1,
+        version: 3,
         poolAddress,
         lastSyncedBlock: state.lastSyncedBlock.toString(),
         commitments: state.commitments,
@@ -18,14 +18,50 @@ function serialize(state, poolAddress) {
             amount: note.amount.toString(),
             rho: note.rho,
             pkHash: note.pkHash,
+            nullifierSecret: note.nullifierSecret,
             commitment: note.commitment,
             leafIndex: note.leafIndex,
             ...(note.depositBlock !== undefined ? { depositBlock: note.depositBlock.toString() } : {}),
             ...(note.spent !== undefined ? { spent: note.spent } : {})
-        }))
+        })),
+        creditStates: Object.fromEntries(Object.entries(state.creditStates).map(([channelId, signed]) => [
+            channelId,
+            {
+                state: {
+                    channelId: signed.state.channelId,
+                    seq: signed.state.seq,
+                    available: signed.state.available,
+                    cumulativeSpent: signed.state.cumulativeSpent,
+                    lastDebitDigest: signed.state.lastDebitDigest,
+                    updatedAt: signed.state.updatedAt,
+                    agentAddress: signed.state.agentAddress,
+                    relayerAddress: signed.state.relayerAddress
+                },
+                agentSignature: signed.agentSignature,
+                relayerSignature: signed.relayerSignature
+            }
+        ]))
     };
 }
 function deserialize(payload) {
+    const persistedCreditStates = payload.creditStates ?? {};
+    const creditStates = {};
+    for (const [channelId, signed] of Object.entries(persistedCreditStates)) {
+        creditStates[channelId] = {
+            state: {
+                channelId: signed.state.channelId,
+                seq: signed.state.seq,
+                available: signed.state.available,
+                cumulativeSpent: signed.state.cumulativeSpent,
+                lastDebitDigest: signed.state.lastDebitDigest,
+                updatedAt: signed.state.updatedAt,
+                agentAddress: signed.state.agentAddress,
+                relayerAddress: signed.state.relayerAddress
+            },
+            agentSignature: signed.agentSignature,
+            relayerSignature: signed.relayerSignature
+        };
+    }
     return {
         lastSyncedBlock: BigInt(payload.lastSyncedBlock),
         commitments: payload.commitments,
@@ -33,11 +69,13 @@ function deserialize(payload) {
             amount: BigInt(note.amount),
             rho: note.rho,
             pkHash: note.pkHash,
+            nullifierSecret: note.nullifierSecret,
             commitment: note.commitment,
             leafIndex: note.leafIndex,
             ...(note.depositBlock !== undefined ? { depositBlock: BigInt(note.depositBlock) } : {}),
             ...(note.spent !== undefined ? { spent: note.spent } : {})
-        }))
+        })),
+        creditStates
     };
 }
 export class FileBackedWalletState {
@@ -50,6 +88,8 @@ export class FileBackedWalletState {
     startBlock;
     indexerFieldNames;
     state;
+    noteIndexesByCommitment;
+    leafIndexByCommitment;
     constructor(config) {
         this.filePath = config.filePath;
         this.rpcUrl = config.rpcUrl;
@@ -61,8 +101,12 @@ export class FileBackedWalletState {
         this.state = {
             lastSyncedBlock: this.startBlock - 1n,
             commitments: [],
-            notes: []
+            notes: [],
+            creditStates: {}
         };
+        this.noteIndexesByCommitment = new Map();
+        this.leafIndexByCommitment = new Map();
+        this.rebuildCommitmentIndexes();
     }
     static async create(config) {
         const instance = new FileBackedWalletState(config);
@@ -73,13 +117,14 @@ export class FileBackedWalletState {
         try {
             const raw = await readFile(this.filePath, 'utf8');
             const parsed = JSON.parse(raw);
-            if (parsed.version !== 1) {
+            if (parsed.version !== 3) {
                 throw new Error(`unsupported wallet state version: ${String(parsed.version)}`);
             }
             if (normalizeHex(parsed.poolAddress) !== normalizeHex(this.shieldedPoolAddress)) {
                 throw new Error(`wallet state pool mismatch: expected ${this.shieldedPoolAddress}, found ${parsed.poolAddress}`);
             }
             this.state = deserialize(parsed);
+            this.rebuildCommitmentIndexes();
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -106,12 +151,34 @@ export class FileBackedWalletState {
     getNotes() {
         return this.state.notes.map((note) => ({ ...note }));
     }
-    async addOrUpdateNote(note, depositBlock) {
-        const normalizedCommitment = normalizeHex(note.commitment);
-        const existingIndex = this.state.notes.findIndex((candidate) => normalizeHex(candidate.commitment) === normalizedCommitment);
+    getCreditState(channelId) {
+        const state = this.state.creditStates[channelId.toLowerCase()];
+        if (!state)
+            return undefined;
+        return {
+            state: { ...state.state },
+            agentSignature: state.agentSignature,
+            relayerSignature: state.relayerSignature
+        };
+    }
+    async setCreditState(signedState) {
+        this.state.creditStates[signedState.state.channelId.toLowerCase()] = {
+            state: { ...signedState.state },
+            agentSignature: signedState.agentSignature,
+            relayerSignature: signedState.relayerSignature
+        };
+        await this.persist();
+    }
+    async clearCreditState(channelId) {
+        delete this.state.creditStates[channelId.toLowerCase()];
+        await this.persist();
+    }
+    async addOrUpdateNote(note, nullifierSecret, depositBlock) {
+        const existingIndex = this.findNoteIndexByCommitment(note.commitment);
         const existing = existingIndex >= 0 ? this.state.notes[existingIndex] : undefined;
         const record = {
             ...note,
+            nullifierSecret,
             ...(depositBlock !== undefined ? { depositBlock } : {}),
             ...(existing?.spent !== undefined ? { spent: existing.spent } : {})
         };
@@ -124,11 +191,11 @@ export class FileBackedWalletState {
         if (record.leafIndex >= 0) {
             this.state.commitments[record.leafIndex] = record.commitment;
         }
+        this.rebuildCommitmentIndexes();
         await this.persist();
     }
     async markNoteSpent(commitment) {
-        const normalized = normalizeHex(commitment);
-        const existingIndex = this.state.notes.findIndex((candidate) => normalizeHex(candidate.commitment) === normalized);
+        const existingIndex = this.findNoteIndexByCommitment(commitment);
         if (existingIndex < 0) {
             return false;
         }
@@ -148,6 +215,7 @@ export class FileBackedWalletState {
             this.state.commitments[params.merchantLeafIndex] = params.merchantCommitment;
             this.state.commitments[params.changeLeafIndex] = params.changeCommitment;
         }
+        this.rebuildCommitmentIndexes();
         await this.persist();
     }
     async applyRelayerSettlement(params) {
@@ -165,11 +233,139 @@ export class FileBackedWalletState {
         });
         if (params.changeNote) {
             const changeLeafIndex = delta.changeLeafIndex ?? -1;
+            if (!params.changeNullifierSecret) {
+                throw new Error('applyRelayerSettlement requires changeNullifierSecret when changeNote is provided');
+            }
             await this.addOrUpdateNote({
                 ...params.changeNote,
                 leafIndex: changeLeafIndex
-            }, this.state.lastSyncedBlock >= 0n ? this.state.lastSyncedBlock : undefined);
+            }, params.changeNullifierSecret, this.state.lastSyncedBlock >= 0n ? this.state.lastSyncedBlock : undefined);
+        }
+    }
+    applyCommitmentWrites(writes) {
+        writes.sort((a, b) => {
+            if (a.blockNumber !== b.blockNumber)
+                return a.blockNumber < b.blockNumber ? -1 : 1;
+            if (a.logIndex !== b.logIndex)
+                return a.logIndex < b.logIndex ? -1 : 1;
+            return a.order - b.order;
+        });
+        for (const write of writes) {
+            if (write.leafIndex < 0)
+                continue;
+            this.state.commitments[write.leafIndex] = write.commitment;
+            const normalizedCommitment = normalizeHex(write.commitment);
+            this.leafIndexByCommitment.set(normalizedCommitment, write.leafIndex);
+            const noteIndexes = this.noteIndexesByCommitment.get(normalizedCommitment);
+            if (!noteIndexes)
+                continue;
+            for (const noteIndex of noteIndexes) {
+                const note = this.state.notes[noteIndex];
+                if (!note)
+                    continue;
+                note.leafIndex = write.leafIndex;
+                if (note.depositBlock === undefined) {
+                    note.depositBlock = write.blockNumber;
+                }
+            }
+        }
+    }
+    rebuildCommitmentIndexes() {
+        this.noteIndexesByCommitment.clear();
+        for (let i = 0; i < this.state.notes.length; i += 1) {
+            const note = this.state.notes[i];
+            if (!note)
+                continue;
+            const normalizedCommitment = normalizeHex(note.commitment);
+            const indexes = this.noteIndexesByCommitment.get(normalizedCommitment) ?? [];
+            indexes.push(i);
+            this.noteIndexesByCommitment.set(normalizedCommitment, indexes);
+        }
+        this.leafIndexByCommitment.clear();
+        for (let i = 0; i < this.state.commitments.length; i += 1) {
+            const commitment = this.state.commitments[i];
+            if (!commitment)
+                continue;
+            this.leafIndexByCommitment.set(normalizeHex(commitment), i);
+        }
+    }
+    mapRpcEventsToWrites(params) {
+        const writes = [];
+        let depositsApplied = 0;
+        let spendsApplied = 0;
+        for (const log of params.depositLogs) {
+            const args = log.args;
+            if (args.commitment === undefined || args.leafIndex === undefined)
+                continue;
+            writes.push({
+                blockNumber: log.blockNumber ?? 0n,
+                logIndex: log.logIndex ?? 0,
+                order: 0,
+                leafIndex: Number(args.leafIndex),
+                commitment: args.commitment
+            });
+            depositsApplied += 1;
         }
+        for (const log of params.spendLogs) {
+            const args = log.args;
+            if (args.merchantCommitment === undefined ||
+                args.changeCommitment === undefined ||
+                args.merchantLeafIndex === undefined ||
+                args.changeLeafIndex === undefined) {
+                continue;
+            }
+            writes.push({
+                blockNumber: log.blockNumber ?? 0n,
+                logIndex: log.logIndex ?? 0,
+                order: 0,
+                leafIndex: Number(args.merchantLeafIndex),
+                commitment: args.merchantCommitment
+            });
+            writes.push({
+                blockNumber: log.blockNumber ?? 0n,
+                logIndex: log.logIndex ?? 0,
+                order: 1,
+                leafIndex: Number(args.changeLeafIndex),
+                commitment: args.changeCommitment
+            });
+            spendsApplied += 1;
+        }
+        return { writes, depositsApplied, spendsApplied };
+    }
+    mapIndexerEventsToWrites(deposits, spends) {
+        const writes = [];
+        let depositsApplied = 0;
+        let spendsApplied = 0;
+        for (const deposit of deposits) {
+            const { blockNumber, logIndex } = parseEventPositionFromId(deposit.id);
+            writes.push({
+                blockNumber,
+                logIndex,
+                order: 0,
+                leafIndex: Number(deposit.leafIndex),
+                commitment: deposit.commitment
+            });
+            depositsApplied += 1;
+        }
+        for (const spend of spends) {
+            const { blockNumber, logIndex } = parseEventPositionFromId(spend.id);
+            writes.push({
+                blockNumber,
+                logIndex,
+                order: 0,
+                leafIndex: Number(spend.merchantLeafIndex),
+                commitment: spend.merchantCommitment
+            });
+            writes.push({
+                blockNumber,
+                logIndex,
+                order: 1,
+                leafIndex: Number(spend.changeLeafIndex),
+                commitment: spend.changeCommitment
+            });
+            spendsApplied += 1;
+        }
+        return { writes, depositsApplied, spendsApplied };
     }
     async sync() {
         if (this.indexerGraphqlUrl) {
@@ -212,68 +408,13 @@ export class FileBackedWalletState {
                     toBlock
                 })
             ]);
-            const writes = [];
-            for (const log of depositLogs) {
-                const args = log.args;
-                if (args.commitment === undefined || args.leafIndex === undefined)
-                    continue;
-                writes.push({
-                    blockNumber: log.blockNumber ?? 0n,
-                    logIndex: log.logIndex ?? 0,
-                    order: 0,
-                    leafIndex: Number(args.leafIndex),
-                    commitment: args.commitment
-                });
-                depositsApplied += 1;
-            }
-            for (const log of spendLogs) {
-                const args = log.args;
-                if (args.merchantCommitment === undefined ||
-                    args.changeCommitment === undefined ||
-                    args.merchantLeafIndex === undefined ||
-                    args.changeLeafIndex === undefined) {
-                    continue;
-                }
-                writes.push({
-                    blockNumber: log.blockNumber ?? 0n,
-                    logIndex: log.logIndex ?? 0,
-                    order: 0,
-                    leafIndex: Number(args.merchantLeafIndex),
-                    commitment: args.merchantCommitment
-                });
-                writes.push({
-                    blockNumber: log.blockNumber ?? 0n,
-                    logIndex: log.logIndex ?? 0,
-                    order: 1,
-                    leafIndex: Number(args.changeLeafIndex),
-                    commitment: args.changeCommitment
-                });
-                spendsApplied += 1;
-            }
-            writes.sort((a, b) => {
-                if (a.blockNumber !== b.blockNumber)
-                    return a.blockNumber < b.blockNumber ? -1 : 1;
-                if (a.logIndex !== b.logIndex)
-                    return a.logIndex < b.logIndex ? -1 : 1;
-                return a.order - b.order;
+            const mapped = this.mapRpcEventsToWrites({
+                depositLogs: depositLogs,
+                spendLogs: spendLogs
             });
-            for (const write of writes) {
-                if (write.leafIndex < 0)
-                    continue;
-                this.state.commitments[write.leafIndex] = write.commitment;
-                const normalized = normalizeHex(write.commitment);
-                for (let i = 0; i < this.state.notes.length; i += 1) {
-                    const note = this.state.notes[i];
-                    if (!note)
-                        continue;
-                    if (normalizeHex(note.commitment) !== normalized)
-                        continue;
-                    note.leafIndex = write.leafIndex;
-                    if (note.depositBlock === undefined) {
-                        note.depositBlock = write.blockNumber;
-                    }
-                }
-            }
+            this.applyCommitmentWrites(mapped.writes);
+            depositsApplied += mapped.depositsApplied;
+            spendsApplied += mapped.spendsApplied;
             this.state.lastSyncedBlock = toBlock;
             await this.persist();
             cursor = toBlock + 1n;
@@ -288,117 +429,62 @@ export class FileBackedWalletState {
     async syncFromIndexer() {
         const fromBlock = this.state.lastSyncedBlock + 1n;
         const { deposits, spends, maxBlockNumber } = await this.fetchIndexerEvents();
-        const writes = [];
-        let depositsApplied = 0;
-        let spendsApplied = 0;
-        for (const deposit of deposits) {
-            const { blockNumber, logIndex } = parseEventPositionFromId(deposit.id);
-            writes.push({
-                blockNumber,
-                logIndex,
-                order: 0,
-                leafIndex: Number(deposit.leafIndex),
-                commitment: deposit.commitment
-            });
-            depositsApplied += 1;
-        }
-        for (const spend of spends) {
-            const { blockNumber, logIndex } = parseEventPositionFromId(spend.id);
-            writes.push({
-                blockNumber,
-                logIndex,
-                order: 0,
-                leafIndex: Number(spend.merchantLeafIndex),
-                commitment: spend.merchantCommitment
-            });
-            writes.push({
-                blockNumber,
-                logIndex,
-                order: 1,
-                leafIndex: Number(spend.changeLeafIndex),
-                commitment: spend.changeCommitment
-            });
-            spendsApplied += 1;
-        }
-        writes.sort((a, b) => {
-            if (a.blockNumber !== b.blockNumber)
-                return a.blockNumber < b.blockNumber ? -1 : 1;
-            if (a.logIndex !== b.logIndex)
-                return a.logIndex < b.logIndex ? -1 : 1;
-            return a.order - b.order;
-        });
-        for (const write of writes) {
-            if (write.leafIndex < 0)
-                continue;
-            this.state.commitments[write.leafIndex] = write.commitment;
-            const normalized = normalizeHex(write.commitment);
-            for (let i = 0; i < this.state.notes.length; i += 1) {
-                const note = this.state.notes[i];
-                if (!note)
-                    continue;
-                if (normalizeHex(note.commitment) !== normalized)
-                    continue;
-                note.leafIndex = write.leafIndex;
-                if (note.depositBlock === undefined) {
-                    note.depositBlock = write.blockNumber;
-                }
-            }
-        }
+        const mapped = this.mapIndexerEventsToWrites(deposits, spends);
+        this.applyCommitmentWrites(mapped.writes);
         const targetBlock = maxBlockNumber >= this.state.lastSyncedBlock ? maxBlockNumber : this.state.lastSyncedBlock;
         this.state.lastSyncedBlock = targetBlock;
         await this.persist();
         return {
             fromBlock,
             toBlock: targetBlock,
-            depositsApplied,
-            spendsApplied
+            depositsApplied: mapped.depositsApplied,
+            spendsApplied: mapped.spendsApplied
         };
     }
     async fetchIndexerEvents() {
+        const { deposits, spends } = await this.fetchIndexerRows();
+        return {
+            deposits,
+            spends,
+            maxBlockNumber: this.computeIndexerMaxBlock(deposits, spends)
+        };
+    }
+    async indexerPost(query, variables) {
         if (!this.indexerGraphqlUrl) {
             throw new Error('indexerGraphqlUrl is not configured');
         }
-        const endpoint = this.indexerGraphqlUrl;
-        const post = async (query, variables) => {
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json'
-                },
-                body: JSON.stringify({
-                    query,
-                    ...(variables ? { variables } : {})
-                })
-            });
-            if (!response.ok) {
-                const text = await response.text();
-                throw new Error(`indexer graphql request failed: ${response.status} ${text}`);
-            }
-            const payload = (await response.json());
-            if (payload.errors && payload.errors.length > 0) {
-                const message = payload.errors.map((error) => error.message ?? 'unknown error').join('; ');
-                throw new Error(`indexer graphql error: ${message}`);
-            }
-            if (!payload.data) {
-                throw new Error('indexer graphql response missing data');
-            }
-            return payload.data;
-        };
-        if (!this.indexerFieldNames) {
-            const introspection = await post(`query WalletIndexerFields { __schema { queryType { fields { name } } } }`);
-            const fieldNames = introspection.__schema.queryType.fields.map((field) => field.name);
-            const pickField = (needle) => fieldNames.find((name) => name.toLowerCase().includes(needle) &&
-                !name.toLowerCase().includes('aggregate') &&
-                !name.toLowerCase().includes('by_pk'));
-            const deposits = pickField('shieldedpool_deposited');
-            const spends = pickField('shieldedpool_spent');
-            if (!deposits || !spends) {
-                throw new Error(`unable to detect Envio fields for deposits/spends at ${endpoint}; available fields: ${fieldNames.join(', ')}`);
-            }
-            this.indexerFieldNames = { deposits, spends };
+        const payload = await postJson(fetch, this.indexerGraphqlUrl, {
+            query,
+            ...(variables ? { variables } : {})
+        }, { errorPrefix: 'indexer graphql request failed' });
+        if (payload.errors && payload.errors.length > 0) {
+            const message = payload.errors.map((error) => error.message ?? 'unknown error').join('; ');
+            throw new Error(`indexer graphql error: ${message}`);
+        }
+        if (!payload.data) {
+            throw new Error('indexer graphql response missing data');
         }
-        const depositsField = this.indexerFieldNames.deposits;
-        const spendsField = this.indexerFieldNames.spends;
+        return payload.data;
+    }
+    async ensureIndexerFieldNames() {
+        if (this.indexerFieldNames) {
+            return this.indexerFieldNames;
+        }
+        const introspection = await this.indexerPost(`query WalletIndexerFields { __schema { queryType { fields { name } } } }`);
+        const fieldNames = introspection.__schema.queryType.fields.map((field) => field.name);
+        const pickField = (needle) => fieldNames.find((name) => name.toLowerCase().includes(needle) &&
+            !name.toLowerCase().includes('aggregate') &&
+            !name.toLowerCase().includes('by_pk'));
+        const deposits = pickField('shieldedpool_deposited');
+        const spends = pickField('shieldedpool_spent');
+        if (!deposits || !spends) {
+            throw new Error(`unable to detect Envio fields for deposits/spends at ${this.indexerGraphqlUrl}; available fields: ${fieldNames.join(', ')}`);
+        }
+        this.indexerFieldNames = { deposits, spends };
+        return this.indexerFieldNames;
+    }
+    async fetchIndexerRows() {
+        const { deposits: depositsField, spends: spendsField } = await this.ensureIndexerFieldNames();
         const withPaginationQuery = `
       query WalletIndexerData($limit: Int!, $offset: Int!) {
         deposits: ${depositsField}(limit: $limit, offset: $offset) {
@@ -434,23 +520,28 @@ export class FileBackedWalletState {
         let deposits = [];
         let spends = [];
         try {
-            const pageSize = 500;
             let offset = 0;
             while (true) {
-                const page = await post(withPaginationQuery, { limit: pageSize, offset });
+                const page = await this.indexerPost(withPaginationQuery, {
+                    limit: INDEXER_PAGE_SIZE,
+                    offset
+                });
                 deposits = deposits.concat(page.deposits);
                 spends = spends.concat(page.spends);
-                if (page.deposits.length < pageSize && page.spends.length < pageSize) {
+                if (page.deposits.length < INDEXER_PAGE_SIZE && page.spends.length < INDEXER_PAGE_SIZE) {
                     break;
                 }
-                offset += pageSize;
+                offset += INDEXER_PAGE_SIZE;
             }
         }
         catch {
-            const data = await post(fullQuery);
+            const data = await this.indexerPost(fullQuery);
             deposits = data.deposits;
             spends = data.spends;
         }
+        return { deposits, spends };
+    }
+    computeIndexerMaxBlock(deposits, spends) {
         let maxBlockNumber = this.state.lastSyncedBlock;
         for (const deposit of deposits) {
             const position = parseEventPositionFromId(deposit.id);
@@ -464,11 +555,11 @@ export class FileBackedWalletState {
                 maxBlockNumber = position.blockNumber;
             }
         }
-        return { deposits, spends, maxBlockNumber };
+        return maxBlockNumber;
     }
-    getSpendContextByCommitment(commitment, payerPkHash) {
-        const normalized = normalizeHex(commitment);
-        const note = this.state.notes.find((candidate) => normalizeHex(candidate.commitment) === normalized);
+    getSpendContextByCommitment(commitment) {
+        const noteIndex = this.findNoteIndexByCommitment(commitment);
+        const note = noteIndex >= 0 ? this.state.notes[noteIndex] : undefined;
         if (!note) {
             throw new Error(`note not found in wallet state for commitment ${commitment}; add note secrets first with addOrUpdateNote()`);
         }
@@ -488,19 +579,19 @@ export class FileBackedWalletState {
         return {
             note: { ...note, leafIndex },
             witness,
-            payerPkHash
+            nullifierSecret: note.nullifierSecret
         };
     }
+    findNoteIndexByCommitment(commitment) {
+        const normalized = normalizeHex(commitment);
+        const noteIndexes = this.noteIndexesByCommitment.get(normalized);
+        if (!noteIndexes || noteIndexes.length === 0)
+            return -1;
+        return noteIndexes[0] ?? -1;
+    }
     findLeafIndex(commitment) {
         const normalized = normalizeHex(commitment);
-        for (let i = this.state.commitments.length - 1; i >= 0; i -= 1) {
-            const candidate = this.state.commitments[i];
-            if (!candidate)
-                continue;
-            if (normalizeHex(candidate) === normalized)
-                return i;
-        }
-        return -1;
+        return this.leafIndexByCommitment.get(normalized) ?? -1;
     }
 }
 function parseEventPositionFromId(id) {