@miden-sdk/miden-sdk 0.14.0-alpha → 0.14.0

package/dist/workers/{Cargo-D064yzd4-D064yzd4.js → Cargo-M1xGvXNQ-M1xGvXNQ.js}

@@ -7515,7 +7515,10 @@ function getDatabase(dbId) {
  */
 async function openDatabase(network, clientVersion) {
     const db = new MidenDatabase(network);
-    await db.open(clientVersion);
+    const success = await db.open(clientVersion);
+    if (!success) {
+        throw new Error(`Failed to open IndexedDB database: ${network}`);
+    }
     databaseRegistry.set(network, db);
     return network;
 }
@@ -7553,19 +7556,19 @@ function indexes(...items) {
 const V1_STORES = {
     [Table.AccountCode]: indexes("root"),
     [Table.LatestAccountStorage]: indexes("[accountId+slotName]", "accountId"),
-    [Table.HistoricalAccountStorage]: indexes("[accountId+nonce+slotName]", "accountId", "[accountId+nonce]"),
+    [Table.HistoricalAccountStorage]: indexes("[accountId+replacedAtNonce+slotName]", "accountId", "[accountId+replacedAtNonce]"),
     [Table.LatestStorageMapEntries]: indexes("[accountId+slotName+key]", "accountId", "[accountId+slotName]"),
-    [Table.HistoricalStorageMapEntries]: indexes("[accountId+nonce+slotName+key]", "accountId", "[accountId+nonce]"),
-    [Table.LatestAccountAssets]: indexes("[accountId+vaultKey]", "accountId", "faucetIdPrefix"),
-    [Table.HistoricalAccountAssets]: indexes("[accountId+nonce+vaultKey]", "accountId", "[accountId+nonce]"),
+    [Table.HistoricalStorageMapEntries]: indexes("[accountId+replacedAtNonce+slotName+key]", "accountId", "[accountId+replacedAtNonce]"),
+    [Table.LatestAccountAssets]: indexes("[accountId+vaultKey]", "accountId"),
+    [Table.HistoricalAccountAssets]: indexes("[accountId+replacedAtNonce+vaultKey]", "accountId", "[accountId+replacedAtNonce]"),
     [Table.AccountAuth]: indexes("pubKeyCommitmentHex"),
     [Table.AccountKeyMapping]: indexes("[accountIdHex+pubKeyCommitmentHex]", "accountIdHex", "pubKeyCommitmentHex"),
     [Table.LatestAccountHeaders]: indexes("&id", "accountCommitment"),
-    [Table.HistoricalAccountHeaders]: indexes("&accountCommitment", "id", "[id+nonce]"),
+    [Table.HistoricalAccountHeaders]: indexes("&accountCommitment", "id", "[id+replacedAtNonce]"),
     [Table.Addresses]: indexes("address", "id"),
     [Table.Transactions]: indexes("id", "statusVariant"),
     [Table.TransactionScripts]: indexes("scriptRoot"),
-    [Table.InputNotes]: indexes("noteId", "nullifier", "stateDiscriminant"),
+    [Table.InputNotes]: indexes("noteId", "nullifier", "stateDiscriminant", "[consumedBlockHeight+consumedTxOrder+noteId]"),
     [Table.OutputNotes]: indexes("noteId", "recipientDigest", "stateDiscriminant", "nullifier"),
     [Table.NotesScripts]: indexes("scriptRoot"),
     [Table.StateSync]: indexes("id"),
@@ -7843,21 +7846,25 @@ async function getAccountCode(dbId, codeRoot) {
         logWebStoreError(error, `Error fetching account code for root ${codeRoot}`);
     }
 }
-async function getAccountStorage(dbId, accountId) {
+async function getAccountStorage(dbId, accountId, slotNames) {
     try {
         const db = getDatabase(dbId);
-        const allMatchingRecords = await db.latestAccountStorages
-            .where("accountId")
-            .equals(accountId)
-            .toArray();
-        const slots = allMatchingRecords.map((record) => {
-            return {
-                slotName: record.slotName,
-                slotValue: record.slotValue,
-                slotType: record.slotType,
-            };
-        });
-        return slots;
+        let query = db.latestAccountStorages.where("accountId").equals(accountId);
+        let allMatchingRecords;
+        if (slotNames.length) {
+            const nameSet = new Set(slotNames);
+            allMatchingRecords = await query
+                .and((record) => nameSet.has(record.slotName))
+                .toArray();
+        }
+        else {
+            allMatchingRecords = await query.toArray();
+        }
+        return allMatchingRecords.map((record) => ({
+            slotName: record.slotName,
+            slotValue: record.slotValue,
+            slotType: record.slotType,
+        }));
     }
     catch (error) {
         logWebStoreError(error, `Error fetching account storage for account ${accountId}`);
@@ -7876,38 +7883,29 @@ async function getAccountStorageMaps(dbId, accountId) {
         logWebStoreError(error, `Error fetching account storage maps for account ${accountId}`);
     }
 }
-async function getAccountVaultAssets(dbId, accountId) {
+async function getAccountVaultAssets(dbId, accountId, vaultKeys) {
     try {
         const db = getDatabase(dbId);
-        const allMatchingRecords = await db.latestAccountAssets
-            .where("accountId")
-            .equals(accountId)
-            .toArray();
-        const assets = allMatchingRecords.map((record) => {
-            return {
-                asset: record.asset,
-            };
-        });
-        return assets;
+        let query = db.latestAccountAssets.where("accountId").equals(accountId);
+        let records;
+        if (vaultKeys.length) {
+            const keySet = new Set(vaultKeys);
+            records = await query
+                .and((record) => keySet.has(record.vaultKey))
+                .toArray();
+        }
+        else {
+            records = await query.toArray();
+        }
+        return records.map((record) => ({
+            vaultKey: record.vaultKey,
+            asset: record.asset,
+        }));
     }
     catch (error) {
         logWebStoreError(error, `Error fetching account vault for account ${accountId}`);
     }
 }
-async function getAccountAuthByPubKeyCommitment(dbId, pubKeyCommitmentHex) {
-    const db = getDatabase(dbId);
-    const accountSecretKey = await db.accountAuths
-        .where("pubKeyCommitmentHex")
-        .equals(pubKeyCommitmentHex)
-        .first();
-    if (!accountSecretKey) {
-        throw new Error("Account auth not found in cache.");
-    }
-    const data = {
-        secretKey: accountSecretKey.secretKeyHex,
-    };
-    return data;
-}
 async function getAccountAddresses(dbId, accountId) {
     try {
         const db = getDatabase(dbId);
@@ -7938,7 +7936,7 @@ async function upsertAccountCode(dbId, codeRoot, code) {
         logWebStoreError(error, `Error inserting code with root: ${codeRoot}`);
     }
 }
-async function upsertAccountStorage(dbId, accountId, nonce, storageSlots) {
+async function upsertAccountStorage(dbId, accountId, storageSlots) {
     try {
         const db = getDatabase(dbId);
         await db.latestAccountStorages
@@ -7953,43 +7951,19 @@ async function upsertAccountStorage(dbId, accountId, nonce, storageSlots) {
             slotValue: slot.slotValue,
             slotType: slot.slotType,
         }));
-        const historicalEntries = latestEntries.map((entry) => ({
-            ...entry,
-            nonce,
-        }));
         await db.latestAccountStorages.bulkPut(latestEntries);
-        await db.historicalAccountStorages.bulkPut(historicalEntries);
     }
     catch (error) {
         logWebStoreError(error, `Error inserting storage slots`);
     }
 }
-async function upsertStorageMapEntries(dbId, accountId, nonce, entries) {
+async function upsertStorageMapEntries(dbId, accountId, entries) {
     try {
         const db = getDatabase(dbId);
-        // Read old latest entries before clearing, to detect removals
-        const oldEntries = await db.latestStorageMapEntries
-            .where("accountId")
-            .equals(accountId)
-            .toArray();
         await db.latestStorageMapEntries
             .where("accountId")
             .equals(accountId)
             .delete();
-        // Build a set of new keys for fast lookup
-        const newKeySet = new Set(entries.map((e) => `${e.slotName}\0${e.key}`));
-        // Write tombstones to historical for entries that existed but are now absent
-        for (const old of oldEntries) {
-            if (!newKeySet.has(`${old.slotName}\0${old.key}`)) {
-                await db.historicalStorageMapEntries.put({
-                    accountId,
-                    nonce,
-                    slotName: old.slotName,
-                    key: old.key,
-                    value: null,
-                });
-            }
-        }
         if (entries.length === 0)
             return;
         const latestEntries = entries.map((entry) => ({
@@ -7998,60 +7972,30 @@ async function upsertStorageMapEntries(dbId, accountId, nonce, entries) {
             key: entry.key,
             value: entry.value,
         }));
-        const historicalEntries = latestEntries.map((entry) => ({
-            ...entry,
-            nonce,
-        }));
         await db.latestStorageMapEntries.bulkPut(latestEntries);
-        await db.historicalStorageMapEntries.bulkPut(historicalEntries);
     }
     catch (error) {
         logWebStoreError(error, `Error inserting storage map entries`);
     }
 }
-async function upsertVaultAssets(dbId, accountId, nonce, assets) {
+async function upsertVaultAssets(dbId, accountId, assets) {
     try {
         const db = getDatabase(dbId);
-        // Read old latest entries before clearing, to detect removals
-        const oldAssets = await db.latestAccountAssets
-            .where("accountId")
-            .equals(accountId)
-            .toArray();
         await db.latestAccountAssets.where("accountId").equals(accountId).delete();
-        // Build a set of new vault keys for fast lookup
-        const newKeySet = new Set(assets.map((a) => a.vaultKey));
-        // Write tombstones to historical for assets that existed but are now absent
-        for (const old of oldAssets) {
-            if (!newKeySet.has(old.vaultKey)) {
-                await db.historicalAccountAssets.put({
-                    accountId,
-                    nonce,
-                    vaultKey: old.vaultKey,
-                    faucetIdPrefix: old.faucetIdPrefix,
-                    asset: null,
-                });
-            }
-        }
         if (assets.length === 0)
             return;
         const latestEntries = assets.map((asset) => ({
             accountId,
             vaultKey: asset.vaultKey,
-            faucetIdPrefix: asset.faucetIdPrefix,
             asset: asset.asset,
         }));
-        const historicalEntries = latestEntries.map((entry) => ({
-            ...entry,
-            nonce,
-        }));
         await db.latestAccountAssets.bulkPut(latestEntries);
-        await db.historicalAccountAssets.bulkPut(historicalEntries);
     }
     catch (error) {
         logWebStoreError(error, `Error inserting assets`);
     }
 }
-async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, changedMapEntries, changedAssets, codeRoot, storageRoot, vaultRoot, committed, commitment, accountSeed) {
+async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, changedMapEntries, changedAssets, codeRoot, storageRoot, vaultRoot, committed, commitment) {
     try {
         const db = getDatabase(dbId);
         await db.dexie.transaction("rw", [
@@ -8064,108 +8008,299 @@ async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, chang
             db.latestAccountHeaders,
             db.historicalAccountHeaders,
         ], async () => {
-            // Apply storage delta
+            // Apply storage delta: read old → archive → write new
             for (const slot of updatedSlots) {
-                await db.latestAccountStorages.put({
+                const oldSlot = await db.latestAccountStorages
+                    .where("[accountId+slotName]")
+                    .equals([accountId, slot.slotName])
+                    .first();
+                await db.historicalAccountStorages.put({
                     accountId,
+                    replacedAtNonce: nonce,
                     slotName: slot.slotName,
-                    slotValue: slot.slotValue,
+                    oldSlotValue: oldSlot?.slotValue ?? null,
                     slotType: slot.slotType,
                 });
-                await db.historicalAccountStorages.put({
+                await db.latestAccountStorages.put({
                     accountId,
-                    nonce,
                     slotName: slot.slotName,
                     slotValue: slot.slotValue,
                     slotType: slot.slotType,
                 });
             }
-            // Process map entries: value="" means removal
+            // Process map entries: read old → archive → update latest
             for (const entry of changedMapEntries) {
+                const oldEntry = await db.latestStorageMapEntries
+                    .where("[accountId+slotName+key]")
+                    .equals([accountId, entry.slotName, entry.key])
+                    .first();
+                await db.historicalStorageMapEntries.put({
+                    accountId,
+                    replacedAtNonce: nonce,
+                    slotName: entry.slotName,
+                    key: entry.key,
+                    oldValue: oldEntry?.value ?? null,
+                });
+                // "" means removal
                 if (entry.value === "") {
-                    // Removal: delete from latest, write tombstone to historical
                     await db.latestStorageMapEntries
                         .where("[accountId+slotName+key]")
                         .equals([accountId, entry.slotName, entry.key])
                         .delete();
-                    await db.historicalStorageMapEntries.put({
-                        accountId,
-                        nonce,
-                        slotName: entry.slotName,
-                        key: entry.key,
-                        value: null,
-                    });
                 }
                 else {
-                    // Update: put to both latest and historical
                     await db.latestStorageMapEntries.put({
                         accountId,
                         slotName: entry.slotName,
                         key: entry.key,
                         value: entry.value,
                     });
-                    await db.historicalStorageMapEntries.put({
-                        accountId,
-                        nonce,
-                        slotName: entry.slotName,
-                        key: entry.key,
-                        value: entry.value,
-                    });
                 }
             }
-            // Apply vault delta
+            // Apply vault delta: read old → archive → update latest
             for (const entry of changedAssets) {
+                const oldAsset = await db.latestAccountAssets
+                    .where("[accountId+vaultKey]")
+                    .equals([accountId, entry.vaultKey])
+                    .first();
+                await db.historicalAccountAssets.put({
+                    accountId,
+                    replacedAtNonce: nonce,
+                    vaultKey: entry.vaultKey,
+                    oldAsset: oldAsset?.asset ?? null,
+                });
+                // "" means removal
                 if (entry.asset === "") {
-                    // Removal: delete from latest, write tombstone to historical
                     await db.latestAccountAssets
                         .where("[accountId+vaultKey]")
                         .equals([accountId, entry.vaultKey])
                         .delete();
-                    await db.historicalAccountAssets.put({
-                        accountId,
-                        nonce,
-                        vaultKey: entry.vaultKey,
-                        faucetIdPrefix: entry.faucetIdPrefix,
-                        asset: null,
-                    });
                 }
                 else {
-                    // Update: put to both latest and historical
                     await db.latestAccountAssets.put({
                         accountId,
                         vaultKey: entry.vaultKey,
-                        faucetIdPrefix: entry.faucetIdPrefix,
-                        asset: entry.asset,
-                    });
-                    await db.historicalAccountAssets.put({
-                        accountId,
-                        nonce,
-                        vaultKey: entry.vaultKey,
-                        faucetIdPrefix: entry.faucetIdPrefix,
                         asset: entry.asset,
                     });
                 }
             }
-            // Upsert account record
-            const data = {
+            // Archive old header and write new header
+            const oldHeader = await db.latestAccountHeaders
+                .where("id")
+                .equals(accountId)
+                .first();
+            if (oldHeader) {
+                await db.historicalAccountHeaders.put({
+                    id: accountId,
+                    replacedAtNonce: nonce,
+                    codeRoot: oldHeader.codeRoot,
+                    storageRoot: oldHeader.storageRoot,
+                    vaultRoot: oldHeader.vaultRoot,
+                    nonce: oldHeader.nonce,
+                    committed: oldHeader.committed,
+                    accountSeed: oldHeader.accountSeed,
+                    accountCommitment: oldHeader.accountCommitment,
+                    locked: oldHeader.locked,
+                });
+            }
+            await db.latestAccountHeaders.put({
                 id: accountId,
                 codeRoot,
                 storageRoot,
                 vaultRoot,
                 nonce,
                 committed,
-                accountSeed,
+                accountSeed: undefined,
                 accountCommitment: commitment,
                 locked: false,
-            };
-            await db.historicalAccountHeaders.put(data);
-            await db.latestAccountHeaders.put(data);
+            });
         });
     }
     catch (error) {
         logWebStoreError(error, `Error applying transaction delta`);
     }
 }
+async function archiveAndReplaceStorageSlots(db, accountId, nonce, newSlots) {
+    const oldSlots = await db.latestAccountStorages
+        .where("accountId")
+        .equals(accountId)
+        .toArray();
+    // Archive every old slot
+    for (const slot of oldSlots) {
+        await db.historicalAccountStorages.put({
+            accountId,
+            replacedAtNonce: nonce,
+            slotName: slot.slotName,
+            oldSlotValue: slot.slotValue,
+            slotType: slot.slotType,
+        });
+    }
+    // Write NULL markers for genuinely new slots (no old value to archive)
+    const oldSlotNames = new Set(oldSlots.map((s) => s.slotName));
+    for (const slot of newSlots) {
+        if (!oldSlotNames.has(slot.slotName)) {
+            await db.historicalAccountStorages.put({
+                accountId,
+                replacedAtNonce: nonce,
+                slotName: slot.slotName,
+                oldSlotValue: null,
+                slotType: slot.slotType,
+            });
+        }
+    }
+    // Replace latest
+    await db.latestAccountStorages.where("accountId").equals(accountId).delete();
+    if (newSlots.length > 0) {
+        await db.latestAccountStorages.bulkPut(newSlots.map((slot) => ({
+            accountId,
+            slotName: slot.slotName,
+            slotValue: slot.slotValue,
+            slotType: slot.slotType,
+        })));
+    }
+}
+async function archiveAndReplaceMapEntries(db, accountId, nonce, newEntries) {
+    const oldEntries = await db.latestStorageMapEntries
+        .where("accountId")
+        .equals(accountId)
+        .toArray();
+    for (const entry of oldEntries) {
+        await db.historicalStorageMapEntries.put({
+            accountId,
+            replacedAtNonce: nonce,
+            slotName: entry.slotName,
+            key: entry.key,
+            oldValue: entry.value,
+        });
+    }
+    const oldKeys = new Set(oldEntries.map((e) => `${e.slotName}\0${e.key}`));
+    for (const entry of newEntries) {
+        if (!oldKeys.has(`${entry.slotName}\0${entry.key}`)) {
+            await db.historicalStorageMapEntries.put({
+                accountId,
+                replacedAtNonce: nonce,
+                slotName: entry.slotName,
+                key: entry.key,
+                oldValue: null,
+            });
+        }
+    }
+    await db.latestStorageMapEntries
+        .where("accountId")
+        .equals(accountId)
+        .delete();
+    if (newEntries.length > 0) {
+        await db.latestStorageMapEntries.bulkPut(newEntries.map((entry) => ({
+            accountId,
+            slotName: entry.slotName,
+            key: entry.key,
+            value: entry.value,
+        })));
+    }
+}
+async function archiveAndReplaceVaultAssets(db, accountId, nonce, newAssets) {
+    const oldAssets = await db.latestAccountAssets
+        .where("accountId")
+        .equals(accountId)
+        .toArray();
+    for (const asset of oldAssets) {
+        await db.historicalAccountAssets.put({
+            accountId,
+            replacedAtNonce: nonce,
+            vaultKey: asset.vaultKey,
+            oldAsset: asset.asset,
+        });
+    }
+    const oldKeys = new Set(oldAssets.map((a) => a.vaultKey));
+    for (const asset of newAssets) {
+        if (!oldKeys.has(asset.vaultKey)) {
+            await db.historicalAccountAssets.put({
+                accountId,
+                replacedAtNonce: nonce,
+                vaultKey: asset.vaultKey,
+                oldAsset: null,
+            });
+        }
+    }
+    await db.latestAccountAssets.where("accountId").equals(accountId).delete();
+    if (newAssets.length > 0) {
+        await db.latestAccountAssets.bulkPut(newAssets.map((asset) => ({
+            accountId,
+            vaultKey: asset.vaultKey,
+            asset: asset.asset,
+        })));
+    }
+}
+async function restoreSlotsFromHistorical(db, accountId, nonce) {
+    const oldSlots = await db.historicalAccountStorages
+        .where("[accountId+replacedAtNonce]")
+        .equals([accountId, nonce])
+        .toArray();
+    for (const slot of oldSlots) {
+        if (slot.oldSlotValue !== null) {
+            await db.latestAccountStorages.put({
+                accountId: slot.accountId,
+                slotName: slot.slotName,
+                slotValue: slot.oldSlotValue,
+                slotType: slot.slotType,
+            });
+        }
+        else {
+            await db.latestAccountStorages
+                .where("[accountId+slotName]")
+                .equals([accountId, slot.slotName])
+                .delete();
+        }
+    }
+}
+async function restoreMapEntriesFromHistorical(db, accountId, nonce) {
+    const oldEntries = await db.historicalStorageMapEntries
+        .where("[accountId+replacedAtNonce]")
+        .equals([accountId, nonce])
+        .toArray();
+    for (const entry of oldEntries) {
+        if (entry.oldValue !== null) {
+            await db.latestStorageMapEntries.put({
+                accountId: entry.accountId,
+                slotName: entry.slotName,
+                key: entry.key,
+                value: entry.oldValue,
+            });
+        }
+        else {
+            await db.latestStorageMapEntries
+                .where("[accountId+slotName+key]")
+                .equals([accountId, entry.slotName, entry.key])
+                .delete();
+        }
+    }
+}
+async function restoreAssetsFromHistorical(db, accountId, nonce) {
+    const oldAssets = await db.historicalAccountAssets
+        .where("[accountId+replacedAtNonce]")
+        .equals([accountId, nonce])
+        .toArray();
+    for (const asset of oldAssets) {
+        if (asset.oldAsset !== null) {
+            await db.latestAccountAssets.put({
+                accountId: asset.accountId,
+                vaultKey: asset.vaultKey,
+                asset: asset.oldAsset,
+            });
+        }
+        else {
+            await db.latestAccountAssets
+                .where("[accountId+vaultKey]")
+                .equals([accountId, asset.vaultKey])
+                .delete();
+        }
+    }
+}
+/**
+ * Replaces an account's full state (storage, map entries, vault assets, header)
+ * with a new snapshot. Before overwriting, all current latest values are archived
+ * to historical.
+ */
 async function applyFullAccountState(dbId, accountState) {
     try {
         const db = getDatabase(dbId);
@@ -8180,13 +8315,31 @@ async function applyFullAccountState(dbId, accountState) {
             db.latestAccountHeaders,
             db.historicalAccountHeaders,
         ], async () => {
-            // Upsert account storage (calls existing helpers — Dexie nesting
-            // joins them to this outer transaction)
-            await upsertAccountStorage(dbId, accountId, nonce, storageSlots);
-            await upsertStorageMapEntries(dbId, accountId, nonce, storageMapEntries);
-            await upsertVaultAssets(dbId, accountId, nonce, assets);
-            // Upsert account record
-            const data = {
+            // Archive: save current latest values to historical (so they can be
+            // restored on undo), then replace latest with the new state.
+            await archiveAndReplaceStorageSlots(db, accountId, nonce, storageSlots);
+            await archiveAndReplaceMapEntries(db, accountId, nonce, storageMapEntries);
+            await archiveAndReplaceVaultAssets(db, accountId, nonce, assets);
+            // Archive old header and write new header
+            const oldHeader = await db.latestAccountHeaders
+                .where("id")
+                .equals(accountId)
+                .first();
+            if (oldHeader) {
+                await db.historicalAccountHeaders.put({
+                    id: accountId,
+                    replacedAtNonce: nonce,
+                    codeRoot: oldHeader.codeRoot,
+                    storageRoot: oldHeader.storageRoot,
+                    vaultRoot: oldHeader.vaultRoot,
+                    nonce: oldHeader.nonce,
+                    committed: oldHeader.committed,
+                    accountSeed: oldHeader.accountSeed,
+                    accountCommitment: oldHeader.accountCommitment,
+                    locked: oldHeader.locked,
+                });
+            }
+            await db.latestAccountHeaders.put({
                 id: accountId,
                 codeRoot,
                 storageRoot,
@@ -8196,9 +8349,7 @@ async function applyFullAccountState(dbId, accountState) {
                 accountSeed,
                 accountCommitment,
                 locked: false,
-            };
-            await db.historicalAccountHeaders.put(data);
-            await db.latestAccountHeaders.put(data);
+            });
         });
     }
     catch (error) {
@@ -8219,26 +8370,12 @@ async function upsertAccountRecord(dbId, accountId, codeRoot, storageRoot, vault
             accountCommitment: commitment,
             locked: false,
         };
-        await db.historicalAccountHeaders.put(data);
         await db.latestAccountHeaders.put(data);
     }
     catch (error) {
         logWebStoreError(error, `Error inserting account: ${accountId}`);
     }
 }
-async function insertAccountAuth(dbId, pubKeyCommitmentHex, secretKey) {
-    try {
-        const db = getDatabase(dbId);
-        const data = {
-            pubKeyCommitmentHex,
-            secretKeyHex: secretKey,
-        };
-        await db.accountAuths.add(data);
-    }
-    catch (error) {
-        logWebStoreError(error, `Error inserting account auth for pubKey: ${pubKeyCommitmentHex}`);
-    }
-}
 async function insertAccountAddress(dbId, accountId, address) {
     try {
         const db = getDatabase(dbId);
@@ -8328,96 +8465,87 @@ async function lockAccount(dbId, accountId) {
     }
 }
 /**
- * Rebuilds latest storage slots from historical data.
- * Groups by slotName, takes the entry with MAX(nonce) per slot.
- * Slots cannot be removed, so no tombstone filtering needed.
+ * Prunes historical account states for a single account up to the given nonce.
+ *
+ * Deletes all historical entries with `replacedAtNonce <= upToNonce` and any
+ * orphaned account code. Mirrors the SQLite implementation.
  */
-async function rebuildLatestStorageSlots(db, accountId) {
-    await db.latestAccountStorages.where("accountId").equals(accountId).delete();
-    const allHist = await db.historicalAccountStorages
-        .where("accountId")
-        .equals(accountId)
-        .toArray();
-    // Group by slotName, take MAX(nonce) per slot
-    const bySlot = new Map();
-    for (const entry of allHist) {
-        const existing = bySlot.get(entry.slotName);
-        if (!existing || BigInt(entry.nonce) > BigInt(existing.nonce)) {
-            bySlot.set(entry.slotName, entry);
-        }
-    }
-    if (bySlot.size > 0) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const entries = [...bySlot.values()].map(({ nonce, ...rest }) => rest);
-        await db.latestAccountStorages.bulkPut(entries);
+async function pruneAccountHistory(dbId, accountId, upToNonce) {
+    try {
+        const db = getDatabase(dbId);
+        let totalDeleted = 0;
+        const boundaryNonce = BigInt(upToNonce);
+        await db.dexie.transaction("rw", [
+            db.historicalAccountHeaders,
+            db.historicalAccountStorages,
+            db.historicalStorageMapEntries,
+            db.historicalAccountAssets,
+            db.accountCodes,
+            db.latestAccountHeaders,
+            db.foreignAccountCode,
+        ], async () => {
+            // Nonces are stored as strings so we cannot use index range queries
+            // (lexicographic ordering would be wrong). Filter in JS instead.
+            const headers = await db.historicalAccountHeaders
+                .where("id")
+                .equals(accountId)
+                .toArray();
+            const toPrune = headers.filter((h) => BigInt(h.replacedAtNonce) <= boundaryNonce);
+            // Collect code roots from headers we are about to delete.
+            const candidateCodeRoots = new Set(toPrune.map((h) => h.codeRoot));
+            for (const h of toPrune) {
+                await db.historicalAccountHeaders
+                    .where("accountCommitment")
+                    .equals(h.accountCommitment)
+                    .delete();
+                const rat = h.replacedAtNonce;
+                totalDeleted += 1;
+                totalDeleted += await db.historicalAccountStorages
+                    .where("[accountId+replacedAtNonce]")
+                    .equals([accountId, rat])
+                    .delete();
+                totalDeleted += await db.historicalStorageMapEntries
+                    .where("[accountId+replacedAtNonce]")
+                    .equals([accountId, rat])
+                    .delete();
+                totalDeleted += await db.historicalAccountAssets
+                    .where("[accountId+replacedAtNonce]")
+                    .equals([accountId, rat])
+                    .delete();
+            }
+            // Delete orphaned code: only check roots from the deleted headers,
+            // and only if they are not referenced by any remaining header or foreign code.
+            if (candidateCodeRoots.size > 0) {
+                const latestHeaders = await db.latestAccountHeaders.toArray();
+                const remainingHistorical = await db.historicalAccountHeaders.toArray();
+                const foreignCodes = await db.foreignAccountCode.toArray();
+                const referencedCodeRoots = new Set();
+                for (const h of latestHeaders)
+                    referencedCodeRoots.add(h.codeRoot);
+                for (const h of remainingHistorical)
+                    referencedCodeRoots.add(h.codeRoot);
+                for (const f of foreignCodes)
+                    referencedCodeRoots.add(f.codeRoot);
+                for (const root of candidateCodeRoots) {
+                    if (!referencedCodeRoots.has(root)) {
+                        await db.accountCodes.where("root").equals(root).delete();
+                        totalDeleted += 1;
+                    }
+                }
+            }
+        });
+        return totalDeleted;
     }
-}
-/**
- * Rebuilds latest storage map entries from historical data.
- * Groups by (slotName, key), takes the entry with MAX(nonce) per key.
- * Filters out tombstones (value === null).
- */
-async function rebuildLatestStorageMapEntries(db, accountId) {
-    await db.latestStorageMapEntries
-        .where("accountId")
-        .equals(accountId)
-        .delete();
-    const allHist = await db.historicalStorageMapEntries
-        .where("accountId")
-        .equals(accountId)
-        .toArray();
-    // Group by (slotName, key), take MAX(nonce) per key
-    const byKey = new Map();
-    for (const entry of allHist) {
-        const compositeKey = `${entry.slotName}\0${entry.key}`;
-        const existing = byKey.get(compositeKey);
-        if (!existing || BigInt(entry.nonce) > BigInt(existing.nonce)) {
-            byKey.set(compositeKey, entry);
-        }
-    }
-    // Filter out tombstones and strip nonce
-    const entries = [...byKey.values()]
-        .filter((e) => e.value !== null)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(({ nonce, value, ...rest }) => ({
-        ...rest,
-        value: value,
-    }));
-    if (entries.length > 0) {
-        await db.latestStorageMapEntries.bulkPut(entries);
+    catch (error) {
+        logWebStoreError(error, `Error pruning account history for ${accountId}`);
+        throw error;
     }
 }
 /**
- * Rebuilds latest vault assets from historical data.
- * Groups by vaultKey, takes the entry with MAX(nonce) per key.
- * Filters out tombstones (asset === null).
+ * Undoes discarded account states by restoring old values from historical
+ * back to latest. Non-null old values overwrite latest; null old values
+ * (entries that didn't exist before that nonce) cause deletion from latest.
  */
-async function rebuildLatestVaultAssets(db, accountId) {
-    await db.latestAccountAssets.where("accountId").equals(accountId).delete();
-    const allHist = await db.historicalAccountAssets
-        .where("accountId")
-        .equals(accountId)
-        .toArray();
-    // Group by vaultKey, take MAX(nonce) per key
-    const byKey = new Map();
-    for (const entry of allHist) {
-        const existing = byKey.get(entry.vaultKey);
-        if (!existing || BigInt(entry.nonce) > BigInt(existing.nonce)) {
-            byKey.set(entry.vaultKey, entry);
-        }
-    }
-    // Filter out tombstones and strip nonce
-    const entries = [...byKey.values()]
-        .filter((e) => e.asset !== null)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(({ nonce, asset, ...rest }) => ({
-        ...rest,
-        asset: asset,
-    }));
-    if (entries.length > 0) {
-        await db.latestAccountAssets.bulkPut(entries);
-    }
-}
 async function undoAccountStates(dbId, accountCommitments) {
     try {
         const db = getDatabase(dbId);
@@ -8431,49 +8559,66 @@ async function undoAccountStates(dbId, accountCommitments) {
             db.latestAccountHeaders,
             db.historicalAccountHeaders,
         ], async () => {
-            // Find affected records to get their account IDs and nonces before deleting
-            const affectedRecords = await db.historicalAccountHeaders
-                .where("accountCommitment")
-                .anyOf(accountCommitments)
-                .toArray();
-            // Collect affected (accountId, nonce) pairs
+            // Step 1: Resolve nonces from both latest and historical headers
             const accountNonces = new Map();
-            for (const record of affectedRecords) {
-                if (!accountNonces.has(record.id)) {
-                    accountNonces.set(record.id, new Set());
+            for (const commitment of accountCommitments) {
+                const latestRecord = await db.latestAccountHeaders
+                    .where("accountCommitment")
+                    .equals(commitment)
+                    .first();
+                if (latestRecord) {
+                    if (!accountNonces.has(latestRecord.id)) {
+                        accountNonces.set(latestRecord.id, new Set());
+                    }
+                    accountNonces.get(latestRecord.id).add(latestRecord.nonce);
+                    continue;
+                }
+                const histRecord = await db.historicalAccountHeaders
+                    .where("accountCommitment")
+                    .equals(commitment)
+                    .first();
+                if (histRecord) {
+                    if (!accountNonces.has(histRecord.id)) {
+                        accountNonces.set(histRecord.id, new Set());
+                    }
+                    accountNonces.get(histRecord.id).add(histRecord.nonce);
                 }
-                accountNonces.get(record.id).add(record.nonce);
             }
-            // Delete matching records from historical account headers
-            await db.historicalAccountHeaders
-                .where("accountCommitment")
-                .anyOf(accountCommitments)
-                .delete();
-            // Delete historical storage/map/assets for affected (accountId, nonce) pairs
+            // Step 2: Group nonces by account, sort descending (undo most recent first).
+            // Descending order is needed because each nonce's old value is the state before
+            // that nonce — processing most recent first lets earlier nonces overwrite with
+            // the correct final value.
             for (const [accountId, nonces] of accountNonces) {
-                for (const nonce of nonces) {
-                    await db.historicalAccountStorages
-                        .where("[accountId+nonce]")
-                        .equals([accountId, nonce])
-                        .delete();
-                    await db.historicalStorageMapEntries
-                        .where("[accountId+nonce]")
-                        .equals([accountId, nonce])
-                        .delete();
-                    await db.historicalAccountAssets
-                        .where("[accountId+nonce]")
-                        .equals([accountId, nonce])
-                        .delete();
+                const sortedNonces = [...nonces].sort((a, b) => Number(BigInt(b) - BigInt(a)));
+                // Step 3: Restore old values from historical back to latest, undoing
+                // each nonce in descending order. Non-null old values overwrite latest;
+                // null old values (entries that didn't exist before) cause deletion.
+                for (const nonce of sortedNonces) {
+                    await restoreSlotsFromHistorical(db, accountId, nonce);
+                    await restoreMapEntriesFromHistorical(db, accountId, nonce);
+                    await restoreAssetsFromHistorical(db, accountId, nonce);
                 }
-            }
-            // Rebuild latest for each affected account
-            for (const accountId of accountNonces.keys()) {
-                const remaining = await db.historicalAccountHeaders
-                    .where("id")
-                    .equals(accountId)
-                    .toArray();
-                if (remaining.length === 0) {
-                    // Account completely undone — clear all latest tables
+                // Step 4: Restore old header from the earliest discarded nonce
+                const minNonce = sortedNonces[sortedNonces.length - 1];
+                const oldHeader = await db.historicalAccountHeaders
+                    .where("[id+replacedAtNonce]")
+                    .equals([accountId, minNonce])
+                    .first();
+                if (oldHeader) {
+                    await db.latestAccountHeaders.put({
+                        id: oldHeader.id,
+                        codeRoot: oldHeader.codeRoot,
+                        storageRoot: oldHeader.storageRoot,
+                        vaultRoot: oldHeader.vaultRoot,
+                        nonce: oldHeader.nonce,
+                        committed: oldHeader.committed,
+                        accountSeed: oldHeader.accountSeed,
+                        accountCommitment: oldHeader.accountCommitment,
+                        locked: oldHeader.locked,
+                    });
+                }
+                else {
+                    // No previous state — delete the account entirely
                     await db.latestAccountHeaders
                         .where("id")
                         .equals(accountId)
@@ -8491,25 +8636,71 @@ async function undoAccountStates(dbId, accountCommitments) {
                         .equals(accountId)
                         .delete();
                 }
-                else {
-                    // Find the record with the highest nonce
-                    let maxRecord = remaining[0];
-                    for (const record of remaining) {
-                        if (BigInt(record.nonce) > BigInt(maxRecord.nonce)) {
-                            maxRecord = record;
-                        }
-                    }
-                    // Rebuild latest from historical using MAX(nonce) per key
-                    await db.latestAccountHeaders.put(maxRecord);
-                    await rebuildLatestStorageSlots(db, accountId);
-                    await rebuildLatestStorageMapEntries(db, accountId);
-                    await rebuildLatestVaultAssets(db, accountId);
+                // Step 5: Delete consumed historical entries at discarded nonces
+                for (const nonce of sortedNonces) {
+                    await db.historicalAccountStorages
+                        .where("[accountId+replacedAtNonce]")
+                        .equals([accountId, nonce])
+                        .delete();
+                    await db.historicalStorageMapEntries
+                        .where("[accountId+replacedAtNonce]")
+                        .equals([accountId, nonce])
+                        .delete();
+                    await db.historicalAccountAssets
+                        .where("[accountId+replacedAtNonce]")
+                        .equals([accountId, nonce])
+                        .delete();
+                    await db.historicalAccountHeaders
+                        .where("[id+replacedAtNonce]")
+                        .equals([accountId, nonce])
+                        .delete();
                 }
             }
         });
     }
     catch (error) {
         logWebStoreError(error, `Error undoing account states: ${accountCommitments.join(",")}`);
+        throw error;
+    }
+}
+
+async function insertAccountAuth(dbId, pubKeyCommitmentHex, secretKey) {
+    try {
+        const db = getDatabase(dbId);
+        const data = {
+            pubKeyCommitmentHex,
+            secretKeyHex: secretKey,
+        };
+        await db.accountAuths.add(data);
+    }
+    catch (error) {
+        logWebStoreError(error, `Error inserting account auth for pubKey: ${pubKeyCommitmentHex}`);
+    }
+}
+async function getAccountAuthByPubKeyCommitment(dbId, pubKeyCommitmentHex) {
+    const db = getDatabase(dbId);
+    const accountSecretKey = await db.accountAuths
+        .where("pubKeyCommitmentHex")
+        .equals(pubKeyCommitmentHex)
+        .first();
+    if (!accountSecretKey) {
+        throw new Error("Account auth not found in cache.");
+    }
+    const data = {
+        secretKey: accountSecretKey.secretKeyHex,
+    };
+    return data;
+}
+async function removeAccountAuth(dbId, pubKeyCommitmentHex) {
+    try {
+        const db = getDatabase(dbId);
+        await db.accountAuths
+            .where("pubKeyCommitmentHex")
+            .equals(pubKeyCommitmentHex)
+            .delete();
+    }
+    catch (error) {
+        logWebStoreError(error, `Error removing account auth for pubKey: ${pubKeyCommitmentHex}`);
     }
 }
 async function insertAccountKeyMapping(dbId, accountIdHex, pubKeyCommitmentHex) {
@@ -8539,6 +8730,18 @@ async function getKeyCommitmentsByAccountId(dbId, accountIdHex) {
         return [];
     }
 }
+async function removeAllMappingsForKey(dbId, pubKeyCommitmentHex) {
+    try {
+        const db = getDatabase(dbId);
+        await db.accountKeyMappings
+            .where("pubKeyCommitmentHex")
+            .equals(pubKeyCommitmentHex)
+            .delete();
+    }
+    catch (error) {
+        logWebStoreError(error, `Error removing all mappings for key: ${pubKeyCommitmentHex}`);
+    }
+}
 async function getAccountIdByKeyCommitment(dbId, pubKeyCommitmentHex) {
     try {
         const db = getDatabase(dbId);
@@ -8636,6 +8839,19 @@ async function getTrackedBlockHeaders(dbId) {
         logWebStoreError(err, "Failed to get tracked block headers");
     }
 }
+async function getTrackedBlockHeaderNumbers(dbId) {
+    try {
+        const db = getDatabase(dbId);
+        const blockNums = await db.blockHeaders
+            .where("hasClientNotes")
+            .equals("true")
+            .primaryKeys();
+        return blockNums;
+    }
+    catch (err) {
+        logWebStoreError(err, "Failed to get tracked block header numbers");
+    }
+}
 async function getPartialBlockchainPeaksByBlockNum(dbId, blockNum) {
     try {
         const db = getDatabase(dbId);
@@ -8717,7 +8933,10 @@ async function pruneIrrelevantBlocks(dbId) {
 async function recursivelyTransformForExport(obj) {
     switch (obj.type) {
         case "Uint8Array":
-            return Array.from(obj.value);
+            return {
+                __type: "Uint8Array",
+                data: uint8ArrayToBase64(obj.value),
+            };
         case "Blob":
             return {
                 __type: "Blob",
@@ -8769,6 +8988,8 @@ async function recursivelyTransformForImport(obj) {
     switch (obj.type) {
         case "Blob":
             return new Blob([base64ToUint8Array(obj.value.data)]);
+        case "Uint8Array":
+            return base64ToUint8Array(obj.value.data);
         case "Array":
             return await Promise.all(obj.value.map((v) => recursivelyTransformForImport({ type: getImportType(v), value: v })));
         case "Object":
@@ -8787,6 +9008,9 @@ function getImportType(value) {
     if (value && typeof value === "object" && value.__type === "Blob") {
         return "Blob";
     }
+    if (value && typeof value === "object" && value.__type === "Uint8Array") {
+        return "Uint8Array";
+    }
     if (Array.isArray(value))
         return "Array";
     if (value && typeof value === "object")
@@ -8946,9 +9170,9 @@ async function getNoteScript(dbId, scriptRoot) {
         logWebStoreError(err, "Failed to get note script from root");
     }
 }
-async function upsertInputNote(dbId, noteId, assets, serialNumber, inputs, scriptRoot, serializedNoteScript, nullifier, serializedCreatedAt, stateDiscriminant, state) {
+async function upsertInputNote(dbId, noteId, assets, serialNumber, inputs, scriptRoot, serializedNoteScript, nullifier, serializedCreatedAt, stateDiscriminant, state, consumedBlockHeight, consumedTxOrder, consumerAccountId, tx) {
     const db = getDatabase(dbId);
-    return db.dexie.transaction("rw", db.inputNotes, db.notesScripts, async (tx) => {
+    const doWork = async (t) => {
         try {
             const data = {
                 noteId,
@@ -8960,22 +9184,59 @@ async function upsertInputNote(dbId, noteId, assets, serialNumber, inputs, scrip
                 state,
                 stateDiscriminant,
                 serializedCreatedAt,
+                // These fields are null for non-consumed notes.
+                // Convert null -> undefined so Dexie omits them from compound indexes.
+                consumedBlockHeight: consumedBlockHeight ?? undefined,
+                consumedTxOrder: consumedTxOrder ?? undefined,
+                consumerAccountId: consumerAccountId ?? undefined,
             };
-            await tx.inputNotes.put(data);
+            await t.inputNotes.put(data);
             const noteScriptData = {
                 scriptRoot,
                 serializedNoteScript,
             };
-            await tx.notesScripts.put(noteScriptData);
+            await t.notesScripts.put(noteScriptData);
         }
         catch (error) {
             logWebStoreError(error, `Error inserting note: ${noteId}`);
         }
-    });
+    };
+    return db.dexie.transaction("rw", db.inputNotes, db.notesScripts, doWork);
 }
-async function upsertOutputNote(dbId, noteId, assets, recipientDigest, metadata, nullifier, expectedHeight, stateDiscriminant, state) {
+// Uses the [consumedBlockHeight+consumedTxOrder+noteId] compound index for cursor-based
+// iteration, filtering by consumer account.
+async function getInputNoteByOffset(dbId, states, consumerAccountId, blockStart, blockEnd, offset) {
+    try {
+        const db = getDatabase(dbId);
+        // The compound index sorts by consumedBlockHeight, consumedTxOrder, noteId.
+        // Rows without these fields are excluded by the index.
+        const results = await db.inputNotes
+            .orderBy("[consumedBlockHeight+consumedTxOrder+noteId]")
+            .filter((n) => {
+            if (states.length > 0 && !states.includes(n.stateDiscriminant))
+                return false;
+            if (n.consumerAccountId !== consumerAccountId)
+                return false;
+            if (blockStart != null && n.consumedBlockHeight < blockStart)
+                return false;
+            if (blockEnd != null && n.consumedBlockHeight > blockEnd)
+                return false;
+            return true;
+        })
+            .offset(offset)
+            .limit(1)
+            .toArray();
+        if (results.length === 0)
+            return [];
+        return await processInputNotes(dbId, results);
+    }
+    catch (err) {
+        logWebStoreError(err, "Failed to get input note by offset");
+    }
+}
+async function upsertOutputNote(dbId, noteId, assets, recipientDigest, metadata, nullifier, expectedHeight, stateDiscriminant, state, tx) {
     const db = getDatabase(dbId);
-    return db.dexie.transaction("rw", db.outputNotes, db.notesScripts, async (tx) => {
+    const doWork = async (t) => {
         try {
             const data = {
                 noteId,
@@ -8987,12 +9248,13 @@ async function upsertOutputNote(dbId, noteId, assets, recipientDigest, metadata,
                 stateDiscriminant,
                 state,
             };
-            await tx.outputNotes.put(data);
+            await t.outputNotes.put(data);
         }
         catch (error) {
             logWebStoreError(error, `Error inserting note: ${noteId}`);
         }
-    });
+    };
+    return db.dexie.transaction("rw", db.outputNotes, db.notesScripts, doWork);
 }
 async function processInputNotes(dbId, notes) {
     const db = getDatabase(dbId);
@@ -9190,7 +9452,7 @@ async function getTransactions(dbId, filter) {
         logWebStoreError(err, "Failed to get transactions");
     }
 }
-async function insertTransactionScript(dbId, scriptRoot, txScript) {
+async function insertTransactionScript(dbId, scriptRoot, txScript, tx) {
     try {
         const db = getDatabase(dbId);
         const scriptRootArray = new Uint8Array(scriptRoot);
@@ -9199,13 +9461,13 @@ async function insertTransactionScript(dbId, scriptRoot, txScript) {
             scriptRoot: scriptRootBase64,
             txScript: mapOption(txScript, (txScript) => new Uint8Array(txScript)),
         };
-        await db.transactionScripts.put(data);
+        await (tx || db).transactionScripts.put(data);
     }
     catch (error) {
         logWebStoreError(error, "Failed to insert transaction script");
     }
 }
-async function upsertTransactionRecord(dbId, transactionId, details, blockNum, statusVariant, status, scriptRoot) {
+async function upsertTransactionRecord(dbId, transactionId, details, blockNum, statusVariant, status, scriptRoot, tx) {
     try {
         const db = getDatabase(dbId);
         const data = {
@@ -9216,7 +9478,7 @@ async function upsertTransactionRecord(dbId, transactionId, details, blockNum, s
             statusVariant,
             status,
         };
-        await db.transactions.put(data);
+        await (tx || db).transactions.put(data);
     }
     catch (err) {
         logWebStoreError(err, "Failed to insert proven transaction data");
@@ -9317,7 +9579,7 @@ async function applyStateSync(dbId, stateUpdate) {
     return await db.dexie.transaction("rw", tablesToAccess, async (tx) => {
         await Promise.all([
             Promise.all(serializedInputNotes.map((note) => {
-                return upsertInputNote(dbId, note.noteId, note.noteAssets, note.serialNumber, note.inputs, note.noteScriptRoot, note.noteScript, note.nullifier, note.createdAt, note.stateDiscriminant, note.state);
+                return upsertInputNote(dbId, note.noteId, note.noteAssets, note.serialNumber, note.inputs, note.noteScriptRoot, note.noteScript, note.nullifier, note.createdAt, note.stateDiscriminant, note.state, note.consumedBlockHeight, note.consumedTxOrder, note.consumerAccountId);
             })),
             Promise.all(serializedOutputNotes.map((note) => {
                 return upsertOutputNote(dbId, note.noteId, note.noteAssets, note.recipientDigest, note.metadata, note.nullifier, note.expectedHeight, note.stateDiscriminant, note.state);
@@ -9331,14 +9593,19 @@ async function applyStateSync(dbId, stateUpdate) {
                 }
                 return Promise.all(promises);
             })),
-            Promise.all(accountUpdates.flatMap((accountUpdate) => {
-                return [
-                    upsertAccountStorage(dbId, accountUpdate.accountId, accountUpdate.nonce, accountUpdate.storageSlots),
-                    upsertStorageMapEntries(dbId, accountUpdate.accountId, accountUpdate.nonce, accountUpdate.storageMapEntries),
-                    upsertVaultAssets(dbId, accountUpdate.accountId, accountUpdate.nonce, accountUpdate.assets),
-                    upsertAccountRecord(dbId, accountUpdate.accountId, accountUpdate.codeRoot, accountUpdate.storageRoot, accountUpdate.vaultRoot, accountUpdate.nonce, accountUpdate.committed, accountUpdate.accountCommitment, accountUpdate.accountSeed),
-                ];
-            })),
+            Promise.all(accountUpdates.map((accountUpdate) => applyFullAccountState(dbId, {
+                accountId: accountUpdate.accountId,
+                nonce: accountUpdate.nonce,
+                storageSlots: accountUpdate.storageSlots,
+                storageMapEntries: accountUpdate.storageMapEntries,
+                assets: accountUpdate.assets,
+                codeRoot: accountUpdate.codeRoot,
+                storageRoot: accountUpdate.storageRoot,
+                vaultRoot: accountUpdate.vaultRoot,
+                committed: accountUpdate.committed,
+                accountCommitment: accountUpdate.accountCommitment,
+                accountSeed: accountUpdate.accountSeed,
+            }))),
             updateSyncHeight(tx, blockNum),
             updatePartialBlockchainNodes(tx, serializedNodeIds, serializedNodes),
             updateCommittedNoteTags(tx, committedNoteIds),
@@ -9697,13 +9964,20 @@ class AccountBuilder {
     }
     /**
      * Sets the account type (regular, faucet, etc.).
-     * @param {AccountType} account_type
+     *
+     * Accepts either a numeric WASM enum value (0–3) or a string name
+     * (`"FungibleFaucet"`, `"NonFungibleFaucet"`,
+     * `"RegularAccountImmutableCode"`, `"RegularAccountUpdatableCode"`).
+     * @param {any} account_type
      * @returns {AccountBuilder}
      */
     accountType(account_type) {
         const ptr = this.__destroy_into_raw();
         const ret = wasm.accountbuilder_accountType(ptr, account_type);
-        return AccountBuilder.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountBuilder.__wrap(ret[0]);
     }
     /**
      * Builds the account and returns it together with the derived seed.
@@ -9965,6 +10239,10 @@ class AccountComponent {
     }
     /**
      * Returns the hex-encoded MAST root for a procedure by name.
+     *
+     * Matches by full path, relative path, or local name (after the last `::`).
+     * When matching by local name, if multiple procedures share the same local
+     * name across modules, the first match is returned.
      * @param {string} procedure_name
      * @returns {string}
      */
@@ -10339,6 +10617,26 @@ class AccountId {
         }
         return AccountId.__wrap(ret[0]);
     }
+    /**
+     * Builds an account ID from its prefix and suffix field elements.
+     *
+     * This is useful when the account ID components are stored separately (e.g., in storage
+     * maps) and need to be recombined into an `AccountId`.
+     *
+     * Returns an error if the provided felts do not form a valid account ID.
+     * @param {Felt} prefix
+     * @param {Felt} suffix
+     * @returns {AccountId}
+     */
+    static fromPrefixSuffix(prefix, suffix) {
+        _assertClass(prefix, Felt);
+        _assertClass(suffix, Felt);
+        const ret = wasm.accountid_fromPrefixSuffix(prefix.__wbg_ptr, suffix.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountId.__wrap(ret[0]);
+    }
     /**
      * Returns true if the ID refers to a faucet.
      * @returns {boolean}
@@ -10523,7 +10821,8 @@ const AccountInterface = Object.freeze({
 /**
  * Proof of existence of an account's state at a specific block number, as returned by the node.
  *
- * For public accounts, this includes the account header, storage slot values and account code.
+ * For public accounts, this includes the account header, storage slot values, account code,
+ * and optionally storage map entries for the requested storage maps.
  * For private accounts, only the account commitment and merkle proof are available.
  */
 class AccountProof {
@@ -10584,6 +10883,46 @@ class AccountProof {
         const ret = wasm.accountproof_blockNum(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Returns storage map entries for a given slot name, if available.
+     *
+     * Returns `undefined` if the account is private, the slot was not requested in the
+     * storage requirements, or the slot is not a map.
+     *
+     * Each entry contains a `key` and `value` as `Word` objects.
+     * @param {string} slot_name
+     * @returns {StorageMapEntry[] | undefined}
+     */
+    getStorageMapEntries(slot_name) {
+        const ptr0 = passStringToWasm0(slot_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.accountproof_getStorageMapEntries(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v2;
+    }
+    /**
+     * Returns the names of all storage slots that have map details available.
+     *
+     * This can be used to discover which storage maps were included in the proof response.
+     * Returns `undefined` if the account is private.
+     * @returns {string[] | undefined}
+     */
+    getStorageMapSlotNames() {
+        const ret = wasm.accountproof_getStorageMapSlotNames(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Returns the value of a storage slot by name, if available.
      *
@@ -10603,6 +10942,25 @@ class AccountProof {
         }
         return ret[0] === 0 ? undefined : Word.__wrap(ret[0]);
     }
+    /**
+     * Returns whether a storage map slot had too many entries to return inline.
+     *
+     * When this returns `true`, use `RpcClient.syncStorageMaps()` to fetch the full
+     * storage map data.
+     *
+     * Returns `undefined` if the slot was not found or the account is private.
+     * @param {string} slot_name
+     * @returns {boolean | undefined}
+     */
+    hasStorageMapTooManyEntries(slot_name) {
+        const ptr0 = passStringToWasm0(slot_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.accountproof_hasStorageMapTooManyEntries(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0xFFFFFF ? undefined : ret[0] !== 0;
+    }
     /**
      * Returns the number of storage slots, if available (public accounts only).
      * @returns {number | undefined}
@@ -11366,6 +11724,16 @@ class AdviceInputs {
         }
         return v1;
     }
+    /**
+     * `wasm_bindgen` requires an explicit constructor; `#[derive(Default)]` alone
+     * is not callable from JS.
+     */
+    constructor() {
+        const ret = wasm.adviceinputs_new();
+        this.__wbg_ptr = ret >>> 0;
+        AdviceInputsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     /**
      * Returns the stack inputs as a vector of felts.
      * @returns {Felt[]}
@@ -11478,7 +11846,7 @@ class AssetVault {
      * @returns {Word}
      */
     root() {
-        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        const ret = wasm.accountheader_codeCommitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
 }
@@ -11748,7 +12116,7 @@ class BasicFungibleFaucetComponent {
      * @returns {Felt}
      */
     maxSupply() {
-        const ret = wasm.accountid_suffix(this.__wbg_ptr);
+        const ret = wasm.accountid_prefix(this.__wbg_ptr);
         return Felt.__wrap(ret);
     }
     /**
@@ -11883,7 +12251,7 @@ class BlockHeader {
      * @returns {Word}
      */
     txKernelCommitment() {
-        const ret = wasm.accountbuilderresult_seed(this.__wbg_ptr);
+        const ret = wasm.blockheader_txKernelCommitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -12042,7 +12410,7 @@ class CodeBuilder {
 if (Symbol.dispose) CodeBuilder.prototype[Symbol.dispose] = CodeBuilder.prototype.free;
 
 /**
- * Represents a note committed on chain, as returned by `syncNotes`.
+ * Represents a note committed on chain.
  */
 class CommittedNote {
     static __wrap(ptr) {
@@ -12063,15 +12431,34 @@ class CommittedNote {
         wasm.__wbg_committednote_free(ptr, 0);
     }
     /**
-     * Returns the inclusion path for the note.
+     * Returns the full note metadata when the attachment payload is available.
+     * @returns {NoteMetadata | undefined}
+     */
+    fullMetadata() {
+        const ret = wasm.committednote_fullMetadata(this.__wbg_ptr);
+        return ret === 0 ? undefined : NoteMetadata.__wrap(ret);
+    }
+    /**
+     * Returns the inclusion path for the note in the block's note tree.
      * @returns {SparseMerklePath}
      */
     inclusionPath() {
         const ret = wasm.committednote_inclusionPath(this.__wbg_ptr);
         return SparseMerklePath.__wrap(ret);
     }
+    /**
+     * Returns the inclusion proof for this note.
+     * @returns {NoteInclusionProof}
+     */
+    inclusionProof() {
+        const ret = wasm.committednote_inclusionProof(this.__wbg_ptr);
+        return NoteInclusionProof.__wrap(ret);
+    }
     /**
      * Returns the note metadata.
+     *
+     * If only metadata headers are available, the returned metadata contains
+     * the sender, note type, and tag without attachment payload.
      * @returns {NoteMetadata}
      */
     metadata() {
@@ -12094,6 +12481,30 @@ class CommittedNote {
         const ret = wasm.committednote_noteIndex(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Returns the note type (public, private, etc.).
+     * @returns {NoteType}
+     */
+    noteType() {
+        const ret = wasm.committednote_noteType(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the note sender, even when only header metadata is available.
+     * @returns {AccountId}
+     */
+    sender() {
+        const ret = wasm.committednote_sender(this.__wbg_ptr);
+        return AccountId.__wrap(ret);
+    }
+    /**
+     * Returns the note tag.
+     * @returns {number}
+     */
+    tag() {
+        const ret = wasm.committednote_tag(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 if (Symbol.dispose) CommittedNote.prototype[Symbol.dispose] = CommittedNote.prototype.free;
 
@@ -12601,7 +13012,7 @@ class FetchedAccount {
      * @returns {number}
      */
     lastBlockNum() {
-        const ret = wasm.fetchedaccount_lastBlockNum(this.__wbg_ptr);
+        const ret = wasm.accountproof_blockNum(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -14360,7 +14771,6 @@ class JsVaultAsset {
     toJSON() {
         return {
             asset: this.asset,
-            faucetIdPrefix: this.faucetIdPrefix,
             vaultKey: this.vaultKey,
         };
     }
@@ -14393,22 +14803,6 @@ class JsVaultAsset {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Asset's faucet ID prefix.
-     * @returns {string}
-     */
-    get faucetIdPrefix() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_jsvaultasset_faucetIdPrefix(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
     /**
      * The vault key associated with the asset.
      * @returns {string}
@@ -14430,15 +14824,6 @@ class JsVaultAsset {
      * @param {string} arg0
      */
     set asset(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstoragemapentry_value(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * Asset's faucet ID prefix.
-     * @param {string} arg0
-     */
-    set faucetIdPrefix(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_jsstoragemapentry_key(this.__wbg_ptr, ptr0, len0);
@@ -14506,7 +14891,10 @@ class MerklePath {
     computeRoot(index, node) {
         _assertClass(node, Word);
         const ret = wasm.merklepath_computeRoot(this.__wbg_ptr, index, node.__wbg_ptr);
-        return Word.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Word.__wrap(ret[0]);
     }
     /**
      * Returns the depth of the path.
@@ -14763,7 +15151,7 @@ class Note {
      * @returns {Word}
      */
     nullifier() {
-        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        const ret = wasm.note_nullifier(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -14824,13 +15212,12 @@ class NoteAndArgs {
      */
     constructor(note, args) {
         _assertClass(note, Note);
-        var ptr0 = note.__destroy_into_raw();
-        let ptr1 = 0;
+        let ptr0 = 0;
         if (!isLikeNone(args)) {
             _assertClass(args, Word);
-            ptr1 = args.__destroy_into_raw();
+            ptr0 = args.__destroy_into_raw();
         }
-        const ret = wasm.noteandargs_new(ptr0, ptr1);
+        const ret = wasm.noteandargs_new(note.__wbg_ptr, ptr0);
         this.__wbg_ptr = ret >>> 0;
         NoteAndArgsFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -14908,6 +15295,76 @@ class NoteAndArgsArray {
 }
 if (Symbol.dispose) NoteAndArgsArray.prototype[Symbol.dispose] = NoteAndArgsArray.prototype.free;
 
+class NoteArray {
+    toJSON() {
+        return {
+        };
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NoteArrayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_notearray_free(ptr, 0);
+    }
+    /**
+     * Get element at index, will always return a clone to avoid aliasing issues.
+     * @param {number} index
+     * @returns {Note}
+     */
+    get(index) {
+        const ret = wasm.notearray_get(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Note.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    length() {
+        const ret = wasm.notearray_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Note[] | null} [elements]
+     */
+    constructor(elements) {
+        var ptr0 = isLikeNone(elements) ? 0 : passArrayJsValueToWasm0(elements, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.notearray_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        NoteArrayFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Note} element
+     */
+    push(element) {
+        _assertClass(element, Note);
+        wasm.notearray_push(this.__wbg_ptr, element.__wbg_ptr);
+    }
+    /**
+     * @param {number} index
+     * @param {Note} elem
+     */
+    replaceAt(index, elem) {
+        _assertClass(elem, Note);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.notearray_replaceAt(this.__wbg_ptr, index, ptr0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) NoteArray.prototype[Symbol.dispose] = NoteArray.prototype.free;
+
 /**
  * An asset container for a note.
  *
@@ -15530,7 +15987,10 @@ class NoteExecutionHint {
      */
     canBeConsumed(block_num) {
         const ret = wasm.noteexecutionhint_canBeConsumed(this.__wbg_ptr, block_num);
-        return ret !== 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
     }
     /**
      * Reconstructs a hint from its encoded tag and payload.
@@ -15540,7 +16000,10 @@ class NoteExecutionHint {
      */
     static fromParts(tag, payload) {
         const ret = wasm.noteexecutionhint_fromParts(tag, payload);
-        return NoteExecutionHint.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return NoteExecutionHint.__wrap(ret[0]);
     }
     /**
      * Creates a hint that does not specify any execution constraint.
@@ -15814,14 +16277,6 @@ class NoteHeader {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_noteheader_free(ptr, 0);
     }
-    /**
-     * Returns a commitment to the note ID and metadata.
-     * @returns {Word}
-     */
-    commitment() {
-        const ret = wasm.noteheader_commitment(this.__wbg_ptr);
-        return Word.__wrap(ret);
-    }
     /**
      * Returns the unique identifier for the note.
      * @returns {NoteId}
@@ -15838,6 +16293,14 @@ class NoteHeader {
         const ret = wasm.noteheader_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
+    /**
+     * Returns a commitment to the note ID and metadata.
+     * @returns {Word}
+     */
+    toCommitment() {
+        const ret = wasm.noteheader_toCommitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
 }
 if (Symbol.dispose) NoteHeader.prototype[Symbol.dispose] = NoteHeader.prototype.free;
 
@@ -16107,20 +16570,20 @@ class NoteLocation {
         wasm.__wbg_notelocation_free(ptr, 0);
     }
     /**
-     * Returns the block height containing the note.
+     * Returns the index of the note leaf within the block's note tree.
      * @returns {number}
      */
-    blockNum() {
-        const ret = wasm.noteattachmentscheme_asU32(this.__wbg_ptr);
-        return ret >>> 0;
+    blockNoteTreeIndex() {
+        const ret = wasm.notelocation_blockNoteTreeIndex(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Returns the index of the note leaf within the block's note tree.
+     * Returns the block height containing the note.
      * @returns {number}
      */
-    nodeIndexInBlock() {
-        const ret = wasm.notelocation_nodeIndexInBlock(this.__wbg_ptr);
-        return ret;
+    blockNum() {
+        const ret = wasm.noteattachmentscheme_asU32(this.__wbg_ptr);
+        return ret >>> 0;
     }
 }
 if (Symbol.dispose) NoteLocation.prototype[Symbol.dispose] = NoteLocation.prototype.free;
@@ -16415,7 +16878,8 @@ class NoteScript {
     }
     /**
      * Creates a `NoteScript` from the given `Package`.
-     * Throws if the package is invalid.
+     * The package must contain a library with exactly one procedure annotated with
+     * `@note_script`.
      * @param {Package} _package
      * @returns {NoteScript}
      */
@@ -16530,13 +16994,66 @@ class NoteStorage {
     constructor(felt_array) {
         _assertClass(felt_array, FeltArray);
         const ret = wasm.notestorage_new(felt_array.__wbg_ptr);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         NoteStorageFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
 }
 if (Symbol.dispose) NoteStorage.prototype[Symbol.dispose] = NoteStorage.prototype.free;
 
+/**
+ * Represents a single block's worth of note sync data.
+ */
+class NoteSyncBlock {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(NoteSyncBlock.prototype);
+        obj.__wbg_ptr = ptr;
+        NoteSyncBlockFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NoteSyncBlockFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_notesyncblock_free(ptr, 0);
+    }
+    /**
+     * Returns the block header for this block.
+     * @returns {BlockHeader}
+     */
+    blockHeader() {
+        const ret = wasm.notesyncblock_blockHeader(this.__wbg_ptr);
+        return BlockHeader.__wrap(ret);
+    }
+    /**
+     * Returns the MMR path for the block header.
+     * @returns {MerklePath}
+     */
+    mmrPath() {
+        const ret = wasm.notesyncblock_mmrPath(this.__wbg_ptr);
+        return MerklePath.__wrap(ret);
+    }
+    /**
+     * Returns the committed notes in this block.
+     * @returns {CommittedNote[]}
+     */
+    notes() {
+        const ret = wasm.notesyncblock_notes(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) NoteSyncBlock.prototype[Symbol.dispose] = NoteSyncBlock.prototype.free;
+
 /**
  * Represents the response data from `syncNotes`.
  */
@@ -16559,31 +17076,49 @@ class NoteSyncInfo {
         wasm.__wbg_notesyncinfo_free(ptr, 0);
     }
     /**
-     * Returns the block header associated with the matching notes.
-     * @returns {BlockHeader}
+     * Returns the first block header associated with matching notes, if any.
+     * @returns {BlockHeader | undefined}
      */
     blockHeader() {
         const ret = wasm.notesyncinfo_blockHeader(this.__wbg_ptr);
-        return BlockHeader.__wrap(ret);
+        return ret === 0 ? undefined : BlockHeader.__wrap(ret);
+    }
+    /**
+     * Returns the last block checked by the node. Used as a cursor for pagination.
+     * @returns {number}
+     */
+    blockTo() {
+        const ret = wasm.notesyncinfo_blockTo(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the blocks containing matching notes.
+     * @returns {NoteSyncBlock[]}
+     */
+    blocks() {
+        const ret = wasm.notesyncinfo_blocks(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * Returns the latest block number in the chain.
      * @returns {number}
      */
     chainTip() {
-        const ret = wasm.notesyncinfo_chainTip(this.__wbg_ptr);
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Returns the MMR path for the block header.
-     * @returns {MerklePath}
+     * Returns the first block MMR path associated with matching notes, if any.
+     * @returns {MerklePath | undefined}
      */
     mmrPath() {
         const ret = wasm.notesyncinfo_mmrPath(this.__wbg_ptr);
-        return MerklePath.__wrap(ret);
+        return ret === 0 ? undefined : MerklePath.__wrap(ret);
     }
     /**
-     * Returns the committed notes returned by the node.
+     * Returns the committed notes across all matching blocks.
      * @returns {CommittedNote[]}
      */
     notes() {
@@ -16686,7 +17221,7 @@ const NoteType = Object.freeze({
 });
 
 /**
- * Representation of a note produced by a transaction (full, partial, or header-only).
+ * Representation of a note produced by a transaction (full or partial).
  */
 class OutputNote {
     static __wrap(ptr) {
@@ -16730,16 +17265,6 @@ class OutputNote {
         const ret = wasm.outputnote_full(note.__wbg_ptr);
         return OutputNote.__wrap(ret);
     }
-    /**
-     * Wraps only the header of a note.
-     * @param {NoteHeader} note_header
-     * @returns {OutputNote}
-     */
-    static header(note_header) {
-        _assertClass(note_header, NoteHeader);
-        const ret = wasm.outputnote_header(note_header.__wbg_ptr);
-        return OutputNote.__wrap(ret);
-    }
     /**
      * Returns the note ID for this output.
      * @returns {NoteId}
@@ -16776,20 +17301,12 @@ class OutputNote {
         return OutputNote.__wrap(ret);
     }
     /**
-     * Returns the recipient digest if the recipient is known.
-     * @returns {Word | undefined}
+     * Returns the recipient digest.
+     * @returns {Word}
      */
     recipientDigest() {
         const ret = wasm.outputnote_recipientDigest(this.__wbg_ptr);
-        return ret === 0 ? undefined : Word.__wrap(ret);
-    }
-    /**
-     * Returns a more compact representation if possible (e.g. dropping details).
-     * @returns {OutputNote}
-     */
-    shrink() {
-        const ret = wasm.outputnote_shrink(this.__wbg_ptr);
-        return OutputNote.__wrap(ret);
+        return Word.__wrap(ret);
     }
 }
 if (Symbol.dispose) OutputNote.prototype[Symbol.dispose] = OutputNote.prototype.free;
@@ -16828,7 +17345,7 @@ class OutputNoteArray {
      * @returns {number}
      */
     length() {
-        const ret = wasm.outputnotearray_length(this.__wbg_ptr);
+        const ret = wasm.notearray_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -17004,12 +17521,6 @@ class OutputNotes {
         OutputNotesFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof OutputNotes)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -17056,85 +17567,15 @@ class OutputNotes {
         return v1;
     }
     /**
-     * Returns the number of notes emitted.
-     * @returns {number}
-     */
-    numNotes() {
-        const ret = wasm.outputnotes_numNotes(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) OutputNotes.prototype[Symbol.dispose] = OutputNotes.prototype.free;
-
-class OutputNotesArray {
-    toJSON() {
-        return {
-        };
-    }
-    toString() {
-        return JSON.stringify(this);
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        OutputNotesArrayFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_outputnotesarray_free(ptr, 0);
-    }
-    /**
-     * Get element at index, will always return a clone to avoid aliasing issues.
-     * @param {number} index
-     * @returns {OutputNotes}
-     */
-    get(index) {
-        const ret = wasm.outputnotesarray_get(this.__wbg_ptr, index);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return OutputNotes.__wrap(ret[0]);
-    }
-    /**
-     * @returns {number}
-     */
-    length() {
-        const ret = wasm.outputnotesarray_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @param {OutputNotes[] | null} [elements]
-     */
-    constructor(elements) {
-        var ptr0 = isLikeNone(elements) ? 0 : passArrayJsValueToWasm0(elements, wasm.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.outputnotesarray_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        OutputNotesArrayFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {OutputNotes} element
-     */
-    push(element) {
-        _assertClass(element, OutputNotes);
-        wasm.outputnotesarray_push(this.__wbg_ptr, element.__wbg_ptr);
-    }
-    /**
-     * @param {number} index
-     * @param {OutputNotes} elem
+     * Returns the number of notes emitted.
+     * @returns {number}
      */
-    replaceAt(index, elem) {
-        _assertClass(elem, OutputNotes);
-        var ptr0 = elem.__destroy_into_raw();
-        const ret = wasm.outputnotesarray_replaceAt(this.__wbg_ptr, index, ptr0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    numNotes() {
+        const ret = wasm.outputnotes_numNotes(this.__wbg_ptr);
+        return ret >>> 0;
     }
 }
-if (Symbol.dispose) OutputNotesArray.prototype[Symbol.dispose] = OutputNotesArray.prototype.free;
+if (Symbol.dispose) OutputNotes.prototype[Symbol.dispose] = OutputNotes.prototype.free;
 
 /**
  * Compiled VM package containing libraries and metadata.
@@ -17259,6 +17700,33 @@ class PartialNote {
 }
 if (Symbol.dispose) PartialNote.prototype[Symbol.dispose] = PartialNote.prototype.free;
 
+/**
+ * Poseidon2 hashing helpers exposed to JavaScript.
+ */
+class Poseidon2 {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Poseidon2Finalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_poseidon2_free(ptr, 0);
+    }
+    /**
+     * Computes a Poseidon2 digest from the provided field elements.
+     * @param {FeltArray} felt_array
+     * @returns {Word}
+     */
+    static hashElements(felt_array) {
+        _assertClass(felt_array, FeltArray);
+        const ret = wasm.poseidon2_hashElements(felt_array.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Poseidon2.prototype[Symbol.dispose] = Poseidon2.prototype.free;
+
 class ProcedureThreshold {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -17359,7 +17827,7 @@ class ProvenTransaction {
      * @returns {AccountId}
      */
     accountId() {
-        const ret = wasm.proventransaction_accountId(this.__wbg_ptr);
+        const ret = wasm.account_id(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
     /**
@@ -17387,7 +17855,7 @@ class ProvenTransaction {
      * @returns {TransactionId}
      */
     id() {
-        const ret = wasm.proventransaction_id(this.__wbg_ptr);
+        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
         return TransactionId.__wrap(ret);
     }
     /**
@@ -17400,20 +17868,12 @@ class ProvenTransaction {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
-    /**
-     * Returns notes created by this transaction.
-     * @returns {OutputNotes}
-     */
-    outputNotes() {
-        const ret = wasm.proventransaction_outputNotes(this.__wbg_ptr);
-        return OutputNotes.__wrap(ret);
-    }
     /**
      * Returns the commitment of the reference block.
      * @returns {Word}
      */
     refBlockCommitment() {
-        const ret = wasm.proventransaction_refBlockCommitment(this.__wbg_ptr);
+        const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -17551,20 +18011,44 @@ class RpcClient {
      * Fetches an account proof from the node.
      *
      * This is a lighter-weight alternative to `getAccountDetails` that makes a single RPC call
-     * and returns the account proof and, for public accounts, the account header, storage slot
-     * values, and account code without reconstructing the full account state.
+     * and returns the account proof alongside the account header, storage slot values, and
+     * account code without reconstructing the full account state.
      *
      * For private accounts, the proof is returned but account details will not be available
      * since they are not stored on-chain.
      *
-     * Useful for reading storage slot values (e.g., faucet metadata) without the overhead of
-     * fetching the complete account with all vault assets and storage map entries.
+     * Useful for reading storage slot values (e.g., faucet metadata) or specific storage map
+     * entries without the overhead of fetching the complete account with all vault assets and
+     * storage map entries.
+     *
+     * @param `account_id` - The account to fetch the proof for.
+     * @param `storage_requirements` - Optional storage requirements specifying which storage
+     *   maps and keys to include. When `undefined`, no storage map data is requested.
+     * @param `block_num` - Optional block number to fetch the account state at. When `undefined`,
+     *   fetches the latest state (chain tip).
+     * @param `known_vault_commitment` - Optional known vault commitment. When provided,
+     *   vault data is returned only if the account's current vault root differs from this
+     *   value. Use `Word.new([0, 0, 0, 0])` to always fetch. When `undefined`, vault data
+     *   is not requested.
      * @param {AccountId} account_id
+     * @param {AccountStorageRequirements | null} [storage_requirements]
+     * @param {number | null} [block_num]
+     * @param {Word | null} [known_vault_commitment]
      * @returns {Promise<AccountProof>}
      */
-    getAccountProof(account_id) {
+    getAccountProof(account_id, storage_requirements, block_num, known_vault_commitment) {
         _assertClass(account_id, AccountId);
-        const ret = wasm.rpcclient_getAccountProof(this.__wbg_ptr, account_id.__wbg_ptr);
+        let ptr0 = 0;
+        if (!isLikeNone(storage_requirements)) {
+            _assertClass(storage_requirements, AccountStorageRequirements);
+            ptr0 = storage_requirements.__destroy_into_raw();
+        }
+        let ptr1 = 0;
+        if (!isLikeNone(known_vault_commitment)) {
+            _assertClass(known_vault_commitment, Word);
+            ptr1 = known_vault_commitment.__destroy_into_raw();
+        }
+        const ret = wasm.rpcclient_getAccountProof(this.__wbg_ptr, account_id.__wbg_ptr, ptr0, isLikeNone(block_num) ? 0x100000001 : (block_num) >>> 0, ptr1);
         return ret;
     }
     /**
@@ -17647,6 +18131,26 @@ class RpcClient {
         const ret = wasm.rpcclient_syncNotes(this.__wbg_ptr, block_num, isLikeNone(block_to) ? 0x100000001 : (block_to) >>> 0, ptr0, len0);
         return ret;
     }
+    /**
+     * Syncs storage map updates for an account within a block range.
+     *
+     * This is used when `AccountProof.hasStorageMapTooManyEntries()` returns `true` for a
+     * slot, indicating the storage map was too large to return inline. This endpoint fetches
+     * the full storage map data with pagination support.
+     *
+     * @param `block_from` - The starting block number.
+     * @param `block_to` - Optional ending block number. When `undefined`, syncs to chain tip.
+     * @param `account_id` - The account to sync storage maps for.
+     * @param {number} block_from
+     * @param {number | null | undefined} block_to
+     * @param {AccountId} account_id
+     * @returns {Promise<StorageMapInfo>}
+     */
+    syncStorageMaps(block_from, block_to, account_id) {
+        _assertClass(account_id, AccountId);
+        const ret = wasm.rpcclient_syncStorageMaps(this.__wbg_ptr, block_from, isLikeNone(block_to) ? 0x100000001 : (block_to) >>> 0, account_id.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) RpcClient.prototype[Symbol.dispose] = RpcClient.prototype.free;
 
@@ -17701,6 +18205,32 @@ class SerializedInputNoteData {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_serializedinputnotedata_free(ptr, 0);
     }
+    /**
+     * @returns {number | undefined}
+     */
+    get consumedBlockHeight() {
+        const ret = wasm.__wbg_get_serializedinputnotedata_consumedBlockHeight(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get consumedTxOrder() {
+        const ret = wasm.__wbg_get_serializedinputnotedata_consumedTxOrder(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get consumerAccountId() {
+        const ret = wasm.__wbg_get_serializedinputnotedata_consumerAccountId(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * @returns {string}
      */
@@ -17813,13 +18343,33 @@ class SerializedInputNoteData {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set consumedBlockHeight(arg0) {
+        wasm.__wbg_set_serializedinputnotedata_consumedBlockHeight(this.__wbg_ptr, isLikeNone(arg0) ? 0x100000001 : (arg0) >>> 0);
+    }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set consumedTxOrder(arg0) {
+        wasm.__wbg_set_serializedinputnotedata_consumedTxOrder(this.__wbg_ptr, isLikeNone(arg0) ? 0x100000001 : (arg0) >>> 0);
+    }
+    /**
+     * @param {string | null} [arg0]
+     */
+    set consumerAccountId(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_serializedinputnotedata_consumerAccountId(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {string} arg0
      */
     set createdAt(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsaccountupdate_accountCommitment(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedinputnotedata_createdAt(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array} arg0
@@ -17843,7 +18393,7 @@ class SerializedInputNoteData {
     set noteId(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsaccountupdate_storageRoot(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedinputnotedata_noteId(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {string} arg0
@@ -17859,7 +18409,7 @@ class SerializedInputNoteData {
     set noteScript(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstatesyncupdate_blockHasRelevantNotes(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedinputnotedata_noteScript(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {string} arg0
@@ -17867,7 +18417,7 @@ class SerializedInputNoteData {
     set nullifier(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsaccountupdate_codeRoot(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedinputnotedata_nullifier(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array} arg0
@@ -18013,7 +18563,7 @@ class SerializedOutputNoteData {
     set metadata(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedinputnotedata_inputs(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedoutputnotedata_metadata(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array} arg0
@@ -18021,7 +18571,7 @@ class SerializedOutputNoteData {
     set noteAssets(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedinputnotedata_noteAssets(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedoutputnotedata_noteAssets(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {string} arg0
@@ -18171,7 +18721,7 @@ class SerializedTransactionData {
     set details(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedinputnotedata_noteAssets(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedoutputnotedata_noteAssets(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {string} arg0
@@ -18201,7 +18751,7 @@ class SerializedTransactionData {
     set status(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedinputnotedata_serialNumber(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedtransactiondata_status(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array | null} [arg0]
@@ -18592,6 +19142,165 @@ class StorageMap {
 }
 if (Symbol.dispose) StorageMap.prototype[Symbol.dispose] = StorageMap.prototype.free;
 
+/**
+ * A key-value entry from a storage map.
+ */
+class StorageMapEntry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StorageMapEntry.prototype);
+        obj.__wbg_ptr = ptr;
+        StorageMapEntryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StorageMapEntryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storagemapentry_free(ptr, 0);
+    }
+    /**
+     * Returns the storage map key.
+     * @returns {Word}
+     */
+    key() {
+        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
+    /**
+     * Returns the storage map value.
+     * @returns {Word}
+     */
+    value() {
+        const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
+}
+if (Symbol.dispose) StorageMapEntry.prototype[Symbol.dispose] = StorageMapEntry.prototype.free;
+
+/**
+ * Information about storage map updates for an account, as returned by the
+ * `syncStorageMaps` RPC endpoint.
+ *
+ * Contains the list of storage map updates within the requested block range,
+ * along with the chain tip and last processed block number.
+ */
+class StorageMapInfo {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StorageMapInfo.prototype);
+        obj.__wbg_ptr = ptr;
+        StorageMapInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StorageMapInfoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storagemapinfo_free(ptr, 0);
+    }
+    /**
+     * Returns the block number of the last check included in this response.
+     * @returns {number}
+     */
+    blockNumber() {
+        const ret = wasm.notesyncinfo_blockTo(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the current chain tip block number.
+     * @returns {number}
+     */
+    chainTip() {
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the list of storage map updates.
+     * @returns {StorageMapUpdate[]}
+     */
+    updates() {
+        const ret = wasm.storagemapinfo_updates(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) StorageMapInfo.prototype[Symbol.dispose] = StorageMapInfo.prototype.free;
+
+/**
+ * A single storage map update entry, containing the block number, slot name,
+ * key, and new value.
+ */
+class StorageMapUpdate {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StorageMapUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        StorageMapUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StorageMapUpdateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storagemapupdate_free(ptr, 0);
+    }
+    /**
+     * Returns the block number in which this update occurred.
+     * @returns {number}
+     */
+    blockNum() {
+        const ret = wasm.storagemapupdate_blockNum(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the storage map key that was updated.
+     * @returns {Word}
+     */
+    key() {
+        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
+    /**
+     * Returns the name of the storage slot that was updated.
+     * @returns {string}
+     */
+    slotName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.storagemapupdate_slotName(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the new value for this storage map key.
+     * @returns {Word}
+     */
+    value() {
+        const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
+    }
+}
+if (Symbol.dispose) StorageMapUpdate.prototype[Symbol.dispose] = StorageMapUpdate.prototype.free;
+
 /**
  * A single storage slot value or map for an account component.
  */
@@ -18908,21 +19617,15 @@ class TokenSymbol {
      * @returns {string}
      */
     toString() {
-        let deferred2_0;
-        let deferred2_1;
+        let deferred1_0;
+        let deferred1_1;
         try {
             const ret = wasm.tokensymbol_toString(this.__wbg_ptr);
-            var ptr1 = ret[0];
-            var len1 = ret[1];
-            if (ret[3]) {
-                ptr1 = 0; len1 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred2_0 = ptr1;
-            deferred2_1 = len1;
-            return getStringFromWasm0(ptr1, len1);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
 }
@@ -19547,6 +20250,16 @@ class TransactionRequestBuilder {
         const ret = wasm.transactionrequestbuilder_withExpectedOutputRecipients(ptr, recipients.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
+    /**
+     * Sets the maximum number of blocks until the transaction request expires.
+     * @param {number} expiration_delta
+     * @returns {TransactionRequestBuilder}
+     */
+    withExpirationDelta(expiration_delta) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withExpirationDelta(ptr, expiration_delta);
+        return TransactionRequestBuilder.__wrap(ret);
+    }
     /**
      * Registers foreign accounts referenced by the transaction.
      * @param {ForeignAccountArray} foreign_accounts
@@ -19570,13 +20283,13 @@ class TransactionRequestBuilder {
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
-     * Adds notes created by the sender that should be emitted by the transaction.
-     * @param {OutputNoteArray} notes
+     * Adds output notes created by the sender that should be emitted by the transaction.
+     * @param {NoteArray} notes
      * @returns {TransactionRequestBuilder}
      */
     withOwnOutputNotes(notes) {
         const ptr = this.__destroy_into_raw();
-        _assertClass(notes, OutputNoteArray);
+        _assertClass(notes, NoteArray);
         const ret = wasm.transactionrequestbuilder_withOwnOutputNotes(ptr, notes.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
@@ -19813,7 +20526,7 @@ class TransactionScriptInputPairArray {
      * @returns {number}
      */
     length() {
-        const ret = wasm.outputnotesarray_length(this.__wbg_ptr);
+        const ret = wasm.transactionscriptinputpairarray_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -19889,7 +20602,10 @@ class TransactionStatus {
         const ptr0 = passStringToWasm0(cause, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.transactionstatus_discarded(ptr0, len0);
-        return TransactionStatus.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionStatus.__wrap(ret[0]);
     }
     /**
      * Returns the block number if the transaction was committed.
@@ -19973,7 +20689,7 @@ class TransactionStoreUpdate {
         return AccountDelta.__wrap(ret);
     }
     /**
-     * Returns the notes created by the transaction.
+     * Returns the output notes created by the transaction.
      * @returns {OutputNotes}
      */
     createdNotes() {
@@ -20162,17 +20878,6 @@ class WebClient {
         }
         return AccountReader.__wrap(ret[0]);
     }
-    /**
-     * @param {AccountId} account_id
-     * @param {AuthSecretKey} secret_key
-     * @returns {Promise<void>}
-     */
-    addAccountSecretKeyToWebStore(account_id, secret_key) {
-        _assertClass(account_id, AccountId);
-        _assertClass(secret_key, AuthSecretKey);
-        const ret = wasm.webclient_addAccountSecretKeyToWebStore(this.__wbg_ptr, account_id.__wbg_ptr, secret_key.__wbg_ptr);
-        return ret;
-    }
     /**
      * @param {string} tag
      * @returns {Promise<void>}
@@ -20224,9 +20929,10 @@ class WebClient {
      * @param {string | null} [node_note_transport_url]
      * @param {Uint8Array | null} [seed]
      * @param {string | null} [store_name]
+     * @param {boolean | null} [debug_mode]
      * @returns {Promise<any>}
      */
-    createClient(node_url, node_note_transport_url, seed, store_name) {
+    createClient(node_url, node_note_transport_url, seed, store_name, debug_mode) {
         var ptr0 = isLikeNone(node_url) ? 0 : passStringToWasm0(node_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(node_note_transport_url) ? 0 : passStringToWasm0(node_note_transport_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -20235,7 +20941,7 @@ class WebClient {
         var len2 = WASM_VECTOR_LEN;
         var ptr3 = isLikeNone(store_name) ? 0 : passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len3 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_createClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        const ret = wasm.webclient_createClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(debug_mode) ? 0xFFFFFF : debug_mode ? 1 : 0);
         return ret;
     }
     /**
@@ -20258,9 +20964,10 @@ class WebClient {
      * @param {Function | null} [get_key_cb]
      * @param {Function | null} [insert_key_cb]
      * @param {Function | null} [sign_cb]
+     * @param {boolean | null} [debug_mode]
      * @returns {Promise<any>}
      */
-    createClientWithExternalKeystore(node_url, node_note_transport_url, seed, store_name, get_key_cb, insert_key_cb, sign_cb) {
+    createClientWithExternalKeystore(node_url, node_note_transport_url, seed, store_name, get_key_cb, insert_key_cb, sign_cb, debug_mode) {
         var ptr0 = isLikeNone(node_url) ? 0 : passStringToWasm0(node_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(node_note_transport_url) ? 0 : passStringToWasm0(node_note_transport_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -20269,7 +20976,7 @@ class WebClient {
         var len2 = WASM_VECTOR_LEN;
         var ptr3 = isLikeNone(store_name) ? 0 : passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len3 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_createClientWithExternalKeystore(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(get_key_cb) ? 0 : addToExternrefTable0(get_key_cb), isLikeNone(insert_key_cb) ? 0 : addToExternrefTable0(insert_key_cb), isLikeNone(sign_cb) ? 0 : addToExternrefTable0(sign_cb));
+        const ret = wasm.webclient_createClientWithExternalKeystore(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(get_key_cb) ? 0 : addToExternrefTable0(get_key_cb), isLikeNone(insert_key_cb) ? 0 : addToExternrefTable0(insert_key_cb), isLikeNone(sign_cb) ? 0 : addToExternrefTable0(sign_cb), isLikeNone(debug_mode) ? 0xFFFFFF : debug_mode ? 1 : 0);
         return ret;
     }
     /**
@@ -20311,13 +21018,31 @@ class WebClient {
      * # Errors
      * - If there is an internal failure during execution.
      * @param {AccountId} account_id
-     * @param {TransactionRequest} transaction_request
-     * @returns {Promise<TransactionSummary>}
+     * @param {TransactionRequest} transaction_request
+     * @returns {Promise<TransactionSummary>}
+     */
+    executeForSummary(account_id, transaction_request) {
+        _assertClass(account_id, AccountId);
+        _assertClass(transaction_request, TransactionRequest);
+        const ret = wasm.webclient_executeForSummary(this.__wbg_ptr, account_id.__wbg_ptr, transaction_request.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Executes the provided transaction script against the specified account
+     * and returns the resulting stack output. This is a local-only "view call"
+     * that does not submit anything to the network.
+     * @param {AccountId} account_id
+     * @param {TransactionScript} tx_script
+     * @param {AdviceInputs} advice_inputs
+     * @param {ForeignAccountArray} foreign_accounts
+     * @returns {Promise<FeltArray>}
      */
-    executeForSummary(account_id, transaction_request) {
+    executeProgram(account_id, tx_script, advice_inputs, foreign_accounts) {
         _assertClass(account_id, AccountId);
-        _assertClass(transaction_request, TransactionRequest);
-        const ret = wasm.webclient_executeForSummary(this.__wbg_ptr, account_id.__wbg_ptr, transaction_request.__wbg_ptr);
+        _assertClass(tx_script, TransactionScript);
+        _assertClass(advice_inputs, AdviceInputs);
+        _assertClass(foreign_accounts, ForeignAccountArray);
+        const ret = wasm.webclient_executeProgram(this.__wbg_ptr, account_id.__wbg_ptr, tx_script.__wbg_ptr, advice_inputs.__wbg_ptr, foreign_accounts.__wbg_ptr);
         return ret;
     }
     /**
@@ -20358,16 +21083,6 @@ class WebClient {
         const ret = wasm.webclient_exportNoteFile(this.__wbg_ptr, ptr0, len0, export_format);
         return ret;
     }
-    /**
-     * Retrieves the entire underlying web store and returns it as a `JsValue`
-     *
-     * Meant to be used in conjunction with the `force_import_store` method
-     * @returns {Promise<any>}
-     */
-    exportStore() {
-        const ret = wasm.webclient_exportStore(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Fetch all private notes from the note transport layer
      *
@@ -20390,17 +21105,6 @@ class WebClient {
         const ret = wasm.webclient_fetchPrivateNotes(this.__wbg_ptr);
         return ret;
     }
-    /**
-     * @param {any} store_dump
-     * @param {string} _store_name
-     * @returns {Promise<any>}
-     */
-    forceImportStore(store_dump, _store_name) {
-        const ptr0 = passStringToWasm0(_store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_forceImportStore(this.__wbg_ptr, store_dump, ptr0, len0);
-        return ret;
-    }
     /**
      * Retrieves the full account data for the given account ID, returning `null` if not found.
      *
@@ -20413,30 +21117,6 @@ class WebClient {
         const ret = wasm.webclient_getAccount(this.__wbg_ptr, account_id.__wbg_ptr);
         return ret;
     }
-    /**
-     * Retrieves an authentication secret key from the keystore given a public key commitment.
-     *
-     * The public key commitment should correspond to one of the keys tracked by the keystore.
-     * Returns the associated [`AuthSecretKey`] if found, or an error if not found.
-     * @param {Word} pub_key_commitment
-     * @returns {Promise<AuthSecretKey>}
-     */
-    getAccountAuthByPubKeyCommitment(pub_key_commitment) {
-        _assertClass(pub_key_commitment, Word);
-        const ret = wasm.webclient_getAccountAuthByPubKeyCommitment(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Retrieves the full account data for the account associated with the given public key
-     * commitment, returning `null` if no account is found.
-     * @param {Word} pub_key_commitment
-     * @returns {Promise<Account | undefined>}
-     */
-    getAccountByKeyCommitment(pub_key_commitment) {
-        _assertClass(pub_key_commitment, Word);
-        const ret = wasm.webclient_getAccountByKeyCommitment(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
-        return ret;
-    }
     /**
      * Retrieves the account code for a specific account.
      *
@@ -20533,19 +21213,6 @@ class WebClient {
         const ret = wasm.webclient_getOutputNotes(this.__wbg_ptr, ptr0);
         return ret;
     }
-    /**
-     * Returns all public key commitments associated with the given account ID.
-     *
-     * These commitments can be used with [`getAccountAuthByPubKeyCommitment`]
-     * to retrieve the corresponding secret keys from the keystore.
-     * @param {AccountId} account_id
-     * @returns {Promise<Word[]>}
-     */
-    getPublicKeyCommitmentsOfAccount(account_id) {
-        _assertClass(account_id, AccountId);
-        const ret = wasm.webclient_getPublicKeyCommitmentsOfAccount(this.__wbg_ptr, account_id.__wbg_ptr);
-        return ret;
-    }
     /**
      * Retrieves the setting value for `key`, or `None` if it hasn’t been set.
      * @param {string} key
@@ -20626,6 +21293,19 @@ class WebClient {
         const ret = wasm.webclient_insertAccountAddress(this.__wbg_ptr, account_id.__wbg_ptr, address.__wbg_ptr);
         return ret;
     }
+    /**
+     * Returns a `WebKeystoreApi` handle for managing secret keys.
+     *
+     * The returned object can be used from JavaScript as `client.keystore`.
+     * @returns {WebKeystoreApi}
+     */
+    get keystore() {
+        const ret = wasm.webclient_keystore(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WebKeystoreApi.__wrap(ret[0]);
+    }
     /**
      * Returns all the existing setting keys from the store.
      * @returns {Promise<string[]>}
@@ -20657,6 +21337,21 @@ class WebClient {
         const ret = wasm.webclient_newAccount(this.__wbg_ptr, account.__wbg_ptr, overwrite);
         return ret;
     }
+    /**
+     * Inserts an account and its secret key in one call, matching how
+     * `newWallet` / `newFaucet` already work internally.  If the key
+     * insertion fails the account is still persisted (same as wallet/faucet),
+     * but callers only need a single await instead of two.
+     * @param {Account} account
+     * @param {AuthSecretKey} secret_key
+     * @returns {Promise<void>}
+     */
+    newAccountWithSecretKey(account, secret_key) {
+        _assertClass(account, Account);
+        _assertClass(secret_key, AuthSecretKey);
+        const ret = wasm.webclient_newAccountWithSecretKey(this.__wbg_ptr, account.__wbg_ptr, secret_key.__wbg_ptr);
+        return ret;
+    }
     /**
      * @param {Note[]} list_of_notes
      * @returns {TransactionRequest}
@@ -20779,6 +21474,24 @@ class WebClient {
         const ret = wasm.webclient_proveTransaction(this.__wbg_ptr, transaction_result.__wbg_ptr, ptr0);
         return ret;
     }
+    /**
+     * Prunes historical account states for the specified account up to the given nonce.
+     *
+     * Deletes all historical entries with `replaced_at_nonce <= up_to_nonce` and any
+     * orphaned account code.
+     *
+     * Returns the total number of rows deleted, including historical entries and orphaned
+     * account code.
+     * @param {AccountId} account_id
+     * @param {Felt} up_to_nonce
+     * @returns {Promise<number>}
+     */
+    pruneAccountHistory(account_id, up_to_nonce) {
+        _assertClass(account_id, AccountId);
+        _assertClass(up_to_nonce, Felt);
+        const ret = wasm.webclient_pruneAccountHistory(this.__wbg_ptr, account_id.__wbg_ptr, up_to_nonce.__wbg_ptr);
+        return ret;
+    }
     /**
      * @param {AccountId} account_id
      * @param {Address} address
@@ -20851,19 +21564,6 @@ class WebClient {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
-    /**
-     * Sets the debug mode for transaction execution.
-     *
-     * When enabled, the transaction executor will record additional information useful for
-     * debugging (the values on the VM stack and the state of the advice provider). This is
-     * disabled by default since it adds overhead.
-     *
-     * Must be called before `createClient`.
-     * @param {boolean} enabled
-     */
-    setDebugMode(enabled) {
-        wasm.webclient_setDebugMode(this.__wbg_ptr, enabled);
-    }
     /**
      * Sets a setting key-value in the store. It can then be retrieved using `get_setting`.
      * @param {string} key
@@ -20876,6 +21576,28 @@ class WebClient {
         const ret = wasm.webclient_setSetting(this.__wbg_ptr, ptr0, len0, value);
         return ret;
     }
+    /**
+     * Returns the identifier of the underlying store (e.g. `IndexedDB` database name, file path).
+     * @returns {string}
+     */
+    storeIdentifier() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.webclient_storeIdentifier(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Executes a transaction specified by the request against the specified account,
      * proves it, submits it to the network, and updates the local database.
@@ -20949,6 +21671,88 @@ class WebClient {
 }
 if (Symbol.dispose) WebClient.prototype[Symbol.dispose] = WebClient.prototype.free;
 
+/**
+ * JavaScript API for the client's keystore.
+ *
+ * Manages the association between accounts and their authentication secret keys,
+ * indexed by public key commitment.
+ */
+class WebKeystoreApi {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WebKeystoreApi.prototype);
+        obj.__wbg_ptr = ptr;
+        WebKeystoreApiFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WebKeystoreApiFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_webkeystoreapi_free(ptr, 0);
+    }
+    /**
+     * Retrieves a secret key from the keystore given a public key commitment.
+     *
+     * Returns the associated `AuthSecretKey` if found, or `null` if not found.
+     * @param {Word} pub_key_commitment
+     * @returns {Promise<AuthSecretKey | undefined>}
+     */
+    get(pub_key_commitment) {
+        _assertClass(pub_key_commitment, Word);
+        const ret = wasm.webkeystoreapi_get(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the account ID associated with a given public key commitment,
+     * or `null` if no account is found.
+     * @param {Word} pub_key_commitment
+     * @returns {Promise<AccountId | undefined>}
+     */
+    getAccountId(pub_key_commitment) {
+        _assertClass(pub_key_commitment, Word);
+        const ret = wasm.webkeystoreapi_getAccountId(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns all public key commitments associated with the given account ID.
+     * @param {AccountId} account_id
+     * @returns {Promise<Word[]>}
+     */
+    getCommitments(account_id) {
+        _assertClass(account_id, AccountId);
+        const ret = wasm.webkeystoreapi_getCommitments(this.__wbg_ptr, account_id.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Inserts a secret key into the keystore, associating it with the given account ID.
+     * @param {AccountId} account_id
+     * @param {AuthSecretKey} secret_key
+     * @returns {Promise<void>}
+     */
+    insert(account_id, secret_key) {
+        _assertClass(account_id, AccountId);
+        _assertClass(secret_key, AuthSecretKey);
+        const ret = wasm.webkeystoreapi_insert(this.__wbg_ptr, account_id.__wbg_ptr, secret_key.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Removes a key from the keystore by its public key commitment.
+     * @param {Word} pub_key_commitment
+     * @returns {Promise<void>}
+     */
+    remove(pub_key_commitment) {
+        _assertClass(pub_key_commitment, Word);
+        const ret = wasm.webkeystoreapi_remove(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) WebKeystoreApi.prototype[Symbol.dispose] = WebKeystoreApi.prototype.free;
+
 class Word {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -21085,6 +21889,37 @@ function createAuthFalcon512RpoMultisig(config) {
     return AccountComponent.__wrap(ret[0]);
 }
 
+/**
+ * Exports the entire contents of an `IndexedDB` store as a JSON string.
+ *
+ * Use together with [`import_store`].
+ * @param {string} store_name
+ * @returns {Promise<any>}
+ */
+function exportStore2(store_name) {
+    const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.exportStore(ptr0, len0);
+    return ret;
+}
+
+/**
+ * Imports store contents from a JSON string, replacing all existing data.
+ *
+ * Use together with [`export_store`].
+ * @param {string} store_name
+ * @param {string} store_dump
+ * @returns {Promise<void>}
+ */
+function importStore(store_name, store_dump) {
+    const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(store_dump, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.importStore(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
 /**
  * Initializes the `tracing` subscriber that routes Rust log output to the
  * browser console via `console.log` / `console.warn` / `console.error`.
@@ -21239,7 +22074,7 @@ function __wbg_get_imports() {
             const ret = AccountStorage.__wrap(arg0);
             return ret;
         },
-        __wbg_addNoteTag_efc29b142a73d6b5: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_addNoteTag_73f23a831a6e3b6a: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -21262,15 +22097,15 @@ function __wbg_get_imports() {
         __wbg_append_a992ccc37aa62dc4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
-        __wbg_applyFullAccountState_91cdb076ae7bb2d3: function(arg0, arg1, arg2) {
+        __wbg_applyFullAccountState_0d845d902fcf8977: function(arg0, arg1, arg2) {
             const ret = applyFullAccountState(getStringFromWasm0(arg0, arg1), JsAccountUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyStateSync_2e469b0d244a1de9: function(arg0, arg1, arg2) {
+        __wbg_applyStateSync_1bcd5a63e003b122: function(arg0, arg1, arg2) {
             const ret = applyStateSync(getStringFromWasm0(arg0, arg1), JsStateSyncUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyTransactionDelta_25cf3f35c06ea5ee: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22) {
+        __wbg_applyTransactionDelta_e3969ada5c15edfa: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -21302,12 +22137,7 @@ function __wbg_get_imports() {
                 deferred7_1 = arg17;
                 deferred8_0 = arg19;
                 deferred8_1 = arg20;
-                let v9;
-                if (arg21 !== 0) {
-                    v9 = getArrayU8FromWasm0(arg21, arg22).slice();
-                    wasm.__wbindgen_free(arg21, arg22 * 1, 1);
-                }
-                const ret = applyTransactionDelta(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), v2, v3, v4, getStringFromWasm0(arg12, arg13), getStringFromWasm0(arg14, arg15), getStringFromWasm0(arg16, arg17), arg18 !== 0, getStringFromWasm0(arg19, arg20), v9);
+                const ret = applyTransactionDelta(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), v2, v3, v4, getStringFromWasm0(arg12, arg13), getStringFromWasm0(arg14, arg15), getStringFromWasm0(arg16, arg17), arg18 !== 0, getStringFromWasm0(arg19, arg20));
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
@@ -21370,6 +22200,10 @@ function __wbg_get_imports() {
             const ret = arg0.catch(arg1);
             return ret;
         },
+        __wbg_clearTimeout_5a54f8841c30079a: function(arg0) {
+            const ret = clearTimeout(arg0);
+            return ret;
+        },
         __wbg_clearTimeout_a7df70ff6fb2f0a7: function(arg0) {
             const ret = clearTimeout(arg0);
             return ret;
@@ -21406,7 +22240,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_exportStore_1b743c9e10508cfe: function(arg0, arg1) {
+        __wbg_exportStore_67cb33e10694e807: function(arg0, arg1) {
             const ret = exportStore(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21418,6 +22252,10 @@ function __wbg_get_imports() {
             const ret = Felt.__unwrap(arg0);
             return ret;
         },
+        __wbg_feltarray_new: function(arg0) {
+            const ret = FeltArray.__wrap(arg0);
+            return ret;
+        },
         __wbg_fetch_a720bfbbf7f6c776: function(arg0, arg1) {
             const ret = fetch(arg0, arg1);
             return ret;
@@ -21434,7 +22272,7 @@ function __wbg_get_imports() {
             const ret = FetchedNote.__wrap(arg0);
             return ret;
         },
-        __wbg_forceImportStore_a8904d160da76801: function(arg0, arg1, arg2) {
+        __wbg_forceImportStore_680f1469df7413c7: function(arg0, arg1, arg2) {
             const ret = forceImportStore(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         },
@@ -21454,7 +22292,7 @@ function __wbg_get_imports() {
             const ret = FungibleAssetDeltaItem.__wrap(arg0);
             return ret;
         },
-        __wbg_getAccountAddresses_133a2ad6e2756c6d: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAddresses_8baffdc3eeb998cf: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21466,7 +22304,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountAuthByPubKeyCommitment_89a3eb2895839850: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAuthByPubKeyCommitment_e43b4fa523c75690: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21478,7 +22316,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountCode_247ea1120858e185: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountCode_2c01e0b1d6e4c0c4: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21490,7 +22328,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeaderByCommitment_dafd1690e2da41ce: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeaderByCommitment_1937c881a4ffe36d: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21502,7 +22340,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeader_dfea2900ab1ca37d: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeader_31cd380543ca54bb: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21514,7 +22352,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIdByKeyCommitment_249eb4f5f0ceaf2f: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountIdByKeyCommitment_7e1627233d417ef0: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21526,11 +22364,11 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIds_2b0e5c260b7b77b1: function(arg0, arg1) {
+        __wbg_getAccountIds_880fce01ae9ed908: function(arg0, arg1) {
             const ret = getAccountIds(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getAccountStorageMaps_b14d35f7e5753f26: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorageMaps_77f9e51e9f936384: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21542,65 +22380,83 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountStorage_4dde9ce45b96b2b2: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorage_b81f8fc1f4174bf4: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                const ret = getAccountStorage(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+                var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
+                wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+                const ret = getAccountStorage(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountVaultAssets_d969b408c93ee997: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountVaultAssets_3aaa86634b9c362e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                const ret = getAccountVaultAssets(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+                var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
+                wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+                const ret = getAccountVaultAssets(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAllAccountHeaders_7e3365d810a2e370: function(arg0, arg1) {
+        __wbg_getAllAccountHeaders_de7adaa6ce6f8022: function(arg0, arg1) {
             const ret = getAllAccountHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getBlockHeaders_519c1498bc872874: function(arg0, arg1, arg2, arg3) {
+        __wbg_getBlockHeaders_1a3602f84753a649: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayU32FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getBlockHeaders(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getForeignAccountCode_6aa0c1b0082719b6: function(arg0, arg1, arg2, arg3) {
+        __wbg_getForeignAccountCode_dcbbf63304933fb9: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getForeignAccountCode(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getInputNotesFromIds_f022ef6d1dd215c2: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNoteByOffset_afd8189342d490ba: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
+                wasm.__wbindgen_free(arg2, arg3 * 1, 1);
+                deferred1_0 = arg4;
+                deferred1_1 = arg5;
+                const ret = getInputNoteByOffset(getStringFromWasm0(arg0, arg1), v0, getStringFromWasm0(arg4, arg5), arg6 === 0x100000001 ? undefined : arg6, arg7 === 0x100000001 ? undefined : arg7, arg8 >>> 0);
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        },
+        __wbg_getInputNotesFromIds_e24a7b2888455307: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getInputNotesFromIds(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getInputNotesFromNullifiers_cbfc1607a1a87d82: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromNullifiers_96cb2e010b7806d6: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getInputNotesFromNullifiers(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getInputNotes_068a27f44d1be31e: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotes_51ceedc136efe8a5: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             const ret = getInputNotes(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getKeyCommitmentsByAccountId_437e1c1e5b346fef: function(arg0, arg1, arg2, arg3) {
+        __wbg_getKeyCommitmentsByAccountId_e7f6c3397b516c99: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21612,7 +22468,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteScript_b32565b4d2a8defe: function(arg0, arg1, arg2, arg3) {
+        __wbg_getNoteScript_ebcab1b756e132b7: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21624,33 +22480,33 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteTags_69f70452ebe653e0: function(arg0, arg1) {
+        __wbg_getNoteTags_430e9c90b199fcaf: function(arg0, arg1) {
             const ret = getNoteTags(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getOutputNotesFromIds_add68eb6b875f350: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromIds_5e6d42b0b3a25b4b: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getOutputNotesFromIds(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getOutputNotesFromNullifiers_71de1015fc31cd73: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromNullifiers_5a9fc255157b6fbd: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getOutputNotesFromNullifiers(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getOutputNotes_b9b4838d8ce2bad9: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotes_4809f2cd6485ad68: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             const ret = getOutputNotes(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getPartialBlockchainNodesAll_d2af4071dc8cedb8: function(arg0, arg1) {
+        __wbg_getPartialBlockchainNodesAll_674fcd3d1955cfaa: function(arg0, arg1) {
             const ret = getPartialBlockchainNodesAll(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getPartialBlockchainNodesUpToInOrderIndex_1dbcd2f21ceeadfd: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodesUpToInOrderIndex_ce09946942839df4: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21662,13 +22518,13 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getPartialBlockchainNodes_984c99245879ddec: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodes_8a5579c21093ba83: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getPartialBlockchainPeaksByBlockNum_9b9b947180ea98e4: function(arg0, arg1, arg2) {
+        __wbg_getPartialBlockchainPeaksByBlockNum_d6eeb9e6a1fba098: function(arg0, arg1, arg2) {
             const ret = getPartialBlockchainPeaksByBlockNum(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
             return ret;
         },
@@ -21679,7 +22535,7 @@ function __wbg_get_imports() {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_getSetting_07289fb0de7071ea: function(arg0, arg1, arg2, arg3) {
+        __wbg_getSetting_1d08025676323ba9: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21691,7 +22547,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getSyncHeight_65a39f243469e871: function(arg0, arg1) {
+        __wbg_getSyncHeight_945bdd99f3962099: function(arg0, arg1) {
             const ret = getSyncHeight(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21699,11 +22555,15 @@ function __wbg_get_imports() {
             const ret = arg0.getTime();
             return ret;
         },
-        __wbg_getTrackedBlockHeaders_c5224ff3bd62243b: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaderNumbers_63af295c749079e4: function(arg0, arg1) {
+            const ret = getTrackedBlockHeaderNumbers(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_getTrackedBlockHeaders_3e40bc541ec5a490: function(arg0, arg1) {
             const ret = getTrackedBlockHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTransactions_7040a5a0a4d7cc1e: function(arg0, arg1, arg2, arg3) {
+        __wbg_getTransactions_3cd589dfbcd48460: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21715,7 +22575,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getUnspentInputNoteNullifiers_f78095a40c0e07f6: function(arg0, arg1) {
+        __wbg_getUnspentInputNoteNullifiers_f403872bd5cdee30: function(arg0, arg1) {
             const ret = getUnspentInputNoteNullifiers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21759,7 +22619,7 @@ function __wbg_get_imports() {
             const ret = InputNoteRecord.__wrap(arg0);
             return ret;
         },
-        __wbg_insertAccountAddress_2975a220df21b9d8: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAddress_010cd84f15a2fba0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21773,7 +22633,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertAccountAuth_b62f4403fa393207: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAuth_47c33fb7c61f1aea: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -21790,7 +22650,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertAccountKeyMapping_d56573fec35ad148: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountKeyMapping_b94e28f85f7038ef: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -21807,7 +22667,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertBlockHeader_267480a0de90bc41: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_insertBlockHeader_f5ae91cdec3dcadd: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
             wasm.__wbindgen_free(arg3, arg4 * 1, 1);
             var v1 = getArrayU8FromWasm0(arg5, arg6).slice();
@@ -21815,7 +22675,7 @@ function __wbg_get_imports() {
             const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, v1, arg7 !== 0);
             return ret;
         },
-        __wbg_insertPartialBlockchainNodes_8b2a7e022f654289: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertPartialBlockchainNodes_b0cb6befaab01e5f: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
@@ -21823,7 +22683,7 @@ function __wbg_get_imports() {
             const ret = insertPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0, v1);
             return ret;
         },
-        __wbg_insertSetting_2d16195f37a7a19e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertSetting_db9299455a50a86e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21837,7 +22697,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertTransactionScript_c1ee93785b0b59f7: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertTransactionScript_0ce3812a118db4dd: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -21930,11 +22790,11 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_listSettingKeys_de6aa9df75473a71: function(arg0, arg1) {
+        __wbg_listSettingKeys_0a51e3f4cad7f036: function(arg0, arg1) {
             const ret = listSettingKeys(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_lockAccount_8d525a8cc074cbce: function(arg0, arg1, arg2, arg3) {
+        __wbg_lockAccount_8a141fe8afe53d1f: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22018,7 +22878,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h4e730be6209b5f2c(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h25a2b6130ec77f92(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -22113,6 +22973,10 @@ function __wbg_get_imports() {
             const ret = NoteScript.__wrap(arg0);
             return ret;
         },
+        __wbg_notesyncblock_new: function(arg0) {
+            const ret = NoteSyncBlock.__wrap(arg0);
+            return ret;
+        },
         __wbg_notesyncinfo_new: function(arg0) {
             const ret = NoteSyncInfo.__wrap(arg0);
             return ret;
@@ -22121,7 +22985,7 @@ function __wbg_get_imports() {
             const ret = NoteTag.__unwrap(arg0);
             return ret;
         },
-        __wbg_openDatabase_7f28f6178310fd2e: function(arg0, arg1, arg2, arg3) {
+        __wbg_openDatabase_cde23913ad00e851: function(arg0, arg1, arg2, arg3) {
             const ret = openDatabase(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return ret;
         },
@@ -22137,10 +23001,6 @@ function __wbg_get_imports() {
             const ret = OutputNoteRecord.__wrap(arg0);
             return ret;
         },
-        __wbg_outputnotes_unwrap: function(arg0) {
-            const ret = OutputNotes.__unwrap(arg0);
-            return ret;
-        },
         __wbg_procedurethreshold_new: function(arg0) {
             const ret = ProcedureThreshold.__wrap(arg0);
             return ret;
@@ -22156,7 +23016,24 @@ function __wbg_get_imports() {
             const ret = ProvenTransaction.__wrap(arg0);
             return ret;
         },
-        __wbg_pruneIrrelevantBlocks_c83e6ef0546f3ecc: function(arg0, arg1) {
+        __wbg_pruneAccountHistory_354251ecd3d1db75: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            let deferred0_0;
+            let deferred0_1;
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                deferred1_0 = arg4;
+                deferred1_1 = arg5;
+                const ret = pruneAccountHistory(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        },
+        __wbg_pruneIrrelevantBlocks_dc97d14f31702d1f: function(arg0, arg1) {
             const ret = pruneIrrelevantBlocks(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -22174,13 +23051,37 @@ function __wbg_get_imports() {
         __wbg_releaseLock_aa5846c2494b3032: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_removeAccountAddress_122130bc390589c3: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAddress_3f0e0ecc294d79fa: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             const ret = removeAccountAddress(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_removeNoteTag_ba4bbf31e8364b9d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_removeAccountAuth_0c07288e7cb5a02d: function(arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = removeAccountAuth(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_removeAllMappingsForKey_17fa2424f229b2ce: function(arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = removeAllMappingsForKey(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_removeNoteTag_3d017b00fc0fe3f2: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -22196,7 +23097,7 @@ function __wbg_get_imports() {
             const ret = removeNoteTag(getStringFromWasm0(arg0, arg1), v0, v1, v2);
             return ret;
         },
-        __wbg_removeSetting_91f3fc4fe0083338: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeSetting_e2432798ff986675: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22243,6 +23144,10 @@ function __wbg_get_imports() {
             const ret = setTimeout(arg0, arg1);
             return ret;
         },
+        __wbg_setTimeout_db2dbaeefb6f39c7: function() { return handleError(function (arg0, arg1) {
+            const ret = setTimeout(arg0, arg1);
+            return ret;
+        }, arguments); },
         __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -22324,6 +23229,18 @@ function __wbg_get_imports() {
             const ret = arg0.status;
             return ret;
         },
+        __wbg_storagemapentry_new: function(arg0) {
+            const ret = StorageMapEntry.__wrap(arg0);
+            return ret;
+        },
+        __wbg_storagemapinfo_new: function(arg0) {
+            const ret = StorageMapInfo.__wrap(arg0);
+            return ret;
+        },
+        __wbg_storagemapupdate_new: function(arg0) {
+            const ret = StorageMapUpdate.__wrap(arg0);
+            return ret;
+        },
         __wbg_storageslot_unwrap: function(arg0) {
             const ret = StorageSlot.__unwrap(arg0);
             return ret;
@@ -22372,13 +23289,13 @@ function __wbg_get_imports() {
             const ret = TransactionSummary.__wrap(arg0);
             return ret;
         },
-        __wbg_undoAccountStates_139a8e442d0e8266: function(arg0, arg1, arg2, arg3) {
+        __wbg_undoAccountStates_f1df265279e53b63: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = undoAccountStates(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_upsertAccountCode_383f5a2c8f14363a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountCode_a4ac11852963005d: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22392,7 +23309,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertAccountRecord_a49d708d1e56f0ca: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) {
+        __wbg_upsertAccountRecord_e676487b1aeca41f: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -22434,26 +23351,21 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
             }
         },
-        __wbg_upsertAccountStorage_222acc1d235b4109: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertAccountStorage_27c35c950278ccb7: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
-            let deferred1_0;
-            let deferred1_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                deferred1_0 = arg4;
-                deferred1_1 = arg5;
-                var v2 = getArrayJsValueFromWasm0(arg6, arg7).slice();
-                wasm.__wbindgen_free(arg6, arg7 * 4, 4);
-                const ret = upsertAccountStorage(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), v2);
+                var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
+                wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+                const ret = upsertAccountStorage(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_upsertForeignAccountCode_bd451c0605095f01: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertForeignAccountCode_ca44fb2bb646a2e5: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             let deferred0_0;
             let deferred0_1;
             let deferred2_0;
@@ -22472,7 +23384,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertInputNote_47842209515779bf: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20) {
+        __wbg_upsertInputNote_c0a91baad890bea3: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23, arg24) {
             let deferred0_0;
             let deferred0_1;
             let deferred4_0;
@@ -22500,7 +23412,12 @@ function __wbg_get_imports() {
                 deferred7_1 = arg17;
                 var v8 = getArrayU8FromWasm0(arg19, arg20).slice();
                 wasm.__wbindgen_free(arg19, arg20 * 1, 1);
-                const ret = upsertInputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, v2, v3, getStringFromWasm0(arg10, arg11), v5, getStringFromWasm0(arg14, arg15), getStringFromWasm0(arg16, arg17), arg18, v8);
+                let v9;
+                if (arg23 !== 0) {
+                    v9 = getStringFromWasm0(arg23, arg24).slice();
+                    wasm.__wbindgen_free(arg23, arg24 * 1, 1);
+                }
+                const ret = upsertInputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, v2, v3, getStringFromWasm0(arg10, arg11), v5, getStringFromWasm0(arg14, arg15), getStringFromWasm0(arg16, arg17), arg18, v8, arg21 === 0x100000001 ? undefined : arg21, arg22 === 0x100000001 ? undefined : arg22, v9);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
@@ -22509,7 +23426,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
             }
         },
-        __wbg_upsertNoteScript_dc58f49497ed8107: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertNoteScript_a3c063a2acfa4780: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22523,7 +23440,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertOutputNote_a0ed1616cd98c34e: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) {
+        __wbg_upsertOutputNote_46d6890a38b77f16: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) {
             let deferred0_0;
             let deferred0_1;
             let deferred2_0;
@@ -22551,26 +23468,21 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertStorageMapEntries_9ac7a55072752cce: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertStorageMapEntries_f21a9df772c69fc9: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
-            let deferred1_0;
-            let deferred1_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                deferred1_0 = arg4;
-                deferred1_1 = arg5;
-                var v2 = getArrayJsValueFromWasm0(arg6, arg7).slice();
-                wasm.__wbindgen_free(arg6, arg7 * 4, 4);
-                const ret = upsertStorageMapEntries(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), v2);
+                var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
+                wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+                const ret = upsertStorageMapEntries(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_upsertTransactionRecord_2393500743c7c885: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+        __wbg_upsertTransactionRecord_0bc4df87c698be51: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22591,23 +23503,18 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertVaultAssets_041e9aafd373834e: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertVaultAssets_ceae9eb0e4c816f0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
-            let deferred1_0;
-            let deferred1_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                deferred1_0 = arg4;
-                deferred1_1 = arg5;
-                var v2 = getArrayJsValueFromWasm0(arg6, arg7).slice();
-                wasm.__wbindgen_free(arg6, arg7 * 4, 4);
-                const ret = upsertVaultAssets(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), v2);
+                var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
+                wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+                const ret = upsertVaultAssets(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
         __wbg_value_0546255b415e96c1: function(arg0) {
@@ -22627,13 +23534,13 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 646, function: Function { arguments: [Externref], shim_idx: 651, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he3a977abd70bfc9b, wasm_bindgen__convert__closures_____invoke__h9b776fcb85dcda59);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [Externref], shim_idx: 694, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h26b09db1ae5ec871, wasm_bindgen__convert__closures_____invoke__hd8a2ee300ada83f0);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 646, function: Function { arguments: [], shim_idx: 647, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he3a977abd70bfc9b, wasm_bindgen__convert__closures_____invoke__h8c553039fb936537);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [], shim_idx: 357, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h26b09db1ae5ec871, wasm_bindgen__convert__closures_____invoke__h1e8a9c24645c31f0);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -22737,16 +23644,16 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h8c553039fb936537(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h8c553039fb936537(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h1e8a9c24645c31f0(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h1e8a9c24645c31f0(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h9b776fcb85dcda59(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h9b776fcb85dcda59(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__hd8a2ee300ada83f0(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hd8a2ee300ada83f0(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4e730be6209b5f2c(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h4e730be6209b5f2c(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h25a2b6130ec77f92(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h25a2b6130ec77f92(arg0, arg1, arg2, arg3);
 }
 
 
@@ -22952,6 +23859,9 @@ const NoteAndArgsFinalization = (typeof FinalizationRegistry === 'undefined')
 const NoteAndArgsArrayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_noteandargsarray_free(ptr >>> 0, 1));
+const NoteArrayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_notearray_free(ptr >>> 0, 1));
 const NoteAssetsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_noteassets_free(ptr >>> 0, 1));
@@ -23018,6 +23928,9 @@ const NoteScriptFinalization = (typeof FinalizationRegistry === 'undefined')
 const NoteStorageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_notestorage_free(ptr >>> 0, 1));
+const NoteSyncBlockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_notesyncblock_free(ptr >>> 0, 1));
 const NoteSyncInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_notesyncinfo_free(ptr >>> 0, 1));
@@ -23036,15 +23949,15 @@ const OutputNoteRecordFinalization = (typeof FinalizationRegistry === 'undefined
 const OutputNotesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_outputnotes_free(ptr >>> 0, 1));
-const OutputNotesArrayFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_outputnotesarray_free(ptr >>> 0, 1));
 const PackageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_package_free(ptr >>> 0, 1));
 const PartialNoteFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_partialnote_free(ptr >>> 0, 1));
+const Poseidon2Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_poseidon2_free(ptr >>> 0, 1));
 const ProcedureThresholdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_procedurethreshold_free(ptr >>> 0, 1));
@@ -23087,6 +24000,15 @@ const SparseMerklePathFinalization = (typeof FinalizationRegistry === 'undefined
 const StorageMapFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_storagemap_free(ptr >>> 0, 1));
+const StorageMapEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storagemapentry_free(ptr >>> 0, 1));
+const StorageMapInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storagemapinfo_free(ptr >>> 0, 1));
+const StorageMapUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storagemapupdate_free(ptr >>> 0, 1));
 const StorageSlotFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_storageslot_free(ptr >>> 0, 1));
@@ -23147,6 +24069,9 @@ const TransactionSummaryFinalization = (typeof FinalizationRegistry === 'undefin
 const WebClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_webclient_free(ptr >>> 0, 1));
+const WebKeystoreApiFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_webkeystoreapi_free(ptr >>> 0, 1));
 const WordFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_word_free(ptr >>> 0, 1));
@@ -23533,5 +24458,5 @@ const module$1 = new URL("assets/miden_client_web.wasm", import.meta.url);
                 
                     await __wbg_init({ module_or_path: module$1 });
 
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountType, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthScheme, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, OutputNotesArray, Package, PartialNote, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, Word, createAuthFalcon512RpoMultisig, initSync, setupLogging };
-//# sourceMappingURL=Cargo-D064yzd4-D064yzd4.js.map
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountType, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthScheme, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore2 as exportStore, importStore, initSync, setupLogging };
+//# sourceMappingURL=Cargo-M1xGvXNQ-M1xGvXNQ.js.map