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

package/dist/{workers → 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 CargoCVlXCH_2; });
+    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
@@ -23,6 +23,7 @@ async function loadWasm() {
 const WorkerAction = Object.freeze({
   INIT: "init",
   INIT_MOCK: "initMock",
+  INIT_THREAD_POOL: "initThreadPool",
   CALL_METHOD: "callMethod",
   EXECUTE_CALLBACK: "executeCallback",
 });
@@ -437,6 +438,7 @@ async function processMessage(event) {
         hasInsertKeyCb,
         hasSignCb,
         logLevel,
+        numThreads,
       ] = args;
       const wasm = await getWasmOrThrow();
 
@@ -444,6 +446,20 @@ async function processMessage(event) {
         wasm.setupLogging(logLevel);
       }
 
+      // Initialize rayon's thread pool inside THIS worker's WASM instance.
+      // The SDK runs every prove call here (NOT on the main thread), so a
+      // pool initialized only in main-thread WASM does not parallelize the
+      // prove. Without this, par_iter()/par_chunks() in miden-crypto +
+      // p3-maybe-rayon return rayon::current_num_threads() == 1 and fall
+      // through to sequential code despite the parallel features being on.
+      if (
+        numThreads &&
+        numThreads > 1 &&
+        typeof wasm.initThreadPool === "function"
+      ) {
+        await wasm.initThreadPool(numThreads);
+      }
+
       wasmWebClient = new wasm.WebClient();
 
       // Check if any callbacks are provided
@@ -8840,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"),
@@ -10032,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
@@ -10046,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
@@ -10104,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",
                 };
             }
@@ -10128,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",
             };
         }));
@@ -10155,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) {
@@ -10488,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,
@@ -10517,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);
@@ -10580,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,
@@ -10607,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;
@@ -10619,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,
@@ -10630,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,
@@ -10902,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,
@@ -10927,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 = [
@@ -10956,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, {
@@ -10977,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) {
@@ -11014,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();
         }
     }
@@ -11126,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}
@@ -11166,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}
@@ -11361,6 +11382,11 @@ 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}
      */
@@ -11627,6 +11653,11 @@ 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() {
@@ -11985,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}
@@ -12017,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}
@@ -12709,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) {
@@ -12744,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}
@@ -12770,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}
      */
@@ -12830,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",
 });
 
 /**
@@ -13198,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}
      */
@@ -13434,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) {
@@ -13480,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);
     }
     /**
@@ -13554,6 +13583,19 @@ class BlockHeader {
         const ret = wasm.blockheader_commitment(this.__wbg_ptr);
         return Word.__wrap(ret);
     }
+    /**
+     * Returns the account ID of the fungible faucet whose assets are accepted as the native
+     * asset of the blockchain (i.e. the asset used for paying transaction verification fees).
+     *
+     * This is stored on-chain as part of the block's fee parameters, which means consumers can
+     * discover the native faucet by reading any block header rather than hardcoding it per
+     * network.
+     * @returns {AccountId}
+     */
+    feeFaucetId() {
+        const ret = wasm.blockheader_feeFaucetId(this.__wbg_ptr);
+        return AccountId.__wrap(ret);
+    }
     /**
      * Returns the note commitment root.
      * @returns {Word}
@@ -13794,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}
@@ -13820,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() {
@@ -14198,11 +14229,17 @@ class Felt {
     }
     /**
      * 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;
     }
@@ -14347,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}
@@ -14385,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) {
@@ -14418,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.
@@ -14771,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}
      */
@@ -14945,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() {
@@ -15031,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}
@@ -15061,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.
@@ -15109,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.
@@ -15352,6 +15423,21 @@ if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderly
 
 /**
  * Represents an update to a single account's state.
+ *
+ * `inspectable` is intentionally omitted (see #2183). When `inspectable` is
+ * set on a struct with public fields, wasm-bindgen auto-generates a
+ * `toJSON()` method that reads every field-getter — each of which calls
+ * back into WASM via `__wbg_get_<class>_<field>(this.__wbg_ptr)`. Under
+ * Next.js 16.2 dev-mode the patched `console.*` runs every non-primitive
+ * argument through `safe-stable-stringify`, which invokes `toJSON()`
+ * automatically. If the underlying pointer has been freed (or another
+ * WASM call is in flight) the resulting `"null pointer passed to rust"`
+ * trap propagates out of the user's `console.log` and crashes the
+ * caller. Without `inspectable`, no `toJSON()` is emitted; JSON.stringify
+ * falls back to `{}` (the wasm-bindgen wrapper has no own enumerable
+ * data — it's all behind the `__wbg_ptr`), and the re-entry never
+ * happens. Field access via the named getters still works exactly as
+ * before; only the auto-stringification path is muted.
  */
 class JsAccountUpdate {
     static __wrap(ptr) {
@@ -15367,24 +15453,6 @@ class JsAccountUpdate {
         }
         return jsValue.__destroy_into_raw();
     }
-    toJSON() {
-        return {
-            accountCommitment: this.accountCommitment,
-            accountId: this.accountId,
-            accountSeed: this.accountSeed,
-            assets: this.assets,
-            codeRoot: this.codeRoot,
-            committed: this.committed,
-            nonce: this.nonce,
-            storageMapEntries: this.storageMapEntries,
-            storageRoot: this.storageRoot,
-            storageSlots: this.storageSlots,
-            vaultRoot: this.vaultRoot,
-        };
-    }
-    toString() {
-        return JSON.stringify(this);
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -15696,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;
@@ -15713,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
@@ -15734,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[]}
@@ -15812,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.
@@ -15829,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
@@ -15850,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
@@ -15900,6 +15974,9 @@ if (Symbol.dispose) JsStateSyncUpdate.prototype[Symbol.dispose] = JsStateSyncUpd
 
 /**
  * A JavaScript representation of a storage map entry in an account.
+ *
+ * `inspectable` is intentionally omitted — see the note on
+ * `JsAccountUpdate` for the full rationale (#2183).
  */
 class JsStorageMapEntry {
     static __wrap(ptr) {
@@ -15915,16 +15992,6 @@ class JsStorageMapEntry {
         }
         return jsValue.__destroy_into_raw();
     }
-    toJSON() {
-        return {
-            key: this.key,
-            slotName: this.slotName,
-            value: this.value,
-        };
-    }
-    toString() {
-        return JSON.stringify(this);
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -16015,6 +16082,9 @@ if (Symbol.dispose) JsStorageMapEntry.prototype[Symbol.dispose] = JsStorageMapEn
 
 /**
  * A JavaScript representation of a storage slot in an account.
+ *
+ * `inspectable` is intentionally omitted — see the note on
+ * `JsAccountUpdate` for the full rationale (#2183).
  */
 class JsStorageSlot {
     static __wrap(ptr) {
@@ -16030,16 +16100,6 @@ class JsStorageSlot {
         }
         return jsValue.__destroy_into_raw();
     }
-    toJSON() {
-        return {
-            slotName: this.slotName,
-            slotType: this.slotType,
-            slotValue: this.slotValue,
-        };
-    }
-    toString() {
-        return JSON.stringify(this);
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -16120,6 +16180,9 @@ if (Symbol.dispose) JsStorageSlot.prototype[Symbol.dispose] = JsStorageSlot.prot
 
 /**
  * An object that contains a serialized vault asset.
+ *
+ * `inspectable` is intentionally omitted — see the note on
+ * `JsAccountUpdate` for the full rationale (#2183).
  */
 class JsVaultAsset {
     static __wrap(ptr) {
@@ -16135,15 +16198,6 @@ class JsVaultAsset {
         }
         return jsValue.__destroy_into_raw();
     }
-    toJSON() {
-        return {
-            asset: this.asset,
-            vaultKey: this.vaultKey,
-        };
-    }
-    toString() {
-        return JSON.stringify(this);
-    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -16491,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() {
@@ -16557,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);
     }
     /**
@@ -16565,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
@@ -16866,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) {
@@ -16888,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}
@@ -16921,81 +16964,90 @@ class NoteAttachment {
         return NoteAttachmentScheme.__wrap(ret);
     }
     /**
-     * Creates a default (empty) note attachment.
+     * Creates a new note attachment from a single word.
+     * @param {NoteAttachmentScheme} scheme
+     * @param {Word} word
+     * @returns {NoteAttachment}
      */
-    constructor() {
-        const ret = wasm.noteattachment_new();
-        this.__wbg_ptr = ret >>> 0;
-        NoteAttachmentFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static fromWord(scheme, word) {
+        _assertClass(scheme, NoteAttachmentScheme);
+        _assertClass(word, Word);
+        const ret = wasm.noteattachment_fromWord(scheme.__wbg_ptr, word.__wbg_ptr);
+        return NoteAttachment.__wrap(ret);
     }
     /**
-     * Creates a new note attachment with Array content from the provided elements.
+     * 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 {FeltArray} elements
+     * @param {Word[]} words
      * @returns {NoteAttachment}
      */
-    static newArray(scheme, elements) {
+    static fromWords(scheme, words) {
         _assertClass(scheme, NoteAttachmentScheme);
-        _assertClass(elements, FeltArray);
-        var ptr0 = elements.__destroy_into_raw();
-        const ret = wasm.noteattachment_newArray(scheme.__wbg_ptr, ptr0);
+        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.
  *
@@ -17020,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}
@@ -17037,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;
     }
@@ -17182,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) {
@@ -17209,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
@@ -17230,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}
@@ -17590,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.
@@ -17623,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() {
@@ -17698,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;
@@ -17720,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);
     }
     /**
@@ -17731,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;
 
@@ -17747,16 +17784,14 @@ if (Symbol.dispose) NoteHeader.prototype[Symbol.dispose] = NoteHeader.prototype.
  *
  * Note ID is computed as:
  *
- * > `hash(recipient, asset_commitment)`
- *
- * where `recipient` is defined as:
+ * > `hash(details_commitment, metadata_commitment)`
  *
- * > `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) {
@@ -17797,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.
@@ -18020,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;
     }
 }
@@ -18029,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) {
@@ -18051,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
@@ -18085,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);
     }
     /**
@@ -18096,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;
 
@@ -18444,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) {
@@ -18494,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) {
@@ -18515,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() {
@@ -18523,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() {
@@ -18541,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() {
@@ -18557,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() {
@@ -18604,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;
     }
     /**
@@ -18612,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;
@@ -18725,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);
     }
     /**
@@ -18853,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;
     }
     /**
@@ -18893,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);
     }
     /**
@@ -19124,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);
     }
     /**
@@ -19525,9 +19534,10 @@ class RpcClient {
      * 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);
@@ -19581,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;
     }
     /**
@@ -19667,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}
      */
@@ -19708,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}
      */
@@ -19727,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}
@@ -19805,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]
      */
@@ -19833,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
      */
@@ -19850,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);
     }
     /**
@@ -19930,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}
      */
@@ -20013,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
      */
@@ -20025,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
@@ -20057,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
@@ -20213,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]
@@ -20774,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;
     }
     /**
@@ -20825,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;
     }
     /**
@@ -21461,6 +21525,33 @@ class TransactionProver {
         }
         return v1;
     }
+    /**
+     * Creates a prover that delegates `prove()` to a JavaScript callback.
+     *
+     * The callback receives the serialized [`TransactionInputs`] as a
+     * `Uint8Array` and must return a `Promise<Uint8Array>` resolving to a
+     * serialized [`ProvenTransaction`] (same encoding the gRPC remote
+     * prover uses: `tx_inputs.to_bytes()` in, `ProvenTransaction::read_from_bytes`
+     * out).
+     *
+     * Use case: routing prove to a native iOS / Android plugin
+     * (`@miden/native-prover`) so mobile builds skip WASM prove entirely
+     * — `WKWebView` can't be made cross-origin-isolated reliably and the
+     * MT WASM bundle can't instantiate without `SharedArrayBuffer`, so the
+     * host wraps a native Rust prover (built with the same `miden_tx`
+     * crate) and exposes a JS-shaped callback over the Capacitor bridge.
+     *
+     * The SDK does NOT serialize the prover for persistence across
+     * reloads (unlike `newRemoteProver`), since the callback is a
+     * runtime JS reference. Hosts must recreate the prover on every
+     * page load.
+     * @param {Function} callback
+     * @returns {TransactionProver}
+     */
+    static newCallbackProver(callback) {
+        const ret = wasm.transactionprover_newCallbackProver(callback);
+        return TransactionProver.__wrap(ret);
+    }
     /**
      * Creates a prover that uses the local proving backend.
      * @returns {TransactionProver}
@@ -22870,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);
@@ -22915,6 +23018,35 @@ class WebClient {
         }
         return WebKeystoreApi.__wrap(ret[0]);
     }
+    /**
+     * Returns the raw JS value that the most recent sign-callback invocation
+     * threw, or `null` if the last sign call succeeded (or no call has
+     * happened yet).
+     *
+     * Combined with the serialized-call discipline enforced at the JS
+     * `WebClient` wrapper, this lets a caller that caught a failed
+     * `executeTransaction` / `submitNewTransaction` recover the original
+     * JS error the signing callback threw — preserving any structured
+     * metadata (e.g. a `reason: 'locked'` property) that the kernel-level
+     * `auth::request` diagnostic would otherwise have erased.
+     *
+     * # Usage (TS)
+     * ```ts
+     * try {
+     *   await client.submitNewTransaction(acc, req);
+     * } catch (e) {
+     *   const authErr = client.lastAuthError();
+     *   if (authErr && authErr.reason === 'locked') {
+     *     // wait for unlock, then retry
+     *   }
+     * }
+     * ```
+     * @returns {any}
+     */
+    lastAuthError() {
+        const ret = wasm.webclient_lastAuthError(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Returns all the existing setting keys from the store.
      * @returns {Promise<string[]>}
@@ -22975,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;
     }
     /**
@@ -23003,6 +23143,53 @@ class WebClient {
         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
@@ -23382,13 +23569,20 @@ class Word {
     }
     /**
      * 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;
     }
@@ -23496,6 +23690,20 @@ function importStore(store_name, store_dump) {
     return ret;
 }
 
+/**
+ * Single-threaded version of `parallel_sum_bench` for direct comparison.
+ * Same workload, plain `iter()` — bypasses rayon entirely. Needs to live
+ * on the WASM side rather than be reimplemented in JS so the workload is
+ * bit-for-bit identical to `parallel_sum_bench` (same libm, same FP
+ * determinism, same constant-folding resistance).
+ * @param {bigint} n
+ * @returns {bigint}
+ */
+function sequentialSumBench(n) {
+    const ret = wasm.sequentialSumBench(n);
+    return BigInt.asUintN(64, ret);
+}
+
 /**
  * Initializes the `tracing` subscriber that routes Rust log output to the
  * browser console via `console.log` / `console.warn` / `console.error`.
@@ -24002,6 +24210,10 @@ function __wbg_get_imports() {
             const ret = getBlockHeaders(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
+        __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);
@@ -24108,10 +24320,6 @@ function __wbg_get_imports() {
             const ret = getPartialBlockchainNodes(getStringFromWasm0(arg0, arg1), v0);
             return ret;
         },
-        __wbg_getPartialBlockchainPeaksByBlockNum_18d5c35d4c5bfbb9: 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); },
@@ -24251,12 +24459,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         },
-        __wbg_insertBlockHeader_3477dcb5e51c9963: 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_403400ec217229f2: function(arg0, arg1, arg2, arg3, arg4, arg5) {
@@ -24466,7 +24672,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__hf3bad69ddb7e770e(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h7a3c25b2fe6d77ec(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -24521,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;
@@ -24984,46 +25194,53 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
             }
         },
-        __wbg_upsertInputNote_16ac41c463f69a4d: 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_77ad6333fd8d09bd: function(arg0, arg1, arg2, arg3, arg4, arg5) {
@@ -25040,32 +25257,34 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_upsertOutputNote_80bcb98476b58b0b: 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_068d8303824fff58: function(arg0, arg1, arg2, arg3, arg4, arg5) {
@@ -25134,13 +25353,13 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 359, function: Function { arguments: [Externref], shim_idx: 699, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h521bf77e4c41e510, wasm_bindgen__convert__closures_____invoke__h305992f72ee30af3);
+            // 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: 359, function: Function { arguments: [], shim_idx: 360, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h521bf77e4c41e510, wasm_bindgen__convert__closures_____invoke__h2aef54828e0d6e2f);
+            // 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) {
@@ -25244,16 +25463,16 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h2aef54828e0d6e2f(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h2aef54828e0d6e2f(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__h305992f72ee30af3(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h305992f72ee30af3(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__hf3bad69ddb7e770e(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hf3bad69ddb7e770e(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);
 }
 
 
@@ -26062,7 +26281,7 @@ async function __wbg_init(module_or_path) {
 
 const module$1 = new URL("assets/miden_client_web.wasm", self.location.href);
 
-var CargoCVlXCH_2 = /*#__PURE__*/Object.freeze({
+var CargoCG4XszZo = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Account: Account,
   AccountArray: AccountArray,
@@ -26134,7 +26353,6 @@ var CargoCVlXCH_2 = /*#__PURE__*/Object.freeze({
   NoteArray: NoteArray,
   NoteAssets: NoteAssets,
   NoteAttachment: NoteAttachment,
-  NoteAttachmentKind: NoteAttachmentKind,
   NoteAttachmentScheme: NoteAttachmentScheme,
   NoteConsumability: NoteConsumability,
   NoteConsumptionStatus: NoteConsumptionStatus,
@@ -26216,6 +26434,7 @@ var CargoCVlXCH_2 = /*#__PURE__*/Object.freeze({
   exportStore: exportStore2,
   importStore: importStore,
   initSync: initSync,
+  sequentialSumBench: sequentialSumBench,
   setupLogging: setupLogging
 });
 //# sourceMappingURL=web-client-methods-worker.js.map