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

package/dist/{crates → st/crates}/miden_client_web.d.ts

@@ -54,13 +54,9 @@ export class Account {
      */
     id(): AccountId;
     /**
-     * Returns true if the account is a faucet.
+     * Returns true if the account exposes a fungible-faucet interface.
      */
     isFaucet(): boolean;
-    /**
-     * Returns true if this is a network-owned account.
-     */
-    isNetwork(): boolean;
     /**
      * Returns true if the account has not yet been committed to the chain.
      */
@@ -74,13 +70,9 @@ export class Account {
      */
     isPublic(): boolean;
     /**
-     * Returns true if the account is a regular account (immutable or updatable code).
+     * Returns true if the account is a regular (non-faucet) account.
      */
     isRegularAccount(): boolean;
-    /**
-     * Returns true if the account can update its code.
-     */
-    isUpdatable(): boolean;
     /**
      * Returns the account nonce, which is incremented on every state update.
      */
@@ -146,6 +138,11 @@ export class AccountBuilder {
     constructor(init_seed: Uint8Array);
     /**
      * 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.
      */
     storageMode(storage_mode: AccountStorageMode): AccountBuilder;
     /**
@@ -235,6 +232,11 @@ export class AccountComponent {
     getProcedures(): GetProceduresResultItem[];
     /**
      * 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.
      */
     withSupportsAllTypes(): AccountComponent;
 }
@@ -390,14 +392,6 @@ export class AccountId {
      * Returns an error if the provided felts do not form a valid account ID.
      */
     static fromPrefixSuffix(prefix: Felt, suffix: Felt): AccountId;
-    /**
-     * Returns true if the ID refers to a faucet.
-     */
-    isFaucet(): boolean;
-    /**
-     * Returns true if the ID is reserved for network accounts.
-     */
-    isNetwork(): boolean;
     /**
      * Returns true if the account uses private storage.
      */
@@ -406,10 +400,6 @@ export class AccountId {
      * Returns true if the account uses public storage.
      */
     isPublic(): boolean;
-    /**
-     * Returns true if the ID refers to a regular account.
-     */
-    isRegularAccount(): boolean;
     /**
      * Returns the prefix field element storing metadata about version, type, and storage mode.
      */
@@ -705,6 +695,15 @@ export class AccountStorageDelta {
 
 /**
  * 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.
  */
 export class AccountStorageMode {
     private constructor();
@@ -714,10 +713,6 @@ export class AccountStorageMode {
      * Returns the storage mode as a string.
      */
     asStr(): string;
-    /**
-     * Creates a network storage mode.
-     */
-    static network(): AccountStorageMode;
     /**
      * Creates a private storage mode.
      */
@@ -728,6 +723,9 @@ export class AccountStorageMode {
     static public(): AccountStorageMode;
     /**
      * Parses a storage mode from its string representation.
+     *
+     * Accepts `"private"` and `"public"`; any other input — including the
+     * previously-supported `"network"` — is rejected.
      */
     static tryFromStr(s: string): AccountStorageMode;
 }
@@ -745,11 +743,17 @@ export class AccountStorageRequirements {
     constructor();
 }
 
+/**
+ * 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.
+ */
 export enum AccountType {
-    FungibleFaucet = 0,
-    NonFungibleFaucet = 1,
-    RegularAccountImmutableCode = 2,
-    RegularAccountUpdatableCode = 3,
+    Private = 0,
+    Public = 1,
 }
 
 /**
@@ -895,6 +899,17 @@ export class AssetVault {
     fungibleAssets(): FungibleAsset[];
     /**
      * 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.
      */
     getBalance(faucet_id: AccountId): bigint;
     /**
@@ -960,6 +975,9 @@ export class AuthSecretKey {
 
 /**
  * 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).
  */
 export class BasicFungibleFaucetComponent {
     private constructor();
@@ -1013,6 +1031,15 @@ export class BlockHeader {
      * Returns the commitment to the block contents.
      */
     commitment(): Word;
+    /**
+     * 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.
+     */
+    feeFaucetId(): AccountId;
     /**
      * Returns the note commitment root.
      */
@@ -1120,10 +1147,6 @@ export class CommittedNote {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Returns the full note metadata when the attachment payload is available.
-     */
-    fullMetadata(): NoteMetadata | undefined;
     /**
      * Returns the inclusion path for the note in the block's note tree.
      */
@@ -1134,9 +1157,6 @@ export class CommittedNote {
     inclusionProof(): NoteInclusionProof;
     /**
      * Returns the note metadata.
-     *
-     * If only metadata headers are available, the returned metadata contains
-     * the sender, note type, and tag without attachment payload.
      */
     metadata(): NoteMetadata;
     /**
@@ -1295,6 +1315,9 @@ export class Felt {
     asInt(): bigint;
     /**
      * 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).
      */
     constructor(value: bigint);
     /**
@@ -1343,10 +1366,6 @@ export class FetchedAccount {
      * Returns the account commitment reported by the node.
      */
     commitment(): Word;
-    /**
-     * Returns true when the account is a network account.
-     */
-    isNetwork(): boolean;
     /**
      * Returns true when the account is private.
      */
@@ -1364,8 +1383,15 @@ export class FetchedAccount {
 /**
  * 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.
  */
 export class FetchedNote {
     free(): void;
@@ -1382,9 +1408,13 @@ export class FetchedNote {
      */
     constructor(note_id: NoteId, metadata: NoteMetadata, inclusion_proof: NoteInclusionProof, note?: Note | null);
     /**
-     * The note's header, containing the ID and metadata.
+     * 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.
      */
-    readonly header: NoteHeader;
+    readonly attachments: NoteAttachment[];
     /**
      * The note's inclusion proof.
      *
@@ -1500,6 +1530,10 @@ export class FungibleAssetDelta {
     [Symbol.dispose](): void;
     /**
      * 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.
      */
     amount(faucet_id: AccountId): bigint | undefined;
     /**
@@ -1573,7 +1607,12 @@ export class InputNote {
      */
     static authenticated(note: Note, inclusion_proof: NoteInclusionProof): InputNote;
     /**
-     * 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.
      */
     commitment(): Word;
     /**
@@ -1618,6 +1657,16 @@ export class InputNoteRecord {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    attachments(): NoteAttachment[];
     /**
      * Returns the note commitment (id + metadata), if available.
      */
@@ -1631,9 +1680,13 @@ export class InputNoteRecord {
      */
     details(): NoteDetails;
     /**
-     * Returns the note ID.
+     * 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.
      */
-    id(): NoteId;
+    id(): NoteId | undefined;
     /**
      * Returns the inclusion proof when the note is authenticated.
      */
@@ -1655,9 +1708,12 @@ export class InputNoteRecord {
      */
     metadata(): NoteMetadata | undefined;
     /**
-     * Returns the nullifier for this note.
+     * 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.
      */
-    nullifier(): string;
+    nullifier(): string | undefined;
     /**
      * Returns the current processing state for this note.
      */
@@ -1743,17 +1799,24 @@ export class IntoUnderlyingSource {
 
 /**
  * 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.
  */
 export class JsAccountUpdate {
     private constructor();
-    /**
-     ** Return copy of self without private attributes.
-     */
-    toJSON(): Object;
-    /**
-     * Return stringified version of self.
-     */
-    toString(): string;
     free(): void;
     [Symbol.dispose](): void;
     /**
@@ -1830,24 +1893,26 @@ export class JsStateSyncUpdate {
      */
     blockNum: number;
     /**
-     * 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.
      */
-    committedNoteIds: string[];
+    committedNoteTagSources: string[];
     /**
      * The new block headers for this state update, serialized into a flattened byte array.
      */
     flattenedNewBlockHeaders: FlattenedU8Vec;
-    /**
-     * Flattened byte array containing partial blockchain peaks used for merkle tree
-     * verification.
-     */
-    flattenedPartialBlockChainPeaks: FlattenedU8Vec;
     /**
      * 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
      * representing the block number for the header at that same index.
      */
     newBlockNums: Uint32Array;
+    /**
+     * 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`.
+     */
+    partialBlockchainPeaks: Uint8Array;
     /**
      * Input notes for this state update in serialized form.
      */
@@ -1872,17 +1937,12 @@ export class JsStateSyncUpdate {
 
 /**
  * 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).
  */
 export class JsStorageMapEntry {
     private constructor();
-    /**
-     ** Return copy of self without private attributes.
-     */
-    toJSON(): Object;
-    /**
-     * Return stringified version of self.
-     */
-    toString(): string;
     free(): void;
     [Symbol.dispose](): void;
     /**
@@ -1901,17 +1961,12 @@ export class JsStorageMapEntry {
 
 /**
  * A JavaScript representation of a storage slot in an account.
+ *
+ * `inspectable` is intentionally omitted — see the note on
+ * `JsAccountUpdate` for the full rationale (#2183).
  */
 export class JsStorageSlot {
     private constructor();
-    /**
-     ** Return copy of self without private attributes.
-     */
-    toJSON(): Object;
-    /**
-     * Return stringified version of self.
-     */
-    toString(): string;
     free(): void;
     [Symbol.dispose](): void;
     /**
@@ -1930,17 +1985,12 @@ export class JsStorageSlot {
 
 /**
  * An object that contains a serialized vault asset.
+ *
+ * `inspectable` is intentionally omitted — see the note on
+ * `JsAccountUpdate` for the full rationale (#2183).
  */
 export class JsVaultAsset {
     private constructor();
-    /**
-     ** Return copy of self without private attributes.
-     */
-    toJSON(): Object;
-    /**
-     * Return stringified version of self.
-     */
-    toString(): string;
     free(): void;
     [Symbol.dispose](): void;
     /**
@@ -2065,7 +2115,12 @@ export class Note {
      */
     assets(): NoteAssets;
     /**
-     * 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.
      */
     commitment(): Word;
     /**
@@ -2090,6 +2145,10 @@ export class Note {
     metadata(): NoteMetadata;
     /**
      * 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.
      */
     constructor(note_assets: NoteAssets, note_metadata: NoteMetadata, note_recipient: NoteRecipient);
     /**
@@ -2191,65 +2250,62 @@ export class NoteAssets {
 /**
  * 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.
  */
 export class NoteAttachment {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Returns the content as an array of Felts if the attachment kind is Array, otherwise None.
-     */
-    asArray(): FeltArray | undefined;
-    /**
-     * Returns the content as a Word if the attachment kind is Word, otherwise None.
-     */
-    asWord(): Word | undefined;
-    /**
-     * Returns the attachment kind.
-     */
-    attachmentKind(): NoteAttachmentKind;
     /**
      * Returns the attachment scheme.
      */
     attachmentScheme(): NoteAttachmentScheme;
     /**
-     * Creates a default (empty) note attachment.
+     * Creates a new note attachment from a single word.
      */
-    constructor();
+    static fromWord(scheme: NoteAttachmentScheme, word: Word): NoteAttachment;
     /**
-     * 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`.
      */
-    static newArray(scheme: NoteAttachmentScheme, elements: FeltArray): NoteAttachment;
+    static fromWords(scheme: NoteAttachmentScheme, words: Word[]): NoteAttachment;
     /**
-     * Creates a new note attachment for a network account target.
+     * Creates a note attachment from an optional list of packed values.
      *
-     * 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.
-     *
-     * # 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.
+     * Returns an error if a value is not a canonical field element, or if the
+     * packed word count exceeds `NoteAttachment::MAX_NUM_WORDS`.
      */
-    static newNetworkAccountTarget(target_id: AccountId, exec_hint: NoteExecutionHint): NoteAttachment;
+    constructor(values?: BigUint64Array | null);
     /**
-     * Creates a new note attachment with Word content from the provided word.
+     * Returns the number of words in this attachment.
      */
-    static newWord(scheme: NoteAttachmentScheme, word: Word): NoteAttachment;
-}
-
-/**
- * Defines the payload shape of a note attachment.
- */
-export enum NoteAttachmentKind {
-    None = 0,
-    Word = 1,
-    Array = 2,
+    numWords(): number;
+    /**
+     * 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.
+     */
+    toWords(): Word[];
 }
 
 /**
@@ -2261,16 +2317,16 @@ export enum NoteAttachmentKind {
 export class NoteAttachmentScheme {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Returns the note attachment scheme as a u32.
-     */
-    asU32(): number;
     /**
      * Returns true if the attachment scheme is the reserved value that signals an absent scheme.
      */
     isNone(): boolean;
     /**
-     * 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).
      */
     constructor(scheme: number);
     /**
@@ -2332,6 +2388,14 @@ export class NoteConsumptionStatus {
  * 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.
  */
 export class NoteDetails {
     free(): void;
@@ -2340,18 +2404,10 @@ export class NoteDetails {
      * Returns the assets locked by the note.
      */
     assets(): NoteAssets;
-    /**
-     * Returns the note identifier derived from these details.
-     */
-    id(): NoteId;
     /**
      * Creates a new set of note details from the given assets and recipient.
      */
     constructor(note_assets: NoteAssets, note_recipient: NoteRecipient);
-    /**
-     * Returns the note nullifier as a word.
-     */
-    nullifier(): Word;
     /**
      * Returns the recipient which controls when the note can be consumed.
      */
@@ -2491,9 +2547,14 @@ export class NoteFile {
      */
     noteDetails(): NoteDetails | undefined;
     /**
-     * Returns the note ID for any `NoteFile` variant.
+     * 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.
      */
-    noteId(): NoteId;
+    noteId(): NoteId | undefined;
     /**
      * Returns the note tag hint when present.
      */
@@ -2504,6 +2565,10 @@ export class NoteFile {
     noteType(): string;
     /**
      * 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`.
      */
     nullifier(): string | undefined;
     /**
@@ -2553,10 +2618,6 @@ export class NoteHeader {
      * Returns the public metadata attached to the note.
      */
     metadata(): NoteMetadata;
-    /**
-     * Returns a commitment to the note ID and metadata.
-     */
-    toCommitment(): Word;
 }
 
 /**
@@ -2564,18 +2625,17 @@ export class NoteHeader {
  *
  * 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).
  */
 export class NoteId {
+    private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
@@ -2583,9 +2643,13 @@ export class NoteId {
      */
     static fromHex(hex: string): NoteId;
     /**
-     * Builds a note ID from the recipient and asset commitments.
+     * 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.
      */
-    constructor(recipient_digest: Word, asset_commitment_digest: Word);
+    static fromRaw(word: Word): NoteId;
     /**
      * Returns the canonical hex representation of the note ID.
      */
@@ -2662,18 +2726,19 @@ export class NoteLocation {
 /**
  * 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.
  */
 export class NoteMetadata {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Returns the attachment of the note.
-     */
-    attachment(): NoteAttachment;
-    /**
-     * Creates metadata for a note.
+     * Creates metadata for a note with no attachments.
      */
     constructor(sender: AccountId, note_type: NoteType, note_tag: NoteTag);
     /**
@@ -2688,18 +2753,6 @@ export class NoteMetadata {
      * Returns the tag associated with the note.
      */
     tag(): NoteTag;
-    /**
-     * 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.
-     */
-    withAttachment(attachment: NoteAttachment): NoteMetadata;
-    /**
-     * Sets the tag for this metadata and returns the updated metadata.
-     */
-    withTag(tag: NoteTag): NoteMetadata;
 }
 
 /**
@@ -2828,7 +2881,7 @@ export class NoteStorage {
 }
 
 /**
- * Represents a single block's worth of note sync data.
+ * Represents a single block's worth of note sync data returned by `syncNotes`.
  */
 export class NoteSyncBlock {
     private constructor();
@@ -2849,34 +2902,38 @@ export class NoteSyncBlock {
 }
 
 /**
- * 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.
  */
 export class NoteSyncInfo {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * 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.
      */
     blockHeader(): BlockHeader | undefined;
     /**
-     * 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`).
      */
     blockTo(): number;
     /**
-     * Returns the blocks containing matching notes.
+     * Returns the per-block breakdown.
      */
     blocks(): NoteSyncBlock[];
     /**
-     * Returns the latest block number in the chain.
-     */
-    chainTip(): number;
-    /**
-     * 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.
      */
     mmrPath(): MerklePath | undefined;
     /**
-     * Returns the committed notes across all matching blocks.
+     * Returns every committed note across all matching blocks (flattened).
      */
     notes(): CommittedNote[];
 }
@@ -3286,9 +3343,10 @@ export 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.
      */
-    getNoteScriptByRoot(script_root: Word): Promise<NoteScript>;
+    getNoteScriptByRoot(script_root: Word): Promise<NoteScript | undefined>;
     /**
      * Fetches notes by their IDs from the connected Miden node.
      *
@@ -3312,7 +3370,7 @@ export class RpcClient {
     /**
      * Fetches notes matching the provided tags from the node.
      */
-    syncNotes(block_num: number, block_to: number | null | undefined, note_tags: NoteTag[]): Promise<NoteSyncInfo>;
+    syncNotes(block_from: number, block_to: number, note_tags: NoteTag[]): Promise<NoteSyncInfo>;
     /**
      * Syncs storage map updates for an account within a block range.
      *
@@ -3344,6 +3402,7 @@ export class SerializedInputNoteData {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    attachments: Uint8Array;
     get consumedBlockHeight(): number | undefined;
     set consumedBlockHeight(value: number | null | undefined);
     get consumedTxOrder(): number | undefined;
@@ -3351,9 +3410,11 @@ export class SerializedInputNoteData {
     get consumerAccountId(): string | undefined;
     set consumerAccountId(value: string | null | undefined);
     createdAt: string;
+    detailsCommitment: string;
     inputs: Uint8Array;
     noteAssets: Uint8Array;
-    noteId: string;
+    get noteId(): string | undefined;
+    set noteId(value: string | null | undefined);
     noteScriptRoot: string;
     noteScript: Uint8Array;
     nullifier: string;
@@ -3366,6 +3427,7 @@ export class SerializedOutputNoteData {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    attachments: Uint8Array;
     expectedHeight: number;
     metadata: Uint8Array;
     noteAssets: Uint8Array;
@@ -3854,6 +3916,28 @@ export class TransactionProver {
      * Returns the endpoint if this is a remote prover.
      */
     endpoint(): string | undefined;
+    /**
+     * 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.
+     */
+    static newCallbackProver(callback: Function): TransactionProver;
     /**
      * Creates a prover that uses the local proving backend.
      */
@@ -4404,9 +4488,48 @@ export class WebClient {
     getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
     importAccountById(account_id: AccountId): Promise<void>;
     importAccountFile(account_file: AccountFile): Promise<string>;
-    importNoteFile(note_file: NoteFile): Promise<NoteId>;
+    /**
+     * 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.
+     */
+    importNoteFile(note_file: NoteFile): Promise<string>;
     importPublicAccountFromSeed(init_seed: Uint8Array, mutable: boolean, auth_scheme: AuthScheme): Promise<Account>;
     insertAccountAddress(account_id: AccountId, address: Address): Promise<void>;
+    /**
+     * 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
+     *   }
+     * }
+     * ```
+     */
+    lastAuthError(): any;
     /**
      * Returns all the existing setting keys from the store.
      */
@@ -4422,8 +4545,18 @@ export class WebClient {
      */
     newAccountWithSecretKey(account: Account, secret_key: AuthSecretKey): Promise<void>;
     newConsumeTransactionRequest(list_of_notes: Note[]): TransactionRequest;
-    newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme: AuthScheme): Promise<Account>;
+    /**
+     * 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.
+     */
+    newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_name: string, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme: AuthScheme): Promise<Account>;
     newMintTransactionRequest(target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint): Promise<TransactionRequest>;
+    newPswapCancelTransactionRequest(pswap_note: Note, creator_account_id: AccountId): TransactionRequest;
+    newPswapConsumeTransactionRequest(pswap_note: Note, consumer_account_id: AccountId, account_fill_amount: bigint, note_fill_amount: bigint): TransactionRequest;
+    newPswapCreateTransactionRequest(creator_account_id: AccountId, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint, note_type: NoteType, payback_note_type: NoteType): Promise<TransactionRequest>;
     newSendTransactionRequest(sender_account_id: AccountId, target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint, recall_height?: number | null, timelock_height?: number | null): Promise<TransactionRequest>;
     newSwapTransactionRequest(sender_account_id: AccountId, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint, note_type: NoteType, payback_note_type: NoteType): Promise<TransactionRequest>;
     newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme: AuthScheme, init_seed?: Uint8Array | null): Promise<Account>;
@@ -4557,6 +4690,10 @@ export class Word {
     static fromHex(hex: string): 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.
      */
     constructor(u64_vec: BigUint64Array);
     /**
@@ -4601,6 +4738,15 @@ export { exportStore2 as exportStore }
  */
 export function importStore(store_name: string, store_dump: string): Promise<void>;
 
+/**
+ * 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).
+ */
+export function sequentialSumBench(n: bigint): bigint;
+
 /**
  * Initializes the `tracing` subscriber that routes Rust log output to the
  * browser console via `console.log` / `console.warn` / `console.error`.