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

package/dist/mt/{Cargo-CnGom-_z.js → Cargo-DKsyWYgG.js}

@@ -8197,6 +8197,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);
@@ -8253,7 +8289,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";
@@ -8264,9 +8300,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"),
@@ -8285,7 +8319,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"),
@@ -8311,7 +8345,7 @@ class MidenDatabase {
     inputNotes;
     outputNotes;
     notesScripts;
-    stateSync;
+    blockchainCheckpoint;
     blockHeaders;
     partialBlockchainNodes;
     tags;
@@ -8321,12 +8355,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.
@@ -8358,43 +8391,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);
@@ -8412,16 +8414,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"));
         });
     }
@@ -8747,7 +8753,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", [
@@ -8760,7 +8766,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]")
@@ -8773,12 +8780,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) {
@@ -8786,13 +8825,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
@@ -8872,7 +8928,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) {
@@ -9111,7 +9166,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) {
@@ -9516,33 +9570,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) {
@@ -9554,25 +9611,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);
@@ -9630,33 +9668,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);
@@ -9698,9 +9709,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.
@@ -10033,7 +10044,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);
@@ -10117,7 +10127,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);
@@ -10360,7 +10369,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) {
@@ -10378,82 +10386,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 {
@@ -10479,7 +10413,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,
@@ -10494,6 +10428,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);
@@ -10534,10 +10487,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,
@@ -10585,46 +10538,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) {
@@ -10648,8 +10596,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");
@@ -10873,17 +10822,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}
@@ -10916,20 +10854,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}
@@ -11283,6 +11207,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
@@ -11309,42 +11245,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
@@ -11471,8 +11371,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 {
@@ -11538,12 +11440,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.
@@ -11938,6 +11840,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.
  *
@@ -12411,74 +12397,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.
  *
@@ -12561,8 +12479,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;
@@ -12704,6 +12684,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).
  */
@@ -12895,13 +12955,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;
@@ -12942,26 +12995,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.
  *
@@ -13243,13 +13276,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) {
@@ -13277,32 +13307,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
@@ -13317,19 +13321,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}
@@ -13346,30 +13337,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;
 
@@ -13430,7 +13397,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);
     }
     /**
@@ -13475,7 +13442,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);
     }
     /**
@@ -13584,6 +13551,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.
@@ -13614,6 +13601,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
@@ -13646,6 +13647,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.
      *
@@ -13937,111 +13952,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
@@ -14065,14 +13982,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}
@@ -14081,6 +13990,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}
@@ -14353,7 +14270,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;
     }
 }
@@ -14704,14 +14621,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}
@@ -14743,20 +14652,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;
 
@@ -14821,7 +14716,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;
     }
     /**
@@ -14829,7 +14724,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;
     }
     /**
@@ -15132,16 +15027,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}
@@ -15872,13 +15757,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;
@@ -15991,15 +15875,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.
@@ -16187,6 +16070,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}
@@ -16227,6 +16121,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
@@ -16428,97 +16332,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.
  */
@@ -16712,16 +16525,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).
      *
@@ -16731,35 +16534,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.
@@ -16823,15 +16600,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}
@@ -16891,30 +16659,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;
 
@@ -17182,12 +16926,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;
@@ -17811,6 +17549,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
@@ -17822,7 +17573,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}
      */
@@ -18418,19 +18173,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
@@ -19118,7 +18860,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;
     }
     /**
@@ -19153,22 +18895,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);
     }
     /**
@@ -19541,7 +19273,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);
     }
     /**
@@ -19569,7 +19301,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);
     }
     /**
@@ -19587,7 +19319,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);
     }
     /**
@@ -19609,119 +19341,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;
@@ -20468,7 +20087,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
@@ -21213,7 +20832,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 {
@@ -21264,8 +20883,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) {
@@ -21286,7 +20905,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() {
@@ -22029,7 +21648,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);
     }
     /**
@@ -22077,7 +21696,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);
     }
     /**
@@ -22142,14 +21761,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}
@@ -22196,20 +21807,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}
@@ -22755,12 +22352,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.
@@ -22971,10 +22568,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>}
@@ -22984,22 +22577,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
@@ -23027,17 +22604,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);
@@ -23046,7 +22619,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;
     }
     /**
@@ -23062,8 +22635,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]
@@ -23071,10 +22642,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);
@@ -23083,7 +22653,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;
     }
     /**
@@ -23112,14 +22682,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
@@ -23343,37 +22917,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.
      *
@@ -23437,10 +22980,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
@@ -23566,30 +23109,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}
@@ -23883,25 +23402,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.
@@ -24521,7 +24021,7 @@ function __wbg_get_imports(memory) {
             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;
@@ -24549,25 +24049,7 @@ function __wbg_get_imports(memory) {
         __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;
@@ -24599,7 +24081,7 @@ function __wbg_get_imports(memory) {
                 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);
@@ -24610,6 +24092,20 @@ function __wbg_get_imports(memory) {
                 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;
@@ -24718,7 +24214,7 @@ function __wbg_get_imports(memory) {
                 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;
         },
@@ -24750,7 +24246,7 @@ function __wbg_get_imports(memory) {
             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;
         },
@@ -24758,10 +24254,6 @@ function __wbg_get_imports(memory) {
             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;
@@ -24774,7 +24266,7 @@ function __wbg_get_imports(memory) {
             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 {
@@ -24786,7 +24278,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24798,7 +24290,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24810,7 +24302,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24822,7 +24314,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24834,7 +24326,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24846,11 +24338,11 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24862,7 +24354,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24876,7 +24368,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24890,27 +24382,27 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24924,31 +24416,31 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24960,7 +24452,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -24972,39 +24464,39 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -25016,20 +24508,20 @@ function __wbg_get_imports(memory) {
                 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_ea728b1d79dae146: function() { return handleError(function (arg0) {
+        __wbg_getRandomValues_90e56bff4f3b89fb: function() { return handleError(function (arg0) {
             globalThis.crypto.getRandomValues(arg0);
         }, 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 {
@@ -25041,7 +24533,7 @@ function __wbg_get_imports(memory) {
                 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;
         },
@@ -25049,15 +24541,15 @@ function __wbg_get_imports(memory) {
             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 {
@@ -25069,7 +24561,7 @@ function __wbg_get_imports(memory) {
                 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;
         },
@@ -25113,7 +24605,7 @@ function __wbg_get_imports(memory) {
             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 {
@@ -25127,7 +24619,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25144,7 +24636,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25161,21 +24653,17 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -25189,7 +24677,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25296,11 +24784,11 @@ function __wbg_get_imports(memory) {
             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 {
@@ -25459,10 +24947,6 @@ function __wbg_get_imports(memory) {
             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;
@@ -25519,7 +25003,7 @@ function __wbg_get_imports(memory) {
             const ret = Array.of(arg0, arg1, arg2);
             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;
         },
@@ -25553,7 +25037,7 @@ function __wbg_get_imports(memory) {
             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;
@@ -25570,7 +25054,7 @@ function __wbg_get_imports(memory) {
                 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();
@@ -25578,14 +25062,6 @@ function __wbg_get_imports(memory) {
             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;
@@ -25600,13 +25076,13 @@ function __wbg_get_imports(memory) {
         __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 {
@@ -25618,7 +25094,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -25630,7 +25106,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25651,7 +25127,7 @@ function __wbg_get_imports(memory) {
             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 {
@@ -25702,9 +25178,6 @@ function __wbg_get_imports(memory) {
             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;
@@ -25861,13 +25334,13 @@ function __wbg_get_imports(memory) {
             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 {
@@ -25881,7 +25354,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25923,7 +25396,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -25937,7 +25410,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -25956,7 +25429,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -26005,7 +25478,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -26019,7 +25492,7 @@ function __wbg_get_imports(memory) {
                 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;
@@ -26054,7 +25527,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -26068,7 +25541,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -26089,7 +25562,7 @@ function __wbg_get_imports(memory) {
                 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 {
@@ -26132,17 +25605,17 @@ function __wbg_get_imports(memory) {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 129, function: Function { arguments: [Externref], shim_idx: 130, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 116, function: Function { arguments: [Externref], shim_idx: 117, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_8294944b14acb139___closure__destroy___dyn_core_91ed24bc3d45dfd0___ops__function__FnMut__wasm_bindgen_8294944b14acb139___JsValue____Output_______, wasm_bindgen_8294944b14acb139___convert__closures_____invoke___wasm_bindgen_8294944b14acb139___JsValue_____);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 129, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 130, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 116, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 117, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_8294944b14acb139___closure__destroy___dyn_core_91ed24bc3d45dfd0___ops__function__FnMut__wasm_bindgen_8294944b14acb139___JsValue____Output_______, wasm_bindgen_8294944b14acb139___convert__closures_____invoke___wasm_bindgen_8294944b14acb139___JsValue_____);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 129, function: Function { arguments: [], shim_idx: 454, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 116, function: Function { arguments: [], shim_idx: 415, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_8294944b14acb139___closure__destroy___dyn_core_91ed24bc3d45dfd0___ops__function__FnMut__wasm_bindgen_8294944b14acb139___JsValue____Output_______, wasm_bindgen_8294944b14acb139___convert__closures_____invoke______);
             return ret;
         },
@@ -26152,91 +25625,79 @@ function __wbg_get_imports(memory) {
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-            const ret = getArrayU8FromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000007: function(arg0) {
+        __wbindgen_cast_0000000000000006: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             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("AccountHeader")) -> 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("Address")) -> 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("ConsumableNoteRecord")) -> 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("FetchedNote")) -> 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("InputNoteRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000d: 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("OutputNoteRecord")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_000000000000000e: 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_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("TransactionRecord")) -> 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("Word")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000011: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000f: 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_0000000000000012: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000010: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -26266,7 +25727,7 @@ function __wbg_get_imports(memory) {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        memory: memory || new WebAssembly.Memory({initial:59,maximum:65536,shared:true}),
+        memory: memory || new WebAssembly.Memory({initial:129,maximum:65536,shared:true}),
     };
     return {
         __proto__: null,
@@ -26342,6 +25803,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));
@@ -26354,18 +25818,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));
@@ -26402,9 +25869,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));
@@ -26483,9 +25947,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));
@@ -26609,9 +26070,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));
@@ -27125,19 +26583,20 @@ var index = /*#__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,
@@ -27148,7 +26607,6 @@ var index = /*#__PURE__*/Object.freeze({
 	CommittedNote: CommittedNote,
 	ConsumableNoteRecord: ConsumableNoteRecord,
 	Endpoint: Endpoint,
-	EthAddress: EthAddress,
 	ExecutedTransaction: ExecutedTransaction,
 	Felt: Felt,
 	FeltArray: FeltArray,
@@ -27176,7 +26634,6 @@ var index = /*#__PURE__*/Object.freeze({
 	JsVaultAsset: JsVaultAsset,
 	Library: Library,
 	MerklePath: MerklePath,
-	NetworkAccountTarget: NetworkAccountTarget,
 	NetworkId: NetworkId,
 	NetworkNoteStatusInfo: NetworkNoteStatusInfo,
 	NetworkType: NetworkType,
@@ -27223,8 +26680,6 @@ var index = /*#__PURE__*/Object.freeze({
 	ProcedureThreshold: ProcedureThreshold,
 	Program: Program,
 	ProvenTransaction: ProvenTransaction,
-	PswapLineageRecord: PswapLineageRecord,
-	PswapLineageState: PswapLineageState,
 	PublicKey: PublicKey,
 	RpcClient: RpcClient,
 	Rpo256: Rpo256,
@@ -27280,5 +26735,5 @@ var index = /*#__PURE__*/Object.freeze({
 });
 
 const module$1 = new URL("assets/miden_client_web.wasm", import.meta.url);
-export {  Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountType, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetCallbackFlag, AssetVault, AuthFalcon512RpoMultisigConfig, AuthScheme, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore2 as exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker , __wbg_init, module$1 as __wasm_url };
-//# sourceMappingURL=Cargo-CnGom-_z.js.map
+export {  Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountPatch, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageMode, AccountStoragePatch, AccountStorageRequirements, AccountType, AccountVaultDelta, AccountVaultPatch, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthScheme, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore2 as exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker , __wbg_init, module$1 as __wasm_url };
+//# sourceMappingURL=Cargo-DKsyWYgG.js.map