@miden-sdk/miden-sdk 0.14.0-alpha.2 → 0.14.1

package/dist/{Cargo-DlfmzoDc.js → Cargo-BZOulF0S.js}

@@ -6644,55 +6644,47 @@ var cmp_1 = cmp;
 
 const { safeRe: re, t } = reExports;
 
-var lrucache;
-var hasRequiredLrucache;
-
-function requireLrucache () {
-	if (hasRequiredLrucache) return lrucache;
-	hasRequiredLrucache = 1;
-	class LRUCache {
-	  constructor () {
-	    this.max = 1000;
-	    this.map = new Map();
-	  }
-
-	  get (key) {
-	    const value = this.map.get(key);
-	    if (value === undefined) {
-	      return undefined
-	    } else {
-	      // Remove the key from the map and add it to the end
-	      this.map.delete(key);
-	      this.map.set(key, value);
-	      return value
-	    }
-	  }
+class LRUCache {
+  constructor () {
+    this.max = 1000;
+    this.map = new Map();
+  }
 
-	  delete (key) {
-	    return this.map.delete(key)
-	  }
+  get (key) {
+    const value = this.map.get(key);
+    if (value === undefined) {
+      return undefined
+    } else {
+      // Remove the key from the map and add it to the end
+      this.map.delete(key);
+      this.map.set(key, value);
+      return value
+    }
+  }
 
-	  set (key, value) {
-	    const deleted = this.delete(key);
+  delete (key) {
+    return this.map.delete(key)
+  }
 
-	    if (!deleted && value !== undefined) {
-	      // If cache is full, delete the least recently used item
-	      if (this.map.size >= this.max) {
-	        const firstKey = this.map.keys().next().value;
-	        this.delete(firstKey);
-	      }
+  set (key, value) {
+    const deleted = this.delete(key);
 
-	      this.map.set(key, value);
-	    }
+    if (!deleted && value !== undefined) {
+      // If cache is full, delete the least recently used item
+      if (this.map.size >= this.max) {
+        const firstKey = this.map.keys().next().value;
+        this.delete(firstKey);
+      }
 
-	    return this
-	  }
-	}
+      this.map.set(key, value);
+    }
 
-	lrucache = LRUCache;
-	return lrucache;
+    return this
+  }
 }
 
+var lrucache = LRUCache;
+
 var range;
 var hasRequiredRange;
 
@@ -6913,7 +6905,7 @@ function requireRange () {
 
 	range = Range;
 
-	const LRU = requireLrucache();
+	const LRU = lrucache;
 	const cache = new LRU();
 
 	const parseOptions = parseOptions_1;
@@ -7515,7 +7507,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 +7548,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 +7838,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 +7875,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 +7928,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 +7943,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 +7964,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 +8000,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 +8307,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 +8341,7 @@ async function applyFullAccountState(dbId, accountState) {
                 accountSeed,
                 accountCommitment,
                 locked: false,
-            };
-            await db.historicalAccountHeaders.put(data);
-            await db.latestAccountHeaders.put(data);
+            });
         });
     }
     catch (error) {
@@ -8219,26 +8362,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 +8457,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 +8551,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 +8628,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 +8722,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 +8831,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 +8925,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 +8980,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 +9000,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 +9162,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 +9176,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 +9240,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 +9444,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 +9453,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 +9470,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 +9571,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 +9585,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 +9956,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 +10231,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 +10609,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 +10813,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 +10875,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 +10934,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 +11716,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 +11838,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 +12108,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 +12243,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 +12402,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 +12423,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 +12473,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 +13004,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 +14763,6 @@ class JsVaultAsset {
     toJSON() {
         return {
             asset: this.asset,
-            faucetIdPrefix: this.faucetIdPrefix,
             vaultKey: this.vaultKey,
         };
     }
@@ -14393,22 +14795,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 +14816,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 +14883,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 +15143,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 +15204,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 +15287,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 +15979,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 +15992,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 +16269,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 +16285,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 +16562,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 +16870,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 +16986,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 +17068,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 +17213,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 +17257,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 +17293,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 +17337,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 +17513,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;
@@ -17052,89 +17555,19 @@ class OutputNotes {
     notes() {
         const ret = wasm.outputnotes_notes(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        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);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * @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 +17692,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 +17819,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 +17847,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 +17860,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 +18003,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 +18123,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 +18197,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 +18335,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 +18385,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 +18401,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 +18409,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 +18555,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 +18563,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 +18713,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 +18743,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 +19134,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 +19609,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 +20242,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 +20275,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 +20518,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 +20594,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 +20681,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 +20870,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 +20921,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 +20933,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 +20956,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 +20968,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;
     }
     /**
@@ -20314,10 +21013,28 @@ class WebClient {
      * @param {TransactionRequest} transaction_request
      * @returns {Promise<TransactionSummary>}
      */
-    executeForSummary(account_id, transaction_request) {
+    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>}
+     */
+    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 +21075,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 +21097,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 +21109,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 +21205,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 +21285,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 +21329,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 +21466,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 +21556,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 +21568,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 +21663,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 +21881,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 +22066,7 @@ function __wbg_get_imports() {
             const ret = AccountStorage.__wrap(arg0);
             return ret;
         },
-        __wbg_addNoteTag_129c8d9b232bafa2: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_addNoteTag_63799a9478c87a90: 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 +22089,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_5984dfa1f9adbcb1: function(arg0, arg1, arg2) {
+        __wbg_applyFullAccountState_f1ff4a1d13811963: function(arg0, arg1, arg2) {
             const ret = applyFullAccountState(getStringFromWasm0(arg0, arg1), JsAccountUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyStateSync_164e7aaf2febbe98: function(arg0, arg1, arg2) {
+        __wbg_applyStateSync_24ad223fd10a4973: function(arg0, arg1, arg2) {
             const ret = applyStateSync(getStringFromWasm0(arg0, arg1), JsStateSyncUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyTransactionDelta_59ccc57856c6bd87: 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_6041c5f076d8405c: 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 +22129,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 +22192,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 +22232,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_exportStore_5874ec863915584b: function(arg0, arg1) {
+        __wbg_exportStore_961eb403ce6401e7: function(arg0, arg1) {
             const ret = exportStore(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21418,6 +22244,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 +22264,7 @@ function __wbg_get_imports() {
             const ret = FetchedNote.__wrap(arg0);
             return ret;
         },
-        __wbg_forceImportStore_6c4f01c5c826a84a: function(arg0, arg1, arg2) {
+        __wbg_forceImportStore_7ec9187226bc64a6: function(arg0, arg1, arg2) {
             const ret = forceImportStore(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         },
@@ -21454,7 +22284,7 @@ function __wbg_get_imports() {
             const ret = FungibleAssetDeltaItem.__wrap(arg0);
             return ret;
         },
-        __wbg_getAccountAddresses_82f229693e2ec7ae: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAddresses_ce9cbae0dbe8d488: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21466,7 +22296,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountAuthByPubKeyCommitment_6fe602f9dfb51fae: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAuthByPubKeyCommitment_9108bcc540b259f8: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21478,7 +22308,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountCode_fff3da1c8f921fb0: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountCode_d6a66dc4c8bcd0fb: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21490,7 +22320,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeaderByCommitment_75f89bbcd8556322: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeaderByCommitment_5a38a4f46714ab0c: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21502,7 +22332,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeader_f11be28051c305aa: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeader_2fc7d24bb322f741: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21514,7 +22344,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIdByKeyCommitment_09d6d47e3075a887: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountIdByKeyCommitment_cd45cb20eb4179c6: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21526,11 +22356,11 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIds_47bd2e2f5585bdd3: function(arg0, arg1) {
+        __wbg_getAccountIds_011f27983158f415: function(arg0, arg1) {
             const ret = getAccountIds(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getAccountStorageMaps_dd2bbc0db626823c: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorageMaps_e66cd035c5bbb97b: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21542,65 +22372,83 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountStorage_440a6bf20267a6af: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorage_ec182807a0c17c91: 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_e97b428441d96ee9: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountVaultAssets_bccdee600be89096: 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_15f6fcfa376fcb5b: function(arg0, arg1) {
+        __wbg_getAllAccountHeaders_74acd216317a5f87: function(arg0, arg1) {
             const ret = getAllAccountHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getBlockHeaders_c2ae17aac376da9c: function(arg0, arg1, arg2, arg3) {
+        __wbg_getBlockHeaders_05b30aae935a1a7d: 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_6c09a7caeb4b9647: function(arg0, arg1, arg2, arg3) {
+        __wbg_getForeignAccountCode_213f3c8e7e729c1a: 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_83d99c60a0a16932: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNoteByOffset_0bee418c75072b27: 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_721daab430964ba8: 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_40921b17ee291c87: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromNullifiers_f3bab786cefda999: 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_246e203a70392bb8: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotes_eb7302d670b898b8: 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_2c21ea614d0bb0bb: function(arg0, arg1, arg2, arg3) {
+        __wbg_getKeyCommitmentsByAccountId_39dba15570f24593: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21612,7 +22460,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteScript_d1134d3cd683d6b2: function(arg0, arg1, arg2, arg3) {
+        __wbg_getNoteScript_efda320e2c0fccf7: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21624,33 +22472,33 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteTags_e4f71e1a8f4feb21: function(arg0, arg1) {
+        __wbg_getNoteTags_d6b8022f9b4859e8: function(arg0, arg1) {
             const ret = getNoteTags(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getOutputNotesFromIds_de8fb6f5fee6c953: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromIds_fa5c634a82cd6bff: 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_9f51be76a0f6c916: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromNullifiers_91fb57f239d4ca70: 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_9cdaa6245bd5714c: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotes_a1065157d0831b01: 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_82f75763ea15d598: function(arg0, arg1) {
+        __wbg_getPartialBlockchainNodesAll_ddea8ea03a56c531: function(arg0, arg1) {
             const ret = getPartialBlockchainNodesAll(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getPartialBlockchainNodesUpToInOrderIndex_0f129ed50a5e4af5: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodesUpToInOrderIndex_959b31301df8c438: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21662,13 +22510,13 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getPartialBlockchainNodes_42cb8c65e5dc9051: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodes_09bd2967864c4c45: 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_22a173865b3df735: function(arg0, arg1, arg2) {
+        __wbg_getPartialBlockchainPeaksByBlockNum_b5b9e95f32003e32: function(arg0, arg1, arg2) {
             const ret = getPartialBlockchainPeaksByBlockNum(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
             return ret;
         },
@@ -21679,7 +22527,7 @@ function __wbg_get_imports() {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_getSetting_f7be8e05ab8bad69: function(arg0, arg1, arg2, arg3) {
+        __wbg_getSetting_ba46bcae2e2b7d6c: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21691,7 +22539,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getSyncHeight_30373234e1db7d59: function(arg0, arg1) {
+        __wbg_getSyncHeight_b986a41f20a4c60f: function(arg0, arg1) {
             const ret = getSyncHeight(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21699,11 +22547,15 @@ function __wbg_get_imports() {
             const ret = arg0.getTime();
             return ret;
         },
-        __wbg_getTrackedBlockHeaders_a2ff7ced468be82b: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaderNumbers_13758201e4acf879: function(arg0, arg1) {
+            const ret = getTrackedBlockHeaderNumbers(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_getTrackedBlockHeaders_e01f9f3411d5db34: function(arg0, arg1) {
             const ret = getTrackedBlockHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTransactions_fba251dc1ae7c5be: function(arg0, arg1, arg2, arg3) {
+        __wbg_getTransactions_39cdbadf132e2cbd: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21715,7 +22567,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getUnspentInputNoteNullifiers_b282e57f53cd12ee: function(arg0, arg1) {
+        __wbg_getUnspentInputNoteNullifiers_454a694b1712e5cb: function(arg0, arg1) {
             const ret = getUnspentInputNoteNullifiers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -21759,7 +22611,7 @@ function __wbg_get_imports() {
             const ret = InputNoteRecord.__wrap(arg0);
             return ret;
         },
-        __wbg_insertAccountAddress_6231e3afe2424f42: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAddress_964930c0efd3f292: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21773,7 +22625,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertAccountAuth_a99c26f21d124b5c: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAuth_15db742f3171bda3: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -21790,7 +22642,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertAccountKeyMapping_4039662d288a5400: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountKeyMapping_9c49660f1ec7399f: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -21807,7 +22659,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertBlockHeader_e30051a2b8f281b7: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_insertBlockHeader_060e7f46d4ec35e7: 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 +22667,7 @@ function __wbg_get_imports() {
             const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, v1, arg7 !== 0);
             return ret;
         },
-        __wbg_insertPartialBlockchainNodes_f03e6846e58f99f7: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertPartialBlockchainNodes_04f374dbb1ca7e77: 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 +22675,7 @@ function __wbg_get_imports() {
             const ret = insertPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0, v1);
             return ret;
         },
-        __wbg_insertSetting_7f257c949e4ba7f9: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertSetting_e8fb47c1a72a54c4: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -21837,7 +22689,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertTransactionScript_c9c414607bf00695: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertTransactionScript_ba6a81a76d47a2d3: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -21930,11 +22782,11 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_listSettingKeys_177323a7e3eb8746: function(arg0, arg1) {
+        __wbg_listSettingKeys_bd877420952aabcf: function(arg0, arg1) {
             const ret = listSettingKeys(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_lockAccount_6e14a5747a738708: function(arg0, arg1, arg2, arg3) {
+        __wbg_lockAccount_b4469b288371ce1b: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22018,7 +22870,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__h5e71136c5fac87ef(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -22113,6 +22965,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 +22977,7 @@ function __wbg_get_imports() {
             const ret = NoteTag.__unwrap(arg0);
             return ret;
         },
-        __wbg_openDatabase_92372e9cfd9e1a0d: function(arg0, arg1, arg2, arg3) {
+        __wbg_openDatabase_2b359f6f1c11112f: function(arg0, arg1, arg2, arg3) {
             const ret = openDatabase(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return ret;
         },
@@ -22137,10 +22993,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 +23008,24 @@ function __wbg_get_imports() {
             const ret = ProvenTransaction.__wrap(arg0);
             return ret;
         },
-        __wbg_pruneIrrelevantBlocks_e695903338107987: function(arg0, arg1) {
+        __wbg_pruneAccountHistory_f6d2c239f5188516: 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_2634ac68b91e6214: function(arg0, arg1) {
             const ret = pruneIrrelevantBlocks(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -22174,13 +23043,37 @@ function __wbg_get_imports() {
         __wbg_releaseLock_aa5846c2494b3032: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_removeAccountAddress_26320801b9cf78cb: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAddress_9378ec2111cfd073: 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_a80684c949d5d911: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_removeAccountAuth_1b38ce482f3a2a01: 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_8e731aa44d99defa: 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_66b88893678278ff: 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 +23089,7 @@ function __wbg_get_imports() {
             const ret = removeNoteTag(getStringFromWasm0(arg0, arg1), v0, v1, v2);
             return ret;
         },
-        __wbg_removeSetting_9baeabb180b1a28d: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeSetting_09bade6bd24dd314: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22243,6 +23136,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 +23221,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 +23281,13 @@ function __wbg_get_imports() {
             const ret = TransactionSummary.__wrap(arg0);
             return ret;
         },
-        __wbg_undoAccountStates_418528d3ab74f47d: function(arg0, arg1, arg2, arg3) {
+        __wbg_undoAccountStates_a9bb97fcb6ee8a5b: 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_f0064d5ee703c4d4: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountCode_9f6c4b97ffdc2a70: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22392,7 +23301,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertAccountRecord_1a44a04b996eea5b: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) {
+        __wbg_upsertAccountRecord_871acd6aa086e68f: 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 +23343,21 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
             }
         },
-        __wbg_upsertAccountStorage_5496ac9020784880: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertAccountStorage_a50e64183e253d97: 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_e29fa0e4e5f4f985: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertForeignAccountCode_9e93abdae6f4c0c7: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             let deferred0_0;
             let deferred0_1;
             let deferred2_0;
@@ -22472,7 +23376,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertInputNote_b4afadbc48fcb67f: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20) {
+        __wbg_upsertInputNote_ebefca636604089b: 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 +23404,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 +23418,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
             }
         },
-        __wbg_upsertNoteScript_2f97ba16d0d984d0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertNoteScript_19e8fc1a041edf85: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22523,7 +23432,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertOutputNote_d46cc5c171b7997d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) {
+        __wbg_upsertOutputNote_fc6f81a8309ef41b: 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 +23460,21 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertStorageMapEntries_4cd61775348e0806: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertStorageMapEntries_a39827348033fe1a: 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_71e12e0dca7738c3: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+        __wbg_upsertTransactionRecord_01aaa20c21552b32: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -22591,23 +23495,18 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertVaultAssets_9afc250da96bd5ab: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertVaultAssets_fa65d63a2d8af8de: 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 +23526,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: 373, function: Function { arguments: [Externref], shim_idx: 695, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h391391dffb6a09df, wasm_bindgen__convert__closures_____invoke__h2a909b4e7ff298f2);
             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: 373, function: Function { arguments: [], shim_idx: 374, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h391391dffb6a09df, wasm_bindgen__convert__closures_____invoke__h53c1e1d8115a3864);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -22737,16 +23636,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__h53c1e1d8115a3864(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h53c1e1d8115a3864(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__h2a909b4e7ff298f2(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h2a909b4e7ff298f2(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__h5e71136c5fac87ef(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h5e71136c5fac87ef(arg0, arg1, arg2, arg3);
 }
 
 
@@ -22952,6 +23851,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 +23920,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 +23941,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 +23992,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 +24061,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));
@@ -23530,8 +24447,5 @@ async function __wbg_init(module_or_path) {
 }
 
 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-DlfmzoDc.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 , __wbg_init, module$1 as __wasm_url };
+//# sourceMappingURL=Cargo-BZOulF0S.js.map