@miden-sdk/miden-sdk 0.13.0-next.1 → 0.13.0-next.3

package/dist/crates/miden_client_web.d.ts

@@ -1,6 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Create an auth component for `Falcon512Rpo` multisig.
+ */
+export function createAuthFalcon512RpoMultisig(config: AuthFalcon512RpoMultisigConfig): AccountComponent;
 export enum AccountInterface {
+  /**
+   * Basic wallet address interface.
+   */
   BasicWallet = 0,
 }
 export enum AccountType {
@@ -9,6 +16,13 @@ export enum AccountType {
   RegularAccountImmutableCode = 2,
   RegularAccountUpdatableCode = 3,
 }
+/**
+ * Authentication schemes supported by the web client.
+ */
+export enum AuthScheme {
+  AuthRpoFalcon512 = 0,
+  AuthEcdsaK256Keccak = 1,
+}
 export enum InputNoteState {
   Expected = 0,
   Unverified = 1,
@@ -20,10 +34,34 @@ export enum InputNoteState {
   ConsumedUnauthenticatedLocal = 7,
   ConsumedExternal = 8,
 }
-export enum NetworkId {
+/**
+ * The type of a Miden network.
+ */
+export enum NetworkType {
+  /**
+   * Main network prefix (`mm`).
+   */
   Mainnet = 0,
+  /**
+   * Public test network prefix (`mtst`).
+   */
   Testnet = 1,
+  /**
+   * Developer network prefix (`mdev`).
+   */
   Devnet = 2,
+  /**
+   * Custom network prefix.
+   */
+  Custom = 3,
+}
+/**
+ * Defines the payload shape of a note attachment.
+ */
+export enum NoteAttachmentKind {
+  None = 0,
+  Word = 1,
+  Array = 2,
 }
 export enum NoteFilterTypes {
   All = 0,
@@ -36,6 +74,9 @@ export enum NoteFilterTypes {
   Nullifiers = 7,
   Unverified = 8,
 }
+/**
+ * Visibility level for note contents when published to the network.
+ */
 export enum NoteType {
   /**
    * Notes with this type have only their hash published to the network.
@@ -50,9 +91,25 @@ export enum NoteType {
    */
   Public = 1,
 }
+export enum OutputNoteState {
+  ExpectedPartial = 0,
+  ExpectedFull = 1,
+  CommittedPartial = 2,
+  CommittedFull = 3,
+  Consumed = 4,
+}
 export enum SigningInputsType {
+  /**
+   * Signing commitment over a transaction summary.
+   */
   TransactionSummary = 0,
+  /**
+   * Arbitrary field elements supplied by caller.
+   */
   Arbitrary = 1,
+  /**
+   * Blind commitment derived from a single word.
+   */
   Blind = 2,
 }
 /**
@@ -65,26 +122,94 @@ type AddressInterface = "BasicWallet";
  * *This API requires the following crate features to be activated: `ReadableStreamType`*
  */
 type ReadableStreamType = "bytes";
+/**
+ * An account which can store assets and define rules for manipulating them.
+ *
+ * An account consists of the following components:
+ * - Account ID, which uniquely identifies the account and also defines basic properties of the
+ *   account.
+ * - Account vault, which stores assets owned by the account.
+ * - Account storage, which is a key-value map (both keys and values are words) used to store
+ *   arbitrary user-defined data.
+ * - Account code, which is a set of Miden VM programs defining the public interface of the
+ *   account.
+ * - Account nonce, a value which is incremented whenever account state is updated.
+ *
+ * Out of the above components account ID is always immutable (once defined it can never be
+ * changed). Other components may be mutated throughout the lifetime of the account. However,
+ * account state can be changed only by invoking one of account interface methods.
+ *
+ * The recommended way to build an account is through an `AccountBuilder`, which can be
+ * instantiated directly from a 32-byte seed.
+ */
 export class Account {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  id(): AccountId;
+  /**
+   * Returns the commitment to the account header, storage, and code.
+   */
   commitment(): Word;
+  /**
+   * Returns true if this is a network-owned account.
+   */
+  isNetwork(): boolean;
+  /**
+   * Returns true if the account storage is private.
+   */
+  isPrivate(): boolean;
+  /**
+   * Restores an account from its serialized bytes.
+   */
+  static deserialize(bytes: Uint8Array): Account;
+  /**
+   * Returns true if the account can update its code.
+   */
+  isUpdatable(): boolean;
+  /**
+   * Returns true if the account is a regular account (immutable or updatable code).
+   */
+  isRegularAccount(): boolean;
+  /**
+   * Returns the public key commitments derived from the account's authentication scheme.
+   */
+  getPublicKeyCommitments(): Word[];
+  /**
+   * Returns the account identifier.
+   */
+  id(): AccountId;
+  /**
+   * Returns the code commitment for this account.
+   */
+  code(): AccountCode;
+  /**
+   * Returns the account nonce, which is incremented on every state update.
+   */
   nonce(): Felt;
+  /**
+   * Returns the vault commitment for this account.
+   */
   vault(): AssetVault;
+  /**
+   * Returns true if the account has not yet been committed to the chain.
+   */
+  isNew(): boolean;
+  /**
+   * Returns the account storage commitment.
+   */
   storage(): AccountStorage;
-  code(): AccountCode;
+  /**
+   * Returns true if the account is a faucet.
+   */
   isFaucet(): boolean;
-  isRegularAccount(): boolean;
-  isUpdatable(): boolean;
+  /**
+   * Returns true if the account exposes public storage.
+   */
   isPublic(): boolean;
-  isPrivate(): boolean;
-  isNetwork(): boolean;
-  isNew(): boolean;
+  /**
+   * Serializes the account into bytes.
+   */
   serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): Account;
-  getPublicKeys(): Word[];
 }
 export class AccountArray {
 /**
@@ -97,114 +222,289 @@ export class AccountArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: Account[] | null);
+  replaceAt(index: number, elem: Account): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): Account;
-  replaceAt(index: number, elem: Account): void;
+  constructor(elements?: Account[] | null);
   push(element: Account): void;
   length(): number;
 }
 export class AccountBuilder {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(init_seed: Uint8Array);
+  /**
+   * Sets the account type (regular, faucet, etc.).
+   */
   accountType(account_type: AccountType): AccountBuilder;
+  /**
+   * Sets the storage mode (public/private) for the account.
+   */
   storageMode(storage_mode: AccountStorageMode): AccountBuilder;
+  /**
+   * Adds a component to the account.
+   */
   withComponent(account_component: AccountComponent): AccountBuilder;
+  /**
+   * Adds an authentication component to the account.
+   */
   withAuthComponent(account_component: AccountComponent): AccountBuilder;
+  /**
+   * Adds a no-auth component to the account (for public accounts).
+   */
   withNoAuthComponent(): AccountBuilder;
   withBasicWalletComponent(): AccountBuilder;
+  /**
+   * Creates a new account builder from a 32-byte initial seed.
+   */
+  constructor(init_seed: Uint8Array);
+  /**
+   * Builds the account and returns it together with the derived seed.
+   */
   build(): AccountBuilderResult;
 }
 export class AccountBuilderResult {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  readonly account: Account;
+  /**
+   * Returns the seed used to derive the account ID.
+   */
   readonly seed: Word;
+  /**
+   * Returns the built account.
+   */
+  readonly account: Account;
 }
+/**
+ * A public interface of an account.
+ *
+ * Account's public interface consists of a set of callable procedures, each committed to by its
+ * root hash and paired with storage bounds (offset and size).
+ *
+ * The full interface commitment hashes every procedure root together with its storage bounds so
+ * that the account code uniquely captures the set of available calls.
+ */
 export class AccountCode {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the code commitment for the account.
+   */
   commitment(): Word;
+  /**
+   * Returns true if the account code exports a procedure with the given MAST root.
+   */
   hasProcedure(mast_root: Word): boolean;
 }
 export class AccountComponent {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static compile(account_code: string, builder: ScriptBuilder, storage_slots: StorageSlot[]): AccountComponent;
-  withSupportsAllTypes(): AccountComponent;
-  getProcedureHash(procedure_name: string): string;
-  getProcedures(): GetProceduresResultItem[];
-  static createAuthComponent(secret_key: SecretKey): AccountComponent;
-  static createAuthComponentFromCommitment(commitment: Word, auth_scheme_id: number): AccountComponent;
+  /**
+   * Creates an account component from a compiled library and storage slots.
+   */
+  static fromLibrary(library: Library, storage_slots: StorageSlot[]): AccountComponent;
+  /**
+   * Creates an account component from a compiled package and storage slots.
+   */
   static fromPackage(_package: Package, storage_slots: StorageSlotArray): AccountComponent;
+  /**
+   * Returns all procedures exported by this component.
+   */
+  getProcedures(): GetProceduresResultItem[];
+  /**
+   * Returns the hex-encoded MAST root for a procedure by name.
+   */
+  getProcedureHash(procedure_name: string): string;
+  /**
+   * Marks the component as supporting all account types.
+   */
+  withSupportsAllTypes(): AccountComponent;
+  static createAuthComponentFromCommitment(commitment: Word, auth_scheme: AuthScheme): AccountComponent;
+  /**
+   * Builds an auth component from a secret key, inferring the auth scheme from the key type.
+   */
+  static createAuthComponentFromSecretKey(secret_key: AuthSecretKey): AccountComponent;
+  /**
+   * Compiles account code with the given storage slots using the provided assembler.
+   */
+  static compile(account_code: AccountComponentCode, storage_slots: StorageSlot[]): AccountComponent;
+}
+/**
+ * A Library that has been assembled for use as component code.
+ */
+export class AccountComponentCode {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the underlying Library
+   */
+  asLibrary(): Library;
 }
+/**
+ * `AccountDelta` stores the differences between two account states.
+ *
+ * The differences are represented as follows:
+ * - `storage`: an `AccountStorageDelta` that contains the changes to the account storage.
+ * - `vault`: an `AccountVaultDelta` object that contains the changes to the account vault.
+ * - `nonce`: if the nonce of the account has changed, the new nonce is stored here.
+ */
 export class AccountDelta {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes an account delta from bytes.
+   */
   static deserialize(bytes: Uint8Array): AccountDelta;
+  /**
+   * Returns the nonce change.
+   */
+  nonceDelta(): Felt;
+  /**
+   * Returns the affected account ID.
+   */
   id(): AccountId;
-  isEmpty(): boolean;
-  storage(): AccountStorageDelta;
+  /**
+   * Returns the vault delta.
+   */
   vault(): AccountVaultDelta;
-  nonceDelta(): Felt;
+  /**
+   * Returns the storage delta.
+   */
+  storage(): AccountStorageDelta;
+  /**
+   * Returns true if there are no changes.
+   */
+  isEmpty(): boolean;
+  /**
+   * Serializes the account delta into bytes.
+   */
+  serialize(): Uint8Array;
 }
 export class AccountFile {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Serializes the `AccountFile` into a byte array
+   * Returns the account ID.
    */
-  serialize(): Uint8Array;
+  accountId(): AccountId;
   /**
    * Deserializes a byte array into an `AccountFile`
    */
   static deserialize(bytes: Uint8Array): AccountFile;
+  /**
+   * Returns the number of auth secret keys included.
+   */
+  authSecretKeyCount(): number;
+  /**
+   * Returns the account data.
+   */
+  account(): Account;
+  /**
+   * Serializes the `AccountFile` into a byte array
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * A header of an account which contains information that succinctly describes the state of the
+ * components of the account.
+ *
+ * The account header is composed of:
+ * - `id`: the account ID (`AccountId`).
+ * - `nonce`: the nonce of the account.
+ * - `vault_root`: a commitment to the account's vault (`AssetVault`).
+ * - `storage_commitment`: a commitment to the account's storage (`AccountStorage`).
+ * - `code_commitment`: a commitment to the account's code (`AccountCode`).
+ */
 export class AccountHeader {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the full account commitment.
+   */
   commitment(): Word;
-  id(): AccountId;
-  nonce(): Felt;
+  /**
+   * Returns the code commitment.
+   */
+  codeCommitment(): Word;
+  /**
+   * Returns the vault commitment.
+   */
   vaultCommitment(): Word;
+  /**
+   * Returns the storage commitment.
+   */
   storageCommitment(): Word;
-  codeCommitment(): Word;
+  /**
+   * Returns the account ID.
+   */
+  id(): AccountId;
+  /**
+   * Returns the current nonce.
+   */
+  nonce(): Felt;
 }
+/**
+ * Uniquely identifies a specific account.
+ *
+ * A Miden account ID is a 120-bit value derived from the commitments to account code and storage,
+ * and a random user-provided seed.
+ */
 export class AccountId {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns true if the ID is reserved for network accounts.
+   */
+  isNetwork(): boolean;
+  /**
+   * Returns true if the account uses private storage.
+   */
+  isPrivate(): boolean;
+  /**
+   * Given a bech32 encoded string, return the matching Account ID for it.
+   */
+  static fromBech32(bech_32_encoded_id: string): AccountId;
+  /**
+   * 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.
+   */
+  prefix(): Felt;
+  /**
+   * Returns the suffix field element derived from the account seed.
+   */
+  suffix(): Felt;
+  /**
+   * Builds an account ID from its hex string representation.
+   */
   static fromHex(hex: string): AccountId;
+  /**
+   * Returns true if the ID refers to a faucet.
+   */
   isFaucet(): boolean;
-  isRegularAccount(): boolean;
+  /**
+   * Returns true if the account uses public storage.
+   */
   isPublic(): boolean;
-  isPrivate(): boolean;
-  isNetwork(): boolean;
-  toString(): string;
   /**
-   * Will turn the Account ID into its bech32 string representation. To avoid a potential
-   * wrongful encoding, this function will expect only IDs for either mainnet ("mm"),
-   * testnet ("mtst") or devnet ("mdev"). To use a custom bech32 prefix, see
-   * `Self::to_bech_32_custom`.
+   * Will turn the Account ID into its bech32 string representation.
    */
   toBech32(network_id: NetworkId, account_interface: AccountInterface): string;
   /**
-   * Turn this Account ID into its bech32 string representation. This method accepts a custom
-   * network ID.
+   * Returns the canonical hex representation of the account ID.
    */
-  toBech32Custom(custom_network_id: string, account_interface: AccountInterface): string;
-  prefix(): Felt;
-  suffix(): Felt;
+  toString(): string;
 }
 export class AccountIdArray {
 /**
@@ -217,65 +517,163 @@ export class AccountIdArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: AccountId[] | null);
+  replaceAt(index: number, elem: AccountId): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): AccountId;
-  replaceAt(index: number, elem: AccountId): void;
+  constructor(elements?: AccountId[] | null);
   push(element: AccountId): void;
   length(): number;
 }
+/**
+ * Account storage is composed of a variable number of index-addressable storage slots up to 255
+ * slots in total.
+ *
+ * Each slot has a type which defines its size and structure. Currently, the following types are
+ * supported:
+ * - `StorageSlot::Value`: contains a single Word of data (i.e., 32 bytes).
+ * - `StorageSlot::Map`: contains a `StorageMap` which is a key-value map where both keys and
+ *   values are Words. The value of a storage slot containing a map is the commitment to the
+ *   underlying map.
+ */
 export class AccountStorage {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the commitment to the full account storage.
+   */
   commitment(): Word;
-  getItem(index: number): Word | undefined;
-  getMapItem(index: number, key: Word): Word | undefined;
   /**
-   * Get all key-value pairs from the map slot at `index`.
-   * Returns `undefined` if the slot isn't a map or `index` is out of bounds (0-255).
+   * Returns the value for a key in the map stored at the given slot, if any.
+   */
+  getMapItem(slot_name: string, key: Word): Word | undefined;
+  /**
+   * Returns the names of all storage slots on this account.
+   */
+  getSlotNames(): string[];
+  /**
+   * Get all key-value pairs from the map slot identified by `slot_name`.
+   * Returns `undefined` if the slot isn't a map or doesn't exist.
    * Returns `[]` if the map exists but is empty.
    */
-  getMapEntries(index: number): JsStorageMapEntry[] | undefined;
+  getMapEntries(slot_name: string): JsStorageMapEntry[] | undefined;
+  /**
+   * Returns the value stored at the given slot name, if any.
+   */
+  getItem(slot_name: string): Word | undefined;
 }
+/**
+ * `AccountStorageDelta` stores the differences between two states of account storage.
+ *
+ * The delta consists of two maps:
+ * - A map containing the updates to value storage slots. The keys in this map are indexes of the
+ *   updated storage slots and the values are the new values for these slots.
+ * - A map containing updates to storage maps. The keys in this map are indexes of the updated
+ *   storage slots and the values are corresponding storage map delta objects.
+ */
 export class AccountStorageDelta {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes a storage delta from bytes.
+   */
   static deserialize(bytes: Uint8Array): AccountStorageDelta;
-  isEmpty(): boolean;
+  /**
+   * Returns the new values for modified storage slots.
+   */
   values(): Word[];
+  /**
+   * Returns true if no storage slots are changed.
+   */
+  isEmpty(): boolean;
+  /**
+   * Serializes the storage delta into bytes.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * Storage visibility mode for an account.
+ */
 export class AccountStorageMode {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static private(): AccountStorageMode;
-  static public(): AccountStorageMode;
-  static network(): AccountStorageMode;
+  /**
+   * Parses a storage mode from its string representation.
+   */
   static tryFromStr(s: string): AccountStorageMode;
+  /**
+   * Returns the storage mode as a string.
+   */
   asStr(): string;
+  /**
+   * Creates a public storage mode.
+   */
+  static public(): AccountStorageMode;
+  /**
+   * Creates a network storage mode.
+   */
+  static network(): AccountStorageMode;
+  /**
+   * Creates a private storage mode.
+   */
+  static private(): AccountStorageMode;
 }
 export class AccountStorageRequirements {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
+  /**
+   * Builds storage requirements from a list of slot/key pairs.
+   */
   static fromSlotAndKeysArray(slots_and_keys: SlotAndKeys[]): AccountStorageRequirements;
+  /**
+   * Creates empty storage requirements.
+   */
+  constructor();
 }
+/**
+ * `AccountVaultDelta` stores the difference between the initial and final account vault states.
+ *
+ * The difference is represented as follows:
+ * - `fungible`: a binary tree map of fungible asset balance changes in the account vault.
+ * - `non_fungible`: a binary tree map of non-fungible assets that were added to or removed from
+ *   the account vault.
+ */
 export class AccountVaultDelta {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes a vault delta from bytes.
+   */
   static deserialize(bytes: Uint8Array): AccountVaultDelta;
-  isEmpty(): boolean;
-  fungible(): FungibleAssetDelta;
+  /**
+   * Returns the fungible assets that increased.
+   */
   addedFungibleAssets(): FungibleAsset[];
+  /**
+   * Returns the fungible assets that decreased.
+   */
   removedFungibleAssets(): FungibleAsset[];
+  /**
+   * Returns the fungible portion of the delta.
+   */
+  fungible(): FungibleAssetDelta;
+  /**
+   * Returns true if no assets are changed.
+   */
+  isEmpty(): boolean;
+  /**
+   * Serializes the vault delta into bytes.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * Representation of a Miden address (account ID plus routing parameters).
+ */
 export class Address {
   private constructor();
 /**
@@ -288,82 +686,341 @@ export class Address {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  static fromAccountId(account_id: AccountId, _interface?: string | null): Address;
-  static fromBech32(bech32: string): Address;
-  interface(): AddressInterface;
+  /**
+   * Returns the account ID embedded in the address.
+   */
   accountId(): AccountId;
+  /**
+   * Deserializes a byte array into an `Address`.
+   */
+  static deserialize(bytes: Uint8Array): Address;
+  /**
+   * Builds an address from a bech32-encoded string.
+   */
+  static fromBech32(bech32: string): Address;
+  /**
+   * Converts the address into a note tag.
+   */
   toNoteTag(): NoteTag;
+  /**
+   * Builds an address from an account ID and optional interface.
+   */
+  static fromAccountId(account_id: AccountId, _interface?: string | null): Address;
+  /**
+   * Returns the address interface.
+   */
+  interface(): AddressInterface;
+  /**
+   * Encodes the address using the provided network prefix.
+   */
   toBech32(network_id: NetworkId): string;
 }
+/**
+ * Advice inputs provided to a transaction or note script.
+ */
 export class AdviceInputs {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  stack(): Felt[];
+  /**
+   * Returns mapped values for a given key if present.
+   */
   mappedValues(key: Word): Felt[] | undefined;
+  /**
+   * Returns the stack inputs as a vector of felts.
+   */
+  stack(): Felt[];
 }
+/**
+ * Map of advice values keyed by words for script execution.
+ */
 export class AdviceMap {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates an empty advice map.
+   */
   constructor();
+  /**
+   * Inserts a value for the given key, returning any previous value.
+   */
   insert(key: Word, value: FeltArray): Felt[] | undefined;
 }
+/**
+ * A container for an unlimited number of assets.
+ *
+ * An asset vault can contain an unlimited number of assets. The assets are stored in a Sparse
+ * Merkle tree as follows:
+ * - For fungible assets, the index of a node is defined by the issuing faucet ID, and the value of
+ *   the node is the asset itself. Thus, for any fungible asset there will be only one node in the
+ *   tree.
+ * - For non-fungible assets, the index is defined by the asset itself, and the asset is also the
+ *   value of the node.
+ *
+ * An asset vault can be reduced to a single hash which is the root of the Sparse Merkle Tree.
+ */
 export class AssetVault {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  root(): Word;
+  /**
+   * Returns the balance for the given fungible faucet, or zero if absent.
+   */
   getBalance(faucet_id: AccountId): bigint;
+  /**
+   * Returns the fungible assets contained in this vault.
+   */
   fungibleAssets(): FungibleAsset[];
+  /**
+   * Returns the root commitment of the asset vault tree.
+   */
+  root(): Word;
+}
+/**
+ * Multisig auth configuration for `RpoFalcon512` signatures.
+ */
+export class AuthFalcon512RpoMultisigConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Per-procedure thresholds.
+   */
+  getProcThresholds(): ProcedureThreshold[];
+  /**
+   * Attach per-procedure thresholds. Each threshold must be >= 1 and <= `approvers.length`.
+   */
+  withProcThresholds(proc_thresholds: ProcedureThreshold[]): AuthFalcon512RpoMultisigConfig;
+  /**
+   * Build a configuration with a list of approver public key commitments and a default
+   * threshold.
+   *
+   * `default_threshold` must be >= 1 and <= `approvers.length`.
+   */
+  constructor(approvers: Word[], default_threshold: number);
+  readonly defaultThreshold: number;
+  /**
+   * Approver public key commitments as Words.
+   */
+  readonly approvers: Word[];
 }
 export class AuthSecretKey {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  getRpoFalcon512PublicKeyAsWord(): Word;
+  publicKey(): PublicKey;
+  static deserialize(bytes: Uint8Array): AuthSecretKey;
+  static ecdsaWithRNG(seed?: Uint8Array | null): AuthSecretKey;
+  static rpoFalconWithRNG(seed?: Uint8Array | null): AuthSecretKey;
+  getPublicKeyAsWord(): Word;
   getRpoFalcon512SecretKeyAsFelts(): Felt[];
-  getEcdsaK256KeccakPublicKeyAsWord(): Word;
+  /**
+   * Returns the ECDSA k256 Keccak secret key bytes encoded as felts.
+   */
   getEcdsaK256KeccakSecretKeyAsFelts(): Felt[];
+  sign(message: Word): Signature;
+  serialize(): Uint8Array;
+  signData(signing_inputs: SigningInputs): Signature;
 }
+/**
+ * Provides metadata for a basic fungible faucet account component.
+ */
 export class BasicFungibleFaucetComponent {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the maximum token supply.
+   */
+  maxSupply(): Felt;
+  /**
+   * Extracts faucet metadata from an account.
+   */
   static fromAccount(account: Account): BasicFungibleFaucetComponent;
+  /**
+   * Returns the faucet's token symbol.
+   */
   symbol(): TokenSymbol;
+  /**
+   * Returns the number of decimal places for the token.
+   */
   decimals(): number;
-  maxSupply(): Felt;
 }
+/**
+ * Public header for a block, containing commitments to the chain state and the proof attesting to
+ * the block's validity.
+ *
+ * Key fields include the previous block commitment, block number, chain/nullifier/note roots,
+ * transaction commitments (including the kernel), proof commitment, and a timestamp. Two derived
+ * values are exposed:
+ * - `sub_commitment`: sequential hash of all fields except the `note_root`.
+ * - `commitment`: a 2-to-1 hash of the `sub_commitment` and the `note_root`.
+ */
 export class BlockHeader {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  version(): number;
+  /**
+   * Returns the commitment to the block contents.
+   */
   commitment(): Word;
+  /**
+   * Returns the account root commitment.
+   */
+  accountRoot(): Word;
+  /**
+   * Returns the transaction commitment.
+   */
+  txCommitment(): Word;
+  /**
+   * Returns the nullifier root commitment.
+   */
+  nullifierRoot(): Word;
+  /**
+   * Returns the commitment to block metadata.
+   */
   subCommitment(): Word;
+  /**
+   * Returns the chain commitment.
+   */
+  chainCommitment(): Word;
+  /**
+   * Returns the proof commitment.
+   */
+  proofCommitment(): Word;
+  /**
+   * Returns the transaction kernel commitment.
+   */
+  txKernelCommitment(): Word;
+  /**
+   * Returns the commitment of the previous block.
+   */
   prevBlockCommitment(): Word;
+  /**
+   * Returns the header version.
+   */
+  version(): number;
+  /**
+   * Returns the block height.
+   */
   blockNum(): number;
-  chainCommitment(): Word;
-  accountRoot(): Word;
-  nullifierRoot(): Word;
+  /**
+   * Returns the note commitment root.
+   */
   noteRoot(): Word;
-  txCommitment(): Word;
-  txKernelCommitment(): Word;
-  proofCommitment(): Word;
+  /**
+   * Returns the block timestamp.
+   */
   timestamp(): number;
 }
+/**
+ * Utility for linking libraries and compiling transaction/note scripts.
+ */
+export class CodeBuilder {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Given a module path (something like `my_lib::module`) and source code, this will
+   * statically link it for use with scripts to be built with this builder.
+   */
+  linkModule(module_path: string, module_code: string): void;
+  /**
+   * Given a Library Path, and a source code, turn it into a Library.
+   * E.g. A path library can be `miden::my_contract`. When turned into a library,
+   * this can be used from another script with an import statement, following the
+   * previous example: `use miden::my_contract'.
+   */
+  buildLibrary(library_path: string, source_code: string): Library;
+  /**
+   * Given a Transaction Script's source code, compiles it with the available
+   * modules under this builder. Returns the compiled script.
+   */
+  compileTxScript(tx_script: string): TransactionScript;
+  /**
+   * Given a Note Script's source code, compiles it with the available
+   * modules under this builder. Returns the compiled script.
+   */
+  compileNoteScript(program: string): NoteScript;
+  /**
+   * Statically links the given library.
+   *
+   * Static linking means the library code is copied into the script code.
+   * Use this for most libraries that are not available on-chain.
+   *
+   * Receives as argument the library to link.
+   */
+  linkStaticLibrary(library: Library): void;
+  /**
+   * This is useful to dynamically link the {@link Library} of a foreign account
+   * that is invoked using foreign procedure invocation (FPI). Its code is available
+   * on-chain and so it does not have to be copied into the script code.
+   *
+   * For all other use cases not involving FPI, link the library statically.
+   * Receives as argument the library to be linked.
+   */
+  linkDynamicLibrary(library: Library): void;
+  /**
+   * Given an `AccountComponentCode`, compiles it
+   * with the available modules under this builder. Returns the compiled account component code.
+   */
+  compileAccountComponentCode(account_code: string): AccountComponentCode;
+}
+/**
+ * Represents a note committed on chain, as returned by `syncNotes`.
+ */
+export class CommittedNote {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the note index in the block's note tree.
+   */
+  noteIndex(): number;
+  /**
+   * Returns the inclusion path for the note.
+   */
+  inclusionPath(): SparseMerklePath;
+  /**
+   * Returns the note ID.
+   */
+  noteId(): NoteId;
+  /**
+   * Returns the note metadata.
+   */
+  metadata(): NoteMetadata;
+}
+/**
+ * Input note record annotated with consumption conditions.
+ */
 export class ConsumableNoteRecord {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(input_note_record: InputNoteRecord, note_consumability: NoteConsumability[]);
+  /**
+   * Returns the underlying input note record.
+   */
   inputNoteRecord(): InputNoteRecord;
+  /**
+   * Returns the consumability entries.
+   */
   noteConsumability(): NoteConsumability[];
+  /**
+   * Creates a new consumable note record from an input note record and consumability metadata.
+   */
+  constructor(input_note_record: InputNoteRecord, note_consumability: NoteConsumability[]);
 }
 /**
- * Represents a network endpoint for connecting to Miden nodes.
+ * The `Endpoint` struct represents a network endpoint, consisting of a protocol, a host, and a
+ * port.
  *
- * An endpoint consists of a protocol (http/https), host, and optional port.
- * Provides convenient constructors for common network configurations.
+ * This struct is used to define the address of a Miden node that the client will connect to.
  */
 export class Endpoint {
   free(): void;
@@ -375,14 +1032,14 @@ export class Endpoint {
    * @throws throws an error if the URL is invalid
    */
   constructor(url: string);
-  /**
-   * Returns the endpoint for the Miden testnet.
-   */
-  static testnet(): Endpoint;
   /**
    * Returns the endpoint for the Miden devnet.
    */
   static devnet(): Endpoint;
+  /**
+   * Returns the endpoint for the Miden testnet.
+   */
+  static testnet(): Endpoint;
   /**
    * Returns the endpoint for a local Miden node.
    *
@@ -393,10 +1050,6 @@ export class Endpoint {
    * Returns the string representation of the endpoint.
    */
   toString(): string;
-  /**
-   * Returns the protocol of the endpoint.
-   */
-  readonly protocol: string;
   /**
    * Returns the host of the endpoint.
    */
@@ -405,26 +1058,81 @@ export class Endpoint {
    * Returns the port of the endpoint.
    */
   readonly port: number | undefined;
+  /**
+   * Returns the protocol of the endpoint.
+   */
+  readonly protocol: string;
 }
+/**
+ * Describes the result of executing a transaction program for the Miden protocol.
+ *
+ * Executed transaction serves two primary purposes:
+ * - It contains a complete description of the effects of the transaction. Specifically, it
+ *   contains all output notes created as the result of the transaction and describes all the
+ *   changes made to the involved account (i.e., the account delta).
+ * - It contains all the information required to re-execute and prove the transaction in a
+ *   stateless manner. This includes all public transaction inputs, but also all nondeterministic
+ *   inputs that the host provided to Miden VM while executing the transaction (i.e., advice
+ *   witness).
+ */
 export class ExecutedTransaction {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  id(): TransactionId;
+  /**
+   * Returns the account the transaction was executed against.
+   */
   accountId(): AccountId;
-  initialAccountHeader(): AccountHeader;
-  finalAccountHeader(): AccountHeader;
+  /**
+   * Returns the input notes consumed by the transaction.
+   */
   inputNotes(): InputNotes;
-  outputNotes(): OutputNotes;
-  txArgs(): TransactionArgs;
+  /**
+   * Returns the block header that included the transaction.
+   */
   blockHeader(): BlockHeader;
+  /**
+   * Returns the output notes produced by the transaction.
+   */
+  outputNotes(): OutputNotes;
+  /**
+   * Returns the account delta resulting from execution.
+   */
   accountDelta(): AccountDelta;
+  /**
+   * Returns the final account header after execution.
+   */
+  finalAccountHeader(): AccountHeader;
+  /**
+   * Returns the initial account header before execution.
+   */
+  initialAccountHeader(): AccountHeader;
+  /**
+   * Returns the transaction ID.
+   */
+  id(): TransactionId;
+  /**
+   * Returns the arguments passed to the transaction script.
+   */
+  txArgs(): TransactionArgs;
 }
+/**
+ * Field element wrapper exposed to JavaScript.
+ */
 export class Felt {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new field element from a u64 value.
+   */
   constructor(value: bigint);
+  /**
+   * Returns the integer representation of the field element.
+   */
   asInt(): bigint;
+  /**
+   * Returns the string representation of the field element.
+   */
   toString(): string;
 }
 export class FeltArray {
@@ -438,25 +1146,88 @@ export class FeltArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: Felt[] | null);
+  replaceAt(index: number, elem: Felt): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): Felt;
-  replaceAt(index: number, elem: Felt): void;
+  constructor(elements?: Felt[] | null);
   push(element: Felt): void;
   length(): number;
 }
 /**
- * Represents a note fetched from a Miden node via RPC.
+ * Account details returned by the node.
+ */
+export class FetchedAccount {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the account ID.
+   */
+  accountId(): AccountId;
+  /**
+   * 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.
+   */
+  isPrivate(): boolean;
+  /**
+   * Returns the last block height where the account was updated.
+   */
+  lastBlockNum(): number;
+  /**
+   * Returns the full account data when the account is public.
+   */
+  account(): Account | undefined;
+  /**
+   * Returns true when the account is public.
+   */
+  isPublic(): boolean;
+}
+/**
+ * Wrapper for a note fetched over RPC.
+ *
+ * It contains the note header and inclusion proof. The note details are only present for
+ * public notes.
  */
 export class FetchedNote {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Create a note with an optional `InputNote`.
+   * Returns an [`InputNote`] when the fetched note is public.
+   *
+   * Returns `undefined` when the note body is missing (e.g. private notes); in that case build
+   * an `InputNote` manually using the inclusion proof and note data obtained elsewhere.
    */
-  constructor(note_id: NoteId, metadata: NoteMetadata, input_note?: InputNote | null);
+  asInputNote(): InputNote | undefined;
+  /**
+   * Create a `FetchedNote` with an optional [`Note`].
+   */
+  constructor(note_id: NoteId, metadata: NoteMetadata, inclusion_proof: NoteInclusionProof, note?: Note | null);
+  /**
+   * The note's inclusion proof.
+   *
+   * Contains the data required to prove inclusion of the note in the canonical chain.
+   */
+  readonly inclusionProof: NoteInclusionProof;
+  /**
+   * The full [`Note`] data.
+   *
+   * For public notes, it contains the complete note data.
+   * For private notes, it will be undefined.
+   */
+  readonly note: Note | undefined;
+  /**
+   * The note's header, containing the ID and metadata.
+   */
+  readonly header: NoteHeader;
   /**
    * The unique identifier of the note.
    */
@@ -467,29 +1238,37 @@ export class FetchedNote {
    */
   readonly metadata: NoteMetadata;
   /**
-   * The full [`InputNote`] with inclusion proof.
-   *
-   * For public notes, it contains the complete note data and inclusion proof.
-   * For private notes, it will be ``None`.
+   * Returns whether the note is private, encrypted, or public.
    */
-  readonly inputNote: InputNote | undefined;
   readonly noteType: NoteType;
 }
 export class FlattenedU8Vec {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  num_inner_vecs(): number;
   data(): Uint8Array;
   lengths(): Uint32Array;
-  num_inner_vecs(): number;
 }
+/**
+ * Description of a foreign account referenced by a transaction.
+ */
 export class ForeignAccount {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static public(account_id: AccountId, storage_requirements: AccountStorageRequirements): ForeignAccount;
-  storage_slot_requirements(): AccountStorageRequirements;
+  /**
+   * Returns the ID of the foreign account.
+   */
   account_id(): AccountId;
+  /**
+   * Returns the required storage slots/keys for this foreign account.
+   */
+  storage_slot_requirements(): AccountStorageRequirements;
+  /**
+   * Creates a foreign account entry for a public account with given storage requirements.
+   */
+  static public(account_id: AccountId, storage_requirements: AccountStorageRequirements): ForeignAccount;
 }
 export class ForeignAccountArray {
 /**
@@ -502,102 +1281,262 @@ export class ForeignAccountArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: ForeignAccount[] | null);
+  replaceAt(index: number, elem: ForeignAccount): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): ForeignAccount;
-  replaceAt(index: number, elem: ForeignAccount): void;
+  constructor(elements?: ForeignAccount[] | null);
   push(element: ForeignAccount): void;
   length(): number;
 }
+/**
+ * A fungible asset.
+ *
+ * A fungible asset consists of a faucet ID of the faucet which issued the asset as well as the
+ * asset amount. Asset amount is guaranteed to be 2^63 - 1 or smaller.
+ */
 export class FungibleAsset {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a fungible asset for the given faucet and amount.
+   */
   constructor(faucet_id: AccountId, amount: bigint);
-  faucetId(): AccountId;
+  /**
+   * Returns the amount of fungible units.
+   */
   amount(): bigint;
+  /**
+   * Returns the faucet account that minted this asset.
+   */
+  faucetId(): AccountId;
+  /**
+   * Encodes this asset into the word layout used in the vault.
+   */
   intoWord(): Word;
 }
+/**
+ * Aggregated fungible deltas keyed by faucet ID.
+ */
 export class FungibleAssetDelta {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Returns the number of distinct fungible assets in the delta.
+   */
+  numAssets(): number;
+  /**
+   * Deserializes a fungible delta from bytes.
+   */
   static deserialize(bytes: Uint8Array): FungibleAssetDelta;
-  isEmpty(): boolean;
+  /**
+   * Returns the delta amount for a given faucet, if present.
+   */
   amount(faucet_id: AccountId): bigint | undefined;
-  numAssets(): number;
+  /**
+   * Returns all fungible asset deltas as a list.
+   */
   assets(): FungibleAssetDeltaItem[];
+  /**
+   * Returns true if no fungible assets are affected.
+   */
+  isEmpty(): boolean;
+  /**
+   * Serializes the fungible delta into bytes.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * A single fungible asset change in the vault delta.
+ */
 export class FungibleAssetDeltaItem {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  readonly faucetId: AccountId;
+  /**
+   * Returns the signed amount change (positive adds assets, negative removes).
+   */
   readonly amount: bigint;
+  /**
+   * Returns the faucet ID this delta refers to.
+   */
+  readonly faucetId: AccountId;
 }
+/**
+ * Procedure digest paired with whether it is an auth procedure.
+ */
 export class GetProceduresResultItem {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the MAST root digest for the procedure.
+   */
   readonly digest: Word;
+  /**
+   * Returns true if the procedure is used for authentication.
+   */
   readonly isAuth: boolean;
 }
+/**
+ * Note supplied as an input to a transaction, optionally with authentication data.
+ */
 export class InputNote {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the commitment to the note ID and metadata.
+   */
+  commitment(): Word;
+  /**
+   * Creates an authenticated input note from a note and its inclusion proof.
+   *
+   * An authenticated note has a proof of inclusion in the block's note tree,
+   * which is required for consuming the note in a transaction.
+   */
+  static authenticated(note: Note, inclusion_proof: NoteInclusionProof): InputNote;
+  /**
+   * Creates an unauthenticated input note from note details.
+   *
+   * An unauthenticated note can be consumed in a transaction as long as the note exists in the
+   * network as of the transaction batch in which the consume transaction is included.
+   */
+  static unauthenticated(note: Note): InputNote;
+  /**
+   * Returns the identifier of the input note.
+   */
   id(): NoteId;
+  /**
+   * Returns the underlying note contents.
+   */
   note(): Note;
-  commitment(): Word;
+  /**
+   * Returns the inclusion proof if the note is authenticated.
+   */
   proof(): NoteInclusionProof | undefined;
+  /**
+   * Returns the note's location within the commitment tree when available.
+   */
   location(): NoteLocation | undefined;
 }
+/**
+ * Represents a Note of which the Store can keep track and retrieve.
+ *
+ * An `InputNoteRecord` contains all the information of a `NoteDetails`, in addition to specific
+ * information about the note state.
+ *
+ * Once a proof is received, the `InputNoteRecord` can be transformed into an `InputNote` and used
+ * as input for transactions. It is also possible to convert `Note` and `InputNote` into
+ * `InputNoteRecord` (we fill the `metadata` and `inclusion_proof` fields if possible).
+ *
+ * Notes can also be consumed as unauthenticated notes, where their existence is verified by the
+ * network.
+ */
 export class InputNoteRecord {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the note commitment (id + metadata), if available.
+   */
+  commitment(): Word | undefined;
+  /**
+   * Returns true if the note has already been consumed.
+   */
+  isConsumed(): boolean;
+  /**
+   * Returns true if the note is currently being processed.
+   */
+  isProcessing(): boolean;
+  /**
+   * Converts the record into an `InputNote` (including proof when available).
+   */
+  toInputNote(): InputNote;
+  /**
+   * Returns the inclusion proof when the note is authenticated.
+   */
+  inclusionProof(): NoteInclusionProof | undefined;
+  /**
+   * Returns true if the record contains authentication data (proof).
+   */
+  isAuthenticated(): boolean;
+  /**
+   * Returns the transaction ID that consumed this note, if any.
+   */
+  consumerTransactionId(): string | undefined;
+  /**
+   * Returns the note ID.
+   */
   id(): NoteId;
+  /**
+   * Returns the current processing state for this note.
+   */
   state(): InputNoteState;
+  /**
+   * Returns the note details, if present.
+   */
   details(): NoteDetails;
+  /**
+   * Converts the record into a `Note` (including proof when available).
+   */
+  toNote(): Note;
+  /**
+   * Returns the note metadata if available.
+   */
   metadata(): NoteMetadata | undefined;
-  commitment(): Word | undefined;
-  inclusionProof(): NoteInclusionProof | undefined;
-  consumerTransactionId(): string | undefined;
+  /**
+   * Returns the nullifier for this note.
+   */
   nullifier(): string;
-  isAuthenticated(): boolean;
-  isConsumed(): boolean;
-  isProcessing(): boolean;
-  toInputNote(): InputNote;
 }
+/**
+ * Input notes for a transaction, empty if the transaction does not consume notes.
+ */
 export class InputNotes {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the commitment to all input notes.
+   */
   commitment(): Word;
-  numNotes(): number;
-  isEmpty(): boolean;
-  getNote(index: number): InputNote;
+  /**
+   * Returns all input notes as a vector.
+   */
   notes(): InputNote[];
+  /**
+   * Returns the input note at the specified index.
+   */
+  getNote(index: number): InputNote;
+  /**
+   * Returns true if there are no input notes.
+   */
+  isEmpty(): boolean;
+  /**
+   * Returns the number of input notes.
+   */
+  numNotes(): number;
 }
 export class IntoUnderlyingByteSource {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  start(controller: ReadableByteStreamController): void;
   pull(controller: ReadableByteStreamController): Promise<any>;
+  start(controller: ReadableByteStreamController): void;
   cancel(): void;
-  readonly type: ReadableStreamType;
   readonly autoAllocateChunkSize: number;
+  readonly type: ReadableStreamType;
 }
 export class IntoUnderlyingSink {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  write(chunk: any): Promise<any>;
-  close(): Promise<any>;
   abort(reason: any): Promise<any>;
+  close(): Promise<any>;
+  write(chunk: any): Promise<any>;
 }
 export class IntoUnderlyingSource {
   private constructor();
@@ -680,10 +1619,9 @@ export class JsStateSyncUpdate {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * The block number for this update, stored as a string since it will be
-   * persisted in `IndexedDB`.
+   * The block number for this update.
    */
-  blockNum: string;
+  blockNum: number;
   /**
    * The new block headers for this state update, serialized into a flattened byte array.
    */
@@ -693,7 +1631,7 @@ export class JsStateSyncUpdate {
    * 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: string[];
+  newBlockNums: Uint32Array;
   /**
    * Flattened byte array containing partial blockchain peaks used for merkle tree
    * verification.
@@ -782,9 +1720,9 @@ export class JsStorageSlot {
    */
   commitment: string;
   /**
-   * The index of the storage slot.
+   * The name of the storage slot.
    */
-  slotIndex: number;
+  slotName: string;
   /**
    * The value stored in the storage slot.
    */
@@ -831,33 +1769,112 @@ export class Library {
   free(): void;
   [Symbol.dispose](): void;
 }
+/**
+ * Represents a Merkle path.
+ */
 export class MerklePath {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Computes the root given a leaf index and value.
+   */
+  computeRoot(index: bigint, node: Word): Word;
+  /**
+   * Returns the depth of the path.
+   */
   depth(): number;
+  /**
+   * Returns the nodes that make up the path.
+   */
   nodes(): Word[];
-  computeRoot(index: bigint, node: Word): Word;
+  /**
+   * Verifies the path against a root.
+   */
   verify(index: bigint, node: Word, root: Word): boolean;
 }
+/**
+ * The identifier of a Miden network.
+ */
+export class NetworkId {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Builds a custom network ID from a provided custom prefix.
+   *
+   * Returns an error if the prefix is invalid.
+   */
+  static custom(custom_prefix: string): NetworkId;
+  static devnet(): NetworkId;
+  static mainnet(): NetworkId;
+  static testnet(): NetworkId;
+}
+/**
+ * A note bundles public metadata with private details: assets, script, inputs, and a serial number
+ * grouped into a recipient. The public identifier (`NoteId`) commits to those
+ * details, while the nullifier stays hidden until the note is consumed. Assets move by
+ * transferring them into the note; the script and inputs define how and when consumption can
+ * happen. See `NoteRecipient` for the shape of the recipient data.
+ */
 export class Note {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(note_assets: NoteAssets, note_metadata: NoteMetadata, note_recipient: NoteRecipient);
-  serialize(): Uint8Array;
+  /**
+   * Returns the commitment to the note ID and metadata.
+   */
+  commitment(): Word;
+  /**
+   * Deserializes a note from its byte representation.
+   */
   static deserialize(bytes: Uint8Array): Note;
+  /**
+   * Builds a standard P2ID note that targets the specified account.
+   */
+  static createP2IDNote(sender: AccountId, target: AccountId, assets: NoteAssets, note_type: NoteType, attachment: NoteAttachment): Note;
+  /**
+   * Builds a P2IDE note that can be reclaimed or timelocked based on block heights.
+   */
+  static createP2IDENote(sender: AccountId, target: AccountId, assets: NoteAssets, reclaim_height: number | null | undefined, timelock_height: number | null | undefined, note_type: NoteType, attachment: NoteAttachment): Note;
+  /**
+   * Returns the unique identifier of the note.
+   */
   id(): NoteId;
-  commitment(): Word;
-  metadata(): NoteMetadata;
-  recipient(): NoteRecipient;
+  /**
+   * Creates a new note from the provided assets, metadata, and recipient.
+   */
+  constructor(note_assets: NoteAssets, note_metadata: NoteMetadata, note_recipient: NoteRecipient);
+  /**
+   * Returns the assets locked inside the note.
+   */
   assets(): NoteAssets;
+  /**
+   * Returns the script that guards the note.
+   */
   script(): NoteScript;
-  static createP2IDNote(sender: AccountId, target: AccountId, assets: NoteAssets, note_type: NoteType, aux: Felt): Note;
-  static createP2IDENote(sender: AccountId, target: AccountId, assets: NoteAssets, reclaim_height: number | null | undefined, timelock_height: number | null | undefined, note_type: NoteType, aux: Felt): Note;
+  /**
+   * Returns the public metadata associated with the note.
+   */
+  metadata(): NoteMetadata;
+  /**
+   * Returns the note nullifier as a word.
+   */
+  nullifier(): Word;
+  /**
+   * Returns the recipient who can consume this note.
+   */
+  recipient(): NoteRecipient;
+  /**
+   * Serializes the note into bytes.
+   */
+  serialize(): Uint8Array;
 }
 export class NoteAndArgs {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new note/args pair for transaction building.
+   */
   constructor(note: Note, args?: Word | null);
 }
 export class NoteAndArgsArray {
@@ -871,42 +1888,214 @@ export class NoteAndArgsArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: NoteAndArgs[] | null);
+  replaceAt(index: number, elem: NoteAndArgs): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): NoteAndArgs;
-  replaceAt(index: number, elem: NoteAndArgs): void;
+  constructor(elements?: NoteAndArgs[] | null);
   push(element: NoteAndArgs): void;
   length(): number;
 }
+/**
+ * An asset container for a note.
+ *
+ * A note must contain at least 1 asset and can contain up to 256 assets. No duplicates are
+ * allowed, but the order of assets is unspecified.
+ *
+ * All the assets in a note can be reduced to a single commitment which is computed by sequentially
+ * hashing the assets. Note that the same list of assets can result in two different commitments if
+ * the asset ordering is different.
+ */
 export class NoteAssets {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns all fungible assets contained in the note.
+   */
+  fungibleAssets(): FungibleAsset[];
+  /**
+   * Creates a new asset list for a note.
+   */
   constructor(assets_array?: FungibleAsset[] | null);
+  /**
+   * Adds a fungible asset to the collection.
+   */
   push(asset: FungibleAsset): void;
-  fungibleAssets(): FungibleAsset[];
+}
+/**
+ * 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.
+ */
+export class NoteAttachment {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the attachment kind.
+   */
+  attachmentKind(): NoteAttachmentKind;
+  /**
+   * Returns the attachment scheme.
+   */
+  attachmentScheme(): NoteAttachmentScheme;
+  /**
+   * 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.
+   *
+   * # 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
+   *
+   * # Errors
+   * Returns an error if the target account is not a network account.
+   */
+  static newNetworkAccountTarget(target_id: AccountId, exec_hint: NoteExecutionHint): NoteAttachment;
+  /**
+   * Creates a default (empty) note attachment.
+   */
+  constructor();
+  /**
+   * Returns the content as a Word if the attachment kind is Word, otherwise None.
+   */
+  asWord(): Word | undefined;
+  /**
+   * Returns the content as an array of Felts if the attachment kind is Array, otherwise None.
+   */
+  asArray(): FeltArray | undefined;
+  /**
+   * Creates a new note attachment with Word content from the provided word.
+   */
+  static newWord(scheme: NoteAttachmentScheme, word: Word): NoteAttachment;
+  /**
+   * Creates a new note attachment with Array content from the provided elements.
+   */
+  static newArray(scheme: NoteAttachmentScheme, elements: FeltArray): NoteAttachment;
+}
+/**
+ * Describes the type of a note attachment.
+ *
+ * Value `0` is reserved to signal that the scheme is none or absent. Whenever the kind of
+ * attachment is not standardized or interoperability is unimportant, this none value can be used.
+ */
+export class NoteAttachmentScheme {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Creates a new `NoteAttachmentScheme` from a u32.
+   */
+  constructor(scheme: number);
+  /**
+   * Returns the `NoteAttachmentScheme` that signals the absence of an attachment scheme.
+   */
+  static none(): NoteAttachmentScheme;
+  /**
+   * 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;
 }
 export class NoteConsumability {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the account that can consume the note.
+   */
   accountId(): AccountId;
+  /**
+   * Returns the consumption status of the note.
+   */
+  consumptionStatus(): NoteConsumptionStatus;
+}
+/**
+ * Describes if a note could be consumed under a specific conditions: target account state and
+ * block height.
+ */
+export class NoteConsumptionStatus {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Constructs a `NoteConsumptionStatus` that is consumable.
+   */
+  static consumable(): NoteConsumptionStatus;
+  /**
+   * Constructs a `NoteConsumptionStatus` that is consumable after a specific block height.
+   */
+  static consumableAfter(block_height: number): NoteConsumptionStatus;
+  /**
+   * Constructs a `NoteConsumptionStatus` that is never consumable.
+   */
+  static neverConsumable(err: string): NoteConsumptionStatus;
+  /**
+   * Returns the block number at which the note can be consumed.
+   * Returns None if the note is already consumable or never possible
+   */
   consumableAfterBlock(): number | undefined;
+  /**
+   * Constructs a `NoteConsumptionStatus` that is unconsumable due to conditions.
+   */
+  static unconsumableConditions(): NoteConsumptionStatus;
+  /**
+   * Constructs a `NoteConsumptionStatus` that is consumable with authorization.
+   */
+  static consumableWithAuthorization(): NoteConsumptionStatus;
 }
+/**
+ * Details of a note consisting of assets, script, inputs, and a serial number.
+ *
+ * See the {@link Note} type for more details.
+ */
 export class NoteDetails {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(note_assets: NoteAssets, note_recipient: NoteRecipient);
+  /**
+   * 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 assets locked by the note.
+   */
   assets(): NoteAssets;
+  /**
+   * Returns the note nullifier as a word.
+   */
+  nullifier(): Word;
+  /**
+   * Returns the recipient which controls when the note can be consumed.
+   */
   recipient(): NoteRecipient;
 }
+/**
+ * Pair of note details and tag used when declaring expected notes.
+ */
 export class NoteDetailsAndTag {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new pair from note details and tag.
+   */
   constructor(note_details: NoteDetails, tag: NoteTag);
+  /**
+   * Returns the note details.
+   */
   readonly noteDetails: NoteDetails;
+  /**
+   * Returns the note tag.
+   */
   readonly tag: NoteTag;
 }
 export class NoteDetailsAndTagArray {
@@ -920,33 +2109,46 @@ export class NoteDetailsAndTagArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: NoteDetailsAndTag[] | null);
+  replaceAt(index: number, elem: NoteDetailsAndTag): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): NoteDetailsAndTag;
-  replaceAt(index: number, elem: NoteDetailsAndTag): void;
+  constructor(elements?: NoteDetailsAndTag[] | null);
   push(element: NoteDetailsAndTag): void;
   length(): number;
 }
+/**
+ * Hint describing when a note can be consumed.
+ */
 export class NoteExecutionHint {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static none(): NoteExecutionHint;
-  static always(): NoteExecutionHint;
+  /**
+   * Reconstructs a hint from its encoded tag and payload.
+   */
+  static fromParts(tag: number, payload: number): NoteExecutionHint;
+  /**
+   * Creates a hint that activates after the given block number.
+   */
   static afterBlock(block_num: number): NoteExecutionHint;
+  /**
+   * Creates a hint that allows execution in a specific slot of a round.
+   */
   static onBlockSlot(epoch_len: number, slot_len: number, slot_offset: number): NoteExecutionHint;
-  static fromParts(tag: number, payload: number): NoteExecutionHint;
+  /**
+   * Returns whether the note can be consumed at the provided block height.
+   */
   canBeConsumed(block_num: number): boolean;
-}
-export class NoteExecutionMode {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static newLocal(): NoteExecutionMode;
-  static newNetwork(): NoteExecutionMode;
-  toString(): string;
+  /**
+   * Creates a hint that does not specify any execution constraint.
+   */
+  static none(): NoteExecutionHint;
+  /**
+   * Creates a hint indicating the note can always be consumed.
+   */
+  static always(): NoteExecutionHint;
 }
 /**
  * A serialized representation of a note.
@@ -964,46 +2166,137 @@ export class NoteFile {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Returns this `NoteFile`'s types.
+   * Given a valid byte representation of a `NoteFile`,
+   * return it as a struct.
    */
-  noteType(): string;
+  static deserialize(bytes: Uint8Array): NoteFile;
   /**
-   * Turn a notefile into its byte representation.
+   * Creates a `NoteFile` from a note ID.
    */
-  serialize(): Uint8Array;
+  static fromNoteId(note_details: NoteId): NoteFile;
   /**
-   * Given a valid byte representation of a `NoteFile`,
-   * return it as a struct.
+   * Returns the note details if present.
+   */
+  noteDetails(): NoteDetails | undefined;
+  /**
+   * Returns the after-block hint when present.
+   */
+  afterBlockNum(): number | undefined;
+  /**
+   * Creates a `NoteFile` from an input note, preserving proof when available.
    */
-  static deserialize(bytes: Uint8Array): NoteFile;
   static fromInputNote(note: InputNote): NoteFile;
+  /**
+   * Returns the inclusion proof if present.
+   */
+  inclusionProof(): NoteInclusionProof | undefined;
+  /**
+   * Creates a `NoteFile` from an output note, choosing details when present.
+   */
   static fromOutputNote(note: OutputNote): NoteFile;
+  /**
+   * Creates a `NoteFile` from note details.
+   */
   static fromNoteDetails(note_details: NoteDetails): NoteFile;
-  static fromNoteId(note_details: NoteId): NoteFile;
+  /**
+   * Returns the full note when the file includes it.
+   */
+  note(): Note | undefined;
+  /**
+   * Returns the note ID for any `NoteFile` variant.
+   */
+  noteId(): NoteId;
+  /**
+   * Returns the note tag hint when present.
+   */
+  noteTag(): NoteTag | undefined;
+  /**
+   * Returns this `NoteFile`'s types.
+   */
+  noteType(): string;
+  /**
+   * Returns the note nullifier when present.
+   */
+  nullifier(): string | undefined;
+  /**
+   * Turn a notefile into its byte representation.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * Filter options for querying notes from the store.
+ */
 export class NoteFilter {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new filter for the given type and optional note IDs.
+   */
   constructor(note_type: NoteFilterTypes, note_ids?: NoteId[] | null);
 }
+/**
+ * Holds the strictly required, public information of a note.
+ *
+ * See `NoteId` and `NoteMetadata` for additional details.
+ */
 export class NoteHeader {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns a commitment to the note ID and metadata.
+   */
+  commitment(): Word;
+  /**
+   * Returns the unique identifier for the note.
+   */
   id(): NoteId;
+  /**
+   * Returns the public metadata attached to the note.
+   */
   metadata(): NoteMetadata;
-  commitment(): Word;
 }
+/**
+ * Returns a unique identifier of a note, which is simultaneously a commitment to the note.
+ *
+ * Note ID is computed as:
+ *
+ * > `hash(recipient, asset_commitment)`
+ *
+ * where `recipient` is defined as:
+ *
+ * > `hash(hash(hash(serial_num, ZERO), script_root), input_commitment)`
+ *
+ * This achieves the following properties:
+ * - Every note can be reduced to a single unique ID.
+ * - To compute a note ID, we do not need to know the note's `serial_num`. Knowing the hash of the
+ *   `serial_num` (as well as script root, input commitment, and note assets) is sufficient.
+ */
 export class NoteId {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Builds a note ID from the recipient and asset commitments.
+   */
   constructor(recipient_digest: Word, asset_commitment_digest: Word);
+  /**
+   * Parses a note ID from its hex encoding.
+   */
   static fromHex(hex: string): NoteId;
+  /**
+   * Returns the canonical hex representation of the note ID.
+   */
   toString(): string;
 }
+/**
+ * Note ID paired with optional arguments for inclusion in a transaction request.
+ */
 export class NoteIdAndArgs {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new NoteId/args pair.
+   */
   constructor(note_id: NoteId, args?: Word | null);
 }
 export class NoteIdAndArgsArray {
@@ -1017,51 +2310,137 @@ export class NoteIdAndArgsArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: NoteIdAndArgs[] | null);
+  replaceAt(index: number, elem: NoteIdAndArgs): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): NoteIdAndArgs;
-  replaceAt(index: number, elem: NoteIdAndArgs): void;
+  constructor(elements?: NoteIdAndArgs[] | null);
   push(element: NoteIdAndArgs): void;
   length(): number;
 }
+/**
+ * Contains the data required to prove inclusion of a note in the canonical chain.
+ */
 export class NoteInclusionProof {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the location of the note within the tree.
+   */
   location(): NoteLocation;
+  /**
+   * Returns the Merkle authentication path for the note.
+   */
   notePath(): MerklePath;
 }
+/**
+ * A container for note inputs.
+ *
+ * A note can be associated with up to 128 input values. Each value is represented by a single
+ * field element. Thus, note input values can contain up to ~1 KB of data.
+ *
+ * All inputs associated with a note can be reduced to a single commitment which is computed by
+ * first padding the inputs with ZEROs to the next multiple of 8, and then by computing a
+ * sequential hash of the resulting elements.
+ */
 export class NoteInputs {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates note inputs from a list of field elements.
+   */
   constructor(felt_array: FeltArray);
+  /**
+   * Returns the raw inputs as an array of field elements.
+   */
   values(): Felt[];
 }
+/**
+ * Contains information about the location of a note.
+ */
 export class NoteLocation {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  blockNum(): number;
+  /**
+   * Returns the index of the note leaf within the block's note tree.
+   */
   nodeIndexInBlock(): number;
+  /**
+   * Returns the block height containing the note.
+   */
+  blockNum(): number;
 }
+/**
+ * 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.
+ */
 export class NoteMetadata {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(sender: AccountId, note_type: NoteType, note_tag: NoteTag, note_execution_hint: NoteExecutionHint, aux?: Felt | null);
-  sender(): AccountId;
+  /**
+   * 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;
+  /**
+   * Creates metadata for a note.
+   */
+  constructor(sender: AccountId, note_type: NoteType, note_tag: NoteTag);
+  /**
+   * Returns the tag associated with the note.
+   */
   tag(): NoteTag;
+  /**
+   * Returns the account that created the note.
+   */
+  sender(): AccountId;
+  /**
+   * Returns whether the note is private, encrypted, or public.
+   */
   noteType(): NoteType;
 }
+/**
+ * Value that describes under which condition a note can be consumed.
+ *
+ * The recipient is not an account address, instead it is a value that describes when a note can be
+ * consumed. Because not all notes have predetermined consumer addresses, e.g. swap notes can be
+ * consumed by anyone, the recipient is defined as the code and its inputs, that when successfully
+ * executed results in the note's consumption.
+ *
+ * Recipient is computed as a nested hash of the serial number, the script root, and the inputs
+ * commitment, ensuring the recipient digest binds all three pieces of data together.
+ */
 export class NoteRecipient {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the serial number that prevents double spends.
+   */
+  serialNum(): Word;
+  /**
+   * Creates a note recipient from its serial number, script, and inputs.
+   */
   constructor(serial_num: Word, note_script: NoteScript, inputs: NoteInputs);
+  /**
+   * Returns the digest of the recipient data (used in the note commitment).
+   */
   digest(): Word;
-  serialNum(): Word;
-  script(): NoteScript;
+  /**
+   * Returns the inputs provided to the script.
+   */
   inputs(): NoteInputs;
+  /**
+   * Returns the script that controls consumption.
+   */
+  script(): NoteScript;
 }
 export class NoteRecipientArray {
 /**
@@ -1074,58 +2453,151 @@ export class NoteRecipientArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: NoteRecipient[] | null);
+  replaceAt(index: number, elem: NoteRecipient): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): NoteRecipient;
-  replaceAt(index: number, elem: NoteRecipient): void;
+  constructor(elements?: NoteRecipient[] | null);
   push(element: NoteRecipient): void;
   length(): number;
 }
+/**
+ * An executable program of a note.
+ *
+ * A note's script represents a program which must be executed for a note to be consumed. As such
+ * it defines the rules and side effects of consuming a given note.
+ */
 export class NoteScript {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Print the MAST source for this script.
+   * Deserializes a script from bytes.
    */
-  toString(): string;
-  serialize(): Uint8Array;
   static deserialize(bytes: Uint8Array): NoteScript;
+  /**
+   * Creates a `NoteScript` from the given `Package`.
+   * Throws if the package is invalid.
+   */
+  static fromPackage(_package: Package): NoteScript;
+  /**
+   * Returns the well-known P2ID script.
+   */
   static p2id(): NoteScript;
-  static p2ide(): NoteScript;
-  static swap(): NoteScript;
+  /**
+   * Returns the MAST root of this script.
+   */
   root(): Word;
   /**
-   * Creates a `NoteScript` from the given `Package`.
-   * Throws if the package is invalid.
+   * Returns the well-known SWAP script.
+   */
+  static swap(): NoteScript;
+  /**
+   * Returns the well-known P2IDE script (P2ID with execution hint).
+   */
+  static p2ide(): NoteScript;
+  /**
+   * Serializes the script into bytes.
+   */
+  serialize(): Uint8Array;
+  /**
+   * Pretty-prints the MAST source for this script.
+   */
+  toString(): string;
+}
+/**
+ * Represents the response data from `syncNotes`.
+ */
+export class NoteSyncInfo {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the block header associated with the matching notes.
+   */
+  blockHeader(): BlockHeader;
+  /**
+   * Returns the committed notes returned by the node.
+   */
+  notes(): CommittedNote[];
+  /**
+   * Returns the MMR path for the block header.
+   */
+  mmrPath(): MerklePath;
+  /**
+   * Returns the latest block number in the chain.
+   */
+  chainTip(): number;
+}
+/**
+ * Note tags are 32-bits of data that serve as best-effort filters for notes.
+ *
+ * Tags enable quick lookups for notes related to particular use cases, scripts, or account
+ * prefixes.
+ */
+export class NoteTag {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Constructs a note tag that targets the given account ID.
+   */
+  static withAccountTarget(account_id: AccountId): NoteTag;
+  /**
+   * Constructs a note tag that targets the given account ID with a custom tag length.
+   */
+  static withCustomAccountTarget(account_id: AccountId, tag_len: number): NoteTag;
+  /**
+   * Creates a new `NoteTag` from an arbitrary u32.
+   */
+  constructor(tag: number);
+  /**
+   * Returns the inner u32 value of this tag.
+   */
+  asU32(): number;
+}
+/**
+ * Representation of a note produced by a transaction (full, partial, or header-only).
+ */
+export class OutputNote {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the recipient digest if the recipient is known.
+   */
+  recipientDigest(): Word | undefined;
+  /**
+   * Returns the note ID for this output.
+   */
+  id(): NoteId;
+  /**
+   * Wraps a full note output.
+   */
+  static full(note: Note): OutputNote;
+  /**
+   * Returns the assets if they are present.
+   */
+  assets(): NoteAssets | undefined;
+  /**
+   * Wraps only the header of a note.
+   */
+  static header(note_header: NoteHeader): OutputNote;
+  /**
+   * Returns a more compact representation if possible (e.g. dropping details).
+   */
+  shrink(): OutputNote;
+  /**
+   * Wraps a partial note containing assets and recipient only.
    */
-  static fromPackage(_package: Package): NoteScript;
-}
-export class NoteTag {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static fromAccountId(account_id: AccountId): NoteTag;
-  static forPublicUseCase(use_case_id: number, payload: number, execution: NoteExecutionMode): NoteTag;
-  static forLocalUseCase(use_case_id: number, payload: number): NoteTag;
-  isSingleTarget(): boolean;
-  executionMode(): NoteExecutionMode;
-  asU32(): number;
-}
-export class OutputNote {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static full(note: Note): OutputNote;
   static partial(partial_note: PartialNote): OutputNote;
-  static header(note_header: NoteHeader): OutputNote;
-  assets(): NoteAssets | undefined;
-  id(): NoteId;
-  recipientDigest(): Word | undefined;
+  /**
+   * Returns the metadata that accompanies this output.
+   */
   metadata(): NoteMetadata;
-  shrink(): OutputNote;
+  /**
+   * Converts into a full note if the data is present.
+   */
   intoFull(): Note | undefined;
 }
 export class OutputNoteArray {
@@ -1139,24 +2611,95 @@ export class OutputNoteArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: OutputNote[] | null);
+  replaceAt(index: number, elem: OutputNote): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): OutputNote;
-  replaceAt(index: number, elem: OutputNote): void;
+  constructor(elements?: OutputNote[] | null);
   push(element: OutputNote): void;
   length(): number;
 }
+/**
+ * Represents an output note tracked by the client store.
+ */
+export class OutputNoteRecord {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns true if the note has been consumed on chain.
+   */
+  isConsumed(): boolean;
+  /**
+   * Returns true if the note is committed on chain.
+   */
+  isCommitted(): boolean;
+  /**
+   * Returns the expected block height for the note.
+   */
+  expectedHeight(): number;
+  /**
+   * Returns the inclusion proof when the note is committed.
+   */
+  inclusionProof(): NoteInclusionProof | undefined;
+  /**
+   * Returns the recipient digest committed for the note.
+   */
+  recipientDigest(): Word;
+  /**
+   * Returns the note ID.
+   */
+  id(): NoteId;
+  /**
+   * Returns the current processing state for this note.
+   */
+  state(): OutputNoteState;
+  /**
+   * Returns the note assets.
+   */
+  assets(): NoteAssets;
+  /**
+   * Returns the note metadata.
+   */
+  metadata(): NoteMetadata;
+  /**
+   * Returns the nullifier when the recipient is known.
+   */
+  nullifier(): string | undefined;
+  /**
+   * Returns the recipient details if available.
+   */
+  recipient(): NoteRecipient | undefined;
+}
+/**
+ * Contains a list of output notes of a transaction. The list can be empty if the transaction does
+ * not produce any notes.
+ */
 export class OutputNotes {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the commitment to all output notes.
+   */
   commitment(): Word;
-  numNotes(): number;
-  isEmpty(): boolean;
-  getNote(index: number): OutputNote;
+  /**
+   * Returns all output notes as a vector.
+   */
   notes(): OutputNote[];
+  /**
+   * Returns the output note at the specified index.
+   */
+  getNote(index: number): OutputNote;
+  /**
+   * Returns true if there are no output notes.
+   */
+  isEmpty(): boolean;
+  /**
+   * Returns the number of notes emitted.
+   */
+  numNotes(): number;
 }
 export class OutputNotesArray {
 /**
@@ -1169,21 +2712,22 @@ export class OutputNotesArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: OutputNotes[] | null);
+  replaceAt(index: number, elem: OutputNotes): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): OutputNotes;
-  replaceAt(index: number, elem: OutputNotes): void;
+  constructor(elements?: OutputNotes[] | null);
   push(element: OutputNotes): void;
   length(): number;
 }
+/**
+ * Compiled VM package containing libraries and metadata.
+ */
 export class Package {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): Package;
   /**
    * Returns the underlying library of a `Package`.
    * Fails if the package is not a library.
@@ -1194,15 +2738,51 @@ export class Package {
    * Fails if the package is not a program.
    */
   asProgram(): Program;
+  /**
+   * Deserializes a package from bytes.
+   */
+  static deserialize(bytes: Uint8Array): Package;
+  /**
+   * Serializes the package into bytes.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * Partial information about a note.
+ *
+ * Partial note consists of `NoteMetadata`, `NoteAssets`, and a recipient digest (see
+ * `NoteRecipient`). However, it does not contain detailed recipient info, including
+ * note script, note inputs, and note's serial number. This means that a partial note is sufficient
+ * to compute note ID and note header, but not sufficient to compute note nullifier, and generally
+ * does not have enough info to execute the note.
+ */
 export class PartialNote {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  id(): NoteId;
-  metadata(): NoteMetadata;
+  /**
+   * Returns the digest of the recipient information.
+   */
   recipientDigest(): Word;
+  /**
+   * Returns the identifier of the partial note.
+   */
+  id(): NoteId;
+  /**
+   * Returns the assets locked in the note.
+   */
   assets(): NoteAssets;
+  /**
+   * Returns the metadata attached to the note.
+   */
+  metadata(): NoteMetadata;
+}
+export class ProcedureThreshold {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(proc_root: Word, threshold: number);
+  readonly procRoot: Word;
+  readonly threshold: number;
 }
 export class Program {
   private constructor();
@@ -1210,59 +2790,78 @@ export class Program {
   [Symbol.dispose](): void;
 }
 /**
- * WASM wrapper around the native [`ProvenTransaction`].
+ * Result of executing and proving a transaction. Contains all the data required to verify that a
+ * transaction was executed correctly.
  */
 export class ProvenTransaction {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Serializes the proven transaction into bytes.
+   * Returns the account ID the transaction was executed against.
    */
-  serialize(): Uint8Array;
+  accountId(): AccountId;
   /**
-   * Deserializes a proven transaction from bytes.
+   * Returns the nullifiers of the consumed input notes.
    */
-  static deserialize(bytes: Uint8Array): ProvenTransaction;
+  nullifiers(): Word[];
   /**
-   * Returns the transaction ID.
+   * Deserializes a proven transaction from bytes.
    */
-  id(): TransactionId;
+  static deserialize(bytes: Uint8Array): ProvenTransaction;
   /**
-   * Returns the account ID the transaction was executed against.
+   * Returns notes created by this transaction.
    */
-  accountId(): AccountId;
+  outputNotes(): OutputNotes;
   /**
    * Returns the reference block number used during execution.
    */
   refBlockNumber(): number;
   /**
-   * Returns the block number at which the transaction expires.
+   * Returns the commitment of the reference block.
    */
-  expirationBlockNumber(): number;
+  refBlockCommitment(): Word;
   /**
-   * Returns notes created by this transaction.
+   * Returns the block number at which the transaction expires.
    */
-  outputNotes(): OutputNotes;
+  expirationBlockNumber(): number;
   /**
-   * Returns the commitment of the reference block.
+   * Returns the transaction ID.
    */
-  refBlockCommitment(): Word;
+  id(): TransactionId;
   /**
-   * Returns the nullifiers of the consumed input notes.
+   * Serializes the proven transaction into bytes.
    */
-  nullifiers(): Word[];
+  serialize(): Uint8Array;
 }
 export class PublicKey {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes a public key from bytes.
+   */
   static deserialize(bytes: Uint8Array): PublicKey;
-  verify(message: Word, signature: Signature): boolean;
-  toCommitment(): Word;
-  static recoverFrom(message: Word, signature: Signature): PublicKey;
+  /**
+   * Verifies a signature over arbitrary signing inputs.
+   */
   verifyData(signing_inputs: SigningInputs, signature: Signature): boolean;
+  /**
+   * Recovers a public key from a signature (only supported for `RpoFalcon512`).
+   */
+  static recoverFrom(message: Word, signature: Signature): PublicKey;
+  /**
+   * Returns the commitment corresponding to this public key.
+   */
+  toCommitment(): Word;
+  /**
+   * Verifies a blind message word against the signature.
+   */
+  verify(message: Word, signature: Signature): boolean;
+  /**
+   * Serializes the public key into bytes.
+   */
+  serialize(): Uint8Array;
 }
 /**
  * RPC Client for interacting with Miden nodes directly.
@@ -1271,100 +2870,56 @@ export class RpcClient {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Creates a new RPC client instance.
-   *
-   * @param endpoint - Endpoint to connect to.
+   * Fetches notes matching the provided tags from the node.
    */
-  constructor(endpoint: Endpoint);
+  syncNotes(block_num: number, block_to: number | null | undefined, note_tags: NoteTag[]): Promise<NoteSyncInfo>;
   /**
    * Fetches notes by their IDs from the connected Miden node.
    *
    * @param note_ids - Array of [`NoteId`] objects to fetch
-   * @returns Promise that resolves to  different data depending on the note type:
-   * - Private notes: Returns only `note_id` and `metadata`. The `input_note` field will be
-   *   `null`.
-   * - Public notes: Returns the full `input_note` with inclusion proof, alongside metadata and
-   *   ID.
+   * @returns Promise that resolves to different data depending on the note type:
+   * - Private notes: Returns the `noteHeader`, and the  `inclusionProof`. The `note` field will
+   *   be `null`.
+   * - Public notes: Returns the full `note` with `inclusionProof`, alongside its header.
    */
   getNotesById(note_ids: NoteId[]): Promise<FetchedNote[]>;
+  /**
+   * Fetches account details for a specific account ID.
+   */
+  getAccountDetails(account_id: AccountId): Promise<FetchedAccount>;
   /**
    * 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`
+   * @param script_root - The root hash of the note script to fetch.
+   * @returns Promise that resolves to the `NoteScript`.
    */
   getNoteScriptByRoot(script_root: Word): Promise<NoteScript>;
-}
-export class Rpo256 {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static hashElements(felt_array: FeltArray): Word;
-}
-export class ScriptBuilder {
-  private constructor();
-/**
-** Return copy of self without private attributes.
-*/
-  toJSON(): Object;
-/**
-* Return stringified version of self.
-*/
-  toString(): string;
-  free(): void;
-  [Symbol.dispose](): void;
   /**
-   * Given a module path (something like `my_lib::module`) and source code, this will
-   * statically link it for use with scripts to be built with this builder.
+   * Fetches a block header by number. When `block_num` is undefined, returns the latest header.
    */
-  linkModule(module_path: string, module_code: string): void;
+  getBlockHeaderByNumber(block_num?: number | null): Promise<BlockHeader>;
   /**
-   * Statically links the given library.
-   *
-   * Static linking means the library code is copied into the script code.
-   * Use this for most libraries that are not available on-chain.
-   *
-   * Receives as argument the library to link.
+   * Fetches the block height at which a nullifier was committed, if any.
    */
-  linkStaticLibrary(library: Library): void;
+  getNullifierCommitHeight(nullifier: Word, block_num: number): Promise<number | undefined>;
   /**
-   * This is useful to dynamically link the [`Library`] of a foreign account
-   * that is invoked using foreign procedure invocation (FPI). Its code is available
-   * on-chain and so it does not have to be copied into the script code.
+   * Creates a new RPC client instance.
    *
-   * For all other use cases not involving FPI, link the library statically.
-   * Receives as argument the library to be linked.
-   */
-  linkDynamicLibrary(library: Library): void;
-  /**
-   * Given a Transaction Script's source code, compiles it with the available
-   * modules under this builder. Returns the compiled script.
-   */
-  compileTxScript(tx_script: string): TransactionScript;
-  /**
-   * Given a Note Script's source code, compiles it with the available
-   * modules under this builder. Returns the compiled script.
-   */
-  compileNoteScript(program: string): NoteScript;
-  /**
-   * Given a Library Path, and a source code, turn it into a Library.
-   * E.g. A path library can be `miden::my_contract`. When turned into a library,
-   * this can be used from another script with an import statement, following the
-   * previous example: `use.miden::my_contract'.
+   * @param endpoint - Endpoint to connect to.
    */
-  buildLibrary(library_path: string, source_code: string): Library;
+  constructor(endpoint: Endpoint);
 }
-export class SecretKey {
+/**
+ * RPO256 hashing helpers exposed to JavaScript.
+ */
+export class Rpo256 {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static rpoFalconWithRNG(seed?: Uint8Array | null): SecretKey;
-  static ecdsaWithRNG(seed?: Uint8Array | null): SecretKey;
-  publicKey(): PublicKey;
-  sign(message: Word): Signature;
-  signData(signing_inputs: SigningInputs): Signature;
-  serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): SecretKey;
+  /**
+   * Computes an RPO256 digest from the provided field elements.
+   */
+  static hashElements(felt_array: FeltArray): Word;
 }
 export class SerializedInputNoteData {
   private constructor();
@@ -1405,54 +2960,168 @@ export class SerializedTransactionData {
   set scriptRoot(value: Uint8Array | null | undefined);
   get txScript(): Uint8Array | undefined;
   set txScript(value: Uint8Array | null | undefined);
-  blockNum: string;
+  blockNum: number;
   statusVariant: number;
   status: Uint8Array;
 }
+/**
+ * Cryptographic signature produced by supported auth schemes.
+ */
 export class Signature {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes a signature from bytes.
+   */
   static deserialize(bytes: Uint8Array): Signature;
+  /**
+   * Converts the signature to the prepared field elements expected by verifying code.
+   */
   toPreparedSignature(message: Word): Felt[];
+  /**
+   * Serializes the signature into bytes.
+   */
+  serialize(): Uint8Array;
 }
 export class SigningInputs {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static newTransactionSummary(summary: TransactionSummary): SigningInputs;
-  static newArbitrary(felts: Felt[]): SigningInputs;
-  static newBlind(word: Word): SigningInputs;
-  transactionSummaryPayload(): TransactionSummary;
-  arbitraryPayload(): FeltArray;
+  /**
+   * Deserializes signing inputs from bytes.
+   */
+  static deserialize(bytes: Uint8Array): SigningInputs;
+  /**
+   * Returns the inputs as field elements.
+   */
+  toElements(): FeltArray;
+  /**
+   * Returns the blind payload as a word.
+   */
   blindPayload(): Word;
+  /**
+   * Creates signing inputs from arbitrary field elements.
+   */
+  static newArbitrary(felts: Felt[]): SigningInputs;
+  /**
+   * Returns the commitment to these signing inputs.
+   */
   toCommitment(): Word;
-  toElements(): FeltArray;
+  /**
+   * Returns the arbitrary payload as an array of felts.
+   */
+  arbitraryPayload(): FeltArray;
+  /**
+   * Creates signing inputs from a transaction summary.
+   */
+  static newTransactionSummary(summary: TransactionSummary): SigningInputs;
+  /**
+   * Returns the transaction summary payload if this variant contains one.
+   */
+  transactionSummaryPayload(): TransactionSummary;
+  /**
+   * Creates blind signing inputs from a single word.
+   */
+  static newBlind(word: Word): SigningInputs;
+  /**
+   * Serializes the signing inputs into bytes.
+   */
   serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): SigningInputs;
+  /**
+   * Returns which variant these signing inputs represent.
+   */
   readonly variantType: SigningInputsType;
 }
+/**
+ * Storage slot index paired with map keys that must be present.
+ */
 export class SlotAndKeys {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(storage_slot_index: number, storage_map_keys: Word[]);
-  storage_slot_index(): number;
+  /**
+   * Returns the storage map keys required for this slot.
+   */
   storage_map_keys(): Word[];
+  /**
+   * Returns the slot name.
+   */
+  storage_slot_name(): string;
+  /**
+   * Creates a new slot-and-keys entry.
+   */
+  constructor(storage_slot_name: string, storage_map_keys: Word[]);
+}
+/**
+ * Represents a sparse Merkle path.
+ */
+export class SparseMerklePath {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the empty nodes mask used by this path.
+   */
+  emptyNodesMask(): bigint;
+  /**
+   * Returns the sibling nodes that make up the path.
+   */
+  nodes(): Word[];
+  /**
+   * Verifies the path against a root.
+   */
+  verify(index: bigint, node: Word, root: Word): boolean;
 }
+/**
+ * An account storage map is a sparse merkle tree of depth 64.
+ *
+ * It can be used to store a large amount of data in an account than would be otherwise possible
+ * using just the account's storage slots. This works by storing the root of the map's underlying
+ * SMT in one account storage slot. Each map entry is a leaf in the tree and its inclusion is
+ * proven while retrieving it (e.g. via `AccountStorage::get_map_item`).
+ *
+ * As a side-effect, this also means that _not all_ entries of the map have to be present at
+ * transaction execution time in order to access or modify the map. It is sufficient if _just_ the
+ * accessed/modified items are present in the advice provider.
+ *
+ * Because the keys of the map are user-chosen and thus not necessarily uniformly distributed, the
+ * tree could be imbalanced and made less efficient. To mitigate that, the keys used in the storage
+ * map are hashed before they are inserted into the SMT, which creates a uniform distribution. The
+ * original keys are retained in a separate map. This causes redundancy but allows for
+ * introspection of the map, e.g. by querying the set of stored (original) keys which is useful in
+ * debugging and explorer scenarios.
+ */
 export class StorageMap {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates an empty storage map.
+   */
   constructor();
+  /**
+   * Inserts a key/value pair, returning any previous value.
+   */
   insert(key: Word, value: Word): Word;
 }
+/**
+ * A single storage slot value or map for an account component.
+ */
 export class StorageSlot {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static fromValue(value: Word): StorageSlot;
-  static emptyValue(): StorageSlot;
-  static map(storage_map: StorageMap): StorageSlot;
+  /**
+   * Creates a storage slot holding a single value.
+   */
+  static fromValue(name: string, value: Word): StorageSlot;
+  /**
+   * Returns an empty value slot (zeroed).
+   */
+  static emptyValue(name: string): StorageSlot;
+  /**
+   * Creates a storage slot backed by a map.
+   */
+  static map(name: string, storage_map: StorageMap): StorageSlot;
 }
 export class StorageSlotArray {
 /**
@@ -1465,26 +3134,50 @@ export class StorageSlotArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: StorageSlot[] | null);
+  replaceAt(index: number, elem: StorageSlot): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): StorageSlot;
-  replaceAt(index: number, elem: StorageSlot): void;
+  constructor(elements?: StorageSlot[] | null);
   push(element: StorageSlot): void;
   length(): number;
 }
+/**
+ * Contains stats about the sync operation.
+ */
 export class SyncSummary {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  blockNum(): number;
-  committedNotes(): NoteId[];
+  /**
+   * Deserializes a sync summary from bytes.
+   */
+  static deserialize(bytes: Uint8Array): SyncSummary;
+  /**
+   * Returns IDs of notes that were consumed.
+   */
   consumedNotes(): NoteId[];
+  /**
+   * Returns IDs of notes committed in this sync window.
+   */
+  committedNotes(): NoteId[];
+  /**
+   * Returns accounts that were updated.
+   */
   updatedAccounts(): AccountId[];
+  /**
+   * Returns transactions that were committed.
+   */
   committedTransactions(): TransactionId[];
+  /**
+   * Returns the block height the summary is based on.
+   */
+  blockNum(): number;
+  /**
+   * Serializes the sync summary into bytes.
+   */
   serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): SyncSummary;
 }
 export class TestUtils {
   private constructor();
@@ -1494,133 +3187,363 @@ export class TestUtils {
   static createMockSerializedLibraryPackage(): Uint8Array;
   static createMockSerializedProgramPackage(): Uint8Array;
 }
+/**
+ * Represents a string token symbol (e.g. "POL", "ETH") as a single {@link Felt | `Felt`} value.
+ *
+ * Token Symbols can consists of up to 6 capital Latin characters, e.g. "C", "ETH", "MIDENC".
+ */
 export class TokenSymbol {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a token symbol from a string.
+   */
   constructor(symbol: string);
+  /**
+   * Returns the validated symbol string.
+   */
   toString(): string;
 }
+/**
+ * Optional transaction arguments.
+ *
+ * - Transaction script: a program that is executed in a transaction after all input notes scripts
+ *   have been executed.
+ * - Note arguments: data put onto the stack right before a note script is executed. These are
+ *   different from note inputs, as the user executing the transaction can specify arbitrary note
+ *   args.
+ * - Advice inputs: Provides data needed by the runtime, like the details of public output notes.
+ * - Account inputs: Provides account data that will be accessed in the transaction.
+ */
 export class TransactionArgs {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  txScript(): TransactionScript | undefined;
-  getNoteArgs(note_id: NoteId): Word | undefined;
+  /**
+   * Returns advice inputs attached to the transaction.
+   */
   adviceInputs(): AdviceInputs;
+  /**
+   * Returns note-specific arguments for the given note ID.
+   */
+  getNoteArgs(note_id: NoteId): Word | undefined;
+  /**
+   * Returns the transaction script if provided.
+   */
+  txScript(): TransactionScript | undefined;
 }
+/**
+ * Filter used when querying stored transactions.
+ */
 export class TransactionFilter {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static all(): TransactionFilter;
-  static ids(ids: TransactionId[]): TransactionFilter;
+  /**
+   * Matches transactions that are not yet committed.
+   */
   static uncommitted(): TransactionFilter;
+  /**
+   * Matches transactions that expired before the given block number.
+   */
   static expiredBefore(block_num: number): TransactionFilter;
+  /**
+   * Matches all transactions.
+   */
+  static all(): TransactionFilter;
+  /**
+   * Matches specific transaction IDs.
+   */
+  static ids(ids: TransactionId[]): TransactionFilter;
 }
+/**
+ * A unique identifier of a transaction.
+ *
+ * Transaction ID is computed as a hash of the initial and final account commitments together with
+ * the commitments of the input and output notes.
+ *
+ * This achieves the following properties:
+ * - Transactions are identical if and only if they have the same ID.
+ * - Computing transaction ID can be done solely from public transaction data.
+ */
 export class TransactionId {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Returns the transaction ID as field elements.
+   */
   asElements(): Felt[];
-  asBytes(): Uint8Array;
-  toHex(): string;
+  /**
+   * Returns the underlying word representation.
+   */
   inner(): Word;
+  /**
+   * Returns the hexadecimal encoding of the transaction ID.
+   */
+  toHex(): string;
+  /**
+   * Returns the transaction ID as raw bytes.
+   */
+  asBytes(): Uint8Array;
 }
+/**
+ * Wrapper over local or remote transaction proving backends.
+ */
 export class TransactionProver {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Reconstructs a prover from its serialized descriptor.
+   *
+   * Parses the format produced by `serialize()`:
+   * - `"local"` for local prover
+   * - `"remote|{endpoint}"` for remote prover without timeout
+   * - `"remote|{endpoint}|{timeout_ms}"` for remote prover with timeout
+   */
+  static deserialize(payload: string): TransactionProver;
+  /**
+   * Creates a prover that uses the local proving backend.
+   */
   static newLocalProver(): TransactionProver;
-  static newRemoteProver(endpoint: string): TransactionProver;
-  serialize(): string;
-  static deserialize(prover_type: string, endpoint?: string | null): TransactionProver;
+  /**
+   * Creates a new remote transaction prover.
+   *
+   * Arguments:
+   * - `endpoint`: The URL of the remote prover.
+   * - `timeout_ms`: The timeout in milliseconds for the remote prover.
+   */
+  static newRemoteProver(endpoint: string, timeout_ms?: bigint | null): TransactionProver;
+  /**
+   * Returns the endpoint if this is a remote prover.
+   */
   endpoint(): string | undefined;
+  /**
+   * Serializes the prover configuration into a string descriptor.
+   *
+   * Format:
+   * - `"local"` for local prover
+   * - `"remote|{endpoint}"` for remote prover without timeout
+   * - `"remote|{endpoint}|{timeout_ms}"` for remote prover with timeout
+   *
+   * Uses `|` as delimiter since it's not a valid URL character.
+   */
+  serialize(): string;
 }
+/**
+ * Describes a transaction that has been executed and is being tracked on the Client.
+ */
 export class TransactionRecord {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  id(): TransactionId;
+  /**
+   * Returns the account this transaction was executed against.
+   */
   accountId(): AccountId;
+  /**
+   * Returns the output notes created by this transaction.
+   */
+  outputNotes(): OutputNotes;
+  /**
+   * Returns the block height at which the transaction was submitted.
+   */
+  submissionHeight(): number;
+  /**
+   * Returns the timestamp when the record was created.
+   */
+  creationTimestamp(): bigint;
+  /**
+   * Returns the initial account state commitment before execution.
+   */
   initAccountState(): Word;
+  /**
+   * Returns the current status of the transaction.
+   */
+  transactionStatus(): TransactionStatus;
+  /**
+   * Returns the final account state commitment after execution.
+   */
   finalAccountState(): Word;
+  /**
+   * Returns the expiration block height for the transaction.
+   */
+  expirationBlockNum(): number;
+  /**
+   * Returns the nullifiers of the consumed input notes.
+   */
   inputNoteNullifiers(): Word[];
-  outputNotes(): OutputNotes;
+  /**
+   * Returns the transaction ID.
+   */
+  id(): TransactionId;
+  /**
+   * Returns the block height in which the transaction was included.
+   */
   blockNum(): number;
-  transactionStatus(): TransactionStatus;
-  creationTimestamp(): bigint;
 }
+/**
+ * Specifies a transaction request that can be executed by an account.
+ *
+ * A request contains information about input notes to be consumed by the transaction (if any),
+ * description of the transaction script to be executed (if any), and a set of notes expected to be
+ * generated by the transaction or by consuming notes generated by the transaction.
+ */
 export class TransactionRequest {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Returns the transaction script argument if present.
+   */
+  scriptArg(): Word | undefined;
+  /**
+   * Deserializes a transaction request from bytes.
+   */
   static deserialize(bytes: Uint8Array): TransactionRequest;
-  expectedOutputOwnNotes(): Note[];
+  /**
+   * Returns notes expected to be created in subsequent executions.
+   */
   expectedFutureNotes(): NoteDetailsAndTag[];
-  scriptArg(): Word | undefined;
+  /**
+   * Returns output notes created by the sender account.
+   */
+  expectedOutputOwnNotes(): Note[];
+  /**
+   * Returns the authentication argument if present.
+   */
   authArg(): Word | undefined;
+  /**
+   * Serializes the transaction request into bytes.
+   */
+  serialize(): Uint8Array;
 }
+/**
+ * A builder for a `TransactionRequest`.
+ *
+ * Use this builder to construct a `TransactionRequest` by adding input notes, specifying
+ * scripts, and setting other transaction parameters.
+ */
 export class TransactionRequestBuilder {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
-  withUnauthenticatedInputNotes(notes: NoteAndArgsArray): TransactionRequestBuilder;
-  withAuthenticatedInputNotes(notes: NoteIdAndArgsArray): TransactionRequestBuilder;
-  withOwnOutputNotes(notes: OutputNoteArray): TransactionRequestBuilder;
-  withCustomScript(script: TransactionScript): TransactionRequestBuilder;
-  withExpectedOutputRecipients(recipients: NoteRecipientArray): TransactionRequestBuilder;
-  withExpectedFutureNotes(note_details_and_tag: NoteDetailsAndTagArray): TransactionRequestBuilder;
+  /**
+   * Adds an authentication argument.
+   */
+  withAuthArg(auth_arg: Word): TransactionRequestBuilder;
+  /**
+   * Adds a transaction script argument.
+   */
+  withScriptArg(script_arg: Word): TransactionRequestBuilder;
+  /**
+   * Adds input notes with optional arguments.
+   */
+  withInputNotes(notes: NoteAndArgsArray): TransactionRequestBuilder;
+  /**
+   * Merges an advice map to be available during script execution.
+   */
   extendAdviceMap(advice_map: AdviceMap): TransactionRequestBuilder;
+  /**
+   * Attaches a custom transaction script.
+   */
+  withCustomScript(script: TransactionScript): TransactionRequestBuilder;
+  /**
+   * Registers foreign accounts referenced by the transaction.
+   */
   withForeignAccounts(foreign_accounts: ForeignAccountArray): TransactionRequestBuilder;
-  withScriptArg(script_arg: Word): TransactionRequestBuilder;
-  withAuthArg(auth_arg: Word): TransactionRequestBuilder;
+  /**
+   * Adds notes created by the sender that should be emitted by the transaction.
+   */
+  withOwnOutputNotes(notes: OutputNoteArray): TransactionRequestBuilder;
+  /**
+   * Declares notes expected to be created in follow-up executions.
+   */
+  withExpectedFutureNotes(note_details_and_tag: NoteDetailsAndTagArray): TransactionRequestBuilder;
+  /**
+   * Declares expected output recipients (used for verification).
+   */
+  withExpectedOutputRecipients(recipients: NoteRecipientArray): TransactionRequestBuilder;
+  /**
+   * Creates a new empty transaction request builder.
+   */
+  constructor();
+  /**
+   * Finalizes the builder into a `TransactionRequest`.
+   */
   build(): TransactionRequest;
 }
 /**
- * WASM wrapper around the native [`TransactionResult`].
+ * Represents the result of executing a transaction by the client.
+ *
+ * It contains an `ExecutedTransaction`, and a list of `future_notes`
+ * that we expect to receive in the future (you can check at swap notes for an example of this).
  */
 export class TransactionResult {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Returns the ID of the transaction.
+   * Deserializes a transaction result from bytes.
+   */
+  static deserialize(bytes: Uint8Array): TransactionResult;
+  /**
+   * Returns notes that are expected to be created as a result of follow-up executions.
    */
-  id(): TransactionId;
+  futureNotes(): NoteDetailsAndTag[];
   /**
    * Returns the executed transaction.
    */
   executedTransaction(): ExecutedTransaction;
   /**
-   * Returns notes that are expected to be created as a result of follow-up executions.
+   * Returns the ID of the transaction.
    */
-  futureNotes(): NoteDetailsAndTag[];
+  id(): TransactionId;
   /**
    * Serializes the transaction result into bytes.
    */
   serialize(): Uint8Array;
-  /**
-   * Deserializes a transaction result from bytes.
-   */
-  static deserialize(bytes: Uint8Array): TransactionResult;
 }
+/**
+ * A transaction script is a program that is executed in a transaction after all input notes have
+ * been executed.
+ *
+ * The `TransactionScript` object is composed of:
+ * - An executable program defined by a MAST forest and an associated entrypoint.
+ * - A set of transaction script inputs defined by a map of key-value inputs that are loaded into
+ *   the advice inputs' map such that the transaction script can access them.
+ */
 export class TransactionScript {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  root(): Word;
   /**
    * Creates a `NoteScript` from the given `Package`.
    * Throws if the package is invalid.
    */
   static fromPackage(_package: Package): TransactionScript;
+  /**
+   * Returns the MAST root commitment of the transaction script.
+   */
+  root(): Word;
 }
+/**
+ * A script argument represented as a word plus additional felts.
+ */
 export class TransactionScriptInputPair {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Creates a new script input pair.
+   */
   constructor(word: Word, felts: FeltArray);
+  /**
+   * Returns the word part of the input.
+   */
   word(): Word;
+  /**
+   * Returns the remaining felts for the input.
+   */
   felts(): FeltArray;
 }
 export class TransactionScriptInputPairArray {
@@ -1634,100 +3557,172 @@ export class TransactionScriptInputPairArray {
   toString(): string;
   free(): void;
   [Symbol.dispose](): void;
-  constructor(elements?: TransactionScriptInputPair[] | null);
+  replaceAt(index: number, elem: TransactionScriptInputPair): void;
   /**
    * Get element at index, will always return a clone to avoid aliasing issues.
    */
   get(index: number): TransactionScriptInputPair;
-  replaceAt(index: number, elem: TransactionScriptInputPair): void;
+  constructor(elements?: TransactionScriptInputPair[] | null);
   push(element: TransactionScriptInputPair): void;
   length(): number;
 }
+/**
+ * Status of a transaction in the node or store.
+ */
 export class TransactionStatus {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static pending(): TransactionStatus;
-  static committed(block_num: number, commit_timestamp: bigint): TransactionStatus;
-  static discarded(cause: string): TransactionStatus;
+  /**
+   * Returns true if the transaction is still pending.
+   */
   isPending(): boolean;
+  /**
+   * Returns true if the transaction has been committed.
+   */
   isCommitted(): boolean;
+  /**
+   * Returns true if the transaction was discarded.
+   */
   isDiscarded(): boolean;
+  /**
+   * Returns the block number if the transaction was committed.
+   */
   getBlockNum(): number | undefined;
+  /**
+   * Returns the commit timestamp if the transaction was committed.
+   */
   getCommitTimestamp(): bigint | undefined;
+  /**
+   * Creates a pending transaction status.
+   */
+  static pending(): TransactionStatus;
+  /**
+   * Creates a committed status with block number and timestamp.
+   */
+  static committed(block_num: number, commit_timestamp: bigint): TransactionStatus;
+  /**
+   * Creates a discarded status from a discard cause string.
+   */
+  static discarded(cause: string): TransactionStatus;
 }
+/**
+ * Represents the changes that need to be applied to the client store as a result of a transaction
+ * execution.
+ */
 export class TransactionStoreUpdate {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  executedTransaction(): ExecutedTransaction;
-  submissionHeight(): number;
-  createdNotes(): OutputNotes;
-  accountDelta(): AccountDelta;
+  /**
+   * Deserializes an update from bytes.
+   */
+  static deserialize(bytes: Uint8Array): TransactionStoreUpdate;
+  /**
+   * Returns notes expected to be created in follow-up executions.
+   */
   futureNotes(): NoteDetailsAndTag[];
+  /**
+   * Returns the account delta applied by the transaction.
+   */
+  accountDelta(): AccountDelta;
+  /**
+   * Returns the notes created by the transaction.
+   */
+  createdNotes(): OutputNotes;
+  /**
+   * Returns the block height at which the transaction was submitted.
+   */
+  submissionHeight(): number;
+  /**
+   * Returns the executed transaction associated with this update.
+   */
+  executedTransaction(): ExecutedTransaction;
+  /**
+   * Serializes the update into bytes.
+   */
   serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): TransactionStoreUpdate;
 }
+/**
+ * Represents a transaction summary.
+ */
 export class TransactionSummary {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  serialize(): Uint8Array;
+  /**
+   * Deserializes a summary from bytes.
+   */
   static deserialize(bytes: Uint8Array): TransactionSummary;
-  accountDelta(): AccountDelta;
+  /**
+   * Returns the input notes referenced by the summary.
+   */
   inputNotes(): InputNotes;
+  /**
+   * Returns the output notes referenced by the summary.
+   */
   outputNotes(): OutputNotes;
+  /**
+   * Returns the account delta described by the summary.
+   */
+  accountDelta(): AccountDelta;
+  /**
+   * Computes the commitment to this `TransactionSummary`.
+   */
+  toCommitment(): Word;
+  /**
+   * Returns the random salt mixed into the summary commitment.
+   */
   salt(): Word;
+  /**
+   * Serializes the summary into bytes.
+   */
+  serialize(): Uint8Array;
 }
 export class WebClient {
   free(): void;
   [Symbol.dispose](): void;
-  getAccounts(): Promise<AccountHeader[]>;
-  getAccount(account_id: AccountId): Promise<Account | undefined>;
-  getAccountAuthByPubKey(pub_key: Word): Promise<AuthSecretKey>;
-  insertAccountAddress(account_id: AccountId, address: Address): Promise<void>;
-  removeAccountAddress(account_id: AccountId, address: Address): Promise<void>;
-  exportNoteFile(note_id: string, export_type: string): Promise<NoteFile>;
+  newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme: AuthScheme): Promise<Account>;
+  newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme: AuthScheme, init_seed?: Uint8Array | null): Promise<Account>;
+  newAccount(account: Account, overwrite: boolean): Promise<void>;
+  addAccountSecretKeyToWebStore(account_id: AccountId, secret_key: AuthSecretKey): Promise<void>;
+  getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
   /**
-   * Retrieves the entire underlying web store and returns it as a `JsValue`
-   *
-   * Meant to be used in conjunction with the `force_import_store` method
+   * Send a private note via the note transport layer
    */
-  exportStore(): Promise<any>;
-  exportAccountFile(account_id: AccountId): Promise<AccountFile>;
-  importAccountFile(account_file: AccountFile): Promise<any>;
-  importPublicAccountFromSeed(init_seed: Uint8Array, mutable: boolean, auth_scheme_id: number): Promise<Account>;
-  importAccountById(account_id: AccountId): Promise<any>;
-  importNoteFile(note_file: NoteFile): Promise<NoteId>;
-  forceImportStore(store_dump: any): Promise<any>;
+  sendPrivateNote(note: Note, address: Address): Promise<void>;
   /**
-   * 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.
+   * Fetch private notes from the note transport layer
+   *
+   * Uses an internal pagination mechanism to avoid fetching duplicate notes.
    */
-  createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<any>;
+  fetchPrivateNotes(): Promise<void>;
   /**
-   * Returns the inner serialized mock chain if it exists.
+   * Fetch all private notes from the note transport layer
+   *
+   * Fetches all notes stored in the transport layer, with no pagination.
+   * Prefer using [`WebClient::fetch_private_notes`] for a more efficient, on-going,
+   * fetching mechanism.
    */
-  serializeMockChain(): Uint8Array;
+  fetchAllPrivateNotes(): Promise<void>;
+  applyTransaction(transaction_result: TransactionResult, submission_height: number): Promise<TransactionStoreUpdate>;
   /**
-   * Returns the inner serialized mock note transport node if it exists.
+   * Generates a transaction proof using either the provided prover or the client's default
+   * prover if none is supplied.
    */
-  serializeMockNoteTransportNode(): Uint8Array;
-  proveBlock(): void;
-  usesMockChain(): boolean;
-  newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme_id: number, init_seed?: Uint8Array | null): Promise<Account>;
-  newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme_id: number): Promise<Account>;
-  newAccount(account: Account, overwrite: boolean): Promise<void>;
-  addAccountSecretKeyToWebStore(secret_key: SecretKey): Promise<void>;
+  proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
   /**
-   * Executes a transaction specified by the request against the specified account,
-   * proves it, submits it to the network, and updates the local database.
+   * Executes a transaction and returns the `TransactionSummary`.
    *
-   * If the transaction utilizes foreign account data, there is a chance that the client doesn't
-   * have the required block header in the local database. In these scenarios, a sync to
-   * the chain tip is performed, and the required block header is retrieved.
+   * If the transaction is unauthorized (auth script emits the unauthorized event),
+   * returns the summary from the error. If the transaction succeeds, constructs
+   * a summary from the executed transaction using the `auth_arg` from the transaction
+   * request as the salt (or a zero salt if not provided).
+   *
+   * # Errors
+   * - If there is an internal failure during execution.
    */
-  submitNewTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionId>;
+  executeForSummary(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionSummary>;
   /**
    * Executes a transaction specified by the request against the specified account but does not
    * submit it to the network nor update the local database. The returned [`TransactionResult`]
@@ -1739,39 +3734,96 @@ export class WebClient {
    */
   executeTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionResult>;
   /**
-   * Generates a transaction proof using either the provided prover or the client's default
-   * prover if none is supplied.
+   * Executes a transaction specified by the request against the specified account,
+   * proves it, submits it to the network, and updates the local database.
+   *
+   * Uses the prover configured for this client.
+   *
+   * If the transaction utilizes foreign account data, there is a chance that the client doesn't
+   * have the required block header in the local database. In these scenarios, a sync to
+   * the chain tip is performed, and the required block header is retrieved.
    */
-  proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
+  submitNewTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionId>;
   submitProvenTransaction(proven_transaction: ProvenTransaction, transaction_result: TransactionResult): Promise<number>;
-  applyTransaction(transaction_result: TransactionResult, submission_height: number): Promise<TransactionStoreUpdate>;
   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;
-  newConsumeTransactionRequest(list_of_note_ids: string[]): 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;
+  newConsumeTransactionRequest(list_of_notes: Note[]): TransactionRequest;
   /**
-   * Send a private note via the note transport layer
+   * Executes a transaction specified by the request against the specified account, proves it
+   * with the user provided prover, submits it to the network, and updates the local database.
+   *
+   * If the transaction utilizes foreign account data, there is a chance that the client doesn't
+   * have the required block header in the local database. In these scenarios, a sync to the
+   * chain tip is performed, and the required block header is retrieved.
    */
-  sendPrivateNote(note: Note, address: Address): Promise<void>;
+  submitNewTransactionWithProver(account_id: AccountId, transaction_request: TransactionRequest, prover: TransactionProver): Promise<TransactionId>;
+  proveBlock(): void;
+  usesMockChain(): boolean;
   /**
-   * Fetch private notes from the note transport layer
-   *
-   * Uses an internal pagination mechanism to avoid fetching duplicate notes.
+   * 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.
    */
-  fetchPrivateNotes(): Promise<void>;
+  createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<any>;
   /**
-   * Fetch all private notes from the note transport layer
+   * Returns the inner serialized mock chain if it exists.
+   */
+  serializeMockChain(): Uint8Array;
+  /**
+   * Returns the inner serialized mock note transport node if it exists.
+   */
+  serializeMockNoteTransportNode(): Uint8Array;
+  static buildSwapTag(note_type: NoteType, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint): NoteTag;
+  getSyncHeight(): Promise<number>;
+  /**
+   * Internal implementation of `sync_state`.
    *
-   * Fetches all notes stored in the transport layer, with no pagination.
-   * Prefer using [`WebClient::fetch_private_notes`] for a more efficient, on-going,
-   * fetching mechanism.
+   * This method performs the actual sync operation. Concurrent call coordination
+   * is handled at the JavaScript layer using the Web Locks API.
+   *
+   * **Note:** Do not call this method directly. Use `syncState()` from JavaScript instead,
+   * which provides proper coordination for concurrent calls.
    */
-  fetchAllPrivateNotes(): Promise<void>;
-  getInputNotes(filter: NoteFilter): Promise<InputNoteRecord[]>;
+  syncStateImpl(): Promise<SyncSummary>;
+  removeTag(tag: string): Promise<void>;
+  addTag(tag: string): Promise<void>;
+  listTags(): Promise<any>;
   getInputNote(note_id: string): Promise<InputNoteRecord | undefined>;
-  getOutputNotes(filter: NoteFilter): Promise<any>;
-  getOutputNote(note_id: string): Promise<any>;
+  getInputNotes(filter: NoteFilter): Promise<InputNoteRecord[]>;
+  getOutputNote(note_id: string): Promise<OutputNoteRecord>;
+  getOutputNotes(filter: NoteFilter): Promise<OutputNoteRecord[]>;
   getConsumableNotes(account_id?: AccountId | null): Promise<ConsumableNoteRecord[]>;
+  /**
+   * Retrieves the entire underlying web store and returns it as a `JsValue`
+   *
+   * Meant to be used in conjunction with the `force_import_store` method
+   */
+  exportStore(): Promise<any>;
+  exportNoteFile(note_id: string, export_type: string): Promise<NoteFile>;
+  exportAccountFile(account_id: AccountId): Promise<AccountFile>;
+  importNoteFile(note_file: NoteFile): Promise<NoteId>;
+  forceImportStore(store_dump: any, _store_name: string): Promise<any>;
+  importAccountFile(account_file: AccountFile): Promise<any>;
+  importAccountById(account_id: AccountId): Promise<any>;
+  importPublicAccountFromSeed(init_seed: Uint8Array, mutable: boolean, auth_scheme: AuthScheme): Promise<Account>;
+  getAccount(account_id: AccountId): Promise<Account | undefined>;
+  getAccounts(): Promise<AccountHeader[]>;
+  insertAccountAddress(account_id: AccountId, address: Address): Promise<void>;
+  removeAccountAddress(account_id: AccountId, address: Address): Promise<void>;
+  /**
+   * 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 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 setting value for `key`, or `None` if it hasn’t been set.
    */
@@ -1788,39 +3840,80 @@ export class WebClient {
    * Returns all the existing setting keys from the store.
    */
   listSettingKeys(): Promise<string[]>;
-  syncState(): Promise<SyncSummary>;
-  getSyncHeight(): Promise<number>;
-  static buildSwapTag(note_type: NoteType, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint): NoteTag;
-  addTag(tag: string): Promise<void>;
-  removeTag(tag: string): Promise<void>;
-  listTags(): Promise<any>;
-  getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
-  constructor();
   /**
-   * Creates a new client with the given node URL and optional seed.
-   * If `node_url` is `None`, it defaults to the testnet endpoint.
+   * Creates a new `WebClient` instance with the specified configuration.
+   *
+   * # Arguments
+   * * `node_url`: The URL of the node RPC endpoint. If `None`, defaults to the testnet endpoint.
+   * * `node_note_transport_url`: Optional URL of the note transport service.
+   * * `seed`: Optional seed for account initialization.
+   * * `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.
    */
-  createClient(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null): Promise<any>;
+  createClient(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, store_name?: string | null): Promise<any>;
   /**
-   * Creates a new client with the given node URL, optional seed, and external keystore
-   * callbacks. If `node_url` is `None`, it defaults to the testnet endpoint.
+   * Sets the debug mode for transaction execution.
+   *
+   * When enabled, the transaction executor will record additional information useful for
+   * debugging (the values on the VM stack and the state of the advice provider). This is
+   * disabled by default since it adds overhead.
+   *
+   * Must be called before `createClient`.
    */
-  createClientWithExternalKeystore(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, get_key_cb?: Function | null, insert_key_cb?: Function | null, sign_cb?: Function | null): Promise<any>;
-  createScriptBuilder(): ScriptBuilder;
+  setDebugMode(enabled: boolean): void;
+  createCodeBuilder(): CodeBuilder;
+  /**
+   * Creates a new `WebClient` instance with external keystore callbacks.
+   *
+   * # Arguments
+   * * `node_url`: The URL of the node RPC endpoint. If `None`, defaults to the testnet endpoint.
+   * * `node_note_transport_url`: Optional URL of the note transport service.
+   * * `seed`: Optional seed for account initialization.
+   * * `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.
+   * * `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.
+   */
+  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): Promise<any>;
+  constructor();
 }
 export class Word {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Deserializes a word from bytes.
+   */
+  static deserialize(bytes: Uint8Array): Word;
+  /**
+   * Creates a word from four field elements.
+   */
+  static newFromFelts(felt_vec: Felt[]): Word;
+  /**
+   * Creates a word from four u64 values.
+   */
   constructor(u64_vec: BigUint64Array);
+  /**
+   * Returns the hex representation of the word.
+   */
+  toHex(): string;
+  /**
+   * Returns the word as an array of u64 values.
+   */
+  toU64s(): BigUint64Array;
   /**
    * 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;
-  static newFromFelts(felt_vec: Felt[]): Word;
-  toHex(): string;
-  serialize(): Uint8Array;
-  static deserialize(bytes: Uint8Array): Word;
-  toU64s(): BigUint64Array;
+  /**
+   * Returns the word as an array of field elements.
+   */
   toFelts(): Felt[];
+  /**
+   * Serializes the word into bytes.
+   */
+  serialize(): Uint8Array;
 }