@miden-sdk/miden-sdk 0.14.11 → 0.15.0-alpha.5

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

@@ -5,7 +5,7 @@
 async function loadWasm() {
   let wasmModule;
   if (!undefined || (undefined && !undefined.SSR)) {
-    wasmModule = await Promise.resolve().then(function () { return CargoDC6jSekr; });
+    wasmModule = await Promise.resolve().then(function () { return CargoCG4XszZo; });
     // The Cargo glue's __wbg_init TLA is stripped by the rollup build to
     // prevent blocking WKWebView module evaluation. Call it explicitly here
     // with the WASM URL that the Cargo glue pre-resolves (relative to its
@@ -251,14 +251,12 @@ const methodHandlers = {
 
     const prover = proverPayload
       ? wasm.TransactionProver.deserialize(proverPayload)
-      : null;
-
-    const proven = prover
-      ? await wasmWebClient.proveTransactionWithProver(
-          transactionResult,
-          prover
-        )
-      : await wasmWebClient.proveTransaction(transactionResult);
+      : undefined;
+
+    const proven = await wasmWebClient.proveTransaction(
+      transactionResult,
+      prover
+    );
     const serializedProven = proven.serialize();
     return serializedProven.buffer;
   },
@@ -311,7 +309,7 @@ const methodHandlers = {
     // Deserialize the prover from the serialized payload
     const prover = proverPayload
       ? wasm.TransactionProver.deserialize(proverPayload)
-      : null;
+      : undefined;
 
     const result = await wasmWebClient.executeTransaction(
       accountId,
@@ -320,9 +318,7 @@ const methodHandlers = {
 
     const transactionId = result.id().toHex();
 
-    const proven = prover
-      ? await wasmWebClient.proveTransactionWithProver(result, prover)
-      : await wasmWebClient.proveTransaction(result);
+    const proven = await wasmWebClient.proveTransaction(result, prover);
     const submissionHeight = await wasmWebClient.submitProvenTransaction(
       proven,
       result
@@ -375,14 +371,18 @@ methodHandlers[MethodName.SUBMIT_NEW_TRANSACTION_MOCK] = async (args) => {
 
   const result = await methodHandlers[MethodName.SUBMIT_NEW_TRANSACTION](args);
 
+  const updatedMockChain = (await wasmWebClient.serializeMockChain()).buffer;
+  const updatedMockNoteTransportNode = (
+    await wasmWebClient.serializeMockNoteTransportNode()
+  ).buffer;
+
   return {
     transactionId: result.transactionId,
     submissionHeight: result.submissionHeight,
     serializedTransactionResult: result.serializedTransactionResult,
     serializedTransactionUpdate: result.serializedTransactionUpdate,
-    serializedMockChain: wasmWebClient.serializeMockChain().buffer,
-    serializedMockNoteTransportNode:
-      wasmWebClient.serializeMockNoteTransportNode().buffer,
+    serializedMockChain: updatedMockChain,
+    serializedMockNoteTransportNode: updatedMockNoteTransportNode,
   };
 };
 
@@ -407,14 +407,18 @@ methodHandlers[MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK] = async (
   const result =
     await methodHandlers[MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER](args);
 
+  const updatedMockChain = (await wasmWebClient.serializeMockChain()).buffer;
+  const updatedMockNoteTransportNode = (
+    await wasmWebClient.serializeMockNoteTransportNode()
+  ).buffer;
+
   return {
     transactionId: result.transactionId,
     submissionHeight: result.submissionHeight,
     serializedTransactionResult: result.serializedTransactionResult,
     serializedTransactionUpdate: result.serializedTransactionUpdate,
-    serializedMockChain: wasmWebClient.serializeMockChain().buffer,
-    serializedMockNoteTransportNode:
-      wasmWebClient.serializeMockNoteTransportNode().buffer,
+    serializedMockChain: updatedMockChain,
+    serializedMockNoteTransportNode: updatedMockNoteTransportNode,
   };
 };
 
@@ -8852,7 +8856,7 @@ const V1_STORES = {
     [Table.Addresses]: indexes("address", "id"),
     [Table.Transactions]: indexes("id", "statusVariant"),
     [Table.TransactionScripts]: indexes("scriptRoot"),
-    [Table.InputNotes]: indexes("noteId", "nullifier", "stateDiscriminant", "[consumedBlockHeight+consumedTxOrder+noteId]"),
+    [Table.InputNotes]: indexes("detailsCommitment", "noteId", "nullifier", "stateDiscriminant", "[consumedBlockHeight+consumedTxOrder+noteId]"),
     [Table.OutputNotes]: indexes("noteId", "recipientDigest", "stateDiscriminant", "nullifier"),
     [Table.NotesScripts]: indexes("scriptRoot"),
     [Table.StateSync]: indexes("id"),
@@ -10044,13 +10048,12 @@ async function getAccountIdByKeyCommitment(dbId, pubKeyCommitmentHex) {
     }
 }
 
-async function insertBlockHeader(dbId, blockNum, header, partialBlockchainPeaks, hasClientNotes) {
+async function insertBlockHeader(dbId, blockNum, header, hasClientNotes) {
     try {
         const db = getDatabase(dbId);
         const data = {
             blockNum: blockNum,
             header,
-            partialBlockchainPeaks,
             hasClientNotes: hasClientNotes.toString(),
         };
         // Mirror SQLite's `insert_block_header_tx`: do an INSERT OR IGNORE on the
@@ -10058,12 +10061,8 @@ async function insertBlockHeader(dbId, blockNum, header, partialBlockchainPeaks,
         // 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. Overwriting
-        //     it would clobber the correct historical peaks (popcount ==
-        //     block_num) with peaks from the caller's current `PartialMmr`
-        //     forest (popcount == current sync height). Later reads of those
-        //     peaks trip `MmrPeaks::new`'s InvalidPeaks validation and wedge
-        //     sync for the rest of the session.
+        //     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
@@ -10116,11 +10115,9 @@ async function getBlockHeaders(dbId, blockNumbers) {
             }
             else {
                 const headerBase64 = uint8ArrayToBase64(result.header);
-                const partialBlockchainPeaksBase64 = uint8ArrayToBase64(result.partialBlockchainPeaks);
                 return {
                     blockNum: result.blockNum,
                     header: headerBase64,
-                    partialBlockchainPeaks: partialBlockchainPeaksBase64,
                     hasClientNotes: result.hasClientNotes === "true",
                 };
             }
@@ -10140,11 +10137,9 @@ async function getTrackedBlockHeaders(dbId) {
             .toArray();
         const processedRecords = await Promise.all(allMatchingRecords.map((record) => {
             const headerBase64 = uint8ArrayToBase64(record.header);
-            const partialBlockchainPeaksBase64 = uint8ArrayToBase64(record.partialBlockchainPeaks);
             return {
                 blockNum: record.blockNum,
                 header: headerBase64,
-                partialBlockchainPeaks: partialBlockchainPeaksBase64,
                 hasClientNotes: record.hasClientNotes === "true",
             };
         }));
@@ -10167,22 +10162,31 @@ async function getTrackedBlockHeaderNumbers(dbId) {
         logWebStoreError(err, "Failed to get tracked block header numbers");
     }
 }
-async function getPartialBlockchainPeaksByBlockNum(dbId, blockNum) {
+/**
+ * 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 blockHeader = await db.blockHeaders.get(blockNum);
-        if (blockHeader == undefined) {
-            return {
-                peaks: undefined,
-            };
+        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 };
         }
-        const partialBlockchainPeaksBase64 = uint8ArrayToBase64(blockHeader.partialBlockchainPeaks);
         return {
-            peaks: partialBlockchainPeaksBase64,
+            blockNum: stateSyncRow.blockNum,
+            peaks: uint8ArrayToBase64(header.partialBlockchainPeaks),
         };
     }
     catch (err) {
-        logWebStoreError(err, "Failed to get partial blockchain peaks");
+        logWebStoreError(err, "Failed to get current blockchain peaks");
     }
 }
 async function getPartialBlockchainNodesAll(dbId) {
@@ -10222,19 +10226,34 @@ async function getPartialBlockchainNodesUpToInOrderIndex(dbId, maxInOrderIndex)
         logWebStoreError(err, "Failed to get partial blockchain nodes up to index");
     }
 }
-async function pruneIrrelevantBlocks(dbId) {
+async function pruneIrrelevantBlocks(dbId, blocksToUntrack, nodeIdsToRemove) {
     try {
         const db = getDatabase(dbId);
+        const numericNodeIds = nodeIdsToRemove.map(Number);
         const syncHeight = await db.stateSync.get(1);
         if (syncHeight == undefined) {
             throw Error("SyncHeight is undefined -- is the state sync table empty?");
         }
-        const allMatchingRecords = await db.blockHeaders
-            .where("hasClientNotes")
-            .equals("false")
-            .and((record) => record.blockNum !== 0 && record.blockNum !== syncHeight.blockNum)
-            .toArray();
-        await db.blockHeaders.bulkDelete(allMatchingRecords.map((r) => r.blockNum));
+        await db.dexie.transaction("rw", db.blockHeaders, db.partialBlockchainNodes, async () => {
+            // 1. Delete stale MMR authentication nodes.
+            if (numericNodeIds.length > 0) {
+                await db.partialBlockchainNodes.bulkDelete(numericNodeIds);
+            }
+            // 2. Mark untracked blocks as irrelevant.
+            if (blocksToUntrack.length > 0) {
+                await db.blockHeaders
+                    .where("blockNum")
+                    .anyOf(blocksToUntrack)
+                    .modify({ hasClientNotes: "false" });
+            }
+            // 3. Delete irrelevant block headers.
+            const allMatchingRecords = await db.blockHeaders
+                .where("hasClientNotes")
+                .equals("false")
+                .and((record) => record.blockNum !== 0 && record.blockNum !== syncHeight.blockNum)
+                .toArray();
+            await db.blockHeaders.bulkDelete(allMatchingRecords.map((r) => r.blockNum));
+        });
     }
     catch (err) {
         logWebStoreError(err, "Failed to prune irrelevant blocks");
@@ -10485,13 +10504,20 @@ async function getNoteScript(dbId, scriptRoot) {
         logWebStoreError(err, "Failed to get note script from root");
     }
 }
-async function upsertInputNote(dbId, noteId, assets, serialNumber, inputs, scriptRoot, serializedNoteScript, nullifier, serializedCreatedAt, stateDiscriminant, state, consumedBlockHeight, consumedTxOrder, consumerAccountId, tx) {
+async function upsertInputNote(dbId, detailsCommitment, noteId, assets, attachments, serialNumber, inputs, scriptRoot, serializedNoteScript, nullifier, serializedCreatedAt, stateDiscriminant, state, consumedBlockHeight, consumedTxOrder, consumerAccountId, tx) {
     const db = getDatabase(dbId);
     const doWork = async (t) => {
         try {
             const data = {
-                noteId,
+                // The details commitment is the primary key. It is always present, even
+                // for partial notes lacking a noteId, so a partial note that later gains
+                // its noteId updates the same row instead of inserting a duplicate.
+                detailsCommitment,
+                // Convert null -> undefined so Dexie omits the noteId secondary index
+                // for partial notes that don't have one yet.
+                noteId: noteId ?? undefined,
                 assets,
+                attachments,
                 serialNumber,
                 inputs,
                 scriptRoot,
@@ -10514,7 +10540,7 @@ async function upsertInputNote(dbId, noteId, assets, serialNumber, inputs, scrip
             /* v8 ignore next 3 — requires a mid-transaction Dexie write failure, not modelable with fake-indexeddb */
         }
         catch (error) {
-            logWebStoreError(error, `Error inserting note: ${noteId}`);
+            logWebStoreError(error, `Error inserting note: ${detailsCommitment}`);
         }
     };
     return db.dexie.transaction("rw", db.inputNotes, db.notesScripts, doWork);
@@ -10577,13 +10603,14 @@ async function getInputNoteByOffset(dbId, states, consumerAccountId, blockStart,
         logWebStoreError(err, "Failed to get input note by offset");
     }
 }
-async function upsertOutputNote(dbId, noteId, assets, recipientDigest, metadata, nullifier, expectedHeight, stateDiscriminant, state, tx) {
+async function upsertOutputNote(dbId, noteId, assets, attachments, recipientDigest, metadata, nullifier, expectedHeight, stateDiscriminant, state, tx) {
     const db = getDatabase(dbId);
     const doWork = async (t) => {
         try {
             const data = {
                 noteId,
                 assets,
+                attachments,
                 recipientDigest,
                 metadata,
                 nullifier: nullifier ? nullifier : undefined,
@@ -10604,6 +10631,7 @@ async function processInputNotes(dbId, notes) {
     const db = getDatabase(dbId);
     return await Promise.all(notes.map(async (note) => {
         const assetsBase64 = uint8ArrayToBase64(note.assets);
+        const attachmentsBase64 = uint8ArrayToBase64(note.attachments);
         const serialNumberBase64 = uint8ArrayToBase64(note.serialNumber);
         const inputsBase64 = uint8ArrayToBase64(note.inputs);
         let serializedNoteScriptBase64 = undefined;
@@ -10616,6 +10644,7 @@ async function processInputNotes(dbId, notes) {
         const stateBase64 = uint8ArrayToBase64(note.state);
         return {
             assets: assetsBase64,
+            attachments: attachmentsBase64,
             serialNumber: serialNumberBase64,
             inputs: inputsBase64,
             createdAt: note.serializedCreatedAt,
@@ -10627,10 +10656,12 @@ async function processInputNotes(dbId, notes) {
 async function processOutputNotes(notes) {
     return await Promise.all(notes.map((note) => {
         const assetsBase64 = uint8ArrayToBase64(note.assets);
+        const attachmentsBase64 = uint8ArrayToBase64(note.attachments);
         const metadataBase64 = uint8ArrayToBase64(note.metadata);
         const stateBase64 = uint8ArrayToBase64(note.state);
         return {
             assets: assetsBase64,
+            attachments: attachmentsBase64,
             recipientDigest: note.recipientDigest,
             metadata: metadataBase64,
             expectedHeight: note.expectedHeight,
@@ -10899,9 +10930,8 @@ async function removeNoteTag(dbId, tag, sourceNoteId, sourceAccountId) {
 }
 async function applyStateSync(dbId, stateUpdate) {
     const db = getDatabase(dbId);
-    const { blockNum, flattenedNewBlockHeaders, flattenedPartialBlockChainPeaks, newBlockNums, blockHasRelevantNotes, serializedNodeIds, serializedNodes, committedNoteIds, serializedInputNotes, serializedOutputNotes, accountUpdates, transactionUpdates, } = stateUpdate;
+    const { blockNum, flattenedNewBlockHeaders, partialBlockchainPeaks, newBlockNums, blockHasRelevantNotes, serializedNodeIds, serializedNodes, committedNoteTagSources, serializedInputNotes, serializedOutputNotes, accountUpdates, transactionUpdates, } = stateUpdate;
     const newBlockHeaders = reconstructFlattenedVec(flattenedNewBlockHeaders);
-    const partialBlockchainPeaks = reconstructFlattenedVec(flattenedPartialBlockChainPeaks);
     const tablesToAccess = [
         db.stateSync,
         db.inputNotes,
@@ -10924,10 +10954,10 @@ async function applyStateSync(dbId, stateUpdate) {
     return await db.dexie.transaction("rw", tablesToAccess, async (tx) => {
         await Promise.all([
             Promise.all(serializedInputNotes.map((note) => {
-                return upsertInputNote(dbId, note.noteId, note.noteAssets, note.serialNumber, note.inputs, note.noteScriptRoot, note.noteScript, note.nullifier, note.createdAt, note.stateDiscriminant, note.state, note.consumedBlockHeight, note.consumedTxOrder, note.consumerAccountId);
+                return 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, note.consumedTxOrder, note.consumerAccountId);
             })),
             Promise.all(serializedOutputNotes.map((note) => {
-                return upsertOutputNote(dbId, note.noteId, note.noteAssets, note.recipientDigest, note.metadata, note.nullifier, note.expectedHeight, note.stateDiscriminant, note.state);
+                return upsertOutputNote(dbId, note.noteId, note.noteAssets, note.attachments, note.recipientDigest, note.metadata, note.nullifier, note.expectedHeight, note.stateDiscriminant, note.state);
             })),
             Promise.all(transactionUpdates.map((transactionRecord) => {
                 let promises = [
@@ -10953,16 +10983,26 @@ async function applyStateSync(dbId, stateUpdate) {
             }))),
             updateSyncHeight(tx, blockNum),
             updatePartialBlockchainNodes(tx, serializedNodeIds, serializedNodes),
-            updateCommittedNoteTags(tx, committedNoteIds),
+            updateCommittedNoteTags(tx, committedNoteTagSources),
             Promise.all(newBlockHeaders.map((newBlockHeader, i) => {
-                return updateBlockHeader(tx, newBlockNums[i], newBlockHeader, partialBlockchainPeaks[i], blockHasRelevantNotes[i] == 1);
+                // 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);
             })),
         ]);
     });
 }
+/**
+ * Advances `stateSync.blockNum` only when moving forward. Mirrors SQLite's
+ * `UPDATE blockchain_checkpoint ... WHERE block_num < ?`.
+ */
 async function updateSyncHeight(tx, blockNum) {
     try {
-        // Only update if moving forward to prevent race conditions
         const current = await tx.stateSync.get(1);
         if (!current || current.blockNum < blockNum) {
             await tx.stateSync.update(1, {
@@ -10974,13 +11014,13 @@ async function updateSyncHeight(tx, blockNum) {
         logWebStoreError(error, "Failed to update sync height");
     }
 }
-async function updateBlockHeader(tx, blockNum, blockHeader, partialBlockchainPeaks, hasClientNotes) {
+async function updateBlockHeader(tx, blockNum, blockHeader, hasClientNotes, partialBlockchainPeaks) {
     try {
         const data = {
             blockNum: blockNum,
             header: blockHeader,
-            partialBlockchainPeaks,
             hasClientNotes: hasClientNotes.toString(),
+            ...(partialBlockchainPeaks !== undefined && { partialBlockchainPeaks }),
         };
         const existingBlockHeader = await tx.blockHeaders.get(blockNum);
         if (!existingBlockHeader) {
@@ -11011,13 +11051,13 @@ async function updatePartialBlockchainNodes(tx, nodeIndexes, nodes) {
         logWebStoreError(err, "Failed to update partial blockchain nodes");
     }
 }
-async function updateCommittedNoteTags(tx, inputNoteIds) {
+async function updateCommittedNoteTags(tx, committedNoteTagSources) {
     try {
-        for (let i = 0; i < inputNoteIds.length; i++) {
-            const noteId = inputNoteIds[i];
+        for (let i = 0; i < committedNoteTagSources.length; i++) {
+            const tagSource = committedNoteTagSources[i];
             await tx.tags
                 .where("sourceNoteId")
-                .equals(noteId)
+                .equals(tagSource)
                 .delete();
         }
     }
@@ -11123,21 +11163,13 @@ class Account {
         return AccountId.__wrap(ret);
     }
     /**
-     * Returns true if the account is a faucet.
+     * Returns true if the account exposes a fungible-faucet interface.
      * @returns {boolean}
      */
     isFaucet() {
         const ret = wasm.account_isFaucet(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true if this is a network-owned account.
-     * @returns {boolean}
-     */
-    isNetwork() {
-        const ret = wasm.account_isNetwork(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns true if the account has not yet been committed to the chain.
      * @returns {boolean}
@@ -11163,21 +11195,13 @@ class Account {
         return ret !== 0;
     }
     /**
-     * Returns true if the account is a regular account (immutable or updatable code).
+     * Returns true if the account is a regular (non-faucet) account.
      * @returns {boolean}
      */
     isRegularAccount() {
         const ret = wasm.account_isRegularAccount(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true if the account can update its code.
-     * @returns {boolean}
-     */
-    isUpdatable() {
-        const ret = wasm.account_isUpdatable(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns the account nonce, which is incremented on every state update.
      * @returns {Felt}
@@ -11277,18 +11301,13 @@ class AccountArray {
         wasm.accountarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {Account} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, Account);
-        const ret = wasm.accountarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.accountarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -11316,28 +11335,31 @@ class AccountBuilder {
     }
     /**
      * Sets the account type (regular, faucet, etc.).
-     *
-     * Accepts either a numeric WASM enum value (0–3) or a string name
-     * (`"FungibleFaucet"`, `"NonFungibleFaucet"`,
-     * `"RegularAccountImmutableCode"`, `"RegularAccountUpdatableCode"`).
-     * @param {any} account_type
+     * @param {AccountType} account_type
      * @returns {AccountBuilder}
      */
     accountType(account_type) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.accountbuilder_accountType(ptr, account_type);
+        const ret = wasm.accountbuilder_accountType(this.__wbg_ptr, account_type);
+        return AccountBuilder.__wrap(ret);
+    }
+    /**
+     * Builds the account (including merged storage schema commitment metadata) and returns it
+     * together with the derived seed.
+     * @returns {AccountBuilderResult}
+     */
+    build() {
+        const ret = wasm.accountbuilder_build(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return AccountBuilder.__wrap(ret[0]);
+        return AccountBuilderResult.__wrap(ret[0]);
     }
     /**
-     * Builds the account and returns it together with the derived seed.
+     * Builds the account without adding the schema commitment component (legacy behavior).
      * @returns {AccountBuilderResult}
      */
-    build() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.accountbuilder_build(ptr);
+    buildWithoutSchemaCommitment() {
+        const ret = wasm.accountbuilder_buildWithoutSchemaCommitment(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -11360,13 +11382,17 @@ class AccountBuilder {
     }
     /**
      * Sets the storage mode (public/private) for the account.
+     *
+     * The 0.15 protocol surface collapsed `AccountStorageMode` and `AccountType` into a
+     * single 2-way `AccountType` flag: setting the storage mode IS setting the account
+     * type. Calling both `accountType()` and `storageMode()` on the same builder is the
+     * last-write-wins on the underlying flag. Method kept for JS-surface back-compat.
      * @param {AccountStorageMode} storage_mode
      * @returns {AccountBuilder}
      */
     storageMode(storage_mode) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(storage_mode, AccountStorageMode);
-        const ret = wasm.accountbuilder_storageMode(ptr, storage_mode.__wbg_ptr);
+        const ret = wasm.accountbuilder_storageMode(this.__wbg_ptr, storage_mode.__wbg_ptr);
         return AccountBuilder.__wrap(ret);
     }
     /**
@@ -11375,17 +11401,15 @@ class AccountBuilder {
      * @returns {AccountBuilder}
      */
     withAuthComponent(account_component) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(account_component, AccountComponent);
-        const ret = wasm.accountbuilder_withAuthComponent(ptr, account_component.__wbg_ptr);
+        const ret = wasm.accountbuilder_withAuthComponent(this.__wbg_ptr, account_component.__wbg_ptr);
         return AccountBuilder.__wrap(ret);
     }
     /**
      * @returns {AccountBuilder}
      */
     withBasicWalletComponent() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.accountbuilder_withBasicWalletComponent(ptr);
+        const ret = wasm.accountbuilder_withBasicWalletComponent(this.__wbg_ptr);
         return AccountBuilder.__wrap(ret);
     }
     /**
@@ -11394,9 +11418,8 @@ class AccountBuilder {
      * @returns {AccountBuilder}
      */
     withComponent(account_component) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(account_component, AccountComponent);
-        const ret = wasm.accountbuilder_withComponent(ptr, account_component.__wbg_ptr);
+        const ret = wasm.accountbuilder_withComponent(this.__wbg_ptr, account_component.__wbg_ptr);
         return AccountBuilder.__wrap(ret);
     }
     /**
@@ -11404,8 +11427,7 @@ class AccountBuilder {
      * @returns {AccountBuilder}
      */
     withNoAuthComponent() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.accountbuilder_withNoAuthComponent(ptr);
+        const ret = wasm.accountbuilder_withNoAuthComponent(this.__wbg_ptr);
         return AccountBuilder.__wrap(ret);
     }
 }
@@ -11583,7 +11605,8 @@ class AccountComponent {
     static fromPackage(_package, storage_slots) {
         _assertClass(_package, Package);
         _assertClass(storage_slots, StorageSlotArray);
-        const ret = wasm.accountcomponent_fromPackage(_package.__wbg_ptr, storage_slots.__wbg_ptr);
+        var ptr0 = storage_slots.__destroy_into_raw();
+        const ret = wasm.accountcomponent_fromPackage(_package.__wbg_ptr, ptr0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -11630,11 +11653,15 @@ class AccountComponent {
     }
     /**
      * Marks the component as supporting all account types.
+     *
+     * The 0.15 protocol collapsed the per-account-type flag set on
+     * `AccountComponentMetadata::new` — every component now applies to every account type
+     * implicitly, so this method's job is to re-derive the metadata under the new
+     * (name-only) constructor while keeping the JS API surface stable.
      * @returns {AccountComponent}
      */
     withSupportsAllTypes() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.accountcomponent_withSupportsAllTypes(ptr);
+        const ret = wasm.accountcomponent_withSupportsAllTypes(this.__wbg_ptr);
         return AccountComponent.__wrap(ret);
     }
 }
@@ -11989,22 +12016,6 @@ class AccountId {
         }
         return AccountId.__wrap(ret[0]);
     }
-    /**
-     * Returns true if the ID refers to a faucet.
-     * @returns {boolean}
-     */
-    isFaucet() {
-        const ret = wasm.accountid_isFaucet(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Returns true if the ID is reserved for network accounts.
-     * @returns {boolean}
-     */
-    isNetwork() {
-        const ret = wasm.accountid_isNetwork(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns true if the account uses private storage.
      * @returns {boolean}
@@ -12021,14 +12032,6 @@ class AccountId {
         const ret = wasm.accountid_isPublic(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Returns true if the ID refers to a regular account.
-     * @returns {boolean}
-     */
-    isRegularAccount() {
-        const ret = wasm.accountid_isRegularAccount(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns the prefix field element storing metadata about version, type, and storage mode.
      * @returns {Felt}
@@ -12146,18 +12149,13 @@ class AccountIdArray {
         wasm.accountidarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {AccountId} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, AccountId);
-        const ret = wasm.accountidarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.accountidarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -12248,7 +12246,7 @@ class AccountProof {
      *
      * Each entry contains a `key` and `value` as `Word` objects.
      * @param {string} slot_name
-     * @returns {StorageMapEntry[] | undefined}
+     * @returns {StorageMapEntryJs[] | undefined}
      */
     getStorageMapEntries(slot_name) {
         const ptr0 = passStringToWasm0(slot_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -12326,6 +12324,22 @@ class AccountProof {
         const ret = wasm.accountproof_numStorageSlots(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
+    /**
+     * Returns the fungible assets in the account's vault, if vault details were included
+     * in the proof response.
+     *
+     * Returns `undefined` if the account is private or vault data was not requested.
+     * @returns {FungibleAsset[] | undefined}
+     */
+    vaultFungibleAssets() {
+        const ret = wasm.accountproof_vaultFungibleAssets(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;
+    }
 }
 if (Symbol.dispose) AccountProof.prototype[Symbol.dispose] = AccountProof.prototype.free;
 
@@ -12593,7 +12607,7 @@ class AccountStorage {
      * Returns `undefined` if the slot isn't a map or doesn't exist.
      * Returns `[]` if the map exists but is empty.
      * @param {string} slot_name
-     * @returns {JsStorageMapEntry[] | undefined}
+     * @returns {StorageMapEntry[] | undefined}
      */
     getMapEntries(slot_name) {
         const ptr0 = passStringToWasm0(slot_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -12702,6 +12716,15 @@ if (Symbol.dispose) AccountStorageDelta.prototype[Symbol.dispose] = AccountStora
 
 /**
  * Storage visibility mode for an account.
+ *
+ * In the 0.15 protocol surface this is the same enum as `AccountType`
+ * (the on-chain identifier no longer carries any faucet-vs-regular or
+ * updatable-vs-immutable distinction), so internally we wrap an
+ * `AccountType`. The standalone `AccountStorageMode` type still exists at
+ * the JS API surface for backwards compatibility with code that wrote
+ * `AccountStorageMode.public()` / `.private()`. The pre-existing `.network()`
+ * constructor was removed — the network storage mode does not exist on the
+ * 0.15 chain.
  */
 class AccountStorageMode {
     static __wrap(ptr) {
@@ -12737,14 +12760,6 @@ class AccountStorageMode {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Creates a network storage mode.
-     * @returns {AccountStorageMode}
-     */
-    static network() {
-        const ret = wasm.accountstoragemode_network();
-        return AccountStorageMode.__wrap(ret);
-    }
     /**
      * Creates a private storage mode.
      * @returns {AccountStorageMode}
@@ -12763,6 +12778,9 @@ class AccountStorageMode {
     }
     /**
      * Parses a storage mode from its string representation.
+     *
+     * Accepts `"private"` and `"public"`; any other input — including the
+     * previously-supported `"network"` — is rejected.
      * @param {string} s
      * @returns {AccountStorageMode}
      */
@@ -12823,13 +12841,17 @@ class AccountStorageRequirements {
 if (Symbol.dispose) AccountStorageRequirements.prototype[Symbol.dispose] = AccountStorageRequirements.prototype.free;
 
 /**
- * @enum {0 | 1 | 2 | 3}
+ * Storage mode of an account. The 0.15 protocol collapses the previous
+ * 4-way `{ FungibleFaucet, NonFungibleFaucet, RegularAccountImmutableCode,
+ * RegularAccountUpdatableCode }` distinction into a 2-way storage flag —
+ * faucet-vs-regular and updatable-vs-immutable distinctions are no longer
+ * part of the on-chain `AccountType` and the API loses no information by
+ * narrowing here too.
+ * @enum {0 | 1}
  */
 const AccountType = Object.freeze({
-    FungibleFaucet: 0, "0": "FungibleFaucet",
-    NonFungibleFaucet: 1, "1": "NonFungibleFaucet",
-    RegularAccountImmutableCode: 2, "2": "RegularAccountImmutableCode",
-    RegularAccountUpdatableCode: 3, "3": "RegularAccountUpdatableCode",
+    Private: 0, "0": "Private",
+    Public: 1, "1": "Public",
 });
 
 /**
@@ -13127,13 +13149,14 @@ class AdviceMap {
     insert(key, value) {
         _assertClass(key, Word);
         _assertClass(value, FeltArray);
-        const ret = wasm.advicemap_insert(this.__wbg_ptr, key.__wbg_ptr, value.__wbg_ptr);
-        let v1;
+        var ptr0 = value.__destroy_into_raw();
+        const ret = wasm.advicemap_insert(this.__wbg_ptr, key.__wbg_ptr, ptr0);
+        let v2;
         if (ret[0] !== 0) {
-            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
             wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         }
-        return v1;
+        return v2;
     }
     /**
      * Creates an empty advice map.
@@ -13190,6 +13213,17 @@ class AssetVault {
     }
     /**
      * Returns the balance for the given fungible faucet, or zero if absent.
+     *
+     * `get_balance` on the 0.15 surface keys by `AssetVaultKey`, not `AccountId`, and
+     * validates the composition. The callback flag is `Disabled` because fungible balance
+     * reads don't run asset callbacks. Returns zero on lookup error (`Err` arms here would
+     * indicate the key was constructed wrong, which can't happen for fungible keys built
+     * this way).
+     *
+     * NOTE: the `AssetVaultKey` encodes the callback flag, so this reports only the balance
+     * of callback-*disabled* fungible assets. Faucets built by this SDK omit transfer policies
+     * and therefore mint callback-disabled assets, so this is exact for them; an asset minted
+     * elsewhere with callbacks enabled would not be counted here.
      * @param {AccountId} faucet_id
      * @returns {bigint}
      */
@@ -13282,10 +13316,9 @@ class AuthFalcon512RpoMultisigConfig {
      * @returns {AuthFalcon512RpoMultisigConfig}
      */
     withProcThresholds(proc_thresholds) {
-        const ptr = this.__destroy_into_raw();
         const ptr0 = passArrayJsValueToWasm0(proc_thresholds, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.authfalcon512rpomultisigconfig_withProcThresholds(ptr, ptr0, len0);
+        const ret = wasm.authfalcon512rpomultisigconfig_withProcThresholds(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -13427,6 +13460,9 @@ if (Symbol.dispose) AuthSecretKey.prototype[Symbol.dispose] = AuthSecretKey.prot
 
 /**
  * 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/maxSupply).
  */
 class BasicFungibleFaucetComponent {
     static __wrap(ptr) {
@@ -13473,7 +13509,7 @@ class BasicFungibleFaucetComponent {
      * @returns {Felt}
      */
     maxSupply() {
-        const ret = wasm.accountid_prefix(this.__wbg_ptr);
+        const ret = wasm.basicfungiblefaucetcomponent_maxSupply(this.__wbg_ptr);
         return Felt.__wrap(ret);
     }
     /**
@@ -13556,8 +13592,8 @@ class BlockHeader {
      * network.
      * @returns {AccountId}
      */
-    nativeAssetId() {
-        const ret = wasm.blockheader_nativeAssetId(this.__wbg_ptr);
+    feeFaucetId() {
+        const ret = wasm.blockheader_feeFaucetId(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
     /**
@@ -13800,14 +13836,6 @@ class CommittedNote {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_committednote_free(ptr, 0);
     }
-    /**
-     * Returns the full note metadata when the attachment payload is available.
-     * @returns {NoteMetadata | undefined}
-     */
-    fullMetadata() {
-        const ret = wasm.committednote_fullMetadata(this.__wbg_ptr);
-        return ret === 0 ? undefined : NoteMetadata.__wrap(ret);
-    }
     /**
      * Returns the inclusion path for the note in the block's note tree.
      * @returns {SparseMerklePath}
@@ -13826,9 +13854,6 @@ class CommittedNote {
     }
     /**
      * Returns the note metadata.
-     *
-     * If only metadata headers are available, the returned metadata contains
-     * the sender, note type, and tag without attachment payload.
      * @returns {NoteMetadata}
      */
     metadata() {
@@ -14203,12 +14228,18 @@ class Felt {
         return BigInt.asUintN(64, ret);
     }
     /**
-     * Creates a new field element from a u64 value.
+     * Creates a new field element.
+     *
+     * Returns an error if `value` is outside the field's representable
+     * range (`Felt::new` is fallible on the 0.15 protocol surface).
      * @param {bigint} value
      */
     constructor(value) {
         const ret = wasm.felt_new(value);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         FeltFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -14294,18 +14325,13 @@ class FeltArray {
         wasm.feltarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {Felt} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, Felt);
-        const ret = wasm.feltarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.feltarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -14358,14 +14384,6 @@ class FetchedAccount {
         const ret = wasm.fetchedaccount_commitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
-    /**
-     * Returns true when the account is a network account.
-     * @returns {boolean}
-     */
-    isNetwork() {
-        const ret = wasm.fetchedaccount_isNetwork(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Returns true when the account is private.
      * @returns {boolean}
@@ -14396,8 +14414,15 @@ if (Symbol.dispose) FetchedAccount.prototype[Symbol.dispose] = FetchedAccount.pr
 /**
  * Wrapper for a note fetched over RPC.
  *
- * It contains the note header and inclusion proof. The note details are only present for
- * public notes.
+ * It carries the note ID, public metadata, and inclusion proof. The full note body is only
+ * present for public notes; for private notes only the header-shaped fields and inclusion
+ * proof are available — the body lives off-chain.
+ *
+ * 0.15 protocol surface: the on-chain `NoteHeader` now commits to a
+ * `NoteDetailsCommitment` rather than the `NoteId`, so a `NoteHeader` can no longer be
+ * reconstructed from header-shaped fields alone for private notes. We therefore expose
+ * the constituent fields (`noteId`, `metadata`) directly on `FetchedNote` instead of a
+ * `header` getter.
  */
 class FetchedNote {
     static __wrap(ptr) {
@@ -14429,12 +14454,18 @@ class FetchedNote {
         return ret === 0 ? undefined : InputNote.__wrap(ret);
     }
     /**
-     * The note's header, containing the ID and metadata.
-     * @returns {NoteHeader}
+     * The note's attachments.
+     *
+     * 0.15 returns attachment content over RPC for both public and private notes, so this is
+     * populated even when the note body itself is private. An empty array means the note
+     * carries no attachments.
+     * @returns {NoteAttachment[]}
      */
-    get header() {
-        const ret = wasm.fetchednote_header(this.__wbg_ptr);
-        return NoteHeader.__wrap(ret);
+    get attachments() {
+        const ret = wasm.fetchednote_attachments(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * The note's inclusion proof.
@@ -14673,18 +14704,13 @@ class ForeignAccountArray {
         wasm.foreignaccountarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {ForeignAccount} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, ForeignAccount);
-        const ret = wasm.foreignaccountarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.foreignaccountarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -14754,7 +14780,10 @@ class FungibleAsset {
     constructor(faucet_id, amount) {
         _assertClass(faucet_id, AccountId);
         const ret = wasm.fungibleasset_new(faucet_id.__wbg_ptr, amount);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         FungibleAssetFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -14784,6 +14813,10 @@ class FungibleAssetDelta {
     }
     /**
      * Returns the delta amount for a given faucet, if present.
+     *
+     * The vault key here is the one used by the fungible-delta tree, which the upstream
+     * surface keys with `AssetCallbackFlag::Disabled` — fungible balance deltas don't run
+     * asset callbacks. `new_fungible` on the 0.15 surface is infallible.
      * @param {AccountId} faucet_id
      * @returns {bigint | undefined}
      */
@@ -14958,7 +14991,12 @@ class InputNote {
         return InputNote.__wrap(ret);
     }
     /**
-     * Returns the commitment to the note ID and metadata.
+     * Returns the commitment to the note (its ID).
+     *
+     * Migration note (miden-client PR #2214): `Note::commitment()` was
+     * removed on the 0.15 surface — the note ID *is* the commitment (it
+     * hashes details + metadata). Return the underlying `NoteId` as a
+     * `Word` so the JS API contract is unchanged.
      * @returns {Word}
      */
     commitment() {
@@ -15044,6 +15082,22 @@ class InputNoteRecord {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_inputnoterecord_free(ptr, 0);
     }
+    /**
+     * Returns the note's attachments.
+     *
+     * On the 0.15 surface the full attachment content (the packed words) lives
+     * on the note record itself rather than on `NoteMetadata` (which only
+     * carries the attachment headers). This exposes that content so JS callers
+     * can decode payloads packed via the `createNoteAttachment` helper. An
+     * empty array means the note carries no attachments.
+     * @returns {NoteAttachment[]}
+     */
+    attachments() {
+        const ret = wasm.inputnoterecord_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 note commitment (id + metadata), if available.
      * @returns {Word | undefined}
@@ -15074,12 +15128,16 @@ class InputNoteRecord {
         return NoteDetails.__wrap(ret);
     }
     /**
-     * Returns the note ID.
-     * @returns {NoteId}
+     * Returns the note ID when available.
+     *
+     * Migration note (miden-client PR #2214): `InputNoteRecord::id()`
+     * returns `Option<NoteId>` — partial / metadata-less notes have no
+     * metadata-bearing ID yet.
+     * @returns {NoteId | undefined}
      */
     id() {
         const ret = wasm.inputnoterecord_id(this.__wbg_ptr);
-        return NoteId.__wrap(ret);
+        return ret === 0 ? undefined : NoteId.__wrap(ret);
     }
     /**
      * Returns the inclusion proof when the note is authenticated.
@@ -15122,20 +15180,20 @@ class InputNoteRecord {
         return ret === 0 ? undefined : NoteMetadata.__wrap(ret);
     }
     /**
-     * Returns the nullifier for this note.
-     * @returns {string}
+     * Returns the nullifier for this note when available.
+     *
+     * Migration note (miden-client PR #2214): `InputNoteRecord::nullifier()`
+     * returns `Option<Nullifier>` — partial notes have no nullifier yet.
+     * @returns {string | undefined}
      */
     nullifier() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.inputnoterecord_nullifier(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);
+        const ret = wasm.inputnoterecord_nullifier(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 current processing state for this note.
@@ -15706,11 +15764,12 @@ class JsStateSyncUpdate {
         return ret >>> 0;
     }
     /**
-     * IDs of note tags that should be removed from the client's local state.
+     * Details-commitment hex of committed notes whose tracking tags
+     * (`NoteTagSource::Note`) should be removed from the client's local state.
      * @returns {string[]}
      */
-    get committedNoteIds() {
-        const ret = wasm.__wbg_get_jsstatesyncupdate_committedNoteIds(this.__wbg_ptr);
+    get committedNoteTagSources() {
+        const ret = wasm.__wbg_get_jsstatesyncupdate_committedNoteTagSources(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -15723,15 +15782,6 @@ class JsStateSyncUpdate {
         const ret = wasm.__wbg_get_jsstatesyncupdate_flattenedNewBlockHeaders(this.__wbg_ptr);
         return FlattenedU8Vec.__wrap(ret);
     }
-    /**
-     * Flattened byte array containing partial blockchain peaks used for merkle tree
-     * verification.
-     * @returns {FlattenedU8Vec}
-     */
-    get flattenedPartialBlockChainPeaks() {
-        const ret = wasm.__wbg_get_jsstatesyncupdate_flattenedPartialBlockChainPeaks(this.__wbg_ptr);
-        return FlattenedU8Vec.__wrap(ret);
-    }
     /**
      * The block numbers corresponding to each header in `flattened_new_block_headers`.
      * This vec should have the same length as the number of headers, with each index
@@ -15744,6 +15794,18 @@ class JsStateSyncUpdate {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         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`.
+     * @returns {Uint8Array}
+     */
+    get partialBlockchainPeaks() {
+        const ret = wasm.__wbg_get_jsstatesyncupdate_partialBlockchainPeaks(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * Input notes for this state update in serialized form.
      * @returns {SerializedInputNoteData[]}
@@ -15822,13 +15884,14 @@ class JsStateSyncUpdate {
         wasm.__wbg_set_jsstatesyncupdate_blockNum(this.__wbg_ptr, arg0);
     }
     /**
-     * IDs of note tags that should be removed from the client's local state.
+     * Details-commitment hex of committed notes whose tracking tags
+     * (`NoteTagSource::Note`) should be removed from the client's local state.
      * @param {string[]} arg0
      */
-    set committedNoteIds(arg0) {
+    set committedNoteTagSources(arg0) {
         const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstatesyncupdate_committedNoteIds(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsstatesyncupdate_committedNoteTagSources(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * The new block headers for this state update, serialized into a flattened byte array.
@@ -15839,16 +15902,6 @@ class JsStateSyncUpdate {
         var ptr0 = arg0.__destroy_into_raw();
         wasm.__wbg_set_jsstatesyncupdate_flattenedNewBlockHeaders(this.__wbg_ptr, ptr0);
     }
-    /**
-     * Flattened byte array containing partial blockchain peaks used for merkle tree
-     * verification.
-     * @param {FlattenedU8Vec} arg0
-     */
-    set flattenedPartialBlockChainPeaks(arg0) {
-        _assertClass(arg0, FlattenedU8Vec);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_jsstatesyncupdate_flattenedPartialBlockChainPeaks(this.__wbg_ptr, ptr0);
-    }
     /**
      * The block numbers corresponding to each header in `flattened_new_block_headers`.
      * This vec should have the same length as the number of headers, with each index
@@ -15860,6 +15913,17 @@ class JsStateSyncUpdate {
         const len0 = WASM_VECTOR_LEN;
         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`.
+     * @param {Uint8Array} arg0
+     */
+    set partialBlockchainPeaks(arg0) {
+        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jsstatesyncupdate_partialBlockchainPeaks(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Input notes for this state update in serialized form.
      * @param {SerializedInputNoteData[]} arg0
@@ -16348,6 +16412,76 @@ class NetworkId {
 }
 if (Symbol.dispose) NetworkId.prototype[Symbol.dispose] = NetworkId.prototype.free;
 
+/**
+ * Status of a network note in the node.
+ */
+class NetworkNoteStatusInfo {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(NetworkNoteStatusInfo.prototype);
+        obj.__wbg_ptr = ptr;
+        NetworkNoteStatusInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NetworkNoteStatusInfoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_networknotestatusinfo_free(ptr, 0);
+    }
+    /**
+     * Returns the number of processing attempts.
+     * @returns {number}
+     */
+    get attemptCount() {
+        const ret = wasm.networknotestatusinfo_attemptCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the block number of the last processing attempt, if any.
+     * @returns {number | undefined}
+     */
+    get lastAttemptBlockNum() {
+        const ret = wasm.networknotestatusinfo_lastAttemptBlockNum(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Returns the last error message, if any.
+     * @returns {string | undefined}
+     */
+    get lastError() {
+        const ret = wasm.networknotestatusinfo_lastError(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 status as a string: `"Pending"`, `"NullifierInflight"`, `"Discarded"`, or
+     * `"NullifierCommitted"`.
+     * @returns {string}
+     */
+    get status() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.networknotestatusinfo_status(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) NetworkNoteStatusInfo.prototype[Symbol.dispose] = NetworkNoteStatusInfo.prototype.free;
+
 /**
  * The type of a Miden network.
  * @enum {0 | 1 | 2 | 3}
@@ -16411,7 +16545,12 @@ class Note {
         return NoteAssets.__wrap(ret);
     }
     /**
-     * Returns the commitment to the note ID and metadata.
+     * Returns the commitment to the note (its ID).
+     *
+     * Migration note (miden-client PR #2214): `Note::commitment()` was
+     * removed on the 0.15 surface — the note ID is the commitment. Return
+     * the underlying `NoteId` as a `Word` so the JS API contract is
+     * unchanged.
      * @returns {Word}
      */
     commitment() {
@@ -16477,7 +16616,7 @@ class Note {
      * @returns {NoteId}
      */
     id() {
-        const ret = wasm.accountheader_storageCommitment(this.__wbg_ptr);
+        const ret = wasm.note_commitment(this.__wbg_ptr);
         return NoteId.__wrap(ret);
     }
     /**
@@ -16485,11 +16624,15 @@ class Note {
      * @returns {NoteMetadata}
      */
     metadata() {
-        const ret = wasm.note_metadata(this.__wbg_ptr);
+        const ret = wasm.committednote_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
     /**
      * Creates a new note from the provided assets, metadata, and recipient.
+     *
+     * Migration note (miden-client PR #2214): `Note::new` now takes a
+     * `PartialNoteMetadata` (not `NoteMetadata`). Extract the partial
+     * fields from the JS-side `NoteMetadata` and reconstruct.
      * @param {NoteAssets} note_assets
      * @param {NoteMetadata} note_metadata
      * @param {NoteRecipient} note_recipient
@@ -16638,18 +16781,13 @@ class NoteAndArgsArray {
         wasm.noteandargsarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {NoteAndArgs} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, NoteAndArgs);
-        const ret = wasm.noteandargsarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.noteandargsarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -16713,18 +16851,13 @@ class NoteArray {
         wasm.notearray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {Note} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, Note);
-        const ret = wasm.notearray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.notearray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -16796,9 +16929,13 @@ if (Symbol.dispose) NoteAssets.prototype[Symbol.dispose] = NoteAssets.prototype.
 /**
  * An attachment to a note.
  *
- * Note attachments provide additional context about how notes should be processed.
- * For example, a network account target attachment indicates that the note should
- * be consumed by a specific network account.
+ * 0.15 protocol surface: an attachment is a `(scheme, content)` pair where
+ * `content` is a flat `Vec<Word>` of 1..=256 words. The previous
+ * `NoteAttachmentKind { Word, Array }` dispatch and the per-variant
+ * `asWord` / `asArray` / `newWord` / `newArray` getters/constructors no
+ * longer exist — content is always word-vector-shaped now. Use
+ * `fromWord(scheme, word)` for the common single-word case or
+ * `fromWords(scheme, words)` for multi-word content.
  */
 class NoteAttachment {
     static __wrap(ptr) {
@@ -16818,30 +16955,6 @@ class NoteAttachment {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_noteattachment_free(ptr, 0);
     }
-    /**
-     * Returns the content as an array of Felts if the attachment kind is Array, otherwise None.
-     * @returns {FeltArray | undefined}
-     */
-    asArray() {
-        const ret = wasm.noteattachment_asArray(this.__wbg_ptr);
-        return ret === 0 ? undefined : FeltArray.__wrap(ret);
-    }
-    /**
-     * Returns the content as a Word if the attachment kind is Word, otherwise None.
-     * @returns {Word | undefined}
-     */
-    asWord() {
-        const ret = wasm.noteattachment_asWord(this.__wbg_ptr);
-        return ret === 0 ? undefined : Word.__wrap(ret);
-    }
-    /**
-     * Returns the attachment kind.
-     * @returns {NoteAttachmentKind}
-     */
-    attachmentKind() {
-        const ret = wasm.noteattachment_attachmentKind(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Returns the attachment scheme.
      * @returns {NoteAttachmentScheme}
@@ -16851,80 +16964,90 @@ class NoteAttachment {
         return NoteAttachmentScheme.__wrap(ret);
     }
     /**
-     * Creates a default (empty) note attachment.
-     */
-    constructor() {
-        const ret = wasm.noteattachment_new();
-        this.__wbg_ptr = ret >>> 0;
-        NoteAttachmentFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Creates a new note attachment with Array content from the provided elements.
+     * Creates a new note attachment from a single word.
      * @param {NoteAttachmentScheme} scheme
-     * @param {FeltArray} elements
+     * @param {Word} word
      * @returns {NoteAttachment}
      */
-    static newArray(scheme, elements) {
+    static fromWord(scheme, word) {
         _assertClass(scheme, NoteAttachmentScheme);
-        _assertClass(elements, FeltArray);
-        const ret = wasm.noteattachment_newArray(scheme.__wbg_ptr, elements.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        _assertClass(word, Word);
+        const ret = wasm.noteattachment_fromWord(scheme.__wbg_ptr, word.__wbg_ptr);
+        return NoteAttachment.__wrap(ret);
+    }
+    /**
+     * Creates a new note attachment from a vector of words.
+     *
+     * # Errors
+     * Returns an error if `words` is empty or exceeds `NoteAttachment::MAX_NUM_WORDS`.
+     * @param {NoteAttachmentScheme} scheme
+     * @param {Word[]} words
+     * @returns {NoteAttachment}
+     */
+    static fromWords(scheme, words) {
+        _assertClass(scheme, NoteAttachmentScheme);
+        const ptr0 = passArrayJsValueToWasm0(words, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.noteattachment_fromWords(scheme.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
         return NoteAttachment.__wrap(ret[0]);
     }
     /**
-     * Creates a new note attachment for a network account target.
-     *
-     * This attachment indicates that the note should be consumed by a specific network account.
-     * Network accounts are accounts whose storage mode is `Network`, meaning the network (nodes)
-     * can execute transactions on behalf of the account.
+     * Creates a note attachment from an optional list of packed values.
      *
-     * # Arguments
-     * * `target_id` - The ID of the network account that should consume the note
-     * * `exec_hint` - A hint about when the note can be executed
+     * Mirrors the encoding the JS-side `createNoteAttachment` helper performs
+     * and preserves the `new NoteAttachment()` / `new NoteAttachment([...])`
+     * ergonomics the package's own JS wrappers (`js/standalone.js`,
+     * `js/resources/transactions.js`) rely on. The 0.15 surface has no truly
+     * empty attachment (content is 1..=256 words), so the empty case is
+     * represented as a single zero [`Word`] with the `none` scheme:
+     * - no args / empty list → single zero-`Word`, `none` scheme.
+     * - any number of values → padded to a whole number of `Word`s, `none` scheme.
      *
      * # Errors
-     * Returns an error if the target account is not a network account.
-     * @param {AccountId} target_id
-     * @param {NoteExecutionHint} exec_hint
-     * @returns {NoteAttachment}
+     * Returns an error if a value is not a canonical field element, or if the
+     * packed word count exceeds `NoteAttachment::MAX_NUM_WORDS`.
+     * @param {BigUint64Array | null} [values]
      */
-    static newNetworkAccountTarget(target_id, exec_hint) {
-        _assertClass(target_id, AccountId);
-        _assertClass(exec_hint, NoteExecutionHint);
-        const ret = wasm.noteattachment_newNetworkAccountTarget(target_id.__wbg_ptr, exec_hint.__wbg_ptr);
+    constructor(values) {
+        var ptr0 = isLikeNone(values) ? 0 : passArray64ToWasm0(values, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.noteattachment_new(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return NoteAttachment.__wrap(ret[0]);
+        this.__wbg_ptr = ret[0] >>> 0;
+        NoteAttachmentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Creates a new note attachment with Word content from the provided word.
-     * @param {NoteAttachmentScheme} scheme
-     * @param {Word} word
-     * @returns {NoteAttachment}
+     * Returns the number of words in this attachment.
+     * @returns {number}
      */
-    static newWord(scheme, word) {
-        _assertClass(scheme, NoteAttachmentScheme);
-        _assertClass(word, Word);
-        const ret = wasm.noteattachment_newWord(scheme.__wbg_ptr, word.__wbg_ptr);
-        return NoteAttachment.__wrap(ret);
+    numWords() {
+        const ret = wasm.noteattachment_numWords(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the attachment content as its constituent words.
+     *
+     * The content is always word-vector-shaped on the 0.15 surface, so this is
+     * the inverse of `fromWord` / `fromWords`: it yields the same `Word`s the
+     * attachment was built from (in order), letting JS callers decode the
+     * packed values back out.
+     * @returns {Word[]}
+     */
+    toWords() {
+        const ret = wasm.noteattachment_toWords(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) NoteAttachment.prototype[Symbol.dispose] = NoteAttachment.prototype.free;
 
-/**
- * Defines the payload shape of a note attachment.
- * @enum {0 | 1 | 2}
- */
-const NoteAttachmentKind = Object.freeze({
-    None: 0, "0": "None",
-    Word: 1, "1": "Word",
-    Array: 2, "2": "Array",
-});
-
 /**
  * Describes the type of a note attachment.
  *
@@ -16949,14 +17072,6 @@ class NoteAttachmentScheme {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_noteattachmentscheme_free(ptr, 0);
     }
-    /**
-     * Returns the note attachment scheme as a u32.
-     * @returns {number}
-     */
-    asU32() {
-        const ret = wasm.noteattachmentscheme_asU32(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * Returns true if the attachment scheme is the reserved value that signals an absent scheme.
      * @returns {boolean}
@@ -16966,12 +17081,19 @@ class NoteAttachmentScheme {
         return ret !== 0;
     }
     /**
-     * Creates a new `NoteAttachmentScheme` from a u32.
+     * Creates a new `NoteAttachmentScheme` from a u32 value.
+     *
+     * Errors if `scheme` is out of range (the 0.15 surface narrowed the
+     * underlying type from u32 → u16, so values outside `0..=u16::MAX`
+     * are rejected).
      * @param {number} scheme
      */
     constructor(scheme) {
         const ret = wasm.noteattachmentscheme_new(scheme);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         NoteAttachmentSchemeFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -17111,6 +17233,14 @@ if (Symbol.dispose) NoteConsumptionStatus.prototype[Symbol.dispose] = NoteConsum
  * Details of a note consisting of assets, script, inputs, and a serial number.
  *
  * See the {@link Note} type for more details.
+ *
+ * Migration note (miden-client PR #2214): `NoteDetails::id()` and
+ * `NoteDetails::nullifier()` were removed on the 0.15 protocol surface —
+ * the ID now requires a `NoteMetadata` to compute (see `NoteId::new`),
+ * and the nullifier moved onto `InputNoteRecord` where it is optional.
+ * Use `details_commitment()` on a containing record (e.g.
+ * `InputNoteRecord::details_commitment`) for the metadata-independent
+ * identifier.
  */
 class NoteDetails {
     static __wrap(ptr) {
@@ -17138,14 +17268,6 @@ class NoteDetails {
         const ret = wasm.notedetails_assets(this.__wbg_ptr);
         return NoteAssets.__wrap(ret);
     }
-    /**
-     * Returns the note identifier derived from these details.
-     * @returns {NoteId}
-     */
-    id() {
-        const ret = wasm.notedetails_id(this.__wbg_ptr);
-        return NoteId.__wrap(ret);
-    }
     /**
      * Creates a new set of note details from the given assets and recipient.
      * @param {NoteAssets} note_assets
@@ -17159,14 +17281,6 @@ class NoteDetails {
         NoteDetailsFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
-    /**
-     * Returns the note nullifier as a word.
-     * @returns {Word}
-     */
-    nullifier() {
-        const ret = wasm.notedetails_nullifier(this.__wbg_ptr);
-        return Word.__wrap(ret);
-    }
     /**
      * Returns the recipient which controls when the note can be consumed.
      * @returns {NoteRecipient}
@@ -17295,18 +17409,13 @@ class NoteDetailsAndTagArray {
         wasm.notedetailsandtagarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {NoteDetailsAndTag} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, NoteDetailsAndTag);
-        const ret = wasm.notedetailsandtagarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.notedetailsandtagarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -17524,12 +17633,17 @@ class NoteFile {
         return ret === 0 ? undefined : NoteDetails.__wrap(ret);
     }
     /**
-     * Returns the note ID for any `NoteFile` variant.
-     * @returns {NoteId}
+     * Returns the note ID when the file carries one.
+     *
+     * Migration note (miden-client PR #2214): `NoteDetails::id()` was
+     * removed (computing the ID now requires `NoteMetadata`), so the
+     * `NoteDetails`-only variant cannot synthesize one without extra
+     * information. Returns `None` in that case.
+     * @returns {NoteId | undefined}
      */
     noteId() {
         const ret = wasm.notefile_noteId(this.__wbg_ptr);
-        return NoteId.__wrap(ret);
+        return ret === 0 ? undefined : NoteId.__wrap(ret);
     }
     /**
      * Returns the note tag hint when present.
@@ -17557,6 +17671,10 @@ class NoteFile {
     }
     /**
      * Returns the note nullifier when present.
+     *
+     * Migration note (miden-client PR #2214): `NoteDetails::nullifier()`
+     * was removed (the nullifier moved onto `InputNoteRecord` and is
+     * optional there), so the `NoteDetails`-only variant returns `None`.
      * @returns {string | undefined}
      */
     nullifier() {
@@ -17632,13 +17750,6 @@ const NoteFilterTypes = Object.freeze({
  * See `NoteId` and `NoteMetadata` for additional details.
  */
 class NoteHeader {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(NoteHeader.prototype);
-        obj.__wbg_ptr = ptr;
-        NoteHeaderFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -17654,7 +17765,7 @@ class NoteHeader {
      * @returns {NoteId}
      */
     id() {
-        const ret = wasm.accountcode_commitment(this.__wbg_ptr);
+        const ret = wasm.noteheader_id(this.__wbg_ptr);
         return NoteId.__wrap(ret);
     }
     /**
@@ -17665,14 +17776,6 @@ class NoteHeader {
         const ret = wasm.noteheader_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
-    /**
-     * Returns a commitment to the note ID and metadata.
-     * @returns {Word}
-     */
-    toCommitment() {
-        const ret = wasm.noteheader_toCommitment(this.__wbg_ptr);
-        return Word.__wrap(ret);
-    }
 }
 if (Symbol.dispose) NoteHeader.prototype[Symbol.dispose] = NoteHeader.prototype.free;
 
@@ -17681,16 +17784,14 @@ if (Symbol.dispose) NoteHeader.prototype[Symbol.dispose] = NoteHeader.prototype.
  *
  * Note ID is computed as:
  *
- * > `hash(recipient, asset_commitment)`
+ * > `hash(details_commitment, metadata_commitment)`
  *
- * where `recipient` is defined as:
- *
- * > `hash(hash(hash(serial_num, ZERO), script_root), input_commitment)`
- *
- * This achieves the following properties:
- * - Every note can be reduced to a single unique ID.
- * - To compute a note ID, we do not need to know the note's `serial_num`. Knowing the hash of the
- *   `serial_num` (as well as script root, input commitment, and note assets) is sufficient.
+ * On the 0.15 protocol surface the upstream `NoteId::new` signature
+ * changed from `(recipient_digest, asset_commitment)` to
+ * `(NoteDetailsCommitment, &NoteMetadata)`. The JS API exposes
+ * `NoteId.fromRaw(word)` for constructing an ID from a pre-computed
+ * 32-byte commitment word (the previous two-Word constructor has no
+ * 0.15 equivalent).
  */
 class NoteId {
     static __wrap(ptr) {
@@ -17731,17 +17832,18 @@ class NoteId {
         return NoteId.__wrap(ret[0]);
     }
     /**
-     * Builds a note ID from the recipient and asset commitments.
-     * @param {Word} recipient_digest
-     * @param {Word} asset_commitment_digest
+     * Builds a note ID from its raw commitment word.
+     *
+     * `word` must already encode the final note-ID commitment — the
+     * metadata-mixing that the previous 2-Word constructor did is no
+     * longer part of the protocol surface.
+     * @param {Word} word
+     * @returns {NoteId}
      */
-    constructor(recipient_digest, asset_commitment_digest) {
-        _assertClass(recipient_digest, Word);
-        _assertClass(asset_commitment_digest, Word);
-        const ret = wasm.noteid_new(recipient_digest.__wbg_ptr, asset_commitment_digest.__wbg_ptr);
-        this.__wbg_ptr = ret >>> 0;
-        NoteIdFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static fromRaw(word) {
+        _assertClass(word, Word);
+        const ret = wasm.accountcode_commitment(word.__wbg_ptr);
+        return NoteId.__wrap(ret);
     }
     /**
      * Returns the canonical hex representation of the note ID.
@@ -17866,18 +17968,13 @@ class NoteIdAndArgsArray {
         wasm.noteidandargsarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {NoteIdAndArgs} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, NoteIdAndArgs);
-        const ret = wasm.noteidandargsarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.noteidandargsarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -17959,7 +18056,7 @@ class NoteLocation {
      * @returns {number}
      */
     blockNum() {
-        const ret = wasm.noteattachmentscheme_asU32(this.__wbg_ptr);
+        const ret = wasm.notelocation_blockNum(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -17968,8 +18065,13 @@ if (Symbol.dispose) NoteLocation.prototype[Symbol.dispose] = NoteLocation.protot
 /**
  * Metadata associated with a note.
  *
- * This metadata includes the sender, note type, tag, and an optional attachment.
- * Attachments provide additional context about how notes should be processed.
+ * 0.15 protocol surface: `NoteMetadata` is now constructed from a
+ * [`PartialNoteMetadata`] (sender / `note_type` / tag) plus a `NoteAttachments`
+ * collection — the previous `with_tag` / `with_attachment` / `attachment`
+ * methods on `NoteMetadata` were moved (`with_tag` lives on
+ * `PartialNoteMetadata`) or removed (`with_attachment` / `attachment`).
+ * The JS constructor narrows back to the common case of an
+ * attachment-less metadata.
  */
 class NoteMetadata {
     static __wrap(ptr) {
@@ -17990,15 +18092,7 @@ class NoteMetadata {
         wasm.__wbg_notemetadata_free(ptr, 0);
     }
     /**
-     * Returns the attachment of the note.
-     * @returns {NoteAttachment}
-     */
-    attachment() {
-        const ret = wasm.notemetadata_attachment(this.__wbg_ptr);
-        return NoteAttachment.__wrap(ret);
-    }
-    /**
-     * Creates metadata for a note.
+     * Creates metadata for a note with no attachments.
      * @param {AccountId} sender
      * @param {NoteType} note_type
      * @param {NoteTag} note_tag
@@ -18024,7 +18118,7 @@ class NoteMetadata {
      * @returns {AccountId}
      */
     sender() {
-        const ret = wasm.accountdelta_id(this.__wbg_ptr);
+        const ret = wasm.notemetadata_sender(this.__wbg_ptr);
         return AccountId.__wrap(ret);
     }
     /**
@@ -18035,30 +18129,6 @@ class NoteMetadata {
         const ret = wasm.notemetadata_tag(this.__wbg_ptr);
         return NoteTag.__wrap(ret);
     }
-    /**
-     * Adds an attachment to this metadata and returns the updated metadata.
-     *
-     * Attachments provide additional context about how notes should be processed.
-     * For example, a `NetworkAccountTarget` attachment indicates that the note
-     * should be consumed by a specific network account.
-     * @param {NoteAttachment} attachment
-     * @returns {NoteMetadata}
-     */
-    withAttachment(attachment) {
-        _assertClass(attachment, NoteAttachment);
-        const ret = wasm.notemetadata_withAttachment(this.__wbg_ptr, attachment.__wbg_ptr);
-        return NoteMetadata.__wrap(ret);
-    }
-    /**
-     * Sets the tag for this metadata and returns the updated metadata.
-     * @param {NoteTag} tag
-     * @returns {NoteMetadata}
-     */
-    withTag(tag) {
-        _assertClass(tag, NoteTag);
-        const ret = wasm.notemetadata_withTag(this.__wbg_ptr, tag.__wbg_ptr);
-        return NoteMetadata.__wrap(ret);
-    }
 }
 if (Symbol.dispose) NoteMetadata.prototype[Symbol.dispose] = NoteMetadata.prototype.free;
 
@@ -18203,18 +18273,13 @@ class NoteRecipientArray {
         wasm.noterecipientarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {NoteRecipient} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, NoteRecipient);
-        const ret = wasm.noterecipientarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.noterecipientarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -18375,7 +18440,8 @@ class NoteStorage {
      */
     constructor(felt_array) {
         _assertClass(felt_array, FeltArray);
-        const ret = wasm.notestorage_new(felt_array.__wbg_ptr);
+        var ptr0 = felt_array.__destroy_into_raw();
+        const ret = wasm.notestorage_new(ptr0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -18387,7 +18453,7 @@ class NoteStorage {
 if (Symbol.dispose) NoteStorage.prototype[Symbol.dispose] = NoteStorage.prototype.free;
 
 /**
- * Represents a single block's worth of note sync data.
+ * Represents a single block's worth of note sync data returned by `syncNotes`.
  */
 class NoteSyncBlock {
     static __wrap(ptr) {
@@ -18437,7 +18503,12 @@ class NoteSyncBlock {
 if (Symbol.dispose) NoteSyncBlock.prototype[Symbol.dispose] = NoteSyncBlock.prototype.free;
 
 /**
- * Represents the response data from `syncNotes`.
+ * Aggregates the response data from `syncNotes`: the per-block updates plus
+ * the upper bound of the requested range.
+ *
+ * The previous `chain_tip` accessor is gone — the upstream `sync_notes` RPC
+ * no longer returns the current chain tip on this endpoint. Use the
+ * regular state-sync flow (`syncState`) for the latest synced height.
  */
 class NoteSyncInfo {
     static __wrap(ptr) {
@@ -18458,7 +18529,9 @@ class NoteSyncInfo {
         wasm.__wbg_notesyncinfo_free(ptr, 0);
     }
     /**
-     * Returns the first block header associated with matching notes, if any.
+     * Returns the first block header with matching notes, if any. Convenience
+     * for callers that only requested a single tag and want the most recent
+     * inclusion block.
      * @returns {BlockHeader | undefined}
      */
     blockHeader() {
@@ -18466,15 +18539,16 @@ class NoteSyncInfo {
         return ret === 0 ? undefined : BlockHeader.__wrap(ret);
     }
     /**
-     * Returns the last block checked by the node. Used as a cursor for pagination.
+     * Returns the upper bound of the block range scanned in this call (the
+     * `blockTo` argument passed to `syncNotes`).
      * @returns {number}
      */
     blockTo() {
-        const ret = wasm.notesyncinfo_blockTo(this.__wbg_ptr);
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Returns the blocks containing matching notes.
+     * Returns the per-block breakdown.
      * @returns {NoteSyncBlock[]}
      */
     blocks() {
@@ -18484,15 +18558,7 @@ class NoteSyncInfo {
         return v1;
     }
     /**
-     * Returns the latest block number in the chain.
-     * @returns {number}
-     */
-    chainTip() {
-        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Returns the first block MMR path associated with matching notes, if any.
+     * Returns the MMR path of the first block with matching notes, if any.
      * @returns {MerklePath | undefined}
      */
     mmrPath() {
@@ -18500,7 +18566,7 @@ class NoteSyncInfo {
         return ret === 0 ? undefined : MerklePath.__wrap(ret);
     }
     /**
-     * Returns the committed notes across all matching blocks.
+     * Returns every committed note across all matching blocks (flattened).
      * @returns {CommittedNote[]}
      */
     notes() {
@@ -18547,7 +18613,7 @@ class NoteTag {
      * @returns {number}
      */
     asU32() {
-        const ret = wasm.noteattachmentscheme_asU32(this.__wbg_ptr);
+        const ret = wasm.notelocation_blockNum(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -18555,7 +18621,7 @@ class NoteTag {
      * @param {number} tag
      */
     constructor(tag) {
-        const ret = wasm.noteattachmentscheme_new(tag);
+        const ret = wasm.notetag_new(tag);
         this.__wbg_ptr = ret >>> 0;
         NoteTagFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -18660,8 +18726,7 @@ class OutputNote {
      * @returns {Note | undefined}
      */
     intoFull() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.outputnote_intoFull(ptr);
+        const ret = wasm.outputnote_intoFull(this.__wbg_ptr);
         return ret === 0 ? undefined : Note.__wrap(ret);
     }
     /**
@@ -18669,7 +18734,7 @@ class OutputNote {
      * @returns {NoteMetadata}
      */
     metadata() {
-        const ret = wasm.outputnote_metadata(this.__wbg_ptr);
+        const ret = wasm.committednote_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
     /**
@@ -18749,18 +18814,13 @@ class OutputNoteArray {
         wasm.outputnotearray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {OutputNote} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, OutputNote);
-        const ret = wasm.outputnotearray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.outputnotearray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -18802,7 +18862,7 @@ class OutputNoteRecord {
      * @returns {number}
      */
     expectedHeight() {
-        const ret = wasm.blockheader_version(this.__wbg_ptr);
+        const ret = wasm.outputnoterecord_expectedHeight(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -18842,7 +18902,7 @@ class OutputNoteRecord {
      * @returns {NoteMetadata}
      */
     metadata() {
-        const ret = wasm.outputnoterecord_metadata(this.__wbg_ptr);
+        const ret = wasm.committednote_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
     /**
@@ -19073,7 +19133,7 @@ class PartialNote {
      * @returns {NoteMetadata}
      */
     metadata() {
-        const ret = wasm.partialnote_metadata(this.__wbg_ptr);
+        const ret = wasm.committednote_metadata(this.__wbg_ptr);
         return NoteMetadata.__wrap(ret);
     }
     /**
@@ -19108,7 +19168,8 @@ class Poseidon2 {
      */
     static hashElements(felt_array) {
         _assertClass(felt_array, FeltArray);
-        const ret = wasm.poseidon2_hashElements(felt_array.__wbg_ptr);
+        var ptr0 = felt_array.__destroy_into_raw();
+        const ret = wasm.poseidon2_hashElements(ptr0);
         return Word.__wrap(ret);
     }
 }
@@ -19440,20 +19501,43 @@ class RpcClient {
     }
     /**
      * Fetches a block header by number. When `block_num` is undefined, returns the latest header.
+     *
+     * @param `block_num` - Optional block number. When `undefined`, returns the latest header.
+     * @param `include_mmr_proof` - When `true`, includes the MMR proof in the response. Defaults
+     *   to `false` when `undefined`.
      * @param {number | null} [block_num]
+     * @param {boolean | null} [include_mmr_proof]
      * @returns {Promise<BlockHeader>}
      */
-    getBlockHeaderByNumber(block_num) {
-        const ret = wasm.rpcclient_getBlockHeaderByNumber(this.__wbg_ptr, isLikeNone(block_num) ? 0x100000001 : (block_num) >>> 0);
+    getBlockHeaderByNumber(block_num, include_mmr_proof) {
+        const ret = wasm.rpcclient_getBlockHeaderByNumber(this.__wbg_ptr, isLikeNone(block_num) ? 0x100000001 : (block_num) >>> 0, isLikeNone(include_mmr_proof) ? 0xFFFFFF : include_mmr_proof ? 1 : 0);
+        return ret;
+    }
+    /**
+     * Fetches the processing status of a network note by its ID.
+     *
+     * Returns information about the note's current status in the network,
+     * including whether it is pending, processed, discarded, or committed,
+     * along with error details and attempt count.
+     *
+     * @param `note_id` - The ID of the note to query.
+     * @returns Promise that resolves to a `NetworkNoteStatusInfo` object.
+     * @param {NoteId} note_id
+     * @returns {Promise<NetworkNoteStatusInfo>}
+     */
+    getNetworkNoteStatus(note_id) {
+        _assertClass(note_id, NoteId);
+        const ret = wasm.rpcclient_getNetworkNoteStatus(this.__wbg_ptr, note_id.__wbg_ptr);
         return ret;
     }
     /**
      * Fetches a note script by its root hash from the connected Miden node.
      *
      * @param script_root - The root hash of the note script to fetch.
-     * @returns Promise that resolves to the `NoteScript`.
+     * @returns Promise that resolves to the `NoteScript`, or `undefined` if the node has no
+     *   script for that root.
      * @param {Word} script_root
-     * @returns {Promise<NoteScript>}
+     * @returns {Promise<NoteScript | undefined>}
      */
     getNoteScriptByRoot(script_root) {
         _assertClass(script_root, Word);
@@ -19507,15 +19591,15 @@ class RpcClient {
     }
     /**
      * Fetches notes matching the provided tags from the node.
-     * @param {number} block_num
-     * @param {number | null | undefined} block_to
+     * @param {number} block_from
+     * @param {number} block_to
      * @param {NoteTag[]} note_tags
      * @returns {Promise<NoteSyncInfo>}
      */
-    syncNotes(block_num, block_to, note_tags) {
+    syncNotes(block_from, block_to, note_tags) {
         const ptr0 = passArrayJsValueToWasm0(note_tags, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rpcclient_syncNotes(this.__wbg_ptr, block_num, isLikeNone(block_to) ? 0x100000001 : (block_to) >>> 0, ptr0, len0);
+        const ret = wasm.rpcclient_syncNotes(this.__wbg_ptr, block_from, block_to, ptr0, len0);
         return ret;
     }
     /**
@@ -19562,7 +19646,8 @@ class Rpo256 {
      */
     static hashElements(felt_array) {
         _assertClass(felt_array, FeltArray);
-        const ret = wasm.rpo256_hashElements(felt_array.__wbg_ptr);
+        var ptr0 = felt_array.__destroy_into_raw();
+        const ret = wasm.rpo256_hashElements(ptr0);
         return Word.__wrap(ret);
     }
 }
@@ -19592,6 +19677,15 @@ class SerializedInputNoteData {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_serializedinputnotedata_free(ptr, 0);
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    get attachments() {
+        const ret = wasm.__wbg_get_serializedinputnotedata_attachments(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -19633,6 +19727,21 @@ class SerializedInputNoteData {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {string}
+     */
+    get detailsCommitment() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_serializedinputnotedata_detailsCommitment(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 {Uint8Array}
      */
@@ -19652,19 +19761,16 @@ class SerializedInputNoteData {
         return v1;
     }
     /**
-     * @returns {string}
+     * @returns {string | undefined}
      */
     get noteId() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_serializedinputnotedata_noteId(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);
+        const ret = wasm.__wbg_get_serializedinputnotedata_noteId(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
+        return v1;
     }
     /**
      * @returns {string}
@@ -19730,6 +19836,14 @@ class SerializedInputNoteData {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {Uint8Array} arg0
+     */
+    set attachments(arg0) {
+        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_serializedinputnotedata_attachments(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -19758,6 +19872,14 @@ class SerializedInputNoteData {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_serializedinputnotedata_createdAt(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * @param {string} arg0
+     */
+    set detailsCommitment(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_serializedinputnotedata_detailsCommitment(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {Uint8Array} arg0
      */
@@ -19775,11 +19897,11 @@ class SerializedInputNoteData {
         wasm.__wbg_set_serializedinputnotedata_noteAssets(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {string} arg0
+     * @param {string | null} [arg0]
      */
     set noteId(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_serializedinputnotedata_noteId(this.__wbg_ptr, ptr0, len0);
     }
     /**
@@ -19855,6 +19977,15 @@ class SerializedOutputNoteData {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_serializedoutputnotedata_free(ptr, 0);
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    get attachments() {
+        const ret = wasm.__wbg_get_serializedoutputnotedata_attachments(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * @returns {number}
      */
@@ -19938,6 +20069,14 @@ class SerializedOutputNoteData {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {Uint8Array} arg0
+     */
+    set attachments(arg0) {
+        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_serializedoutputnotedata_attachments(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {number} arg0
      */
@@ -19950,7 +20089,7 @@ class SerializedOutputNoteData {
     set metadata(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedoutputnotedata_metadata(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsstatesyncupdate_blockHasRelevantNotes(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array} arg0
@@ -19982,7 +20121,7 @@ class SerializedOutputNoteData {
     set recipientDigest(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_jsstoragemapentry_value(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsaccountupdate_vaultRoot(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {number} arg0
@@ -20138,7 +20277,7 @@ class SerializedTransactionData {
     set status(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_serializedtransactiondata_status(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_serializedoutputnotedata_attachments(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Uint8Array | null} [arg0]
@@ -20529,9 +20668,6 @@ class StorageMap {
 }
 if (Symbol.dispose) StorageMap.prototype[Symbol.dispose] = StorageMap.prototype.free;
 
-/**
- * A key-value entry from a storage map.
- */
 class StorageMapEntry {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -20540,6 +20676,16 @@ class StorageMapEntry {
         StorageMapEntryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
+    toJSON() {
+        return {
+            key: this.key,
+            root: this.root,
+            value: this.value,
+        };
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -20550,6 +20696,99 @@ class StorageMapEntry {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_storagemapentry_free(ptr, 0);
     }
+    /**
+     * @returns {string}
+     */
+    get key() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_storagemapentry_key(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 {string}
+     */
+    get root() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_storagemapentry_root(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 {string}
+     */
+    get value() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_storagemapentry_value(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set key(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jsstoragemapentry_key(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} arg0
+     */
+    set root(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jsaccountupdate_storageRoot(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} arg0
+     */
+    set value(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_jsstoragemapentry_value(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) StorageMapEntry.prototype[Symbol.dispose] = StorageMapEntry.prototype.free;
+
+/**
+ * A key-value entry from a storage map.
+ */
+class StorageMapEntryJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StorageMapEntryJs.prototype);
+        obj.__wbg_ptr = ptr;
+        StorageMapEntryJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StorageMapEntryJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storagemapentryjs_free(ptr, 0);
+    }
     /**
      * Returns the storage map key.
      * @returns {Word}
@@ -20567,7 +20806,7 @@ class StorageMapEntry {
         return Word.__wrap(ret);
     }
 }
-if (Symbol.dispose) StorageMapEntry.prototype[Symbol.dispose] = StorageMapEntry.prototype.free;
+if (Symbol.dispose) StorageMapEntryJs.prototype[Symbol.dispose] = StorageMapEntryJs.prototype.free;
 
 /**
  * Information about storage map updates for an account, as returned by the
@@ -20599,7 +20838,7 @@ class StorageMapInfo {
      * @returns {number}
      */
     blockNumber() {
-        const ret = wasm.notesyncinfo_blockTo(this.__wbg_ptr);
+        const ret = wasm.storagemapinfo_blockNumber(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -20650,7 +20889,7 @@ class StorageMapUpdate {
      * @returns {number}
      */
     blockNum() {
-        const ret = wasm.storagemapupdate_blockNum(this.__wbg_ptr);
+        const ret = wasm.committednote_tag(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -20820,18 +21059,13 @@ class StorageSlotArray {
         wasm.storageslotarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {StorageSlot} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, StorageSlot);
-        const ret = wasm.storageslotarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.storageslotarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -21601,9 +21835,11 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequest}
      */
     build() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.transactionrequestbuilder_build(ptr);
-        return TransactionRequest.__wrap(ret);
+        const ret = wasm.transactionrequestbuilder_build(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionRequest.__wrap(ret[0]);
     }
     /**
      * Merges an advice map to be available during script execution.
@@ -21611,16 +21847,15 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     extendAdviceMap(advice_map) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(advice_map, AdviceMap);
-        const ret = wasm.transactionrequestbuilder_extendAdviceMap(ptr, advice_map.__wbg_ptr);
+        const ret = wasm.transactionrequestbuilder_extendAdviceMap(this.__wbg_ptr, advice_map.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
      * Creates a new empty transaction request builder.
      */
     constructor() {
-        const ret = wasm.transactionrequestbuilder_new();
+        const ret = wasm.transactionrequestbuilder_js_new();
         this.__wbg_ptr = ret >>> 0;
         TransactionRequestBuilderFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -21631,9 +21866,8 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withAuthArg(auth_arg) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(auth_arg, Word);
-        const ret = wasm.transactionrequestbuilder_withAuthArg(ptr, auth_arg.__wbg_ptr);
+        const ret = wasm.transactionrequestbuilder_withAuthArg(this.__wbg_ptr, auth_arg.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21642,9 +21876,8 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withCustomScript(script) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(script, TransactionScript);
-        const ret = wasm.transactionrequestbuilder_withCustomScript(ptr, script.__wbg_ptr);
+        const ret = wasm.transactionrequestbuilder_withCustomScript(this.__wbg_ptr, script.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21653,9 +21886,9 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withExpectedFutureNotes(note_details_and_tag) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(note_details_and_tag, NoteDetailsAndTagArray);
-        const ret = wasm.transactionrequestbuilder_withExpectedFutureNotes(ptr, note_details_and_tag.__wbg_ptr);
+        var ptr0 = note_details_and_tag.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withExpectedFutureNotes(this.__wbg_ptr, ptr0);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21664,9 +21897,9 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withExpectedOutputRecipients(recipients) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(recipients, NoteRecipientArray);
-        const ret = wasm.transactionrequestbuilder_withExpectedOutputRecipients(ptr, recipients.__wbg_ptr);
+        var ptr0 = recipients.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withExpectedOutputRecipients(this.__wbg_ptr, ptr0);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21675,8 +21908,7 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withExpirationDelta(expiration_delta) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.transactionrequestbuilder_withExpirationDelta(ptr, expiration_delta);
+        const ret = wasm.transactionrequestbuilder_withExpirationDelta(this.__wbg_ptr, expiration_delta);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21685,9 +21917,9 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withForeignAccounts(foreign_accounts) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(foreign_accounts, ForeignAccountArray);
-        const ret = wasm.transactionrequestbuilder_withForeignAccounts(ptr, foreign_accounts.__wbg_ptr);
+        var ptr0 = foreign_accounts.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withForeignAccounts(this.__wbg_ptr, ptr0);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21696,9 +21928,9 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withInputNotes(notes) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(notes, NoteAndArgsArray);
-        const ret = wasm.transactionrequestbuilder_withInputNotes(ptr, notes.__wbg_ptr);
+        var ptr0 = notes.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withInputNotes(this.__wbg_ptr, ptr0);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21707,9 +21939,9 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withOwnOutputNotes(notes) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(notes, NoteArray);
-        const ret = wasm.transactionrequestbuilder_withOwnOutputNotes(ptr, notes.__wbg_ptr);
+        var ptr0 = notes.__destroy_into_raw();
+        const ret = wasm.transactionrequestbuilder_withOwnOutputNotes(this.__wbg_ptr, ptr0);
         return TransactionRequestBuilder.__wrap(ret);
     }
     /**
@@ -21718,9 +21950,8 @@ class TransactionRequestBuilder {
      * @returns {TransactionRequestBuilder}
      */
     withScriptArg(script_arg) {
-        const ptr = this.__destroy_into_raw();
         _assertClass(script_arg, Word);
-        const ret = wasm.transactionrequestbuilder_withScriptArg(ptr, script_arg.__wbg_ptr);
+        const ret = wasm.transactionrequestbuilder_withScriptArg(this.__wbg_ptr, script_arg.__wbg_ptr);
         return TransactionRequestBuilder.__wrap(ret);
     }
 }
@@ -21895,7 +22126,8 @@ class TransactionScriptInputPair {
         _assertClass(word, Word);
         var ptr0 = word.__destroy_into_raw();
         _assertClass(felts, FeltArray);
-        const ret = wasm.transactionscriptinputpair_new(ptr0, felts.__wbg_ptr);
+        var ptr1 = felts.__destroy_into_raw();
+        const ret = wasm.transactionscriptinputpair_new(ptr0, ptr1);
         this.__wbg_ptr = ret >>> 0;
         TransactionScriptInputPairFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -21967,18 +22199,13 @@ class TransactionScriptInputPairArray {
         wasm.transactionscriptinputpairarray_push(this.__wbg_ptr, element.__wbg_ptr);
     }
     /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
      * @param {number} index
      * @param {TransactionScriptInputPair} elem
      */
     replaceAt(index, elem) {
         _assertClass(elem, TransactionScriptInputPair);
-        const ret = wasm.transactionscriptinputpairarray_replaceAt(this.__wbg_ptr, index, elem.__wbg_ptr);
+        var ptr0 = elem.__destroy_into_raw();
+        const ret = wasm.transactionscriptinputpairarray_replaceAt(this.__wbg_ptr, index, ptr0);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -22292,15 +22519,23 @@ class WebClient {
      * const balance = await reader.getBalance(faucetId);
      * ```
      * @param {AccountId} account_id
-     * @returns {AccountReader}
+     * @returns {Promise<AccountReader>}
      */
     accountReader(account_id) {
         _assertClass(account_id, AccountId);
         const ret = wasm.webclient_accountReader(this.__wbg_ptr, account_id.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return AccountReader.__wrap(ret[0]);
+        return ret;
+    }
+    /**
+     * @param {AccountId} account_id
+     * @param {AuthSecretKey} secret_key
+     * @returns {Promise<void>}
+     */
+    addAccountSecretKeyToWebStore(account_id, secret_key) {
+        _assertClass(account_id, AccountId);
+        _assertClass(secret_key, AuthSecretKey);
+        const ret = wasm.webclient_addAccountSecretKeyToWebStore(this.__wbg_ptr, account_id.__wbg_ptr, secret_key.__wbg_ptr);
+        return ret;
     }
     /**
      * @param {string} tag
@@ -22349,6 +22584,9 @@ 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]
@@ -22381,6 +22619,8 @@ 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]
@@ -22404,14 +22644,11 @@ class WebClient {
         return ret;
     }
     /**
-     * @returns {CodeBuilder}
+     * @returns {Promise<CodeBuilder>}
      */
     createCodeBuilder() {
         const ret = wasm.webclient_createCodeBuilder(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return CodeBuilder.__wrap(ret[0]);
+        return ret;
     }
     /**
      * Creates a new client with a mock RPC API. Useful for testing purposes and proof-of-concept
@@ -22419,7 +22656,7 @@ class WebClient {
      * @param {Uint8Array | null} [seed]
      * @param {Uint8Array | null} [serialized_mock_chain]
      * @param {Uint8Array | null} [serialized_mock_note_transport_node]
-     * @returns {Promise<any>}
+     * @returns {Promise<string>}
      */
     createMockClient(seed, serialized_mock_chain, serialized_mock_note_transport_node) {
         var ptr0 = isLikeNone(seed) ? 0 : passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
@@ -22466,7 +22703,8 @@ class WebClient {
         _assertClass(tx_script, TransactionScript);
         _assertClass(advice_inputs, AdviceInputs);
         _assertClass(foreign_accounts, ForeignAccountArray);
-        const ret = wasm.webclient_executeProgram(this.__wbg_ptr, account_id.__wbg_ptr, tx_script.__wbg_ptr, advice_inputs.__wbg_ptr, foreign_accounts.__wbg_ptr);
+        var ptr0 = foreign_accounts.__destroy_into_raw();
+        const ret = wasm.webclient_executeProgram(this.__wbg_ptr, account_id.__wbg_ptr, tx_script.__wbg_ptr, advice_inputs.__wbg_ptr, ptr0);
         return ret;
     }
     /**
@@ -22493,7 +22731,8 @@ class WebClient {
      */
     exportAccountFile(account_id) {
         _assertClass(account_id, AccountId);
-        const ret = wasm.webclient_exportAccountFile(this.__wbg_ptr, account_id.__wbg_ptr);
+        var ptr0 = account_id.__destroy_into_raw();
+        const ret = wasm.webclient_exportAccountFile(this.__wbg_ptr, ptr0);
         return ret;
     }
     /**
@@ -22541,6 +22780,30 @@ class WebClient {
         const ret = wasm.webclient_getAccount(this.__wbg_ptr, account_id.__wbg_ptr);
         return ret;
     }
+    /**
+     * Retrieves an authentication secret key from the keystore given a public key commitment.
+     *
+     * The public key commitment should correspond to one of the keys tracked by the keystore.
+     * Returns the associated [`AuthSecretKey`] if found, or an error if not found.
+     * @param {Word} pub_key_commitment
+     * @returns {Promise<AuthSecretKey>}
+     */
+    getAccountAuthByPubKeyCommitment(pub_key_commitment) {
+        _assertClass(pub_key_commitment, Word);
+        const ret = wasm.webclient_getAccountAuthByPubKeyCommitment(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Retrieves the full account data for the account associated with the given public key
+     * commitment, returning `null` if no account is found.
+     * @param {Word} pub_key_commitment
+     * @returns {Promise<Account | undefined>}
+     */
+    getAccountByKeyCommitment(pub_key_commitment) {
+        _assertClass(pub_key_commitment, Word);
+        const ret = wasm.webclient_getAccountByKeyCommitment(this.__wbg_ptr, pub_key_commitment.__wbg_ptr);
+        return ret;
+    }
     /**
      * Retrieves the account code for a specific account.
      *
@@ -22638,7 +22901,20 @@ class WebClient {
         return ret;
     }
     /**
-     * Retrieves the setting value for `key`, or `None` if it hasn’t been set.
+     * Returns all public key commitments associated with the given account ID.
+     *
+     * These commitments can be used with [`getAccountAuthByPubKeyCommitment`]
+     * to retrieve the corresponding secret keys from the keystore.
+     * @param {AccountId} account_id
+     * @returns {Promise<Word[]>}
+     */
+    getPublicKeyCommitmentsOfAccount(account_id) {
+        _assertClass(account_id, AccountId);
+        const ret = wasm.webclient_getPublicKeyCommitmentsOfAccount(this.__wbg_ptr, account_id.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Retrieves the setting value for `key`, or `None` if it hasn't been set.
      * @param {string} key
      * @returns {Promise<any | undefined>}
      */
@@ -22667,7 +22943,7 @@ class WebClient {
     }
     /**
      * @param {AccountId} account_id
-     * @returns {Promise<any>}
+     * @returns {Promise<void>}
      */
     importAccountById(account_id) {
         _assertClass(account_id, AccountId);
@@ -22676,7 +22952,7 @@ class WebClient {
     }
     /**
      * @param {AccountFile} account_file
-     * @returns {Promise<any>}
+     * @returns {Promise<string>}
      */
     importAccountFile(account_file) {
         _assertClass(account_file, AccountFile);
@@ -22685,8 +22961,20 @@ class WebClient {
         return ret;
     }
     /**
+     * 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
+     * metadata-independent details commitment is returned instead.
+     *
+     * Migration note (miden-client PR #2214): `Client::import_notes` now
+     * returns `Vec<NoteDetailsCommitment>` rather than `Vec<NoteId>`, since
+     * metadata-less imports have no note ID; this method recovers the `NoteId`
+     * from the note file when one is available.
      * @param {NoteFile} note_file
-     * @returns {Promise<NoteId>}
+     * @returns {Promise<string>}
      */
     importNoteFile(note_file) {
         _assertClass(note_file, NoteFile);
@@ -22768,7 +23056,7 @@ class WebClient {
         return ret;
     }
     /**
-     * @returns {Promise<any>}
+     * @returns {Promise<string[]>}
      */
     listTags() {
         const ret = wasm.webclient_listTags(this.__wbg_ptr);
@@ -22819,19 +23107,27 @@ class WebClient {
         return TransactionRequest.__wrap(ret[0]);
     }
     /**
+     * Creates, persists, and returns a new fungible faucet account.
+     *
+     * Only fungible faucets are supported, so passing `non_fungible = true` fails fast with a
+     * clear message. The faucet is registered with mint and burn policies (both `AllowAll`); its
+     * secret key is added to the keystore.
      * @param {AccountStorageMode} storage_mode
      * @param {boolean} non_fungible
+     * @param {string} token_name
      * @param {string} token_symbol
      * @param {number} decimals
      * @param {bigint} max_supply
      * @param {AuthScheme} auth_scheme
      * @returns {Promise<Account>}
      */
-    newFaucet(storage_mode, non_fungible, token_symbol, decimals, max_supply, auth_scheme) {
+    newFaucet(storage_mode, non_fungible, token_name, token_symbol, decimals, max_supply, auth_scheme) {
         _assertClass(storage_mode, AccountStorageMode);
-        const ptr0 = passStringToWasm0(token_symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(token_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.webclient_newFaucet(this.__wbg_ptr, storage_mode.__wbg_ptr, non_fungible, ptr0, len0, decimals, max_supply, auth_scheme);
+        const ptr1 = passStringToWasm0(token_symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webclient_newFaucet(this.__wbg_ptr, storage_mode.__wbg_ptr, non_fungible, ptr0, len0, ptr1, len1, decimals, max_supply, auth_scheme);
         return ret;
     }
     /**
@@ -22839,17 +23135,61 @@ class WebClient {
      * @param {AccountId} faucet_id
      * @param {NoteType} note_type
      * @param {bigint} amount
-     * @returns {TransactionRequest}
+     * @returns {Promise<TransactionRequest>}
      */
     newMintTransactionRequest(target_account_id, faucet_id, note_type, amount) {
         _assertClass(target_account_id, AccountId);
         _assertClass(faucet_id, AccountId);
         const ret = wasm.webclient_newMintTransactionRequest(this.__wbg_ptr, target_account_id.__wbg_ptr, faucet_id.__wbg_ptr, note_type, amount);
+        return ret;
+    }
+    /**
+     * @param {Note} pswap_note
+     * @param {AccountId} creator_account_id
+     * @returns {TransactionRequest}
+     */
+    newPswapCancelTransactionRequest(pswap_note, creator_account_id) {
+        _assertClass(pswap_note, Note);
+        _assertClass(creator_account_id, AccountId);
+        const ret = wasm.webclient_newPswapCancelTransactionRequest(this.__wbg_ptr, pswap_note.__wbg_ptr, creator_account_id.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionRequest.__wrap(ret[0]);
+    }
+    /**
+     * @param {Note} pswap_note
+     * @param {AccountId} consumer_account_id
+     * @param {bigint} account_fill_amount
+     * @param {bigint} note_fill_amount
+     * @returns {TransactionRequest}
+     */
+    newPswapConsumeTransactionRequest(pswap_note, consumer_account_id, account_fill_amount, note_fill_amount) {
+        _assertClass(pswap_note, Note);
+        _assertClass(consumer_account_id, AccountId);
+        const ret = wasm.webclient_newPswapConsumeTransactionRequest(this.__wbg_ptr, pswap_note.__wbg_ptr, consumer_account_id.__wbg_ptr, account_fill_amount, note_fill_amount);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return TransactionRequest.__wrap(ret[0]);
     }
+    /**
+     * @param {AccountId} creator_account_id
+     * @param {AccountId} offered_asset_faucet_id
+     * @param {bigint} offered_asset_amount
+     * @param {AccountId} requested_asset_faucet_id
+     * @param {bigint} requested_asset_amount
+     * @param {NoteType} note_type
+     * @param {NoteType} payback_note_type
+     * @returns {Promise<TransactionRequest>}
+     */
+    newPswapCreateTransactionRequest(creator_account_id, offered_asset_faucet_id, offered_asset_amount, requested_asset_faucet_id, requested_asset_amount, note_type, payback_note_type) {
+        _assertClass(creator_account_id, AccountId);
+        _assertClass(offered_asset_faucet_id, AccountId);
+        _assertClass(requested_asset_faucet_id, AccountId);
+        const ret = wasm.webclient_newPswapCreateTransactionRequest(this.__wbg_ptr, creator_account_id.__wbg_ptr, offered_asset_faucet_id.__wbg_ptr, offered_asset_amount, requested_asset_faucet_id.__wbg_ptr, requested_asset_amount, note_type, payback_note_type);
+        return ret;
+    }
     /**
      * @param {AccountId} sender_account_id
      * @param {AccountId} target_account_id
@@ -22858,17 +23198,14 @@ class WebClient {
      * @param {bigint} amount
      * @param {number | null} [recall_height]
      * @param {number | null} [timelock_height]
-     * @returns {TransactionRequest}
+     * @returns {Promise<TransactionRequest>}
      */
     newSendTransactionRequest(sender_account_id, target_account_id, faucet_id, note_type, amount, recall_height, timelock_height) {
         _assertClass(sender_account_id, AccountId);
         _assertClass(target_account_id, AccountId);
         _assertClass(faucet_id, AccountId);
         const ret = wasm.webclient_newSendTransactionRequest(this.__wbg_ptr, sender_account_id.__wbg_ptr, target_account_id.__wbg_ptr, faucet_id.__wbg_ptr, note_type, amount, isLikeNone(recall_height) ? 0x100000001 : (recall_height) >>> 0, isLikeNone(timelock_height) ? 0x100000001 : (timelock_height) >>> 0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return TransactionRequest.__wrap(ret[0]);
+        return ret;
     }
     /**
      * @param {AccountId} sender_account_id
@@ -22878,17 +23215,14 @@ class WebClient {
      * @param {bigint} requested_asset_amount
      * @param {NoteType} note_type
      * @param {NoteType} payback_note_type
-     * @returns {TransactionRequest}
+     * @returns {Promise<TransactionRequest>}
      */
     newSwapTransactionRequest(sender_account_id, offered_asset_faucet_id, offered_asset_amount, requested_asset_faucet_id, requested_asset_amount, note_type, payback_note_type) {
         _assertClass(sender_account_id, AccountId);
         _assertClass(offered_asset_faucet_id, AccountId);
         _assertClass(requested_asset_faucet_id, AccountId);
         const ret = wasm.webclient_newSwapTransactionRequest(this.__wbg_ptr, sender_account_id.__wbg_ptr, offered_asset_faucet_id.__wbg_ptr, offered_asset_amount, requested_asset_faucet_id.__wbg_ptr, requested_asset_amount, note_type, payback_note_type);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return TransactionRequest.__wrap(ret[0]);
+        return ret;
     }
     /**
      * @param {AccountStorageMode} storage_mode
@@ -22904,39 +23238,28 @@ class WebClient {
         const ret = wasm.webclient_newWallet(this.__wbg_ptr, storage_mode.__wbg_ptr, mutable, auth_scheme, ptr0, len0);
         return ret;
     }
-    proveBlock() {
-        const ret = wasm.webclient_proveBlock(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
     /**
-     * Generates a transaction proof using the client's default (local) prover.
-     * @param {TransactionResult} transaction_result
-     * @returns {Promise<ProvenTransaction>}
+     * @returns {Promise<void>}
      */
-    proveTransaction(transaction_result) {
-        _assertClass(transaction_result, TransactionResult);
-        const ret = wasm.webclient_proveTransaction(this.__wbg_ptr, transaction_result.__wbg_ptr);
+    proveBlock() {
+        const ret = wasm.webclient_proveBlock(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Generates a transaction proof using the provided prover.
-     *
-     * Takes the prover by reference so the JS-side handle is NOT consumed
-     * by wasm-bindgen. Taking `TransactionProver` by value would transfer
-     * ownership on each call, invalidating the JS object's internal WASM
-     * handle; after one use, subsequent calls from JS would pass a dangling
-     * handle that wasm-bindgen interprets as `None`, silently falling back
-     * to the local prover.
+     * Generates a transaction proof using either the provided prover or the client's default
+     * prover if none is supplied.
      * @param {TransactionResult} transaction_result
-     * @param {TransactionProver} prover
+     * @param {TransactionProver | null} [prover]
      * @returns {Promise<ProvenTransaction>}
      */
-    proveTransactionWithProver(transaction_result, prover) {
+    proveTransaction(transaction_result, prover) {
         _assertClass(transaction_result, TransactionResult);
-        _assertClass(prover, TransactionProver);
-        const ret = wasm.webclient_proveTransactionWithProver(this.__wbg_ptr, transaction_result.__wbg_ptr, prover.__wbg_ptr);
+        let ptr0 = 0;
+        if (!isLikeNone(prover)) {
+            _assertClass(prover, TransactionProver);
+            ptr0 = prover.__destroy_into_raw();
+        }
+        const ret = wasm.webclient_proveTransaction(this.__wbg_ptr, transaction_result.__wbg_ptr, ptr0);
         return ret;
     }
     /**
@@ -23005,29 +23328,19 @@ class WebClient {
     }
     /**
      * Returns the inner serialized mock chain if it exists.
-     * @returns {Uint8Array}
+     * @returns {Promise<Uint8Array>}
      */
     serializeMockChain() {
         const ret = wasm.webclient_serializeMockChain(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+        return ret;
     }
     /**
      * Returns the inner serialized mock note transport node if it exists.
-     * @returns {Uint8Array}
+     * @returns {Promise<Uint8Array>}
      */
     serializeMockNoteTransportNode() {
         const ret = wasm.webclient_serializeMockNoteTransportNode(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+        return ret;
     }
     /**
      * Sets a setting key-value in the store. It can then be retrieved using `get_setting`.
@@ -23043,25 +23356,11 @@ class WebClient {
     }
     /**
      * Returns the identifier of the underlying store (e.g. `IndexedDB` database name, file path).
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     storeIdentifier() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.webclient_storeIdentifier(this.__wbg_ptr);
-            var ptr1 = ret[0];
-            var len1 = ret[1];
-            if (ret[3]) {
-                ptr1 = 0; len1 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred2_0 = ptr1;
-            deferred2_1 = len1;
-            return getStringFromWasm0(ptr1, len1);
-        } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-        }
+        const ret = wasm.webclient_storeIdentifier(this.__wbg_ptr);
+        return ret;
     }
     /**
      * Executes a transaction specified by the request against the specified account,
@@ -23127,11 +23426,11 @@ class WebClient {
         return ret;
     }
     /**
-     * @returns {boolean}
+     * @returns {Promise<boolean>}
      */
     usesMockChain() {
         const ret = wasm.webclient_usesMockChain(this.__wbg_ptr);
-        return ret !== 0;
+        return ret;
     }
 }
 if (Symbol.dispose) WebClient.prototype[Symbol.dispose] = WebClient.prototype.free;
@@ -23256,7 +23555,6 @@ class Word {
     }
     /**
      * Creates a Word from a hex string.
-     * Fails if the provided string is not a valid hex representation of a Word.
      * @param {string} hex
      * @returns {Word}
      */
@@ -23270,14 +23568,21 @@ class Word {
         return Word.__wrap(ret[0]);
     }
     /**
-     * Creates a word from four u64 values.
+     * Creates a word from four numeric values.
+     *
+     * Each input must be a canonical field element, i.e. strictly less than the field modulus.
+     * `Felt::new` (now fallible on the 0.15 surface) errors out on inputs at or beyond the
+     * modulus; the error is surfaced to JS.
      * @param {BigUint64Array} u64_vec
      */
     constructor(u64_vec) {
         const ptr0 = passArray64ToWasm0(u64_vec, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.word_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         WordFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -23327,7 +23632,7 @@ class Word {
         }
     }
     /**
-     * Returns the word as an array of u64 values.
+     * Returns the word as an array of numeric values.
      * @returns {BigUint64Array}
      */
     toU64s() {
@@ -23545,6 +23850,10 @@ function __wbg_get_imports() {
             const ret = AccountProof.__wrap(arg0);
             return ret;
         },
+        __wbg_accountreader_new: function(arg0) {
+            const ret = AccountReader.__wrap(arg0);
+            return ret;
+        },
         __wbg_accountstatus_new: function(arg0) {
             const ret = AccountStatus.__wrap(arg0);
             return ret;
@@ -23553,7 +23862,7 @@ function __wbg_get_imports() {
             const ret = AccountStorage.__wrap(arg0);
             return ret;
         },
-        __wbg_addNoteTag_71f455acb2c33097: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_addNoteTag_40dad1e41d8a6415: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -23576,15 +23885,15 @@ function __wbg_get_imports() {
         __wbg_append_a992ccc37aa62dc4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
-        __wbg_applyFullAccountState_c2b7ca372af269ca: function(arg0, arg1, arg2) {
+        __wbg_applyFullAccountState_0f46ca4819ec19a2: function(arg0, arg1, arg2) {
             const ret = applyFullAccountState(getStringFromWasm0(arg0, arg1), JsAccountUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyStateSync_91fddc562c8bef62: function(arg0, arg1, arg2) {
+        __wbg_applyStateSync_4577b4125b70be6e: function(arg0, arg1, arg2) {
             const ret = applyStateSync(getStringFromWasm0(arg0, arg1), JsStateSyncUpdate.__wrap(arg2));
             return ret;
         },
-        __wbg_applyTransactionDelta_4dddecb0b77b7669: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20) {
+        __wbg_applyTransactionDelta_956ac5d25a74f4f2: 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;
@@ -23693,6 +24002,10 @@ function __wbg_get_imports() {
         __wbg_close_a79afee31de55b36: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
+        __wbg_codebuilder_new: function(arg0) {
+            const ret = CodeBuilder.__wrap(arg0);
+            return ret;
+        },
         __wbg_committednote_new: function(arg0) {
             const ret = CommittedNote.__wrap(arg0);
             return ret;
@@ -23719,7 +24032,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_exportStore_7414a54978b6564b: function(arg0, arg1) {
+        __wbg_exportStore_6122bc835ba1335e: function(arg0, arg1) {
             const ret = exportStore(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -23751,7 +24064,7 @@ function __wbg_get_imports() {
             const ret = FetchedNote.__wrap(arg0);
             return ret;
         },
-        __wbg_forceImportStore_ec328e296b0a4bff: function(arg0, arg1, arg2) {
+        __wbg_forceImportStore_fee039594a1dd764: function(arg0, arg1, arg2) {
             const ret = forceImportStore(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         },
@@ -23771,7 +24084,7 @@ function __wbg_get_imports() {
             const ret = FungibleAssetDeltaItem.__wrap(arg0);
             return ret;
         },
-        __wbg_getAccountAddresses_e92f560e33b96c28: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAddresses_c2905210853e4c1d: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23783,7 +24096,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountAuthByPubKeyCommitment_28efb17c33476b84: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountAuthByPubKeyCommitment_aa1c1ea910be8702: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23795,7 +24108,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountCode_188958db8c438bab: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountCode_624d99224830e698: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23807,7 +24120,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeaderByCommitment_4e6fa83d25c41363: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeaderByCommitment_87400f84a64deb6f: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23819,7 +24132,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountHeader_aabe60772170d684: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountHeader_1bfe2e4c80c39a5a: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23831,7 +24144,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIdByKeyCommitment_3802e17bf8d3c9b9: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountIdByKeyCommitment_119e889c02d0a383: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23843,11 +24156,11 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountIds_8d429d26691ebece: function(arg0, arg1) {
+        __wbg_getAccountIds_b7c51b913d5bf21d: function(arg0, arg1) {
             const ret = getAccountIds(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getAccountStorageMaps_60eba620d7ef3115: function(arg0, arg1, arg2, arg3) {
+        __wbg_getAccountStorageMaps_ea32cd8cf6fc6297: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23859,7 +24172,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountStorage_2e39fb9ee52b36ab: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_getAccountStorage_277a00af1ae659dd: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23873,7 +24186,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAccountVaultAssets_f4af786007a4cd8a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_getAccountVaultAssets_e588f7c19992bf5a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23887,23 +24200,27 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getAllAccountHeaders_41bc150e0b8348ab: function(arg0, arg1) {
+        __wbg_getAllAccountHeaders_cc5df55ad899e5ca: function(arg0, arg1) {
             const ret = getAllAccountHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getBlockHeaders_d37fd9c6e0f0fc3c: function(arg0, arg1, arg2, arg3) {
+        __wbg_getBlockHeaders_08a8804e4b3ff442: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayU32FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getBlockHeaders(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getForeignAccountCode_07c810d364cd77ae: function(arg0, arg1, arg2, arg3) {
+        __wbg_getCurrentBlockchainPeaks_f0d990ec54236a85: function(arg0, arg1) {
+            const ret = getCurrentBlockchainPeaks(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_getForeignAccountCode_d4d803c5248469e8: 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_677e9a33e6340b5d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+        __wbg_getInputNoteByOffset_a1163c6c190c7bc0: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
             let deferred1_0;
             let deferred1_1;
             try {
@@ -23917,25 +24234,25 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_getInputNotesFromIds_44862afd379bbbb6: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromIds_c19092f0da179fdf: 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_2ec2c4e148b8f834: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotesFromNullifiers_ef5e3e241e8f14b9: 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_8e59018ef0fd9758: function(arg0, arg1, arg2, arg3) {
+        __wbg_getInputNotes_9a2890b2c05db53e: 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_8d83fa814d1cc718: function(arg0, arg1, arg2, arg3) {
+        __wbg_getKeyCommitmentsByAccountId_98d1052aa93e54d1: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23947,7 +24264,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteScript_fe7c88df1db18389: function(arg0, arg1, arg2, arg3) {
+        __wbg_getNoteScript_f33c8718fc90d2c4: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23959,33 +24276,33 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getNoteTags_75edb9d48492a785: function(arg0, arg1) {
+        __wbg_getNoteTags_e2ed88e636d0ad2a: function(arg0, arg1) {
             const ret = getNoteTags(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getOutputNotesFromIds_6db6231c439f3c87: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromIds_1cfcb787c56927d6: 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_30c2ca006c9640f8: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotesFromNullifiers_ab2d0529c918ceb6: 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_7a0d64dede8d64be: function(arg0, arg1, arg2, arg3) {
+        __wbg_getOutputNotes_3ce2621bbaa0b67a: 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_15a5f0a63644f546: function(arg0, arg1) {
+        __wbg_getPartialBlockchainNodesAll_97b2296b6f446165: function(arg0, arg1) {
             const ret = getPartialBlockchainNodesAll(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getPartialBlockchainNodesUpToInOrderIndex_6742a36d7d26c921: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodesUpToInOrderIndex_a00a947793bcac3c: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -23997,16 +24314,12 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getPartialBlockchainNodes_35c67e8f4bfd8da6: function(arg0, arg1, arg2, arg3) {
+        __wbg_getPartialBlockchainNodes_ed95c0aed168e0bd: function(arg0, arg1, arg2, arg3) {
             var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 4, 4);
             const ret = getPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getPartialBlockchainPeaksByBlockNum_5a9240ed1087ee15: function(arg0, arg1, arg2) {
-            const ret = getPartialBlockchainPeaksByBlockNum(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
-            return ret;
-        },
         __wbg_getRandomValues_1c61fac11405ffdc: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -24014,7 +24327,7 @@ function __wbg_get_imports() {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_getSetting_25ab76d54f719ecd: function(arg0, arg1, arg2, arg3) {
+        __wbg_getSetting_ae10044e2d623298: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24026,7 +24339,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getSyncHeight_d852979e2c8c1c32: function(arg0, arg1) {
+        __wbg_getSyncHeight_58fc6088ffc73f66: function(arg0, arg1) {
             const ret = getSyncHeight(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -24034,15 +24347,15 @@ function __wbg_get_imports() {
             const ret = arg0.getTime();
             return ret;
         },
-        __wbg_getTrackedBlockHeaderNumbers_7a6dd9bd482b7c1f: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaderNumbers_5ff16c5dbe739bda: function(arg0, arg1) {
             const ret = getTrackedBlockHeaderNumbers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTrackedBlockHeaders_921ecf4c4bdc8c6f: function(arg0, arg1) {
+        __wbg_getTrackedBlockHeaders_b20d19487c2d6df9: function(arg0, arg1) {
             const ret = getTrackedBlockHeaders(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_getTransactions_cb4af339938ce981: function(arg0, arg1, arg2, arg3) {
+        __wbg_getTransactions_162de0ea1d0f2668: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24054,7 +24367,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getUnspentInputNoteNullifiers_1d2344145aa0e85d: function(arg0, arg1) {
+        __wbg_getUnspentInputNoteNullifiers_252553121097b242: function(arg0, arg1) {
             const ret = getUnspentInputNoteNullifiers(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -24098,7 +24411,7 @@ function __wbg_get_imports() {
             const ret = InputNoteRecord.__wrap(arg0);
             return ret;
         },
-        __wbg_insertAccountAddress_e0c46f8e053193e9: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAddress_a6b2f038c55aee0a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24112,7 +24425,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertAccountAuth_07cdbb9f21acbbe0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountAuth_adb2bbf98e1c34d4: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -24129,7 +24442,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertAccountKeyMapping_73ff296a94f45b01: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertAccountKeyMapping_47e616ac5977fb9c: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -24146,15 +24459,13 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertBlockHeader_cd3837e26c067658: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_insertBlockHeader_23b7b30d0614926f: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
             wasm.__wbindgen_free(arg3, arg4 * 1, 1);
-            var v1 = getArrayU8FromWasm0(arg5, arg6).slice();
-            wasm.__wbindgen_free(arg5, arg6 * 1, 1);
-            const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, v1, arg7 !== 0);
+            const ret = insertBlockHeader(getStringFromWasm0(arg0, arg1), arg2 >>> 0, v0, arg5 !== 0);
             return ret;
         },
-        __wbg_insertPartialBlockchainNodes_dc6809b37ef4b562: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertPartialBlockchainNodes_403400ec217229f2: 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();
@@ -24162,7 +24473,7 @@ function __wbg_get_imports() {
             const ret = insertPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0, v1);
             return ret;
         },
-        __wbg_insertSetting_11f6d3c419315d2a: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertSetting_fcdab04463e418b0: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24176,7 +24487,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_insertTransactionScript_54c2f4f1423a8889: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_insertTransactionScript_a97df45bc8841578: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -24269,11 +24580,11 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_listSettingKeys_7a01958cfea9e4ce: function(arg0, arg1) {
+        __wbg_listSettingKeys_aa9e036a0e93602e: function(arg0, arg1) {
             const ret = listSettingKeys(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_lockAccount_4f46ad492483b226: function(arg0, arg1, arg2, arg3) {
+        __wbg_lockAccount_00786cae6f7ea636: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24326,6 +24637,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments); },
+        __wbg_networknotestatusinfo_new: function(arg0) {
+            const ret = NetworkNoteStatusInfo.__wrap(arg0);
+            return ret;
+        },
         __wbg_new_0_73afc35eb544e539: function() {
             const ret = new Date();
             return ret;
@@ -24357,7 +24672,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h22101db9f01e45e1(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h7a3c25b2fe6d77ec(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -24412,6 +24727,10 @@ function __wbg_get_imports() {
             const ret = NoteAndArgs.__unwrap(arg0);
             return ret;
         },
+        __wbg_noteattachment_new: function(arg0) {
+            const ret = NoteAttachment.__wrap(arg0);
+            return ret;
+        },
         __wbg_noteconsumability_new: function(arg0) {
             const ret = NoteConsumability.__wrap(arg0);
             return ret;
@@ -24464,7 +24783,7 @@ function __wbg_get_imports() {
             const ret = NoteTag.__unwrap(arg0);
             return ret;
         },
-        __wbg_openDatabase_1e6c970bd99986cc: function(arg0, arg1, arg2, arg3) {
+        __wbg_openDatabase_8cdde169e05fa396: function(arg0, arg1, arg2, arg3) {
             const ret = openDatabase(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return ret;
         },
@@ -24495,7 +24814,7 @@ function __wbg_get_imports() {
             const ret = ProvenTransaction.__wrap(arg0);
             return ret;
         },
-        __wbg_pruneAccountHistory_b9f8ae9cc42b0264: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_pruneAccountHistory_77197f52f4287754: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -24512,8 +24831,12 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_pruneIrrelevantBlocks_fd53c6ee9a1529de: function(arg0, arg1) {
-            const ret = pruneIrrelevantBlocks(getStringFromWasm0(arg0, arg1));
+        __wbg_pruneIrrelevantBlocks_649b0446c426cb86: 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();
+            wasm.__wbindgen_free(arg4, arg5 * 4, 4);
+            const ret = pruneIrrelevantBlocks(getStringFromWasm0(arg0, arg1), v0, v1);
             return ret;
         },
         __wbg_queueMicrotask_0aa0a927f78f5d98: function(arg0) {
@@ -24530,13 +24853,13 @@ function __wbg_get_imports() {
         __wbg_releaseLock_aa5846c2494b3032: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_removeAccountAddress_d84a263da31a63b1: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAddress_fc888f883a71bd4f: 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_15fe803d63fd684f: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAccountAuth_8f11e01dd6099b42: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24548,7 +24871,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_removeAllMappingsForKey_2a75a1ee44704b87: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeAllMappingsForKey_1fd0c55cb2cd0b61: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24560,7 +24883,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_removeNoteTag_3ffdd59c60d02d5d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_removeNoteTag_77e6e3497d921600: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
             wasm.__wbindgen_free(arg2, arg3 * 1, 1);
             let v1;
@@ -24576,7 +24899,7 @@ function __wbg_get_imports() {
             const ret = removeNoteTag(getStringFromWasm0(arg0, arg1), v0, v1, v2);
             return ret;
         },
-        __wbg_removeSetting_ee0741372caba813: function(arg0, arg1, arg2, arg3) {
+        __wbg_removeSetting_39da4a2d256af0e2: function(arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24712,6 +25035,10 @@ function __wbg_get_imports() {
             const ret = StorageMapEntry.__wrap(arg0);
             return ret;
         },
+        __wbg_storagemapentryjs_new: function(arg0) {
+            const ret = StorageMapEntryJs.__wrap(arg0);
+            return ret;
+        },
         __wbg_storagemapinfo_new: function(arg0) {
             const ret = StorageMapInfo.__wrap(arg0);
             return ret;
@@ -24752,6 +25079,10 @@ function __wbg_get_imports() {
             const ret = TransactionRecord.__wrap(arg0);
             return ret;
         },
+        __wbg_transactionrequest_new: function(arg0) {
+            const ret = TransactionRequest.__wrap(arg0);
+            return ret;
+        },
         __wbg_transactionresult_new: function(arg0) {
             const ret = TransactionResult.__wrap(arg0);
             return ret;
@@ -24768,13 +25099,13 @@ function __wbg_get_imports() {
             const ret = TransactionSummary.__wrap(arg0);
             return ret;
         },
-        __wbg_undoAccountStates_3bb81f0b4777af78: function(arg0, arg1, arg2, arg3) {
+        __wbg_undoAccountStates_e36a3027b0d94828: 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_f54a1c88bec60044: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountCode_a57f0b2098ba7190: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24788,7 +25119,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertAccountRecord_d32c88004f7a361f: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) {
+        __wbg_upsertAccountRecord_3fb1a14436632f21: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) {
             let deferred0_0;
             let deferred0_1;
             let deferred1_0;
@@ -24830,7 +25161,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
             }
         },
-        __wbg_upsertAccountStorage_dc9b3f362de53588: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertAccountStorage_cd428602fca677b1: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24844,7 +25175,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertForeignAccountCode_bc9c9b983d44be62: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_upsertForeignAccountCode_ea1c872f50b83cf7: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             let deferred0_0;
             let deferred0_1;
             let deferred2_0;
@@ -24863,49 +25194,56 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertInputNote_e7e2d594002d33f0: 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) {
+        __wbg_upsertInputNote_54c9d28ec61fd731: 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 deferred4_0;
-            let deferred4_1;
             let deferred6_0;
             let deferred6_1;
-            let deferred7_0;
-            let deferred7_1;
+            let deferred8_0;
+            let deferred8_1;
+            let deferred9_0;
+            let deferred9_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
-                var v1 = getArrayU8FromWasm0(arg4, arg5).slice();
-                wasm.__wbindgen_free(arg4, arg5 * 1, 1);
+                let v1;
+                if (arg4 !== 0) {
+                    v1 = getStringFromWasm0(arg4, arg5).slice();
+                    wasm.__wbindgen_free(arg4, arg5 * 1, 1);
+                }
                 var v2 = getArrayU8FromWasm0(arg6, arg7).slice();
                 wasm.__wbindgen_free(arg6, arg7 * 1, 1);
                 var v3 = getArrayU8FromWasm0(arg8, arg9).slice();
                 wasm.__wbindgen_free(arg8, arg9 * 1, 1);
-                deferred4_0 = arg10;
-                deferred4_1 = arg11;
+                var v4 = getArrayU8FromWasm0(arg10, arg11).slice();
+                wasm.__wbindgen_free(arg10, arg11 * 1, 1);
                 var v5 = getArrayU8FromWasm0(arg12, arg13).slice();
                 wasm.__wbindgen_free(arg12, arg13 * 1, 1);
                 deferred6_0 = arg14;
                 deferred6_1 = arg15;
-                deferred7_0 = arg16;
-                deferred7_1 = arg17;
-                var v8 = getArrayU8FromWasm0(arg19, arg20).slice();
-                wasm.__wbindgen_free(arg19, arg20 * 1, 1);
-                let v9;
-                if (arg23 !== 0) {
-                    v9 = getStringFromWasm0(arg23, arg24).slice();
-                    wasm.__wbindgen_free(arg23, arg24 * 1, 1);
+                var v7 = getArrayU8FromWasm0(arg16, arg17).slice();
+                wasm.__wbindgen_free(arg16, arg17 * 1, 1);
+                deferred8_0 = arg18;
+                deferred8_1 = arg19;
+                deferred9_0 = arg20;
+                deferred9_1 = arg21;
+                var v10 = getArrayU8FromWasm0(arg23, arg24).slice();
+                wasm.__wbindgen_free(arg23, arg24 * 1, 1);
+                let v11;
+                if (arg27 !== 0) {
+                    v11 = getStringFromWasm0(arg27, arg28).slice();
+                    wasm.__wbindgen_free(arg27, arg28 * 1, 1);
                 }
-                const ret = upsertInputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, v2, v3, getStringFromWasm0(arg10, arg11), v5, getStringFromWasm0(arg14, arg15), getStringFromWasm0(arg16, arg17), arg18, v8, arg21 === 0x100000001 ? undefined : arg21, arg22 === 0x100000001 ? undefined : arg22, v9);
+                const ret = upsertInputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, v2, v3, v4, v5, getStringFromWasm0(arg14, arg15), v7, getStringFromWasm0(arg18, arg19), getStringFromWasm0(arg20, arg21), arg22, v10, arg25 === 0x100000001 ? undefined : arg25, arg26 === 0x100000001 ? undefined : arg26, v11);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
                 wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
-                wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+                wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
+                wasm.__wbindgen_free(deferred9_0, deferred9_1, 1);
             }
         },
-        __wbg_upsertNoteScript_e5262374e58464a5: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertNoteScript_77ad6333fd8d09bd: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24919,35 +25257,37 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertOutputNote_fb601f7b4e18f75d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) {
+        __wbg_upsertOutputNote_086a8c1c81f11d3c: 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 deferred2_0;
-            let deferred2_1;
+            let deferred3_0;
+            let deferred3_1;
             try {
                 deferred0_0 = arg2;
                 deferred0_1 = arg3;
                 var v1 = getArrayU8FromWasm0(arg4, arg5).slice();
                 wasm.__wbindgen_free(arg4, arg5 * 1, 1);
-                deferred2_0 = arg6;
-                deferred2_1 = arg7;
-                var v3 = getArrayU8FromWasm0(arg8, arg9).slice();
-                wasm.__wbindgen_free(arg8, arg9 * 1, 1);
-                let v4;
-                if (arg10 !== 0) {
-                    v4 = getStringFromWasm0(arg10, arg11).slice();
-                    wasm.__wbindgen_free(arg10, arg11 * 1, 1);
+                var v2 = getArrayU8FromWasm0(arg6, arg7).slice();
+                wasm.__wbindgen_free(arg6, arg7 * 1, 1);
+                deferred3_0 = arg8;
+                deferred3_1 = arg9;
+                var v4 = getArrayU8FromWasm0(arg10, arg11).slice();
+                wasm.__wbindgen_free(arg10, arg11 * 1, 1);
+                let v5;
+                if (arg12 !== 0) {
+                    v5 = getStringFromWasm0(arg12, arg13).slice();
+                    wasm.__wbindgen_free(arg12, arg13 * 1, 1);
                 }
-                var v5 = getArrayU8FromWasm0(arg14, arg15).slice();
-                wasm.__wbindgen_free(arg14, arg15 * 1, 1);
-                const ret = upsertOutputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, getStringFromWasm0(arg6, arg7), v3, v4, arg12 >>> 0, arg13, v5);
+                var v6 = getArrayU8FromWasm0(arg16, arg17).slice();
+                wasm.__wbindgen_free(arg16, arg17 * 1, 1);
+                const ret = upsertOutputNote(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), v1, v2, getStringFromWasm0(arg8, arg9), v4, v5, arg14 >>> 0, arg15, v6);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+                wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
             }
         },
-        __wbg_upsertStorageMapEntries_875ece6c792aece8: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertStorageMapEntries_068d8303824fff58: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24961,7 +25301,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertTransactionRecord_5f9c83704ca38dc5: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+        __wbg_upsertTransactionRecord_a285bd5d3fd5a278: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -24982,7 +25322,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertVaultAssets_acbcc6d51cb80ac5: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_upsertVaultAssets_53ecfc329186db4e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -25013,13 +25353,13 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 360, function: Function { arguments: [Externref], shim_idx: 698, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h10c3fe8f433ba3dd, wasm_bindgen__convert__closures_____invoke__h69bc00ec8b9a6549);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 441, function: Function { arguments: [Externref], shim_idx: 793, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h3f095fc116138c37, wasm_bindgen__convert__closures_____invoke__h5b85ca27a15b53fc);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 360, function: Function { arguments: [], shim_idx: 361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h10c3fe8f433ba3dd, wasm_bindgen__convert__closures_____invoke__h5c73a4a324493889);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 441, function: Function { arguments: [], shim_idx: 442, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h3f095fc116138c37, wasm_bindgen__convert__closures_____invoke__h8c482c344300c6d3);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0) {
@@ -25123,16 +25463,16 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h5c73a4a324493889(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h5c73a4a324493889(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h8c482c344300c6d3(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h8c482c344300c6d3(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h69bc00ec8b9a6549(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h69bc00ec8b9a6549(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h5b85ca27a15b53fc(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h5b85ca27a15b53fc(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h22101db9f01e45e1(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h22101db9f01e45e1(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h7a3c25b2fe6d77ec(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h7a3c25b2fe6d77ec(arg0, arg1, arg2, arg3);
 }
 
 
@@ -25329,6 +25669,9 @@ const MerklePathFinalization = (typeof FinalizationRegistry === 'undefined')
 const NetworkIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_networkid_free(ptr >>> 0, 1));
+const NetworkNoteStatusInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_networknotestatusinfo_free(ptr >>> 0, 1));
 const NoteFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_note_free(ptr >>> 0, 1));
@@ -25482,6 +25825,9 @@ const StorageMapFinalization = (typeof FinalizationRegistry === 'undefined')
 const StorageMapEntryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_storagemapentry_free(ptr >>> 0, 1));
+const StorageMapEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storagemapentryjs_free(ptr >>> 0, 1));
 const StorageMapInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_storagemapinfo_free(ptr >>> 0, 1));
@@ -25935,7 +26281,7 @@ async function __wbg_init(module_or_path) {
 
 const module$1 = new URL("assets/miden_client_web.wasm", self.location.href);
 
-var CargoDC6jSekr = /*#__PURE__*/Object.freeze({
+var CargoCG4XszZo = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Account: Account,
   AccountArray: AccountArray,
@@ -25999,6 +26345,7 @@ var CargoDC6jSekr = /*#__PURE__*/Object.freeze({
   Library: Library,
   MerklePath: MerklePath,
   NetworkId: NetworkId,
+  NetworkNoteStatusInfo: NetworkNoteStatusInfo,
   NetworkType: NetworkType,
   Note: Note,
   NoteAndArgs: NoteAndArgs,
@@ -26006,7 +26353,6 @@ var CargoDC6jSekr = /*#__PURE__*/Object.freeze({
   NoteArray: NoteArray,
   NoteAssets: NoteAssets,
   NoteAttachment: NoteAttachment,
-  NoteAttachmentKind: NoteAttachmentKind,
   NoteAttachmentScheme: NoteAttachmentScheme,
   NoteConsumability: NoteConsumability,
   NoteConsumptionStatus: NoteConsumptionStatus,
@@ -26057,6 +26403,7 @@ var CargoDC6jSekr = /*#__PURE__*/Object.freeze({
   SparseMerklePath: SparseMerklePath,
   StorageMap: StorageMap,
   StorageMapEntry: StorageMapEntry,
+  StorageMapEntryJs: StorageMapEntryJs,
   StorageMapInfo: StorageMapInfo,
   StorageMapUpdate: StorageMapUpdate,
   StorageSlot: StorageSlot,