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

package/dist/mt/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.
      */
@@ -121,14 +113,6 @@ export class AccountArray {
     length(): number;
     constructor(elements?: Account[] | null);
     push(element: Account): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: Account): void;
 }
 
@@ -137,22 +121,28 @@ export class AccountBuilder {
     [Symbol.dispose](): void;
     /**
      * Sets the account type (regular, faucet, etc.).
-     *
-     * Accepts either a numeric WASM enum value (0–3) or a string name
-     * (`"FungibleFaucet"`, `"NonFungibleFaucet"`,
-     * `"RegularAccountImmutableCode"`, `"RegularAccountUpdatableCode"`).
      */
-    accountType(account_type: any): AccountBuilder;
+    accountType(account_type: AccountType): AccountBuilder;
     /**
-     * Builds the account and returns it together with the derived seed.
+     * Builds the account (including merged storage schema commitment metadata) and returns it
+     * together with the derived seed.
      */
     build(): AccountBuilderResult;
+    /**
+     * Builds the account without adding the schema commitment component (legacy behavior).
+     */
+    buildWithoutSchemaCommitment(): AccountBuilderResult;
     /**
      * Creates a new account builder from a 32-byte initial seed.
      */
     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;
     /**
@@ -242,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;
 }
@@ -397,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.
      */
@@ -413,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.
      */
@@ -453,14 +436,6 @@ export class AccountIdArray {
     length(): number;
     constructor(elements?: AccountId[] | null);
     push(element: AccountId): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: AccountId): void;
 }
 
@@ -510,7 +485,7 @@ export class AccountProof {
      *
      * Each entry contains a `key` and `value` as `Word` objects.
      */
-    getStorageMapEntries(slot_name: string): StorageMapEntry[] | undefined;
+    getStorageMapEntries(slot_name: string): StorageMapEntryJs[] | undefined;
     /**
      * Returns the names of all storage slots that have map details available.
      *
@@ -540,6 +515,13 @@ export class AccountProof {
      * Returns the number of storage slots, if available (public accounts only).
      */
     numStorageSlots(): number | undefined;
+    /**
+     * Returns the fungible assets in the account's vault, if vault details were included
+     * in the proof response.
+     *
+     * Returns `undefined` if the account is private or vault data was not requested.
+     */
+    vaultFungibleAssets(): FungibleAsset[] | undefined;
 }
 
 /**
@@ -669,7 +651,7 @@ export class AccountStorage {
      * Returns `undefined` if the slot isn't a map or doesn't exist.
      * Returns `[]` if the map exists but is empty.
      */
-    getMapEntries(slot_name: string): JsStorageMapEntry[] | undefined;
+    getMapEntries(slot_name: string): StorageMapEntry[] | undefined;
     /**
      * Returns the value for a key in the map stored at the given slot, if any.
      */
@@ -713,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();
@@ -722,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.
      */
@@ -736,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;
 }
@@ -753,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,
 }
 
 /**
@@ -903,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;
     /**
@@ -968,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();
@@ -1029,7 +1039,7 @@ export class BlockHeader {
      * discover the native faucet by reading any block header rather than hardcoding it per
      * network.
      */
-    nativeAssetId(): AccountId;
+    feeFaucetId(): AccountId;
     /**
      * Returns the note commitment root.
      */
@@ -1137,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.
      */
@@ -1151,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;
     /**
@@ -1311,7 +1314,10 @@ export class Felt {
      */
     asInt(): bigint;
     /**
-     * Creates a new field element from a u64 value.
+     * Creates a new field element.
+     *
+     * Returns an error if `value` is outside the field's representable
+     * range (`Felt::new` is fallible on the 0.15 protocol surface).
      */
     constructor(value: bigint);
     /**
@@ -1338,14 +1344,6 @@ export class FeltArray {
     length(): number;
     constructor(elements?: Felt[] | null);
     push(element: Felt): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: Felt): void;
 }
 
@@ -1368,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.
      */
@@ -1389,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;
@@ -1407,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.
      *
@@ -1486,14 +1491,6 @@ export class ForeignAccountArray {
     length(): number;
     constructor(elements?: ForeignAccount[] | null);
     push(element: ForeignAccount): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: ForeignAccount): void;
 }
 
@@ -1533,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;
     /**
@@ -1606,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;
     /**
@@ -1651,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.
      */
@@ -1664,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.
      */
@@ -1688,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.
      */
@@ -1870,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.
      */
@@ -2027,6 +2052,32 @@ export class NetworkId {
     static testnet(): NetworkId;
 }
 
+/**
+ * Status of a network note in the node.
+ */
+export class NetworkNoteStatusInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns the number of processing attempts.
+     */
+    readonly attemptCount: number;
+    /**
+     * Returns the block number of the last processing attempt, if any.
+     */
+    readonly lastAttemptBlockNum: number | undefined;
+    /**
+     * Returns the last error message, if any.
+     */
+    readonly lastError: string | undefined;
+    /**
+     * Returns the status as a string: `"Pending"`, `"NullifierInflight"`, `"Discarded"`, or
+     * `"NullifierCommitted"`.
+     */
+    readonly status: string;
+}
+
 /**
  * The type of a Miden network.
  */
@@ -2064,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;
     /**
@@ -2089,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);
     /**
@@ -2136,14 +2196,6 @@ export class NoteAndArgsArray {
     length(): number;
     constructor(elements?: NoteAndArgs[] | null);
     push(element: NoteAndArgs): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: NoteAndArgs): void;
 }
 
@@ -2165,14 +2217,6 @@ export class NoteArray {
     length(): number;
     constructor(elements?: Note[] | null);
     push(element: Note): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: Note): void;
 }
 
@@ -2206,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.
-     *
-     * 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.
+     * 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[];
 }
 
 /**
@@ -2276,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);
     /**
@@ -2347,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;
@@ -2355,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.
      */
@@ -2411,14 +2452,6 @@ export class NoteDetailsAndTagArray {
     length(): number;
     constructor(elements?: NoteDetailsAndTag[] | null);
     push(element: NoteDetailsAndTag): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: NoteDetailsAndTag): void;
 }
 
@@ -2514,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.
      */
@@ -2527,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;
     /**
@@ -2576,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;
 }
 
 /**
@@ -2587,18 +2625,17 @@ export class NoteHeader {
  *
  * Note ID is computed as:
  *
- * > `hash(recipient, asset_commitment)`
- *
- * where `recipient` is defined as:
- *
- * > `hash(hash(hash(serial_num, ZERO), script_root), input_commitment)`
+ * > `hash(details_commitment, metadata_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;
     /**
@@ -2606,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.
      */
@@ -2645,14 +2686,6 @@ export class NoteIdAndArgsArray {
     length(): number;
     constructor(elements?: NoteIdAndArgs[] | null);
     push(element: NoteIdAndArgs): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: NoteIdAndArgs): void;
 }
 
@@ -2693,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);
     /**
@@ -2719,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;
 }
 
 /**
@@ -2787,14 +2809,6 @@ export class NoteRecipientArray {
     length(): number;
     constructor(elements?: NoteRecipient[] | null);
     push(element: NoteRecipient): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: NoteRecipient): void;
 }
 
@@ -2867,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();
@@ -2888,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[];
 }
@@ -3016,14 +3034,6 @@ export class OutputNoteArray {
     length(): number;
     constructor(elements?: OutputNote[] | null);
     push(element: OutputNote): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: OutputNote): void;
 }
 
@@ -3312,15 +3322,31 @@ export class RpcClient {
     getAccountProof(account_id: AccountId, storage_requirements?: AccountStorageRequirements | null, block_num?: number | null, known_vault_commitment?: Word | null): Promise<AccountProof>;
     /**
      * Fetches a block header by number. When `block_num` is undefined, returns the latest header.
+     *
+     * @param `block_num` - Optional block number. When `undefined`, returns the latest header.
+     * @param `include_mmr_proof` - When `true`, includes the MMR proof in the response. Defaults
+     *   to `false` when `undefined`.
+     */
+    getBlockHeaderByNumber(block_num?: number | null, include_mmr_proof?: boolean | null): Promise<BlockHeader>;
+    /**
+     * Fetches the processing status of a network note by its ID.
+     *
+     * Returns information about the note's current status in the network,
+     * including whether it is pending, processed, discarded, or committed,
+     * along with error details and attempt count.
+     *
+     * @param `note_id` - The ID of the note to query.
+     * @returns Promise that resolves to a `NetworkNoteStatusInfo` object.
      */
-    getBlockHeaderByNumber(block_num?: number | null): Promise<BlockHeader>;
+    getNetworkNoteStatus(note_id: NoteId): Promise<NetworkNoteStatusInfo>;
     /**
      * 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.
      *
@@ -3344,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.
      *
@@ -3376,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;
@@ -3383,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;
@@ -3398,6 +3427,7 @@ export class SerializedOutputNoteData {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    attachments: Uint8Array;
     expectedHeight: number;
     metadata: Uint8Array;
     noteAssets: Uint8Array;
@@ -3583,10 +3613,27 @@ export class StorageMap {
     constructor();
 }
 
+export class StorageMapEntry {
+    private constructor();
+    /**
+     ** Return copy of self without private attributes.
+     */
+    toJSON(): Object;
+    /**
+     * Return stringified version of self.
+     */
+    toString(): string;
+    free(): void;
+    [Symbol.dispose](): void;
+    key: string;
+    root: string;
+    value: string;
+}
+
 /**
  * A key-value entry from a storage map.
  */
-export class StorageMapEntry {
+export class StorageMapEntryJs {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
@@ -3690,14 +3737,6 @@ export class StorageSlotArray {
     length(): number;
     constructor(elements?: StorageSlot[] | null);
     push(element: StorageSlot): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: StorageSlot): void;
 }
 
@@ -4167,14 +4206,6 @@ export class TransactionScriptInputPairArray {
     length(): number;
     constructor(elements?: TransactionScriptInputPair[] | null);
     push(element: TransactionScriptInputPair): void;
-    /**
-     * Replace the element at `index`. Borrows + clones the input
-     * (mirrors `push`), so the caller's JS handle remains valid
-     * after the call. Without this borrow, passing `elem` by
-     * value would move the underlying Rust value out of the
-     * caller's JS handle and any subsequent method on it would
-     * panic with `"null pointer passed to rust"`.
-     */
     replaceAt(index: number, elem: TransactionScriptInputPair): void;
 }
 
@@ -4313,7 +4344,8 @@ export class WebClient {
      * const balance = await reader.getBalance(faucetId);
      * ```
      */
-    accountReader(account_id: AccountId): AccountReader;
+    accountReader(account_id: AccountId): Promise<AccountReader>;
+    addAccountSecretKeyToWebStore(account_id: AccountId, secret_key: AuthSecretKey): Promise<void>;
     addTag(tag: string): Promise<void>;
     applyTransaction(transaction_result: TransactionResult, submission_height: number): Promise<TransactionStoreUpdate>;
     static buildSwapTag(note_type: NoteType, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint): NoteTag;
@@ -4327,6 +4359,9 @@ export class WebClient {
      * * `store_name`: Optional name for the web store. If `None`, the store name defaults to
      *   `MidenClientDB_{network_id}`, where `network_id` is derived from the `node_url`.
      *   Explicitly setting this allows for creating multiple isolated clients.
+     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. When enabled,
+     *   the transaction executor records additional information useful for debugging. Defaults to
+     *   disabled.
      */
     createClient(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, store_name?: string | null, debug_mode?: boolean | null): Promise<any>;
     /**
@@ -4342,14 +4377,16 @@ export class WebClient {
      * * `get_key_cb`: Callback to retrieve the secret key bytes for a given public key.
      * * `insert_key_cb`: Callback to persist a secret key.
      * * `sign_cb`: Callback to produce serialized signature bytes for the provided inputs.
+     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. Defaults to
+     *   disabled.
      */
     createClientWithExternalKeystore(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, store_name?: string | null, get_key_cb?: Function | null, insert_key_cb?: Function | null, sign_cb?: Function | null, debug_mode?: boolean | null): Promise<any>;
-    createCodeBuilder(): CodeBuilder;
+    createCodeBuilder(): Promise<CodeBuilder>;
     /**
      * Creates a new client with a mock RPC API. Useful for testing purposes and proof-of-concept
      * applications as it uses a mock chain that simulates the behavior of a real node.
      */
-    createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<any>;
+    createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<string>;
     /**
      * Executes a transaction and returns the `TransactionSummary`.
      *
@@ -4400,6 +4437,18 @@ export class WebClient {
      * This method loads the complete account state including vault, storage, and code.
      */
     getAccount(account_id: AccountId): Promise<Account | undefined>;
+    /**
+     * Retrieves an authentication secret key from the keystore given a public key commitment.
+     *
+     * The public key commitment should correspond to one of the keys tracked by the keystore.
+     * Returns the associated [`AuthSecretKey`] if found, or an error if not found.
+     */
+    getAccountAuthByPubKeyCommitment(pub_key_commitment: Word): Promise<AuthSecretKey>;
+    /**
+     * Retrieves the full account data for the account associated with the given public key
+     * commitment, returning `null` if no account is found.
+     */
+    getAccountByKeyCommitment(pub_key_commitment: Word): Promise<Account | undefined>;
     /**
      * Retrieves the account code for a specific account.
      *
@@ -4425,14 +4474,35 @@ export class WebClient {
     getOutputNote(note_id: string): Promise<OutputNoteRecord>;
     getOutputNotes(filter: NoteFilter): Promise<OutputNoteRecord[]>;
     /**
-     * Retrieves the setting value for `key`, or `None` if it hasn’t been set.
+     * Returns all public key commitments associated with the given account ID.
+     *
+     * These commitments can be used with [`getAccountAuthByPubKeyCommitment`]
+     * to retrieve the corresponding secret keys from the keystore.
+     */
+    getPublicKeyCommitmentsOfAccount(account_id: AccountId): Promise<Word[]>;
+    /**
+     * Retrieves the setting value for `key`, or `None` if it hasn't been set.
      */
     getSetting(key: string): Promise<any | undefined>;
     getSyncHeight(): Promise<number>;
     getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
-    importAccountById(account_id: AccountId): Promise<any>;
-    importAccountFile(account_file: AccountFile): Promise<any>;
-    importNoteFile(note_file: NoteFile): Promise<NoteId>;
+    importAccountById(account_id: AccountId): Promise<void>;
+    importAccountFile(account_file: AccountFile): Promise<string>;
+    /**
+     * 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>;
     /**
@@ -4464,7 +4534,7 @@ export class WebClient {
      * Returns all the existing setting keys from the store.
      */
     listSettingKeys(): Promise<string[]>;
-    listTags(): Promise<any>;
+    listTags(): Promise<string[]>;
     constructor();
     newAccount(account: Account, overwrite: boolean): Promise<void>;
     /**
@@ -4475,27 +4545,27 @@ 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>;
-    newMintTransactionRequest(target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint): 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): 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): TransactionRequest;
-    newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme: AuthScheme, init_seed?: Uint8Array | null): Promise<Account>;
-    proveBlock(): void;
     /**
-     * Generates a transaction proof using the client's default (local) prover.
-     */
-    proveTransaction(transaction_result: TransactionResult): Promise<ProvenTransaction>;
-    /**
-     * Generates a transaction proof using the provided prover.
+     * Creates, persists, and returns a new fungible faucet account.
      *
-     * Takes the prover by reference so the JS-side handle is NOT consumed
-     * by wasm-bindgen. Taking `TransactionProver` by value would transfer
-     * ownership on each call, invalidating the JS object's internal WASM
-     * handle; after one use, subsequent calls from JS would pass a dangling
-     * handle that wasm-bindgen interprets as `None`, silently falling back
-     * to the local prover.
+     * 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>;
+    proveBlock(): Promise<void>;
+    /**
+     * Generates a transaction proof using either the provided prover or the client's default
+     * prover if none is supplied.
      */
-    proveTransactionWithProver(transaction_result: TransactionResult, prover: TransactionProver): Promise<ProvenTransaction>;
+    proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
     /**
      * Prunes historical account states for the specified account up to the given nonce.
      *
@@ -4519,11 +4589,11 @@ export class WebClient {
     /**
      * Returns the inner serialized mock chain if it exists.
      */
-    serializeMockChain(): Uint8Array;
+    serializeMockChain(): Promise<Uint8Array>;
     /**
      * Returns the inner serialized mock note transport node if it exists.
      */
-    serializeMockNoteTransportNode(): Uint8Array;
+    serializeMockNoteTransportNode(): Promise<Uint8Array>;
     /**
      * Sets a setting key-value in the store. It can then be retrieved using `get_setting`.
      */
@@ -4531,7 +4601,7 @@ export class WebClient {
     /**
      * Returns the identifier of the underlying store (e.g. `IndexedDB` database name, file path).
      */
-    storeIdentifier(): string;
+    storeIdentifier(): Promise<string>;
     /**
      * Executes a transaction specified by the request against the specified account,
      * proves it, submits it to the network, and updates the local database.
@@ -4563,7 +4633,7 @@ export class WebClient {
      * which provides proper coordination for concurrent calls.
      */
     syncStateImpl(): Promise<SyncSummary>;
-    usesMockChain(): boolean;
+    usesMockChain(): Promise<boolean>;
     /**
      * Returns a `WebKeystoreApi` handle for managing secret keys.
      *
@@ -4616,11 +4686,14 @@ export class Word {
     static deserialize(bytes: Uint8Array): Word;
     /**
      * Creates a Word from a hex string.
-     * Fails if the provided string is not a valid hex representation of a Word.
      */
     static fromHex(hex: string): Word;
     /**
-     * Creates a word from four u64 values.
+     * Creates a word from four numeric values.
+     *
+     * Each input must be a canonical field element, i.e. strictly less than the field modulus.
+     * `Felt::new` (now fallible on the 0.15 surface) errors out on inputs at or beyond the
+     * modulus; the error is surfaced to JS.
      */
     constructor(u64_vec: BigUint64Array);
     /**
@@ -4640,7 +4713,7 @@ export class Word {
      */
     toHex(): string;
     /**
-     * Returns the word as an array of u64 values.
+     * Returns the word as an array of numeric values.
      */
     toU64s(): BigUint64Array;
 }