@miden-sdk/miden-sdk 0.15.7 → 0.16.0-alpha.1

package/dist/st/workers/web-client-methods-worker.js

@@ -5,7 +5,7 @@
 async function loadWasm() {
   let wasmModule;
   if (!undefined || (undefined && !undefined.SSR)) {
-    wasmModule = await Promise.resolve().then(function () { return CargoDR9fiMbE; });
+    wasmModule = await Promise.resolve().then(function () { return CargoLwITdlzJ; });
     // The Cargo glue's __wbg_init TLA is stripped by the rollup build to
     // prevent blocking WKWebView module evaluation. Call it explicitly here
     // with the WASM URL that the Cargo glue pre-resolves (relative to its
@@ -8826,6 +8826,42 @@ const logWebStoreError = (error, errorContext) => {
     }
     throw error;
 };
+// Partial blockchain (MMR) authentication nodes are part of the local
+// `PartialMmr` state. Once a node index is known its value is fixed, so a
+// later write with the same index but a different value indicates a buggy or
+// malicious sync path. Insert nodes that are missing, accept writes that match
+// the stored value, and reject conflicting writes so the known-good value is
+// never silently overwritten.
+const putPartialBlockchainNodesNoOverwrite = async (table, data) => {
+    // Collapse duplicate indexes within the same batch up front: identical
+    // copies are deduplicated (a repeated index would otherwise make `bulkAdd`
+    // throw a key-collision error), and copies that disagree are rejected.
+    const unique = new Map();
+    for (const entry of data) {
+        const seen = unique.get(entry.id);
+        if (seen !== undefined && seen.node !== entry.node) {
+            throw new Error(`Conflicting partial blockchain node ${entry.id} within the same write`);
+        }
+        unique.set(entry.id, entry);
+    }
+    const records = [...unique.values()];
+    const existing = await table.bulkGet(records.map((entry) => entry.id));
+    const toAdd = [];
+    for (let i = 0; i < records.length; i++) {
+        const current = existing[i];
+        if (current === undefined) {
+            toAdd.push(records[i]);
+        }
+        else if (current.node !== records[i].node) {
+            throw new Error(`Refusing to overwrite partial blockchain node ${records[i].id}: ` +
+                `stored value differs from the new value`);
+        }
+        // current.node === records[i].node: already stored, nothing to do.
+    }
+    if (toAdd.length > 0) {
+        await table.bulkAdd(toAdd);
+    }
+};
 const uint8ArrayToBase64 = (bytes) => {
     const binary = bytes.reduce((acc, byte) => acc + String.fromCharCode(byte), "");
     return btoa(binary);
@@ -8882,7 +8918,7 @@ var Table;
     Table["InputNotes"] = "inputNotes";
     Table["OutputNotes"] = "outputNotes";
     Table["NotesScripts"] = "notesScripts";
-    Table["StateSync"] = "stateSync";
+    Table["BlockchainCheckpoint"] = "blockchainCheckpoint";
     Table["BlockHeaders"] = "blockHeaders";
     Table["PartialBlockchainNodes"] = "partialBlockchainNodes";
     Table["Tags"] = "tags";
@@ -8893,9 +8929,7 @@ function indexes(...items) {
     return items.join(",");
 }
 /** V1 baseline schema. Extracted as a constant because once migrations are enabled, this must
- *  never be modified — all schema changes should go through new version blocks instead.
- *  Exported for migration tests, which seed a physical v1 database before opening it with the
- *  current version chain. */
+ *  never be modified — all schema changes should go through new version blocks instead. */
 const V1_STORES = {
     [Table.AccountCode]: indexes("root"),
     [Table.LatestAccountStorage]: indexes("[accountId+slotName]", "accountId"),
@@ -8914,7 +8948,7 @@ const V1_STORES = {
     [Table.InputNotes]: indexes("detailsCommitment", "noteId", "nullifier", "stateDiscriminant", "[consumedBlockHeight+consumedTxOrder+noteId]"),
     [Table.OutputNotes]: indexes("detailsCommitment", "noteId", "recipientDigest", "stateDiscriminant", "nullifier"),
     [Table.NotesScripts]: indexes("scriptRoot"),
-    [Table.StateSync]: indexes("id"),
+    [Table.BlockchainCheckpoint]: indexes("id"),
     [Table.BlockHeaders]: indexes("blockNum", "hasClientNotes"),
     [Table.PartialBlockchainNodes]: indexes("id"),
     [Table.Tags]: indexes("id++", "tag", "sourceNoteId", "sourceAccountId"),
@@ -8940,7 +8974,7 @@ class MidenDatabase {
     inputNotes;
     outputNotes;
     notesScripts;
-    stateSync;
+    blockchainCheckpoint;
     blockHeaders;
     partialBlockchainNodes;
     tags;
@@ -8950,12 +8984,11 @@ class MidenDatabase {
         this.dexie = new Dexie(network);
         // --- Schema versioning ---
         //
-        // NOTE: Migrations coexist with the client-version nuke: the database is
-        // still nuked on major/minor client-version changes (network resets — see
-        // ensureClientVersion), while Dexie version blocks below handle schema and
-        // data fixes for stores that survive patch upgrades. Once the network
-        // stabilizes and data can be preserved across all upgrades, the
-        // version-change nuke will be removed and migrations alone will take over.
+        // NOTE: The migration system is not currently in use. The Miden network
+        // resets on every upgrade, so the database is nuked whenever the client
+        // version changes (see ensureClientVersion). Once the network stabilizes
+        // and data can be preserved across upgrades, the version-change nuke will
+        // be removed and migrations will take over.
         //
         // v1 is the baseline schema. To add a migration:
         //   1. Add a .version(N+1).stores({...}).upgrade(tx => {...}) block below.
@@ -8987,43 +9020,12 @@ class MidenDatabase {
         // Note: The `populate` hook (below the version blocks) only fires on
         // first database creation, NOT during upgrades.
         //
-        // Version blocks exist below, so V1_STORES is frozen — never modify it;
-        // add a new version block instead. To retire the nuke entirely (once data
-        // must survive major/minor upgrades), remove the close/delete/open logic
-        // in ensureClientVersion and just persist the new version there.
+        // To enable migrations (stop nuking the DB on version change):
+        //   1. Remove the nuke logic in ensureClientVersion (close/delete/open).
+        //      Just persist the new version instead.
+        //   2. Freeze V1_STORES — never modify it again.
+        //   3. Add version(2+) blocks below for all schema changes going forward.
         this.dexie.version(1).stores(V1_STORES);
-        // v2 (miden-client 0.15.4): prune note tags leaked by output-note
-        // registration. Mirrors sqlite-store migration
-        // `0002_prune_output_note_tags.sql`. Clients built against miden-client
-        // < 0.15.4 registered a `Note`-sourced tag for every output note a
-        // transaction created, but sync cleanup only removes tags of committed
-        // *input* notes — leaking one `tags` row per created note. The client no
-        // longer registers those tags; this upgrade deletes the rows already
-        // leaked. A tag is kept while an inclusion-pending input note
-        // (Expected = 0, Unverified = 1 — the mirror of
-        // `InputNoteRecord::is_inclusion_pending`) still needs it.
-        //
-        // This data-only fix coexists with the version-change nuke above: the
-        // nuke covers major/minor client upgrades (network resets), while this
-        // upgrade runs for stores preserved across patch upgrades.
-        this.dexie
-            .version(2)
-            .stores({})
-            .upgrade(async (tx) => {
-            const outputNoteCommitments = new Set(await tx.outputNotes.toCollection().primaryKeys());
-            if (outputNoteCommitments.size === 0) {
-                return;
-            }
-            const pendingInputNoteCommitments = new Set(await tx.inputNotes
-                .where("stateDiscriminant")
-                .anyOf([0, 1])
-                .primaryKeys());
-            await tx.tags
-                .filter((tag) => !!tag.sourceNoteId &&
-                outputNoteCommitments.has(tag.sourceNoteId) &&
-                !pendingInputNoteCommitments.has(tag.sourceNoteId))
-                .delete();
-        });
         this.accountCodes = this.dexie.table(Table.AccountCode);
         this.latestAccountStorages = this.dexie.table(Table.LatestAccountStorage);
         this.historicalAccountStorages = this.dexie.table(Table.HistoricalAccountStorage);
@@ -9041,16 +9043,20 @@ class MidenDatabase {
         this.inputNotes = this.dexie.table(Table.InputNotes);
         this.outputNotes = this.dexie.table(Table.OutputNotes);
         this.notesScripts = this.dexie.table(Table.NotesScripts);
-        this.stateSync = this.dexie.table(Table.StateSync);
+        this.blockchainCheckpoint = this.dexie.table(Table.BlockchainCheckpoint);
         this.blockHeaders = this.dexie.table(Table.BlockHeaders);
         this.partialBlockchainNodes = this.dexie.table(Table.PartialBlockchainNodes);
         this.tags = this.dexie.table(Table.Tags);
         this.foreignAccountCode = this.dexie.table(Table.ForeignAccountCode);
         this.settings = this.dexie.table(Table.Settings);
         this.dexie.on("populate", () => {
-            this.stateSync
-                .put({ id: 1, blockNum: 0 })
-                /* v8 ignore next 2 — populate stateSync failure requires fake-indexeddb to simulate a write error, not modelable in unit tests */
+            this.blockchainCheckpoint
+                .put({
+                id: 1,
+                blockNum: 0,
+                partialBlockchainPeaks: new Uint8Array(),
+            })
+                /* v8 ignore next 2 — populate blockchainCheckpoint failure requires fake-indexeddb to simulate a write error, not modelable in unit tests */
                 .catch((err) => logWebStoreError(err, "Failed to populate DB"));
         });
     }
@@ -9376,7 +9382,7 @@ async function upsertVaultAssets(dbId, accountId, assets) {
         logWebStoreError(error, `Error inserting assets`);
     }
 }
-async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, changedMapEntries, changedAssets, codeRoot, storageRoot, vaultRoot, committed, commitment) {
+async function applyAccountPatch(dbId, accountId, nonce, updatedSlots, changedMapEntries, changedAssets, codeRoot, storageRoot, vaultRoot, committed, commitment) {
     try {
         const db = getDatabase(dbId);
         await db.dexie.transaction("rw", [
@@ -9389,7 +9395,8 @@ async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, chang
             db.latestAccountHeaders,
             db.historicalAccountHeaders,
         ], async () => {
-            // Apply storage delta: read old → archive → write new
+            const resetMapSlots = new Set();
+            // Apply storage patch: read old → archive → write/delete final state.
             for (const slot of updatedSlots) {
                 const oldSlot = await db.latestAccountStorages
                     .where("[accountId+slotName]")
@@ -9402,12 +9409,44 @@ async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, chang
                     oldSlotValue: oldSlot?.slotValue ?? null,
                     slotType: slot.slotType,
                 });
-                await db.latestAccountStorages.put({
-                    accountId,
-                    slotName: slot.slotName,
-                    slotValue: slot.slotValue,
-                    slotType: slot.slotType,
-                });
+                // A created map is a replacement (a remove followed by create can merge to Create),
+                // while a removed map must drop every persisted entry. Archive those entries so account
+                // rollback can restore them.
+                if (slot.slotType === 1 &&
+                    (slot.patchOperation === 0 || slot.patchOperation === 2)) {
+                    resetMapSlots.add(slot.slotName);
+                    const oldMapEntries = await db.latestStorageMapEntries
+                        .where("[accountId+slotName]")
+                        .equals([accountId, slot.slotName])
+                        .toArray();
+                    for (const entry of oldMapEntries) {
+                        await db.historicalStorageMapEntries.put({
+                            accountId,
+                            replacedAtNonce: nonce,
+                            slotName: entry.slotName,
+                            key: entry.key,
+                            oldValue: entry.value,
+                        });
+                    }
+                    await db.latestStorageMapEntries
+                        .where("[accountId+slotName]")
+                        .equals([accountId, slot.slotName])
+                        .delete();
+                }
+                if (slot.patchOperation === 2) {
+                    await db.latestAccountStorages
+                        .where("[accountId+slotName]")
+                        .equals([accountId, slot.slotName])
+                        .delete();
+                }
+                else {
+                    await db.latestAccountStorages.put({
+                        accountId,
+                        slotName: slot.slotName,
+                        slotValue: slot.slotValue,
+                        slotType: slot.slotType,
+                    });
+                }
             }
             // Process map entries: read old → archive → update latest
             for (const entry of changedMapEntries) {
@@ -9415,13 +9454,30 @@ async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, chang
                     .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,
-                });
+                if (resetMapSlots.has(entry.slotName)) {
+                    const archivedEntry = await db.historicalStorageMapEntries
+                        .where("[accountId+replacedAtNonce+slotName+key]")
+                        .equals([accountId, nonce, entry.slotName, entry.key])
+                        .first();
+                    if (archivedEntry === undefined) {
+                        await db.historicalStorageMapEntries.put({
+                            accountId,
+                            replacedAtNonce: nonce,
+                            slotName: entry.slotName,
+                            key: entry.key,
+                            oldValue: null,
+                        });
+                    }
+                }
+                else {
+                    await db.historicalStorageMapEntries.put({
+                        accountId,
+                        replacedAtNonce: nonce,
+                        slotName: entry.slotName,
+                        key: entry.key,
+                        oldValue: oldEntry?.value ?? null,
+                    });
+                }
                 // "" means removal
                 if (entry.value === "") {
                     await db.latestStorageMapEntries
@@ -9501,7 +9557,6 @@ async function applyTransactionDelta(dbId, accountId, nonce, updatedSlots, chang
     }
     catch (error) {
         logWebStoreError(error, `Error applying transaction delta`);
-        throw error;
     }
 }
 async function archiveAndReplaceStorageSlots(db, accountId, nonce, newSlots) {
@@ -9740,7 +9795,6 @@ async function applyFullAccountState(dbId, accountState) {
     }
     catch (error) {
         logWebStoreError(error, `Error applying full account state`);
-        throw error;
     }
 }
 async function upsertAccountRecord(dbId, accountId, codeRoot, storageRoot, vaultRoot, nonce, committed, commitment, accountSeed, watched) {
@@ -10145,33 +10199,36 @@ async function getAccountIdByKeyCommitment(dbId, pubKeyCommitmentHex) {
     }
 }
 
-async function insertBlockHeader(dbId, blockNum, header, hasClientNotes) {
+async function insertBlockHeader(dbId, blockNum, header, hasClientNotes, nodeIds, nodes) {
     try {
         const db = getDatabase(dbId);
-        const data = {
+        if (nodeIds.length !== nodes.length) {
+            throw new Error("nodeIds and nodes arrays must be of the same length");
+        }
+        const headerData = {
             blockNum: blockNum,
             header,
             hasClientNotes: hasClientNotes.toString(),
         };
-        // Mirror SQLite's `insert_block_header_tx`: do an INSERT OR IGNORE on the
-        // row, then explicitly upgrade `has_client_notes` to true if the caller
-        // says so. Two callers hit this:
-        //   - Genesis flow — no existing row; the add succeeds.
-        //   - `get_and_store_authenticated_block` for a past block — a row
-        //     written by `applyStateSync` typically already exists. We keep that
-        //     row untouched.
-        //
-        // The `has_client_notes` upgrade is load-bearing: `get_tracked_block_
-        // header_numbers` filters by this flag to seed `tracked_leaves`, which
-        // `get_partial_blockchain_nodes(Forest)` relies on. A private-note
-        // import at a block previously synced as irrelevant must flip the flag
-        // to true or the auth paths won't be tracked.
-        await db.blockHeaders.add(data).catch(async (err) => {
-            if (!isConstraintError(err))
-                throw err;
-            if (hasClientNotes) {
-                await db.blockHeaders.update(blockNum, { hasClientNotes: "true" });
-            }
+        const nodeData = nodes.map((node, index) => ({
+            id: Number(nodeIds[index]),
+            node: node,
+        }));
+        // Persist the header and its MMR nodes in one transaction so a header is never stored
+        // without the nodes that rebuild its `PartialMmr` (mirrors miden-client's atomic insert).
+        await db.dexie.transaction("rw", db.blockHeaders, db.partialBlockchainNodes, async () => {
+            // Header: INSERT OR IGNORE, then one-way upgrade `has_client_notes` to true (load-bearing:
+            // `get_tracked_block_header_numbers` filters on it to seed forest-node tracking).
+            await db.blockHeaders.add(headerData).catch(async (err) => {
+                if (!isConstraintError(err))
+                    throw err;
+                if (hasClientNotes) {
+                    await db.blockHeaders.update(blockNum, { hasClientNotes: "true" });
+                }
+            });
+            // Nodes: insert-if-missing with overwrite protection; a conflicting value throws and
+            // aborts the transaction, rolling back the header write too.
+            await putPartialBlockchainNodesNoOverwrite(db.partialBlockchainNodes, nodeData);
         });
     }
     catch (err) {
@@ -10183,25 +10240,6 @@ function isConstraintError(err) {
     const e = err;
     return e?.name === "ConstraintError" || e?.inner?.name === "ConstraintError";
 }
-async function insertPartialBlockchainNodes(dbId, ids, nodes) {
-    try {
-        const db = getDatabase(dbId);
-        if (ids.length !== nodes.length) {
-            throw new Error("ids and nodes arrays must be of the same length");
-        }
-        if (ids.length === 0) {
-            return;
-        }
-        const data = nodes.map((node, index) => ({
-            id: Number(ids[index]),
-            node: node,
-        }));
-        await db.partialBlockchainNodes.bulkPut(data);
-    }
-    catch (err) {
-        logWebStoreError(err, "Failed to insert partial blockchain nodes");
-    }
-}
 async function getBlockHeaders(dbId, blockNumbers) {
     try {
         const db = getDatabase(dbId);
@@ -10259,33 +10297,6 @@ async function getTrackedBlockHeaderNumbers(dbId) {
         logWebStoreError(err, "Failed to get tracked block header numbers");
     }
 }
-/**
- * Returns the blockchain peaks at the current sync height. Peaks live on the
- * `blockHeaders` row at `stateSync.blockNum` — the block that was the chain
- * tip when its sync ran. Returns `{ blockNum, peaks: undefined }` if the
- * stateSync row is missing or if that block was inserted via backfill
- * (which leaves `partialBlockchainPeaks` unset).
- */
-async function getCurrentBlockchainPeaks(dbId) {
-    try {
-        const db = getDatabase(dbId);
-        const stateSyncRow = await db.stateSync.get(1);
-        if (stateSyncRow == undefined) {
-            return { blockNum: 0, peaks: undefined };
-        }
-        const header = await db.blockHeaders.get(stateSyncRow.blockNum);
-        if (header == undefined || header.partialBlockchainPeaks == undefined) {
-            return { blockNum: stateSyncRow.blockNum, peaks: undefined };
-        }
-        return {
-            blockNum: stateSyncRow.blockNum,
-            peaks: uint8ArrayToBase64(header.partialBlockchainPeaks),
-        };
-    }
-    catch (err) {
-        logWebStoreError(err, "Failed to get current blockchain peaks");
-    }
-}
 async function getPartialBlockchainNodesAll(dbId) {
     try {
         const db = getDatabase(dbId);
@@ -10327,9 +10338,9 @@ async function pruneIrrelevantBlocks(dbId, blocksToUntrack, nodeIdsToRemove) {
     try {
         const db = getDatabase(dbId);
         const numericNodeIds = nodeIdsToRemove.map(Number);
-        const syncHeight = await db.stateSync.get(1);
+        const syncHeight = await db.blockchainCheckpoint.get(1);
         if (syncHeight == undefined) {
-            throw Error("SyncHeight is undefined -- is the state sync table empty?");
+            throw Error("SyncHeight is undefined -- is the blockchain_checkpoint table empty?");
         }
         await db.dexie.transaction("rw", db.blockHeaders, db.partialBlockchainNodes, async () => {
             // 1. Delete stale MMR authentication nodes.
@@ -10662,7 +10673,6 @@ async function upsertInputNote(dbId, detailsCommitment, noteId, assets, attachme
         }
         catch (error) {
             logWebStoreError(error, `Error inserting note: ${detailsCommitment}`);
-            throw error;
         }
     };
     return db.dexie.transaction("rw", db.inputNotes, db.notesScripts, doWork);
@@ -10746,7 +10756,6 @@ async function upsertOutputNote(dbId, detailsCommitment, noteId, assets, attachm
         }
         catch (error) {
             logWebStoreError(error, `Error inserting note: ${detailsCommitment}`);
-            throw error;
         }
     };
     return db.dexie.transaction("rw", db.outputNotes, db.notesScripts, doWork);
@@ -10989,7 +10998,6 @@ async function insertTransactionScript(dbId, scriptRoot, txScript, tx) {
     }
     catch (error) {
         logWebStoreError(error, "Failed to insert transaction script");
-        throw error;
     }
 }
 async function upsertTransactionRecord(dbId, transactionId, details, blockNum, statusVariant, status, scriptRoot, tx) {
@@ -11007,82 +11015,8 @@ async function upsertTransactionRecord(dbId, transactionId, details, blockNum, s
     }
     catch (err) {
         logWebStoreError(err, "Failed to insert proven transaction data");
-        throw err;
     }
 }
-/**
- * Applies a batch of transaction updates atomically inside a single Dexie transaction.
- *
- * All sub-operations that internally call `db.dexie.transaction()` are auto-joined by Dexie
- * as nested sub-transactions when run inside this parent transaction, provided the parent
- * scope is a superset of every sub-transaction scope.
- */
-async function applyTransactionBatch(dbId, payloads) {
-    const db = getDatabase(dbId);
-    await db.dexie.transaction("rw", [
-        db.transactions,
-        db.transactionScripts,
-        db.latestAccountStorages,
-        db.historicalAccountStorages,
-        db.latestStorageMapEntries,
-        db.historicalStorageMapEntries,
-        db.latestAccountAssets,
-        db.historicalAccountAssets,
-        db.latestAccountHeaders,
-        db.historicalAccountHeaders,
-        db.inputNotes,
-        db.outputNotes,
-        db.notesScripts,
-        db.tags,
-    ], async () => {
-        for (const payload of payloads) {
-            // 1. Insert the transaction record (script first, then record)
-            const rec = payload.transactionRecord;
-            if (rec.scriptRoot && rec.txScript) {
-                await insertTransactionScript(dbId, rec.scriptRoot, rec.txScript);
-            }
-            await upsertTransactionRecord(dbId, rec.id, rec.details, rec.blockNum, rec.statusVariant, rec.status, rec.scriptRoot);
-            // 2. Apply account state (full or delta)
-            const acct = payload.accountState;
-            if (acct.kind === "full") {
-                await applyFullAccountState(dbId, acct.account);
-            }
-            else {
-                await applyTransactionDelta(dbId, acct.accountId, acct.nonce, acct.updatedSlots, acct.changedMapEntries, acct.changedAssets, acct.codeRoot, acct.storageRoot, acct.vaultRoot, acct.committed, acct.commitment);
-            }
-            // 3. Upsert input and output notes
-            for (const note of payload.inputNotes) {
-                await upsertInputNote(dbId, note.detailsCommitment, note.noteId, note.noteAssets, note.attachments, note.serialNumber, note.inputs, note.noteScriptRoot, note.noteScript, note.nullifier, note.createdAt, note.stateDiscriminant, note.state, note.consumedBlockHeight ?? null, note.consumedTxOrder ?? null, note.consumerAccountId ?? null);
-            }
-            for (const note of payload.outputNotes) {
-                await upsertOutputNote(dbId, note.detailsCommitment, note.noteId, note.noteAssets, note.attachments, note.recipientDigest, note.metadata, note.nullifier, note.expectedHeight, note.stateDiscriminant, note.state);
-            }
-            // 4. Add note tags (deduplicated within the transaction)
-            for (const tagEntry of payload.tags) {
-                const tagArray = new Uint8Array(tagEntry.tag);
-                const tagBase64 = uint8ArrayToBase64(tagArray);
-                const sourceNoteId = tagEntry.sourceNoteId ?? "";
-                const sourceAccountId = tagEntry.sourceAccountId ?? "";
-                const sourceSubscriptionKey = tagEntry.sourceSubscriptionKey ?? "";
-                // Check for existing tag to avoid duplicates (mirrors the Rust add_note_tag logic).
-                // sourceSubscriptionKey is unindexed, so filter on it in memory — distinct
-                // subscriptions may share a tag and must remain separate rows.
-                const existing = await db.tags
-                    .where({ tag: tagBase64, sourceNoteId, sourceAccountId })
-                    .filter((t) => (t.sourceSubscriptionKey ?? "") === sourceSubscriptionKey)
-                    .first();
-                if (!existing) {
-                    await db.tags.add({
-                        tag: tagBase64,
-                        sourceNoteId,
-                        sourceAccountId,
-                        sourceSubscriptionKey,
-                    });
-                }
-            }
-        }
-    });
-}
 
 async function getNoteTags(dbId) {
     try {
@@ -11108,7 +11042,7 @@ async function getNoteTags(dbId) {
 async function getSyncHeight(dbId) {
     try {
         const db = getDatabase(dbId);
-        const record = await db.stateSync.get(1);
+        const record = await db.blockchainCheckpoint.get(1);
         if (record) {
             let data = {
                 blockNum: record.blockNum,
@@ -11123,6 +11057,25 @@ async function getSyncHeight(dbId) {
         logWebStoreError(error, "Error fetching sync height");
     }
 }
+async function getCurrentBlockchainPeaks(dbId) {
+    try {
+        const db = getDatabase(dbId);
+        const record = await db.blockchainCheckpoint.get(1);
+        if (!record || record.partialBlockchainPeaks.length === 0) {
+            return {
+                blockNum: record?.blockNum ?? 0,
+                peaks: uint8ArrayToBase64(new Uint8Array()),
+            };
+        }
+        return {
+            blockNum: record.blockNum,
+            peaks: uint8ArrayToBase64(record.partialBlockchainPeaks),
+        };
+    }
+    catch (error) {
+        logWebStoreError(error, "Error fetching current blockchain peaks");
+    }
+}
 async function addNoteTag(dbId, tag, sourceNoteId, sourceAccountId, sourceSubscriptionKey) {
     try {
         const db = getDatabase(dbId);
@@ -11163,10 +11116,10 @@ async function removeNoteTag(dbId, tag, sourceNoteId, sourceAccountId, sourceSub
 }
 async function applyStateSync(dbId, stateUpdate) {
     const db = getDatabase(dbId);
-    const { blockNum, flattenedNewBlockHeaders, partialBlockchainPeaks, newBlockNums, blockHasRelevantNotes, serializedNodeIds, serializedNodes, committedNoteTagSources, serializedInputNotes, serializedOutputNotes, accountUpdates, transactionUpdates, } = stateUpdate;
+    const { blockNum, flattenedNewBlockHeaders, newPeaks, newBlockNums, blockHasRelevantNotes, serializedNodeIds, serializedNodes, committedNoteTagSources, serializedInputNotes, serializedOutputNotes, accountUpdates, transactionUpdates, } = stateUpdate;
     const newBlockHeaders = reconstructFlattenedVec(flattenedNewBlockHeaders);
     const tablesToAccess = [
-        db.stateSync,
+        db.blockchainCheckpoint,
         db.inputNotes,
         db.outputNotes,
         db.notesScripts,
@@ -11214,46 +11167,41 @@ async function applyStateSync(dbId, stateUpdate) {
                 accountCommitment: accountUpdate.accountCommitment,
                 accountSeed: accountUpdate.accountSeed,
             }))),
-            updateSyncHeight(tx, blockNum),
+            updateSyncHeight(tx, blockNum, newPeaks),
             updatePartialBlockchainNodes(tx, serializedNodeIds, serializedNodes),
             updateCommittedNoteTags(tx, committedNoteTagSources),
             Promise.all(newBlockHeaders.map((newBlockHeader, i) => {
-                // Peaks are attached only to the chain-tip block (the one whose
-                // blockNum matches the new sync height). That row is always
-                // present in this iteration because `partial_blockchain_updates`
-                // includes the chain tip header by construction.
-                // TODO: potentially move this to be under the sync state info table
-                // as currently done in SQLite
-                const peaks = newBlockNums[i] === blockNum ? partialBlockchainPeaks : undefined;
-                return updateBlockHeader(tx, newBlockNums[i], newBlockHeader, blockHasRelevantNotes[i] == 1, peaks);
+                return updateBlockHeader(tx, newBlockNums[i], newBlockHeader, blockHasRelevantNotes[i] == 1);
             })),
         ]);
     });
 }
-/**
- * Advances `stateSync.blockNum` only when moving forward. Mirrors SQLite's
- * `UPDATE blockchain_checkpoint ... WHERE block_num < ?`.
- */
-async function updateSyncHeight(tx, blockNum) {
+async function updateSyncHeight(tx, blockNum, newPeaks) {
     try {
-        const current = await tx.stateSync.get(1);
+        // Only update if moving forward to prevent race conditions.
+        // Peaks travel with blockNum: skipping the height update also skips the
+        // peaks update, by design — a backward-going sync must not overwrite the
+        // newer peaks with older ones.
+        const current = await tx.blockchainCheckpoint.get(1);
         if (!current || current.blockNum < blockNum) {
-            await tx.stateSync.update(1, {
+            await tx.blockchainCheckpoint.update(1, {
                 blockNum: blockNum,
+                partialBlockchainPeaks: newPeaks,
             });
         }
     }
     catch (error) {
+        // logWebStoreError always re-throws, so a failure here aborts the whole
+        // Dexie rw transaction rather than silently committing a partial update.
         logWebStoreError(error, "Failed to update sync height");
     }
 }
-async function updateBlockHeader(tx, blockNum, blockHeader, hasClientNotes, partialBlockchainPeaks) {
+async function updateBlockHeader(tx, blockNum, blockHeader, hasClientNotes) {
     try {
         const data = {
             blockNum: blockNum,
             header: blockHeader,
             hasClientNotes: hasClientNotes.toString(),
-            ...(partialBlockchainPeaks !== undefined && { partialBlockchainPeaks }),
         };
         const existingBlockHeader = await tx.blockHeaders.get(blockNum);
         if (!existingBlockHeader) {
@@ -11277,8 +11225,9 @@ async function updatePartialBlockchainNodes(tx, nodeIndexes, nodes) {
             id: Number(nodeIndexes[index]),
             node: node,
         }));
-        // Use bulkPut to add/overwrite the entries
-        await tx.partialBlockchainNodes.bulkPut(data);
+        // Insert missing nodes and reject conflicting writes
+        await putPartialBlockchainNodesNoOverwrite(tx
+            .partialBlockchainNodes, data);
     }
     catch (err) {
         logWebStoreError(err, "Failed to update partial blockchain nodes");
@@ -11403,17 +11352,6 @@ class Account {
         const ret = wasm.account_isFaucet(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true if this is a network account.
-     *
-     * A network account is a public account whose storage
-     * carries the standardized network-account note-script allowlist slot.
-     * @returns {boolean}
-     */
-    isNetworkAccount() {
-        const ret = wasm.account_isNetworkAccount(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns true if the account has not yet been committed to the chain.
      * @returns {boolean}
@@ -11446,20 +11384,6 @@ class Account {
         const ret = wasm.account_isRegularAccount(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns the note-script roots this network account is allowed to
-     * consume, or `undefined` if this is not a network account.
-     * @returns {Word[] | undefined}
-     */
-    networkNoteAllowlist() {
-        const ret = wasm.account_networkNoteAllowlist(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 account nonce, which is incremented on every state update.
      * @returns {Felt}
@@ -11813,6 +11737,18 @@ class AccountComponent {
         }
         return AccountComponent.__wrap(ret[0]);
     }
+    /**
+     * Returns the exact compiled code used by this component.
+     *
+     * Link this code when compiling scripts that invoke the component. Rebuilding a library from
+     * the original source can produce different procedure identities than the code installed on
+     * the account.
+     * @returns {AccountComponentCode}
+     */
+    componentCode() {
+        const ret = wasm.accountcomponent_componentCode(this.__wbg_ptr);
+        return AccountComponentCode.__wrap(ret);
+    }
     /**
      * @param {Word} commitment
      * @param {AuthScheme} auth_scheme
@@ -11839,42 +11775,6 @@ class AccountComponent {
         }
         return AccountComponent.__wrap(ret[0]);
     }
-    /**
-     * Builds the auth component for a network account.
-     *
-     * A network account is a public account carrying this component: its
-     * note-script allowlist is the standardized storage slot the node's
-     * network-transaction builder inspects to identify the account as a network
-     * account and route matching notes to it for auto-consumption. The account
-     * may only consume notes whose script root is in `allowedNoteScriptRoots`
-     * (obtain a root via `NoteScript.root()`).
-     *
-     * `allowedTxScriptRoots` optionally allowlists transaction script roots
-     * (from `TransactionScript.root()`) the account will execute. When omitted
-     * or empty, the account permits no transaction scripts and deploys and
-     * advances via scriptless transactions only. Allowlist a script root only
-     * if the script's effect is safe for *every* possible input: a root pins
-     * the script's code but not its arguments or advice inputs, which the
-     * (arbitrary) transaction submitter controls.
-     *
-     * # Errors
-     * Errors if `allowedNoteScriptRoots` is empty: a network account with no
-     * allowlisted note scripts could never consume a note.
-     * @param {Word[]} allowed_note_script_roots
-     * @param {Word[] | null} [allowed_tx_script_roots]
-     * @returns {AccountComponent}
-     */
-    static createNetworkAuth(allowed_note_script_roots, allowed_tx_script_roots) {
-        const ptr0 = passArrayJsValueToWasm0(allowed_note_script_roots, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(allowed_tx_script_roots) ? 0 : passArrayJsValueToWasm0(allowed_tx_script_roots, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.accountcomponent_createNetworkAuth(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return AccountComponent.__wrap(ret[0]);
-    }
     /**
      * Creates an account component from a compiled library and storage slots.
      * @param {Library} library
@@ -12001,8 +11901,10 @@ if (Symbol.dispose) AccountComponentCode.prototype[Symbol.dispose] = AccountComp
  * `AccountDelta` stores the differences between two account states.
  *
  * The differences are represented as follows:
- * - `storage`: an `AccountStorageDelta` that contains the changes to the account storage.
- * - `vault`: an `AccountVaultDelta` object that contains the changes to the account vault.
+ * - `storage`: an `AccountStoragePatch` with the absolute final values of changed storage slots
+ *   (storage changes have identical semantics in the delta and patch models).
+ * - `vault`: an `AccountVaultDelta` object that contains the relative changes to the account
+ *   vault.
  * - `nonce`: if the nonce of the account has changed, the new nonce is stored here.
  */
 class AccountDelta {
@@ -12068,12 +11970,12 @@ class AccountDelta {
         return ret;
     }
     /**
-     * Returns the storage delta.
-     * @returns {AccountStorageDelta}
+     * Returns the storage patch (storage changes are absolute in both models).
+     * @returns {AccountStoragePatch}
      */
     storage() {
         const ret = wasm.accountdelta_storage(this.__wbg_ptr);
-        return AccountStorageDelta.__wrap(ret);
+        return AccountStoragePatch.__wrap(ret);
     }
     /**
      * Returns the vault delta.
@@ -12468,6 +12370,90 @@ const AccountInterface = Object.freeze({
     BasicWallet: 0, "0": "BasicWallet",
 });
 
+/**
+ * Describes the new absolute account state produced by a transaction.
+ */
+class AccountPatch {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AccountPatch.prototype);
+        obj.__wbg_ptr = ptr;
+        AccountPatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AccountPatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_accountpatch_free(ptr, 0);
+    }
+    /**
+     * Deserializes an account patch from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {AccountPatch}
+     */
+    static deserialize(bytes) {
+        const ret = wasm.accountpatch_deserialize(bytes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountPatch.__wrap(ret[0]);
+    }
+    /**
+     * Returns the final nonce, or `None` if it was unchanged.
+     * @returns {Felt | undefined}
+     */
+    finalNonce() {
+        const ret = wasm.accountpatch_finalNonce(this.__wbg_ptr);
+        return ret === 0 ? undefined : Felt.__wrap(ret);
+    }
+    /**
+     * Returns the affected account ID.
+     * @returns {AccountId}
+     */
+    id() {
+        const ret = wasm.accountpatch_id(this.__wbg_ptr);
+        return AccountId.__wrap(ret);
+    }
+    /**
+     * Returns true if this patch contains no state changes.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.accountpatch_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Serializes the account patch into bytes.
+     * @returns {Uint8Array}
+     */
+    serialize() {
+        const ret = wasm.accountpatch_serialize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the account storage patch.
+     * @returns {AccountStoragePatch}
+     */
+    storage() {
+        const ret = wasm.accountpatch_storage(this.__wbg_ptr);
+        return AccountStoragePatch.__wrap(ret);
+    }
+    /**
+     * Returns the account vault patch.
+     * @returns {AccountVaultPatch}
+     */
+    vault() {
+        const ret = wasm.accountpatch_vault(this.__wbg_ptr);
+        return AccountVaultPatch.__wrap(ret);
+    }
+}
+if (Symbol.dispose) AccountPatch.prototype[Symbol.dispose] = AccountPatch.prototype.free;
+
 /**
  * Proof of existence of an account's state at a specific block number, as returned by the node.
  *
@@ -12941,74 +12927,6 @@ class AccountStorage {
 }
 if (Symbol.dispose) AccountStorage.prototype[Symbol.dispose] = AccountStorage.prototype.free;
 
-/**
- * `AccountStorageDelta` stores the differences between two states of account storage.
- *
- * The delta consists of two maps:
- * - A map containing the updates to value storage slots. The keys in this map are indexes of the
- *   updated storage slots and the values are the new values for these slots.
- * - A map containing updates to storage maps. The keys in this map are indexes of the updated
- *   storage slots and the values are corresponding storage map delta objects.
- */
-class AccountStorageDelta {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AccountStorageDelta.prototype);
-        obj.__wbg_ptr = ptr;
-        AccountStorageDeltaFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AccountStorageDeltaFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_accountstoragedelta_free(ptr, 0);
-    }
-    /**
-     * Deserializes a storage delta from bytes.
-     * @param {Uint8Array} bytes
-     * @returns {AccountStorageDelta}
-     */
-    static deserialize(bytes) {
-        const ret = wasm.accountstoragedelta_deserialize(bytes);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return AccountStorageDelta.__wrap(ret[0]);
-    }
-    /**
-     * Returns true if no storage slots are changed.
-     * @returns {boolean}
-     */
-    isEmpty() {
-        const ret = wasm.accountstoragedelta_isEmpty(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Serializes the storage delta into bytes.
-     * @returns {Uint8Array}
-     */
-    serialize() {
-        const ret = wasm.accountstoragedelta_serialize(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the new values for modified storage slots.
-     * @returns {Word[]}
-     */
-    values() {
-        const ret = wasm.accountstoragedelta_values(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) AccountStorageDelta.prototype[Symbol.dispose] = AccountStorageDelta.prototype.free;
-
 /**
  * Storage visibility mode for an account.
  *
@@ -13091,8 +13009,70 @@ class AccountStorageMode {
 }
 if (Symbol.dispose) AccountStorageMode.prototype[Symbol.dispose] = AccountStorageMode.prototype.free;
 
-class AccountStorageRequirements {
-    static __wrap(ptr) {
+/**
+ * Absolute updates to named account storage slots.
+ */
+class AccountStoragePatch {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AccountStoragePatch.prototype);
+        obj.__wbg_ptr = ptr;
+        AccountStoragePatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AccountStoragePatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_accountstoragepatch_free(ptr, 0);
+    }
+    /**
+     * Deserializes a storage patch from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {AccountStoragePatch}
+     */
+    static deserialize(bytes) {
+        const ret = wasm.accountstoragepatch_deserialize(bytes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountStoragePatch.__wrap(ret[0]);
+    }
+    /**
+     * Returns true if no storage slots are changed.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.accountstoragepatch_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Serializes the storage patch into bytes.
+     * @returns {Uint8Array}
+     */
+    serialize() {
+        const ret = wasm.accountstoragepatch_serialize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the final values for created or updated value slots.
+     * @returns {Word[]}
+     */
+    values() {
+        const ret = wasm.accountstoragepatch_values(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) AccountStoragePatch.prototype[Symbol.dispose] = AccountStoragePatch.prototype.free;
+
+class AccountStorageRequirements {
+    static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(AccountStorageRequirements.prototype);
         obj.__wbg_ptr = ptr;
@@ -13234,6 +13214,86 @@ class AccountVaultDelta {
 }
 if (Symbol.dispose) AccountVaultDelta.prototype[Symbol.dispose] = AccountVaultDelta.prototype.free;
 
+/**
+ * Absolute updates to account vault entries.
+ */
+class AccountVaultPatch {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AccountVaultPatch.prototype);
+        obj.__wbg_ptr = ptr;
+        AccountVaultPatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AccountVaultPatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_accountvaultpatch_free(ptr, 0);
+    }
+    /**
+     * Deserializes a vault patch from bytes.
+     * @param {Uint8Array} bytes
+     * @returns {AccountVaultPatch}
+     */
+    static deserialize(bytes) {
+        const ret = wasm.accountvaultpatch_deserialize(bytes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountVaultPatch.__wrap(ret[0]);
+    }
+    /**
+     * Returns true if no vault entries are changed.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.accountstoragepatch_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns the number of changed vault entries.
+     * @returns {number}
+     */
+    numAssets() {
+        const ret = wasm.accountvaultpatch_numAssets(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the IDs of removed assets as their canonical words.
+     * @returns {Word[]}
+     */
+    removedAssetIds() {
+        const ret = wasm.accountvaultpatch_removedAssetIds(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Serializes the vault patch into bytes.
+     * @returns {Uint8Array}
+     */
+    serialize() {
+        const ret = wasm.accountvaultpatch_serialize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns fungible assets whose final balance was added or updated.
+     * @returns {FungibleAsset[]}
+     */
+    updatedFungibleAssets() {
+        const ret = wasm.accountvaultpatch_updatedFungibleAssets(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) AccountVaultPatch.prototype[Symbol.dispose] = AccountVaultPatch.prototype.free;
+
 /**
  * Representation of a Miden address (account ID plus routing parameters).
  */
@@ -13425,13 +13485,6 @@ if (Symbol.dispose) AdviceInputs.prototype[Symbol.dispose] = AdviceInputs.protot
  * Map of advice values keyed by words for script execution.
  */
 class AdviceMap {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AdviceMap.prototype);
-        obj.__wbg_ptr = ptr;
-        AdviceMapFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -13472,26 +13525,6 @@ class AdviceMap {
 }
 if (Symbol.dispose) AdviceMap.prototype[Symbol.dispose] = AdviceMap.prototype.free;
 
-/**
- * Whether a faucet's asset callbacks run when an asset is added to an account or a note.
- *
- * The flag is part of an asset's vault key, so two assets from the same faucet with different
- * flags occupy different vault slots and do not merge. Assets minted by a faucet that registers
- * transfer policies carry `Enabled`; everything else carries `Disabled`.
- * @enum {0 | 1}
- */
-const AssetCallbackFlag = Object.freeze({
-    /**
-     * The faucet's callbacks are not invoked for this asset. This is the default for an asset
-     * built via the `FungibleAsset` constructor.
-     */
-    Disabled: 0, "0": "Disabled",
-    /**
-     * The faucet's callbacks are invoked before this asset is added to an account or a note.
-     */
-    Enabled: 1, "1": "Enabled",
-});
-
 /**
  * A container for an unlimited number of assets.
  *
@@ -13773,13 +13806,10 @@ class AuthSecretKey {
 if (Symbol.dispose) AuthSecretKey.prototype[Symbol.dispose] = AuthSecretKey.prototype.free;
 
 /**
- * Provides metadata for a fungible faucet account component.
+ * Provides metadata for a basic fungible faucet account component.
  *
- * Reads the on-chain `FungibleFaucet` component for the account, which holds the per-token
- * info (symbol, decimals, supply, and the descriptive metadata). The same component backs both
- * "basic" public faucets and network-style faucets — in the current protocol the distinction is
- * a function of the surrounding account configuration (account type, auth, access control), not
- * of the faucet component itself — so this reads metadata from either kind of faucet account.
+ * Reads the on-chain [`FungibleFaucet`] component for the account, which holds the
+ * per-token info (symbol/decimals/maxSupply).
  */
 class BasicFungibleFaucetComponent {
     static __wrap(ptr) {
@@ -13807,32 +13837,6 @@ class BasicFungibleFaucetComponent {
         const ret = wasm.basicfungiblefaucetcomponent_decimals(this.__wbg_ptr);
         return ret;
     }
-    /**
-     * Returns the optional free-form token description, or `undefined` when unset.
-     * @returns {string | undefined}
-     */
-    description() {
-        const ret = wasm.basicfungiblefaucetcomponent_description(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 the optional external link (e.g. project website), or `undefined` when unset.
-     * @returns {string | undefined}
-     */
-    externalLink() {
-        const ret = wasm.basicfungiblefaucetcomponent_externalLink(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;
-    }
     /**
      * Extracts faucet metadata from an account.
      * @param {Account} account
@@ -13847,19 +13851,6 @@ class BasicFungibleFaucetComponent {
         }
         return BasicFungibleFaucetComponent.__wrap(ret[0]);
     }
-    /**
-     * Returns the optional token logo URI, or `undefined` when unset.
-     * @returns {string | undefined}
-     */
-    logoUri() {
-        const ret = wasm.basicfungiblefaucetcomponent_logoUri(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 the maximum token supply.
      * @returns {Felt}
@@ -13876,30 +13867,6 @@ class BasicFungibleFaucetComponent {
         const ret = wasm.basicfungiblefaucetcomponent_symbol(this.__wbg_ptr);
         return TokenSymbol.__wrap(ret);
     }
-    /**
-     * Returns the human-readable token name.
-     * @returns {string}
-     */
-    tokenName() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.basicfungiblefaucetcomponent_tokenName(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 current token supply (the amount minted so far).
-     * @returns {Felt}
-     */
-    tokenSupply() {
-        const ret = wasm.basicfungiblefaucetcomponent_tokenSupply(this.__wbg_ptr);
-        return Felt.__wrap(ret);
-    }
 }
 if (Symbol.dispose) BasicFungibleFaucetComponent.prototype[Symbol.dispose] = BasicFungibleFaucetComponent.prototype.free;
 
@@ -13960,7 +13927,7 @@ class BlockHeader {
      * @returns {Word}
      */
     commitment() {
-        const ret = wasm.blockheader_commitment(this.__wbg_ptr);
+        const ret = wasm.accountbuilderresult_seed(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -14005,7 +13972,7 @@ class BlockHeader {
      * @returns {Word}
      */
     proofCommitment() {
-        const ret = wasm.blockheader_commitment(this.__wbg_ptr);
+        const ret = wasm.accountbuilderresult_seed(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -14114,6 +14081,26 @@ class CodeBuilder {
         }
         return AccountComponentCode.__wrap(ret[0]);
     }
+    /**
+     * Compiles account component code under an explicit module path.
+     *
+     * The module path is part of procedure identity in Miden Assembly 0.25. Callers that also
+     * link this component into a transaction script must use the same path for both operations.
+     * @param {string} component_path
+     * @param {string} account_code
+     * @returns {AccountComponentCode}
+     */
+    compileAccountComponentCodeWithPath(component_path, account_code) {
+        const ptr0 = passStringToWasm0(component_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(account_code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codebuilder_compileAccountComponentCodeWithPath(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AccountComponentCode.__wrap(ret[0]);
+    }
     /**
      * Given a Note Script's source code, compiles it with the available
      * modules under this builder. Returns the compiled script.
@@ -14144,6 +14131,20 @@ class CodeBuilder {
         }
         return TransactionScript.__wrap(ret[0]);
     }
+    /**
+     * Dynamically links the exact library installed by an account component.
+     *
+     * Use this for component procedures that are available on-chain and invoked with dynamic
+     * calls, including foreign procedure invocation.
+     * @param {AccountComponentCode} account_component_code
+     */
+    linkDynamicAccountComponentCode(account_component_code) {
+        _assertClass(account_component_code, AccountComponentCode);
+        const ret = wasm.codebuilder_linkDynamicAccountComponentCode(this.__wbg_ptr, account_component_code.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * This is useful to dynamically link the {@link Library} of a foreign account
      * that is invoked using foreign procedure invocation (FPI). Its code is available
@@ -14176,6 +14177,20 @@ class CodeBuilder {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Statically links the exact library installed by an account component.
+     *
+     * This should be preferred over rebuilding the component source with `buildLibrary`, because
+     * the installed component code is the source of truth for its procedure identities.
+     * @param {AccountComponentCode} account_component_code
+     */
+    linkStaticAccountComponentCode(account_component_code) {
+        _assertClass(account_component_code, AccountComponentCode);
+        const ret = wasm.codebuilder_linkStaticAccountComponentCode(this.__wbg_ptr, account_component_code.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Statically links the given library.
      *
@@ -14467,111 +14482,13 @@ class Endpoint {
 }
 if (Symbol.dispose) Endpoint.prototype[Symbol.dispose] = Endpoint.prototype.free;
 
-/**
- * A 20-byte Ethereum address, used as the destination of an `AggLayer` bridge-out (B2AGG) note.
- *
- * Construct one from a hex string with [`EthAddress::from_hex`] (the `0x` prefix is optional) or
- * from raw bytes with [`EthAddress::from_bytes`]. The canonical lowercase, `0x`-prefixed hex form
- * is available via [`EthAddress::to_hex`] (also exposed as `toString`).
- */
-class EthAddress {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(EthAddress.prototype);
-        obj.__wbg_ptr = ptr;
-        EthAddressFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        EthAddressFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ethaddress_free(ptr, 0);
-    }
-    /**
-     * Builds an Ethereum address from its raw 20-byte big-endian representation.
-     *
-     * Returns an error if the input is not exactly 20 bytes long.
-     * @param {Uint8Array} bytes
-     * @returns {EthAddress}
-     */
-    static fromBytes(bytes) {
-        const ret = wasm.ethaddress_fromBytes(bytes);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return EthAddress.__wrap(ret[0]);
-    }
-    /**
-     * Builds an Ethereum address from a hex string (with or without the `0x` prefix).
-     *
-     * Returns an error if the string is not valid hex or does not encode exactly 20 bytes.
-     * @param {string} hex
-     * @returns {EthAddress}
-     */
-    static fromHex(hex) {
-        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ethaddress_fromHex(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return EthAddress.__wrap(ret[0]);
-    }
-    /**
-     * Returns the raw 20-byte big-endian representation of the address.
-     * @returns {Uint8Array}
-     */
-    toBytes() {
-        const ret = wasm.ethaddress_toBytes(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the canonical lowercase, `0x`-prefixed hex representation of the address.
-     * @returns {string}
-     */
-    toHex() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ethaddress_toHex(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 canonical lowercase, `0x`-prefixed hex representation of the address.
-     * @returns {string}
-     */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ethaddress_toString(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);
-        }
-    }
-}
-if (Symbol.dispose) EthAddress.prototype[Symbol.dispose] = EthAddress.prototype.free;
-
 /**
  * Describes the result of executing a transaction program for the Miden protocol.
  *
  * Executed transaction serves two primary purposes:
  * - It contains a complete description of the effects of the transaction. Specifically, it
- *   contains all output notes created as the result of the transaction and describes all the
- *   changes made to the involved account (i.e., the account delta).
+ *   contains all output notes created as the result of the transaction and the absolute-valued
+ *   account patch produced by execution.
  * - It contains all the information required to re-execute and prove the transaction in a
  *   stateless manner. This includes all public transaction inputs, but also all nondeterministic
  *   inputs that the host provided to Miden VM while executing the transaction (i.e., advice
@@ -14595,14 +14512,6 @@ class ExecutedTransaction {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_executedtransaction_free(ptr, 0);
     }
-    /**
-     * Returns the account delta resulting from execution.
-     * @returns {AccountDelta}
-     */
-    accountDelta() {
-        const ret = wasm.executedtransaction_accountDelta(this.__wbg_ptr);
-        return AccountDelta.__wrap(ret);
-    }
     /**
      * Returns the account the transaction was executed against.
      * @returns {AccountId}
@@ -14611,6 +14520,14 @@ class ExecutedTransaction {
         const ret = wasm.executedtransaction_accountId(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
+    /**
+     * Returns the absolute account patch resulting from execution.
+     * @returns {AccountPatch}
+     */
+    accountPatch() {
+        const ret = wasm.executedtransaction_accountPatch(this.__wbg_ptr);
+        return AccountPatch.__wrap(ret);
+    }
     /**
      * Returns the block header that included the transaction.
      * @returns {BlockHeader}
@@ -14883,7 +14800,7 @@ class FetchedAccount {
      * @returns {number}
      */
     lastBlockNum() {
-        const ret = wasm.accountproof_blockNum(this.__wbg_ptr);
+        const ret = wasm.fetchedaccount_lastBlockNum(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -15234,14 +15151,6 @@ class FungibleAsset {
         const ret = wasm.fungibleasset_amount(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
-    /**
-     * Returns whether this asset invokes its faucet's callbacks.
-     * @returns {AssetCallbackFlag}
-     */
-    callbacks() {
-        const ret = wasm.fungibleasset_callbacks(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Returns the faucet account that minted this asset.
      * @returns {AccountId}
@@ -15273,20 +15182,6 @@ class FungibleAsset {
         FungibleAssetFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
-    /**
-     * Returns a copy of this asset carrying the given callback flag.
-     *
-     * The flag is part of the asset's vault key, so it must match the flag the issuing faucet
-     * applies — an asset built with the wrong flag addresses a different vault slot than the one
-     * holding the balance. The constructor always produces `Disabled`; pass `Enabled` only for
-     * assets from a faucet that registers transfer policies.
-     * @param {AssetCallbackFlag} callbacks
-     * @returns {FungibleAsset}
-     */
-    withCallbacks(callbacks) {
-        const ret = wasm.fungibleasset_withCallbacks(this.__wbg_ptr, callbacks);
-        return FungibleAsset.__wrap(ret);
-    }
 }
 if (Symbol.dispose) FungibleAsset.prototype[Symbol.dispose] = FungibleAsset.prototype.free;
 
@@ -15351,7 +15246,7 @@ class FungibleAssetDelta {
      * @returns {boolean}
      */
     isEmpty() {
-        const ret = wasm.accountstoragedelta_isEmpty(this.__wbg_ptr);
+        const ret = wasm.accountstoragepatch_isEmpty(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -15359,7 +15254,7 @@ class FungibleAssetDelta {
      * @returns {number}
      */
     numAssets() {
-        const ret = wasm.fungibleassetdelta_numAssets(this.__wbg_ptr);
+        const ret = wasm.accountvaultpatch_numAssets(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -15662,16 +15557,6 @@ class InputNoteRecord {
         const ret = wasm.inputnoterecord_isConsumed(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true while the note's on-chain inclusion is still unsettled
-     * (`Expected` or `Unverified`), i.e. while sync is the mechanism that can
-     * advance this record.
-     * @returns {boolean}
-     */
-    isInclusionPending() {
-        const ret = wasm.inputnoterecord_isInclusionPending(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns true if the note is currently being processed.
      * @returns {boolean}
@@ -16402,13 +16287,12 @@ class JsStateSyncUpdate {
         return v1;
     }
     /**
-     * Serialized MMR peaks at the new sync height (single set for the whole update).
-     * Written onto the chain-tip block's `blockHeaders` row (the one whose
-     * `blockNum` matches `block_num`) and read back by `getCurrentBlockchainPeaks`.
+     * Serialized MMR peaks at the new sync height. The only peaks persisted by the
+     * client (peaks for intermediate note blocks are never read, so they are not stored).
      * @returns {Uint8Array}
      */
-    get partialBlockchainPeaks() {
-        const ret = wasm.__wbg_get_jsstatesyncupdate_partialBlockchainPeaks(this.__wbg_ptr);
+    get newPeaks() {
+        const ret = wasm.__wbg_get_jsstatesyncupdate_newPeaks(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -16521,15 +16405,14 @@ class JsStateSyncUpdate {
         wasm.__wbg_set_jsstatesyncupdate_newBlockNums(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Serialized MMR peaks at the new sync height (single set for the whole update).
-     * Written onto the chain-tip block's `blockHeaders` row (the one whose
-     * `blockNum` matches `block_num`) and read back by `getCurrentBlockchainPeaks`.
+     * Serialized MMR peaks at the new sync height. The only peaks persisted by the
+     * client (peaks for intermediate note blocks are never read, so they are not stored).
      * @param {Uint8Array} arg0
      */
-    set partialBlockchainPeaks(arg0) {
+    set newPeaks(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstatesyncupdate_partialBlockchainPeaks(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsstatesyncupdate_newPeaks(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * Input notes for this state update in serialized form.
@@ -16717,6 +16600,17 @@ class JsStorageSlot {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_jsstorageslot_free(ptr, 0);
     }
+    /**
+     * The storage patch operation (create, update, or remove).
+     *
+     * Full-state writes do not inspect this field, but incremental writes use it to distinguish
+     * map replacement/removal from an entry-wise update.
+     * @returns {number}
+     */
+    get patchOperation() {
+        const ret = wasm.__wbg_get_jsstorageslot_patchOperation(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * The name of the storage slot.
      * @returns {string}
@@ -16757,6 +16651,16 @@ class JsStorageSlot {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The storage patch operation (create, update, or remove).
+     *
+     * Full-state writes do not inspect this field, but incremental writes use it to distinguish
+     * map replacement/removal from an entry-wise update.
+     * @param {number} arg0
+     */
+    set patchOperation(arg0) {
+        wasm.__wbg_set_jsstorageslot_patchOperation(this.__wbg_ptr, arg0);
+    }
     /**
      * The name of the storage slot.
      * @param {string} arg0
@@ -16958,97 +16862,6 @@ class MerklePath {
 }
 if (Symbol.dispose) MerklePath.prototype[Symbol.dispose] = MerklePath.prototype.free;
 
-/**
- * Targets a note at a public network account so the operator auto-consumes it.
- *
- * A note is a network note when it is `Public` and carries a valid
- * `NetworkAccountTarget` attachment (see `Note.isNetworkNote`).
- */
-class NetworkAccountTarget {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(NetworkAccountTarget.prototype);
-        obj.__wbg_ptr = ptr;
-        NetworkAccountTargetFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NetworkAccountTargetFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_networkaccounttarget_free(ptr, 0);
-    }
-    /**
-     * Returns the note execution hint.
-     * @returns {NoteExecutionHint}
-     */
-    executionHint() {
-        const ret = wasm.networkaccounttarget_executionHint(this.__wbg_ptr);
-        return NoteExecutionHint.__wrap(ret);
-    }
-    /**
-     * Decodes a `NoteAttachment` back into a `NetworkAccountTarget`.
-     *
-     * # Errors
-     * Errors if the attachment is not a valid network-account-target attachment.
-     * @param {NoteAttachment} attachment
-     * @returns {NetworkAccountTarget}
-     */
-    static fromAttachment(attachment) {
-        _assertClass(attachment, NoteAttachment);
-        const ret = wasm.networkaccounttarget_fromAttachment(attachment.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NetworkAccountTarget.__wrap(ret[0]);
-    }
-    /**
-     * Creates a target for the given network account. `executionHint` defaults
-     * to `NoteExecutionHint.always()`.
-     *
-     * # Errors
-     * Errors if `account_id` is not a public account.
-     * @param {AccountId} account_id
-     * @param {NoteExecutionHint | null} [execution_hint]
-     */
-    constructor(account_id, execution_hint) {
-        _assertClass(account_id, AccountId);
-        let ptr0 = 0;
-        if (!isLikeNone(execution_hint)) {
-            _assertClass(execution_hint, NoteExecutionHint);
-            ptr0 = execution_hint.__destroy_into_raw();
-        }
-        const ret = wasm.networkaccounttarget_new(account_id.__wbg_ptr, ptr0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        NetworkAccountTargetFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Returns the targeted network account id.
-     * @returns {AccountId}
-     */
-    targetId() {
-        const ret = wasm.accountreader_accountId(this.__wbg_ptr);
-        return AccountId.__wrap(ret);
-    }
-    /**
-     * Encodes this target as a `NoteAttachment`.
-     * @returns {NoteAttachment}
-     */
-    toAttachment() {
-        const ret = wasm.networkaccounttarget_toAttachment(this.__wbg_ptr);
-        return NoteAttachment.__wrap(ret);
-    }
-}
-if (Symbol.dispose) NetworkAccountTarget.prototype[Symbol.dispose] = NetworkAccountTarget.prototype.free;
-
 /**
  * The identifier of a Miden network.
  */
@@ -17242,16 +17055,6 @@ class Note {
         const ret = wasm.note_assets(this.__wbg_ptr);
         return NoteAssets.__wrap(ret);
     }
-    /**
-     * Returns the note's attachments.
-     * @returns {NoteAttachment[]}
-     */
-    attachments() {
-        const ret = wasm.note_attachments(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
     /**
      * Returns the commitment to the note (its ID).
      *
@@ -17261,35 +17064,9 @@ class Note {
      * unchanged.
      * @returns {Word}
      */
-    commitment() {
-        const ret = wasm.note_commitment(this.__wbg_ptr);
-        return Word.__wrap(ret);
-    }
-    /**
-     * Builds a B2AGG (Bridge-to-AggLayer) note that bridges the given assets out to another
-     * network via the `AggLayer`.
-     *
-     * The note is always public and is consumed by `bridge_account`, which burns the assets so
-     * they can be claimed on the destination network at `destination_address` (an Ethereum
-     * address on the AggLayer-assigned `destination_network`). The assets must be fungible assets
-     * issued by a network faucet.
-     * @param {AccountId} sender
-     * @param {AccountId} bridge_account
-     * @param {NoteAssets} assets
-     * @param {number} destination_network
-     * @param {EthAddress} destination_address
-     * @returns {Note}
-     */
-    static createB2AggNote(sender, bridge_account, assets, destination_network, destination_address) {
-        _assertClass(sender, AccountId);
-        _assertClass(bridge_account, AccountId);
-        _assertClass(assets, NoteAssets);
-        _assertClass(destination_address, EthAddress);
-        const ret = wasm.note_createB2AggNote(sender.__wbg_ptr, bridge_account.__wbg_ptr, assets.__wbg_ptr, destination_network, destination_address.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Note.__wrap(ret[0]);
+    commitment() {
+        const ret = wasm.note_commitment(this.__wbg_ptr);
+        return Word.__wrap(ret);
     }
     /**
      * Builds a P2IDE note that can be reclaimed or timelocked based on block heights.
@@ -17353,15 +17130,6 @@ class Note {
         const ret = wasm.note_commitment(this.__wbg_ptr);
         return NoteId.__wrap(ret);
     }
-    /**
-     * Returns true if the note is a network note (public + a valid
-     * `NetworkAccountTarget` attachment).
-     * @returns {boolean}
-     */
-    isNetworkNote() {
-        const ret = wasm.note_isNetworkNote(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns the public metadata associated with the note.
      * @returns {NoteMetadata}
@@ -17421,30 +17189,6 @@ class Note {
         const ret = wasm.note_serialize(this.__wbg_ptr);
         return ret;
     }
-    /**
-     * Creates a note carrying the provided attachments, using the metadata's
-     * sender / note type / tag (attachments on the metadata itself are ignored).
-     *
-     * # Errors
-     * Errors if the attachment set is invalid (too many attachments or words).
-     * @param {NoteAssets} note_assets
-     * @param {NoteMetadata} note_metadata
-     * @param {NoteRecipient} note_recipient
-     * @param {NoteAttachment[]} attachments
-     * @returns {Note}
-     */
-    static withAttachments(note_assets, note_metadata, note_recipient, attachments) {
-        _assertClass(note_assets, NoteAssets);
-        _assertClass(note_metadata, NoteMetadata);
-        _assertClass(note_recipient, NoteRecipient);
-        const ptr0 = passArrayJsValueToWasm0(attachments, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.note_withAttachments(note_assets.__wbg_ptr, note_metadata.__wbg_ptr, note_recipient.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Note.__wrap(ret[0]);
-    }
 }
 if (Symbol.dispose) Note.prototype[Symbol.dispose] = Note.prototype.free;
 
@@ -17712,12 +17456,6 @@ class NoteAttachment {
         NoteAttachmentFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof NoteAttachment)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -18341,6 +18079,19 @@ class NoteFile {
         }
         return NoteFile.__wrap(ret[0]);
     }
+    /**
+     * Creates an expected-note file with the sync hint required by miden-client 0.16.
+     * @param {NoteDetails} note_details
+     * @param {NoteTag} note_tag
+     * @param {number} after_block_num
+     * @returns {NoteFile}
+     */
+    static fromExpectedNote(note_details, note_tag, after_block_num) {
+        _assertClass(note_details, NoteDetails);
+        _assertClass(note_tag, NoteTag);
+        const ret = wasm.notefile_fromExpectedNote(note_details.__wbg_ptr, note_tag.__wbg_ptr, after_block_num);
+        return NoteFile.__wrap(ret);
+    }
     /**
      * Creates a `NoteFile` from an input note, preserving proof when available.
      * @param {InputNote} note
@@ -18352,7 +18103,11 @@ class NoteFile {
         return NoteFile.__wrap(ret);
     }
     /**
-     * Creates a `NoteFile` from note details.
+     * Creates a `NoteFile` from note details using a zero-valued sync hint.
+     *
+     * miden-client 0.16 requires every expected note to include a tag and an after-block hint.
+     * This retains the old one-argument JS API by using block zero and the default tag. Prefer
+     * [`from_expected_note`](Self::from_expected_note) when the real sync hint is available.
      * @param {NoteDetails} note_details
      * @returns {NoteFile}
      */
@@ -18948,19 +18703,6 @@ class NoteRecipient {
         const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
-    /**
-     * Creates a recipient from a script and storage, generating a fresh random
-     * serial number (the secret that prevents double-spends).
-     * @param {NoteScript} note_script
-     * @param {NoteStorage} storage
-     * @returns {NoteRecipient}
-     */
-    static fromScript(note_script, storage) {
-        _assertClass(note_script, NoteScript);
-        _assertClass(storage, NoteStorage);
-        const ret = wasm.noterecipient_fromScript(note_script.__wbg_ptr, storage.__wbg_ptr);
-        return NoteRecipient.__wrap(ret);
-    }
     /**
      * Creates a note recipient from its serial number, script, and storage.
      * @param {Word} serial_num
@@ -19648,7 +19390,7 @@ class OutputNoteRecord {
      * @returns {number}
      */
     expectedHeight() {
-        const ret = wasm.outputnoterecord_expectedHeight(this.__wbg_ptr);
+        const ret = wasm.blockheader_version(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -19683,22 +19425,12 @@ class OutputNoteRecord {
         const ret = wasm.outputnoterecord_isConsumed(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true while the note's on-chain inclusion is still unsettled
-     * (`ExpectedFull` or `ExpectedPartial`), i.e. while sync is the mechanism
-     * that can advance this record.
-     * @returns {boolean}
-     */
-    isInclusionPending() {
-        const ret = wasm.outputnoterecord_isInclusionPending(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns the note metadata.
      * @returns {NoteMetadata}
      */
     metadata() {
-        const ret = wasm.committednote_metadata(this.__wbg_ptr);
+        const ret = wasm.outputnoterecord_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
     /**
@@ -20071,7 +19803,7 @@ class ProvenTransaction {
      * @returns {AccountId}
      */
     accountId() {
-        const ret = wasm.account_id(this.__wbg_ptr);
+        const ret = wasm.proventransaction_accountId(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
     /**
@@ -20099,7 +19831,7 @@ class ProvenTransaction {
      * @returns {TransactionId}
      */
     id() {
-        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        const ret = wasm.proventransaction_id(this.__wbg_ptr);
         return TransactionId.__wrap(ret);
     }
     /**
@@ -20117,7 +19849,7 @@ class ProvenTransaction {
      * @returns {Word}
      */
     refBlockCommitment() {
-        const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
+        const ret = wasm.proventransaction_refBlockCommitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -20139,119 +19871,6 @@ class ProvenTransaction {
 }
 if (Symbol.dispose) ProvenTransaction.prototype[Symbol.dispose] = ProvenTransaction.prototype.free;
 
-/**
- * Read-only view of one PSWAP order's chain state, exposed to JavaScript.
- * The mutable fields (remaining amounts, depth, tip, state) advance
- * round-by-round as fills are discovered during sync.
- */
-class PswapLineageRecord {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(PswapLineageRecord.prototype);
-        obj.__wbg_ptr = ptr;
-        PswapLineageRecordFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        PswapLineageRecordFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_pswaplineagerecord_free(ptr, 0);
-    }
-    /**
-     * Account that created the order and receives every payback.
-     * @returns {AccountId}
-     */
-    creatorAccountId() {
-        const ret = wasm.pswaplineagerecord_creatorAccountId(this.__wbg_ptr);
-        return AccountId.__wrap(ret);
-    }
-    /**
-     * Depth of the current tip: 0 for the original PSWAP, +1 per fill round.
-     * @returns {number}
-     */
-    currentDepth() {
-        const ret = wasm.pswaplineagerecord_currentDepth(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Note id of the current tip in the chain.
-     * @returns {NoteId}
-     */
-    currentTipNoteId() {
-        const ret = wasm.pswaplineagerecord_currentTipNoteId(this.__wbg_ptr);
-        return NoteId.__wrap(ret);
-    }
-    /**
-     * Stable identifier shared by every note in the chain, as a decimal string.
-     * @returns {string}
-     */
-    orderId() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.pswaplineagerecord_orderId(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);
-        }
-    }
-    /**
-     * Offered amount still unfilled on the current tip. The offered faucet is
-     * chain-invariant and recovered from the original PSWAP note when needed.
-     * @returns {bigint}
-     */
-    remainingOffered() {
-        const ret = wasm.pswaplineagerecord_remainingOffered(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * Requested amount still outstanding on the current tip. The requested
-     * faucet is recovered from the original PSWAP note when needed.
-     * @returns {bigint}
-     */
-    remainingRequested() {
-        const ret = wasm.pswaplineagerecord_remainingRequested(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * Lifecycle state of the order.
-     * @returns {PswapLineageState}
-     */
-    state() {
-        const ret = wasm.pswaplineagerecord_state(this.__wbg_ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) PswapLineageRecord.prototype[Symbol.dispose] = PswapLineageRecord.prototype.free;
-
-/**
- * Lifecycle state of a PSWAP order.
- *
- * Discriminants match the on-disk encoding in the store.
- * @enum {0 | 1 | 2}
- */
-const PswapLineageState = Object.freeze({
-    /**
-     * Still fillable and reclaimable.
-     */
-    Active: 0, "0": "Active",
-    /**
-     * Fully filled. Terminal.
-     */
-    FullyFilled: 1, "1": "FullyFilled",
-    /**
-     * Reclaimed by the creator. Terminal.
-     */
-    Reclaimed: 2, "2": "Reclaimed",
-});
-
 class PublicKey {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -20998,7 +20617,7 @@ class SerializedOutputNoteData {
     set attachments(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstatesyncupdate_partialBlockchainPeaks(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsstatesyncupdate_newPeaks(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {string} arg0
@@ -21743,7 +21362,7 @@ if (Symbol.dispose) StorageMapEntryJs.prototype[Symbol.dispose] = StorageMapEntr
  * 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,
+ * Contains the storage map entries merged over the requested block range,
  * along with the chain tip and last processed block number.
  */
 class StorageMapInfo {
@@ -21794,8 +21413,8 @@ class StorageMapInfo {
 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.
+ * A merged storage map entry containing the last processed block number, slot name, key, and
+ * final value. The node no longer exposes the individual block number for each update.
  */
 class StorageMapUpdate {
     static __wrap(ptr) {
@@ -21816,7 +21435,7 @@ class StorageMapUpdate {
         wasm.__wbg_storagemapupdate_free(ptr, 0);
     }
     /**
-     * Returns the block number in which this update occurred.
+     * Returns the last processed block number for the merged response.
      * @returns {number}
      */
     blockNum() {
@@ -22559,7 +22178,7 @@ class TransactionRecord {
      * @returns {AccountId}
      */
     accountId() {
-        const ret = wasm.transactionrecord_accountId(this.__wbg_ptr);
+        const ret = wasm.proventransaction_accountId(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
     /**
@@ -22607,7 +22226,7 @@ class TransactionRecord {
      * @returns {Word}
      */
     initAccountState() {
-        const ret = wasm.pswaplineagerecord_currentTipNoteId(this.__wbg_ptr);
+        const ret = wasm.transactionrecord_initAccountState(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
     /**
@@ -22672,14 +22291,6 @@ class TransactionRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_transactionrequest_free(ptr, 0);
     }
-    /**
-     * Returns a copy of the advice map carried by this request.
-     * @returns {AdviceMap}
-     */
-    adviceMap() {
-        const ret = wasm.transactionrequest_adviceMap(this.__wbg_ptr);
-        return AdviceMap.__wrap(ret);
-    }
     /**
      * Returns the authentication argument if present.
      * @returns {Word | undefined}
@@ -22726,20 +22337,6 @@ class TransactionRequest {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
-    /**
-     * Returns a copy of this request with `advice_map` merged into its advice map.
-     *
-     * Entries are merged with last-write-wins semantics: a key already present in the request is
-     * overwritten by the value from `advice_map`. Use this to inject advice (e.g. a signature
-     * produced by an external signer) after the request has already been built.
-     * @param {AdviceMap} advice_map
-     * @returns {TransactionRequest}
-     */
-    extendAdviceMap(advice_map) {
-        _assertClass(advice_map, AdviceMap);
-        const ret = wasm.transactionrequest_extendAdviceMap(this.__wbg_ptr, advice_map.__wbg_ptr);
-        return TransactionRequest.__wrap(ret);
-    }
     /**
      * Returns the transaction script argument if present.
      * @returns {Word | undefined}
@@ -23285,12 +22882,12 @@ class TransactionStoreUpdate {
         wasm.__wbg_transactionstoreupdate_free(ptr, 0);
     }
     /**
-     * Returns the account delta applied by the transaction.
-     * @returns {AccountDelta}
+     * Returns the absolute account patch applied by the transaction.
+     * @returns {AccountPatch}
      */
-    accountDelta() {
-        const ret = wasm.transactionstoreupdate_accountDelta(this.__wbg_ptr);
-        return AccountDelta.__wrap(ret);
+    accountPatch() {
+        const ret = wasm.transactionstoreupdate_accountPatch(this.__wbg_ptr);
+        return AccountPatch.__wrap(ret);
     }
     /**
      * Returns the output notes created by the transaction.
@@ -23501,10 +23098,6 @@ class WebClient {
         return ret;
     }
     /**
-     * Persists a submitted transaction and returns its pre-apply
-     * [`TransactionStoreUpdate`]. Routes through the high-level
-     * `Client::apply_transaction` so registered observers (e.g. PSWAP
-     * tracking) fire.
      * @param {TransactionResult} transaction_result
      * @param {number} submission_height
      * @returns {Promise<TransactionStoreUpdate>}
@@ -23514,22 +23107,6 @@ class WebClient {
         const ret = wasm.webclient_applyTransaction(this.__wbg_ptr, transaction_result.__wbg_ptr, submission_height);
         return ret;
     }
-    /**
-     * Builds a transaction reclaiming the unfilled offered asset on the current
-     * tip of an Active lineage.
-     *
-     * `order_id` is the order's stable identifier as a decimal string. The
-     * returned request flows into the same submit path as the other PSWAP
-     * cancel transactions.
-     * @param {string} order_id
-     * @returns {Promise<TransactionRequest>}
-     */
-    buildPswapCancelByOrder(order_id) {
-        const ptr0 = passStringToWasm0(order_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_buildPswapCancelByOrder(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
     /**
      * @param {NoteType} note_type
      * @param {AccountId} offered_asset_faucet_id
@@ -23557,17 +23134,13 @@ class WebClient {
      * * `store_name`: Optional name for the web store. If `None`, the store name defaults to
      *   `MidenClientDB_{network_id}`, where `network_id` is derived from the `node_url`.
      *   Explicitly setting this allows for creating multiple isolated clients.
-     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. When enabled,
-     *   the transaction executor records additional information useful for debugging. Defaults to
-     *   disabled.
      * @param {string | null} [node_url]
      * @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, debug_mode) {
+    createClient(node_url, node_note_transport_url, seed, store_name) {
         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);
@@ -23576,7 +23149,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, isLikeNone(debug_mode) ? 0xFFFFFF : debug_mode ? 1 : 0);
+        const ret = wasm.webclient_createClient(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
         return ret;
     }
     /**
@@ -23592,8 +23165,6 @@ class WebClient {
      * * `get_key_cb`: Callback to retrieve the secret key bytes for a given public key.
      * * `insert_key_cb`: Callback to persist a secret key.
      * * `sign_cb`: Callback to produce serialized signature bytes for the provided inputs.
-     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. Defaults to
-     *   disabled.
      * @param {string | null} [node_url]
      * @param {string | null} [node_note_transport_url]
      * @param {Uint8Array | null} [seed]
@@ -23601,10 +23172,9 @@ 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, debug_mode) {
+    createClientWithExternalKeystore(node_url, node_note_transport_url, seed, store_name, get_key_cb, insert_key_cb, sign_cb) {
         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);
@@ -23613,7 +23183,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), isLikeNone(debug_mode) ? 0xFFFFFF : debug_mode ? 1 : 0);
+        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));
         return ret;
     }
     /**
@@ -23642,14 +23212,18 @@ class WebClient {
         return ret;
     }
     /**
-     * Executes a transaction and returns the `TransactionSummary`.
+     * Executes a transaction and returns the `TransactionSummary` the account is being asked
+     * to authorize.
      *
-     * If the transaction is unauthorized (auth script emits the unauthorized event),
-     * returns the summary from the error. If the transaction succeeds, constructs
-     * a summary from the executed transaction using the `auth_arg` from the transaction
-     * request as the salt (or a zero salt if not provided).
+     * The summary only exists while authorization is pending: when the auth procedure aborts
+     * with the unauthorized event (e.g. a multisig below its signing threshold), the summary
+     * built during execution is returned so it can be signed out-of-band. If the transaction
+     * executes successfully it was already fully authorized, no summary is produced, and this
+     * method returns an error with code `TRANSACTION_ALREADY_AUTHORIZED` — submit the
+     * transaction with `execute` instead.
      *
      * # Errors
+     * - If the transaction executes successfully (error code `TRANSACTION_ALREADY_AUTHORIZED`).
      * - If there is an internal failure during execution.
      * @param {AccountId} account_id
      * @param {TransactionRequest} transaction_request
@@ -23873,37 +23447,6 @@ class WebClient {
         const ret = wasm.webclient_getOutputNotes(this.__wbg_ptr, ptr0);
         return ret;
     }
-    /**
-     * Returns the lineage for one order, or `null` if not tracked.
-     *
-     * `order_id` is the order's stable identifier as a decimal string.
-     * @param {string} order_id
-     * @returns {Promise<PswapLineageRecord | undefined>}
-     */
-    getPswapLineage(order_id) {
-        const ptr0 = passStringToWasm0(order_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_getPswapLineage(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Returns every PSWAP lineage tracked by this client.
-     * @returns {Promise<PswapLineageRecord[]>}
-     */
-    getPswapLineages() {
-        const ret = wasm.webclient_getPswapLineages(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns lineages created by a specific local account.
-     * @param {AccountId} creator
-     * @returns {Promise<PswapLineageRecord[]>}
-     */
-    getPswapLineagesFor(creator) {
-        _assertClass(creator, AccountId);
-        const ret = wasm.webclient_getPswapLineagesFor(this.__wbg_ptr, creator.__wbg_ptr);
-        return ret;
-    }
     /**
      * Returns all public key commitments associated with the given account ID.
      *
@@ -23967,10 +23510,10 @@ class WebClient {
     /**
      * Imports a note file and returns the imported note's identifier.
      *
-     * A note file that carries metadata — an explicit `NoteId` or a full note
-     * with proof — resolves to a concrete `NoteId`, which is returned so the
-     * caller can look the note up with [`get_input_note`]. A details-only file
-     * (`NoteDetails`) has no metadata and therefore no `NoteId` yet, so its
+     * A note file that carries metadata — an explicit `NoteId` or a committed
+     * note with proof — resolves to a concrete `NoteId`, which is returned so
+     * the caller can look the note up with [`get_input_note`]. An expected-note
+     * file has no metadata and therefore no `NoteId` yet, so its
      * metadata-independent details commitment is returned instead.
      *
      * Migration note (miden-client PR #2214): `Client::import_notes` now
@@ -24096,30 +23639,6 @@ class WebClient {
         const ret = wasm.webclient_newAccountWithSecretKey(this.__wbg_ptr, account.__wbg_ptr, secret_key.__wbg_ptr);
         return ret;
     }
-    /**
-     * Builds a transaction request that bridges a fungible asset out to another network via the
-     * `AggLayer`.
-     *
-     * The request emits a single public B2AGG (Bridge-to-AggLayer) note holding `amount` units of
-     * the `faucet_id` asset. The note is consumed by `bridge_account_id`, which burns the asset so
-     * it can be claimed at `destination_address` (an Ethereum address) on the AggLayer-assigned
-     * `destination_network`.
-     * @param {AccountId} sender_account_id
-     * @param {AccountId} bridge_account_id
-     * @param {AccountId} faucet_id
-     * @param {bigint} amount
-     * @param {number} destination_network
-     * @param {EthAddress} destination_address
-     * @returns {Promise<TransactionRequest>}
-     */
-    newB2AggTransactionRequest(sender_account_id, bridge_account_id, faucet_id, amount, destination_network, destination_address) {
-        _assertClass(sender_account_id, AccountId);
-        _assertClass(bridge_account_id, AccountId);
-        _assertClass(faucet_id, AccountId);
-        _assertClass(destination_address, EthAddress);
-        const ret = wasm.webclient_newB2AggTransactionRequest(this.__wbg_ptr, sender_account_id.__wbg_ptr, bridge_account_id.__wbg_ptr, faucet_id.__wbg_ptr, amount, destination_network, destination_address.__wbg_ptr);
-        return ret;
-    }
     /**
      * @param {Note[]} list_of_notes
      * @returns {TransactionRequest}
@@ -24413,25 +23932,6 @@ class WebClient {
         const ret = wasm.webclient_submitNewTransaction(this.__wbg_ptr, account_id.__wbg_ptr, transaction_request.__wbg_ptr);
         return ret;
     }
-    /**
-     * Executes a batch of transactions against the specified account, proves them individually
-     * and as a batch, submits the batch to the network, and atomically applies the per-tx
-     * updates to the local store. Returns the block number the batch was accepted into.
-     *
-     * All transactions must target the same local account — the `account_id` argument.
-     * Each element of `transaction_requests` is the serialized-bytes form of a
-     * `TransactionRequest` (obtained via `tx_request.serialize()`)
-     * @param {AccountId} account_id
-     * @param {Uint8Array[]} transaction_requests
-     * @returns {Promise<number>}
-     */
-    submitNewTransactionBatch(account_id, transaction_requests) {
-        _assertClass(account_id, AccountId);
-        const ptr0 = passArrayJsValueToWasm0(transaction_requests, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_submitNewTransactionBatch(this.__wbg_ptr, account_id.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
     /**
      * Executes a transaction specified by the request against the specified account, proves it
      * with the user provided prover, submits it to the network, and updates the local database.
@@ -24929,7 +24429,7 @@ function __wbg_get_imports() {
             const ret = AccountStorage.__wrap(arg0);
             return ret;
         },
-        __wbg_addNoteTag_94ee2f838ec544dc: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        __wbg_addNoteTag_1500aff2fa0d151c: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -24957,25 +24457,7 @@ 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_43caa7474baffc0b: function(arg0, arg1, arg2) {
-            const ret = applyFullAccountState(getStringFromWasm0(arg0, arg1), JsAccountUpdate.__wrap(arg2));
-            return ret;
-        },
-        __wbg_applySettingsMutations_5de1d94023be9157: function(arg0, arg1, arg2, arg3) {
-            var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
-            wasm.__wbindgen_free(arg2, arg3 * 4, 4);
-            const ret = applySettingsMutations(getStringFromWasm0(arg0, arg1), v0);
-            return ret;
-        },
-        __wbg_applyStateSync_189438332d96496e: function(arg0, arg1, arg2) {
-            const ret = applyStateSync(getStringFromWasm0(arg0, arg1), JsStateSyncUpdate.__wrap(arg2));
-            return ret;
-        },
-        __wbg_applyTransactionBatch_c300ed1fee34127a: function(arg0, arg1, arg2) {
-            const ret = applyTransactionBatch(getStringFromWasm0(arg0, arg1), arg2);
-            return ret;
-        },
-        __wbg_applyTransactionDelta_88c7fcff9175e58e: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20) {
+        __wbg_applyAccountPatch_ade374c1e2049a8e: 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;
@@ -25007,7 +24489,7 @@ function __wbg_get_imports() {
                 deferred7_1 = arg17;
                 deferred8_0 = arg19;
                 deferred8_1 = arg20;
-                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));
+                const ret = applyAccountPatch(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);
@@ -25018,6 +24500,20 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
             }
         },
+        __wbg_applyFullAccountState_f9562e4091c2eaf6: function(arg0, arg1, arg2) {
+            const ret = applyFullAccountState(getStringFromWasm0(arg0, arg1), JsAccountUpdate.__wrap(arg2));
+            return ret;
+        },
+        __wbg_applySettingsMutations_722d272d653902a1: function(arg0, arg1, arg2, arg3) {
+            var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
+            wasm.__wbindgen_free(arg2, arg3 * 4, 4);
+            const ret = applySettingsMutations(getStringFromWasm0(arg0, arg1), v0);
+            return ret;
+        },
+        __wbg_applyStateSync_4c25ec00de2f60bb: function(arg0, arg1, arg2) {
+            const ret = applyStateSync(getStringFromWasm0(arg0, arg1), JsStateSyncUpdate.__wrap(arg2));
+            return ret;
+        },
         __wbg_assetvault_new: function(arg0) {
             const ret = AssetVault.__wrap(arg0);
             return ret;
@@ -25114,7 +24610,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_exportStore_cf4d695fbf6de143: function(arg0, arg1) {
+        __wbg_exportStore_3b84792dca9a9ef1: function(arg0, arg1) {
             const ret = exportStore(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -25146,7 +24642,7 @@ function __wbg_get_imports() {
             const ret = FetchedNote.__wrap(arg0);
             return ret;
         },
-        __wbg_forceImportStore_c50115d19ee606c7: function(arg0, arg1, arg2) {
+        __wbg_forceImportStore_6a4fb8bc450bbf4a: function(arg0, arg1, arg2) {
             const ret = forceImportStore(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         },
@@ -25154,10 +24650,6 @@ function __wbg_get_imports() {
             const ret = ForeignAccount.__unwrap(arg0);
             return ret;
         },
-        __wbg_from_bddd64e7d5ff6941: function(arg0) {
-            const ret = Array.from(arg0);
-            return ret;
-        },
         __wbg_fungibleasset_new: function(arg0) {
             const ret = FungibleAsset.__wrap(arg0);
             return ret;
@@ -25170,7 +24662,7 @@ function __wbg_get_imports() {
             const ret = FungibleAssetDeltaItem.__wrap(arg0);
             return ret;
         },
-        __wbg_getAccountAddresses_cbd727101b08a9f6: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAddresses_68ba5f3f8a9c7e15: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25182,7 +24674,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountAuthByPubKeyCommitment_bb937a852fc252bc: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAuthByPubKeyCommitment_568661071566f307: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25194,7 +24686,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountCode_3cc0ae7a622f54fc: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountCode_14e446cd1a3f814f: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25206,7 +24698,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeaderByCommitment_9944282b839bf9b6: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeaderByCommitment_0e10e9ac733f359b: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25218,7 +24710,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeader_84fb6f83a11e9cea: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeader_ef6ad25115d9bd02: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25230,7 +24722,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIdByKeyCommitment_f993328b4b855b21: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountIdByKeyCommitment_c0c17f1af8b92023: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25242,11 +24734,11 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIds_e80dceb4cc97875f: function(arg0, arg1) {
+        __wbg_getAccountIds_07de8c6f4a5ee883: function(arg0, arg1) {
             const ret = getAccountIds(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getAccountStorageMaps_e36e581a33dc958a: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorageMaps_b16de6210ce82188: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25258,7 +24750,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountStorage_50de137ac49bdf17: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_getAccountStorage_c876ec60dbfa6cee: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25272,7 +24764,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountVaultAssets_30c74124867dbf56: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_getAccountVaultAssets_479ef945dd51412a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25286,27 +24778,27 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAllAccountHeaders_b3e3ae880833a8cc: function(arg0, arg1) {
+        __wbg_getAllAccountHeaders_f78e678ad24296de: function(arg0, arg1) {
             const ret = getAllAccountHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getBlockHeaders_8fa268d7fb3d3c28: function(arg0, arg1, arg2, arg3) {
+        __wbg_getBlockHeaders_a55990d3957c0d9d: 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_getCurrentBlockchainPeaks_ea97e8dd83a3db2f: function(arg0, arg1) {
+        __wbg_getCurrentBlockchainPeaks_b276a676a0f16d93: function(arg0, arg1) {
             const ret = getCurrentBlockchainPeaks(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getForeignAccountCode_7de2117da915f4be: function(arg0, arg1, arg2, arg3) {
+        __wbg_getForeignAccountCode_9f88c11936e9c43d: 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_getInputNoteByOffset_1cd4bd9db2e38694: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+        __wbg_getInputNoteByOffset_d8ec28ef8b63a88f: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
             let deferred1_0;
             let deferred1_1;
             try {
@@ -25320,31 +24812,31 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_getInputNotesFromDetailsCommitments_334d006c0e228205: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromDetailsCommitments_9590f42d9e96e86c: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getInputNotesFromDetailsCommitments(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getInputNotesFromIds_bbaec98ba444d49e: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromIds_d290a8e093978eae: 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_dde5b06918045f75: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromNullifiers_2b5fa39ec52ecab6: 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_02d3daccecb4c763: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotes_1c76764676f21be5: 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_de5d140392884430: function(arg0, arg1, arg2, arg3) {
+        __wbg_getKeyCommitmentsByAccountId_7962a39c985c54e5: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25356,7 +24848,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteScript_bc2ab9b3b789361a: function(arg0, arg1, arg2, arg3) {
+        __wbg_getNoteScript_b2cf59d7cf9d19e7: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25368,39 +24860,39 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteTags_34a8fb7ffdde9e33: function(arg0, arg1) {
+        __wbg_getNoteTags_a45689c54d964e46: function(arg0, arg1) {
             const ret = getNoteTags(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getOutputNotesFromDetailsCommitments_6e202d70d207d37f: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromDetailsCommitments_b15793905bc47309: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getOutputNotesFromDetailsCommitments(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getOutputNotesFromIds_2b07a4ef2fa3fdd9: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromIds_d340ff4a6d4c5c8e: 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_f59492590ecad477: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromNullifiers_48b112e53ca4eea7: 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_7ddd237b643a22e2: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotes_2679465821c837b7: 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_e2e8c0d62a978ef1: function(arg0, arg1) {
+        __wbg_getPartialBlockchainNodesAll_9496498a665775d9: function(arg0, arg1) {
             const ret = getPartialBlockchainNodesAll(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getPartialBlockchainNodesUpToInOrderIndex_2f8e8d802df6ede2: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodesUpToInOrderIndex_2196a0e786754bd1: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25412,20 +24904,20 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getPartialBlockchainNodes_4505db840ba96409: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodes_0a6c2a323b1f4caa: 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_getRandomValues_1c61fac11405ffdc: function() { return handleError(function (arg0, arg1) {
+        __wbg_getRandomValues_e9de607763a970bd: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
         __wbg_getReader_f47519d698a4505e: function() { return handleError(function (arg0) {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_getSetting_62039934dd52148a: function(arg0, arg1, arg2, arg3) {
+        __wbg_getSetting_319d65b5a2e111a2: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25437,7 +24929,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getSyncHeight_1c355e9af8a6c5c1: function(arg0, arg1) {
+        __wbg_getSyncHeight_94e6d0d761426ec9: function(arg0, arg1) {
             const ret = getSyncHeight(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -25445,15 +24937,15 @@ function __wbg_get_imports() {
             const ret = arg0.getTime();
             return ret;
         },
-        __wbg_getTrackedBlockHeaderNumbers_1127c2c0de9e8f2d: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaderNumbers_5a8edd94c7b7613c: function(arg0, arg1) {
             const ret = getTrackedBlockHeaderNumbers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTrackedBlockHeaders_0c9acbd5575e41f1: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaders_3292740bff6c9b4c: function(arg0, arg1) {
             const ret = getTrackedBlockHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTransactions_71b6f120136d4406: function(arg0, arg1, arg2, arg3) {
+        __wbg_getTransactions_0c5674a652c44917: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25465,7 +24957,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getUnspentInputNoteNullifiers_ac153627e18848ab: function(arg0, arg1) {
+        __wbg_getUnspentInputNoteNullifiers_6c9d5852b42b8c73: function(arg0, arg1) {
             const ret = getUnspentInputNoteNullifiers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -25509,7 +25001,7 @@ function __wbg_get_imports() {
             const ret = InputNoteRecord.__wrap(arg0);
             return ret;
         },
-        __wbg_insertAccountAddress_15069fe099e1619e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAddress_36db2bb32e10fd9b: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25523,7 +25015,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertAccountAuth_d0cb9c2601ea7324: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAuth_2763614f9c61eb99: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -25540,7 +25032,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertAccountKeyMapping_995e470bad5ead0b: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountKeyMapping_5440caed0fe18250: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -25557,21 +25049,17 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertBlockHeader_e5a6e2ded97f2403: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertBlockHeader_ca254bedd530d7a3: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
             wasm.__wbindgen_free(arg3, arg4 * 1, 1);
-            const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, arg5 !== 0);
-            return ret;
-        },
-        __wbg_insertPartialBlockchainNodes_d6d5d926855e4d21: 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();
-            wasm.__wbindgen_free(arg4, arg5 * 4, 4);
-            const ret = insertPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0, v1);
+            var v1 = getArrayJsValueFromWasm0(arg6, arg7).slice();
+            wasm.__wbindgen_free(arg6, arg7 * 4, 4);
+            var v2 = getArrayJsValueFromWasm0(arg8, arg9).slice();
+            wasm.__wbindgen_free(arg8, arg9 * 4, 4);
+            const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, arg5 !== 0, v1, v2);
             return ret;
         },
-        __wbg_insertSetting_0b89216c93defa8f: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertSetting_2b672c0bf3a3668d: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25585,7 +25073,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertTransactionScript_25a8761c16b219bb: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertTransactionScript_f052607e004c23aa: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -25682,11 +25170,11 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_listSettingKeys_2b136b1269935560: function(arg0, arg1) {
+        __wbg_listSettingKeys_73b3c34ff51ee657: function(arg0, arg1) {
             const ret = listSettingKeys(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_lockAccount_77845432e7766df6: function(arg0, arg1, arg2, arg3) {
+        __wbg_lockAccount_a59ff3c777c9188c: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25833,10 +25321,6 @@ function __wbg_get_imports() {
             const ret = NoteAttachment.__wrap(arg0);
             return ret;
         },
-        __wbg_noteattachment_unwrap: function(arg0) {
-            const ret = NoteAttachment.__unwrap(arg0);
-            return ret;
-        },
         __wbg_noteconsumability_new: function(arg0) {
             const ret = NoteConsumability.__wrap(arg0);
             return ret;
@@ -25889,7 +25373,7 @@ function __wbg_get_imports() {
             const ret = NoteTag.__unwrap(arg0);
             return ret;
         },
-        __wbg_openDatabase_2f30006b5f901ff6: function(arg0, arg1, arg2, arg3) {
+        __wbg_openDatabase_8ac110fce86d145e: function(arg0, arg1, arg2, arg3) {
             const ret = openDatabase(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return ret;
         },
@@ -25920,7 +25404,7 @@ function __wbg_get_imports() {
             const ret = ProvenTransaction.__wrap(arg0);
             return ret;
         },
-        __wbg_pruneAccountHistory_f92187e012bea002: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_pruneAccountHistory_c2e9f7b1d4846bc6: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -25937,7 +25421,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_pruneIrrelevantBlocks_802f17c51c071490: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_pruneIrrelevantBlocks_33e6cf62a24f1f38: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU32FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             var v1 = getArrayJsValueFromWasm0(arg4, arg5).slice();
@@ -25945,14 +25429,6 @@ function __wbg_get_imports() {
             const ret = pruneIrrelevantBlocks(getStringFromWasm0(arg0, arg1), v0, v1);
             return ret;
         },
-        __wbg_pswaplineagerecord_new: function(arg0) {
-            const ret = PswapLineageRecord.__wrap(arg0);
-            return ret;
-        },
-        __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
-            const ret = arg0.push(arg1);
-            return ret;
-        },
         __wbg_queueMicrotask_0aa0a927f78f5d98: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -25967,13 +25443,13 @@ function __wbg_get_imports() {
         __wbg_releaseLock_aa5846c2494b3032: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_removeAccountAddress_26bf46414ef4d36b: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAddress_5cbeda1f06e27b96: 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_removeAccountAuth_eee531cc8fc556ab: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAuth_825600c45bdd5aa3: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25985,7 +25461,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_removeAllMappingsForKey_bb2ce4d992b13353: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAllMappingsForKey_3f439269152ce6e0: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25997,7 +25473,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_removeNoteTag_ce18a2071a471486: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+        __wbg_removeNoteTag_e2ea5486d35929ca: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -26018,7 +25494,7 @@ function __wbg_get_imports() {
             const ret = removeNoteTag(getStringFromWasm0(arg0, arg1), v0, v1, v2, v3);
             return ret;
         },
-        __wbg_removeSetting_a6764e1ec62f8c0f: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeSetting_5fac6592df936024: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26069,9 +25545,6 @@ function __wbg_get_imports() {
             const ret = setTimeout(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
-            arg0[arg1] = arg2;
-        },
         __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -26221,13 +25694,13 @@ function __wbg_get_imports() {
             const ret = TransactionSummary.__wrap(arg0);
             return ret;
         },
-        __wbg_undoAccountStates_829a6daf4a392818: function(arg0, arg1, arg2, arg3) {
+        __wbg_undoAccountStates_884490500595e8c1: 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_f24cee98a5bbbfe5: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountCode_ce71ea974ae52d20: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26241,7 +25714,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertAccountRecord_f616812a7dd3d5a1: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17) {
+        __wbg_upsertAccountRecord_793d7ddc0ba72c6d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -26283,7 +25756,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
             }
         },
-        __wbg_upsertAccountStorage_4f3a4494f26975fb: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountStorage_5e3e18f2388a4516: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26297,7 +25770,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertForeignAccountCode_6595b4d97e610669: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertForeignAccountCode_dc483b928e37841a: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             let deferred0_0;
             let deferred0_1;
             let deferred2_0;
@@ -26316,7 +25789,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertInputNote_850c7540f297f4d4: 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, arg25, arg26, arg27, arg28) {
+        __wbg_upsertInputNote_570ff0eb47e436a6: 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, arg25, arg26, arg27, arg28) {
             let deferred0_0;
             let deferred0_1;
             let deferred6_0;
@@ -26365,7 +25838,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred9_0, deferred9_1, 1);
             }
         },
-        __wbg_upsertNoteScript_d946217575ba5025: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertNoteScript_478f10dbd569c41c: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26379,7 +25852,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertOutputNote_907da49377d56a48: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) {
+        __wbg_upsertOutputNote_81d633e2913e530c: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -26414,7 +25887,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
             }
         },
-        __wbg_upsertStorageMapEntries_6bf2d15ad885daf0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertStorageMapEntries_6458946c680ec0cc: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26428,7 +25901,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertTransactionRecord_0b4dbeb561124c59: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+        __wbg_upsertTransactionRecord_5f48cbfd35e412bc: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26449,7 +25922,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertVaultAssets_55f07579c9e0113e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertVaultAssets_3d383338bd7746b0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -26480,12 +25953,12 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 427, function: Function { arguments: [Externref], shim_idx: 815, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 388, function: Function { arguments: [Externref], shim_idx: 781, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_8d8dd5a992b1207e___closure__destroy___dyn_core_9b3796e30d99ddb7___ops__function__FnMut__wasm_bindgen_8d8dd5a992b1207e___JsValue____Output_______, wasm_bindgen_8d8dd5a992b1207e___convert__closures_____invoke___wasm_bindgen_8d8dd5a992b1207e___JsValue_____);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 427, function: Function { arguments: [], shim_idx: 428, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 388, function: Function { arguments: [], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_8d8dd5a992b1207e___closure__destroy___dyn_core_9b3796e30d99ddb7___ops__function__FnMut__wasm_bindgen_8d8dd5a992b1207e___JsValue____Output_______, wasm_bindgen_8d8dd5a992b1207e___convert__closures_____invoke______);
             return ret;
         },
@@ -26495,91 +25968,79 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-            const ret = getArrayU8FromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000006: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
         },
-        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("AccountHeader")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("Address")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("ConsumableNoteRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("FetchedNote")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("InputNoteRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("OutputNoteRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
-            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
-            wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-            // Cast intrinsic for `Vector(NamedExternref("PswapLineageRecord")) -> Externref`.
-            const ret = v0;
-            return ret;
-        },
-        __wbindgen_cast_000000000000000e: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("TransactionRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000f: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("Word")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000010: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000e: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000011: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000f: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -26670,6 +26131,9 @@ const AccountIdFinalization = (typeof FinalizationRegistry === 'undefined')
 const AccountIdArrayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountidarray_free(ptr >>> 0, 1));
+const AccountPatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_accountpatch_free(ptr >>> 0, 1));
 const AccountProofFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountproof_free(ptr >>> 0, 1));
@@ -26682,18 +26146,21 @@ const AccountStatusFinalization = (typeof FinalizationRegistry === 'undefined')
 const AccountStorageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountstorage_free(ptr >>> 0, 1));
-const AccountStorageDeltaFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_accountstoragedelta_free(ptr >>> 0, 1));
 const AccountStorageModeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountstoragemode_free(ptr >>> 0, 1));
+const AccountStoragePatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_accountstoragepatch_free(ptr >>> 0, 1));
 const AccountStorageRequirementsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountstoragerequirements_free(ptr >>> 0, 1));
 const AccountVaultDeltaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accountvaultdelta_free(ptr >>> 0, 1));
+const AccountVaultPatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_accountvaultpatch_free(ptr >>> 0, 1));
 const AddressFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_address_free(ptr >>> 0, 1));
@@ -26730,9 +26197,6 @@ const ConsumableNoteRecordFinalization = (typeof FinalizationRegistry === 'undef
 const EndpointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_endpoint_free(ptr >>> 0, 1));
-const EthAddressFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ethaddress_free(ptr >>> 0, 1));
 const ExecutedTransactionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_executedtransaction_free(ptr >>> 0, 1));
@@ -26811,9 +26275,6 @@ const LibraryFinalization = (typeof FinalizationRegistry === 'undefined')
 const MerklePathFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_merklepath_free(ptr >>> 0, 1));
-const NetworkAccountTargetFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_networkaccounttarget_free(ptr >>> 0, 1));
 const NetworkIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_networkid_free(ptr >>> 0, 1));
@@ -26937,9 +26398,6 @@ const ProgramFinalization = (typeof FinalizationRegistry === 'undefined')
 const ProvenTransactionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_proventransaction_free(ptr >>> 0, 1));
-const PswapLineageRecordFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pswaplineagerecord_free(ptr >>> 0, 1));
 const PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_publickey_free(ptr >>> 0, 1));
@@ -27432,7 +26890,7 @@ async function __wbg_init(module_or_path) {
 
 const module$1 = new URL("assets/miden_client_web.wasm", self.location.href);
 
-var CargoDR9fiMbE = /*#__PURE__*/Object.freeze({
+var CargoLwITdlzJ = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Account: Account,
   AccountArray: AccountArray,
@@ -27447,19 +26905,20 @@ var CargoDR9fiMbE = /*#__PURE__*/Object.freeze({
   AccountId: AccountId,
   AccountIdArray: AccountIdArray,
   AccountInterface: AccountInterface,
+  AccountPatch: AccountPatch,
   AccountProof: AccountProof,
   AccountReader: AccountReader,
   AccountStatus: AccountStatus,
   AccountStorage: AccountStorage,
-  AccountStorageDelta: AccountStorageDelta,
   AccountStorageMode: AccountStorageMode,
+  AccountStoragePatch: AccountStoragePatch,
   AccountStorageRequirements: AccountStorageRequirements,
   AccountType: AccountType,
   AccountVaultDelta: AccountVaultDelta,
+  AccountVaultPatch: AccountVaultPatch,
   Address: Address,
   AdviceInputs: AdviceInputs,
   AdviceMap: AdviceMap,
-  AssetCallbackFlag: AssetCallbackFlag,
   AssetVault: AssetVault,
   AuthFalcon512RpoMultisigConfig: AuthFalcon512RpoMultisigConfig,
   AuthScheme: AuthScheme,
@@ -27470,7 +26929,6 @@ var CargoDR9fiMbE = /*#__PURE__*/Object.freeze({
   CommittedNote: CommittedNote,
   ConsumableNoteRecord: ConsumableNoteRecord,
   Endpoint: Endpoint,
-  EthAddress: EthAddress,
   ExecutedTransaction: ExecutedTransaction,
   Felt: Felt,
   FeltArray: FeltArray,
@@ -27498,7 +26956,6 @@ var CargoDR9fiMbE = /*#__PURE__*/Object.freeze({
   JsVaultAsset: JsVaultAsset,
   Library: Library,
   MerklePath: MerklePath,
-  NetworkAccountTarget: NetworkAccountTarget,
   NetworkId: NetworkId,
   NetworkNoteStatusInfo: NetworkNoteStatusInfo,
   NetworkType: NetworkType,
@@ -27545,8 +27002,6 @@ var CargoDR9fiMbE = /*#__PURE__*/Object.freeze({
   ProcedureThreshold: ProcedureThreshold,
   Program: Program,
   ProvenTransaction: ProvenTransaction,
-  PswapLineageRecord: PswapLineageRecord,
-  PswapLineageState: PswapLineageState,
   PublicKey: PublicKey,
   RpcClient: RpcClient,
   Rpo256: Rpo256,