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

package/dist/api-types.d.ts

@@ -32,17 +32,17 @@ import type {
   NoteScript,
   AdviceInputs,
   FeltArray,
-} from "./crates/miden_client_web";
+} from "./crates/miden_client_web.js";
 
 // Import the full namespace for the MidenArrayConstructors type
-import type * as WasmExports from "./crates/miden_client_web";
+import type * as WasmExports from "./crates/miden_client_web.js";
 
 // Source of truth for standalone-wrapper return types. By deriving them from
 // the wasm-bindgen-generated namespace (rather than hand-writing `: Note`),
 // the declarations below cannot drift from the actual runtime behavior — the
 // exact class of bug behind #2042. Any forwarder-style wrapper should follow
 // the same pattern: `ReturnType<WasmModule["Class"]["method"]>`.
-type WasmModule = typeof import("./crates/miden_client_web");
+type WasmModule = typeof import("./crates/miden_client_web.js");
 
 // ════════════════════════════════════════════════════════════════
 // Callback types for external keystore support
@@ -187,6 +187,8 @@ export interface ClientOptions {
   storeName?: string;
   /** Sync state on creation (default: false). */
   autoSync?: boolean;
+  /** Enable debug mode for transaction execution (default: false). */
+  debugMode?: boolean;
   /** External keystore callbacks. */
   keystore?: {
     getKey: GetKeyCallback;
@@ -436,11 +438,18 @@ export interface PreviewSwapOptions {
   paybackType?: NoteVisibility;
 }
 
+export interface PreviewCustomOptions {
+  operation: "custom";
+  account: AccountRef;
+  request: TransactionRequest;
+}
+
 export type PreviewOptions =
   | PreviewSendOptions
   | PreviewMintOptions
   | PreviewConsumeOptions
-  | PreviewSwapOptions;
+  | PreviewSwapOptions
+  | PreviewCustomOptions;
 
 /** Status values reported during waitFor polling. */
 export type WaitStatus = "pending" | "submitted" | "committed";
@@ -520,12 +529,6 @@ export interface MockOptions {
   serializedNoteTransport?: Uint8Array;
 }
 
-/** Versioned store snapshot for backup/restore. */
-export interface StoreSnapshot {
-  version: number;
-  data: unknown;
-}
-
 // ════════════════════════════════════════════════════════════════
 // Swap tag options
 // ════════════════════════════════════════════════════════════════
@@ -921,15 +924,6 @@ export declare class MidenClient {
   static createDevnet(options?: ClientOptions): Promise<MidenClient>;
   /** Creates a mock client for testing. */
   static createMock(options?: MockOptions): Promise<MidenClient>;
-  /**
-   * Resolves once the WASM module is initialized and safe to use.
-   *
-   * Idempotent and shared across callers — concurrent invocations await the
-   * same in-flight promise, and post-init callers resolve immediately.
-   * Primarily useful on the `/lazy` entry (Next.js / Capacitor) where no
-   * top-level await runs at import time; harmless on the eager entry.
-   */
-  static ready(): Promise<void>;
 
   readonly accounts: AccountsResource;
   readonly transactions: TransactionsResource;
@@ -943,46 +937,22 @@ export declare class MidenClient {
   sync(options?: { timeout?: number }): Promise<SyncSummary>;
   /** Returns the current sync height. */
   getSyncHeight(): Promise<number>;
-  /**
-   * Resolves once every serialized WASM call that was already on the
-   * internal call chain when `waitForIdle()` was called (execute, submit,
-   * prove, apply, sync, or account creation) has settled. Use this from
-   * callers that need to perform a non-WASM-side action — e.g. clearing
-   * an in-memory auth key on wallet lock — after the kernel finishes, so
-   * its auth callback doesn't race with the key being cleared. Does NOT
-   * wait for calls enqueued after `waitForIdle()` returns.
-   *
-   * Caveat for `sync`: a `syncState` blocked on its sync lock (Web
-   * Locks) has not yet reached the internal chain, so `waitForIdle`
-   * does not await it. Other serialized methods are always observed.
-   *
-   * Returns immediately if nothing was in flight.
-   */
-  waitForIdle(): Promise<void>;
-  /**
-   * Returns the raw JS value that the most recent sign-callback invocation
-   * threw, or `null` if the last sign call succeeded (or no call has
-   * happened yet). Useful for recovering structured metadata (e.g. a
-   * `reason: 'locked'` property) that the kernel-level `auth::request`
-   * diagnostic would otherwise erase.
-   */
-  lastAuthError(): unknown;
   /** Returns the client-level default prover. */
   readonly defaultProver: TransactionProver | null;
   /** Terminates the underlying Web Worker. After this, all method calls throw. */
   terminate(): void;
 
   /** Returns the identifier of the underlying store (e.g. IndexedDB database name, file path). */
-  storeIdentifier(): string;
+  storeIdentifier(): Promise<string>;
 
   /** Advances the mock chain by one block. Only available on mock clients. */
-  proveBlock(): void;
+  proveBlock(): Promise<void>;
   /** Returns true if this client uses a mock chain. */
   usesMockChain(): boolean;
   /** Serializes the mock chain state for snapshot/restore in tests. */
-  serializeMockChain(): Uint8Array;
+  serializeMockChain(): Promise<Uint8Array>;
   /** Serializes the mock note transport node state. */
-  serializeMockNoteTransportNode(): Uint8Array;
+  serializeMockNoteTransportNode(): Promise<Uint8Array>;
 
   [Symbol.dispose](): void;
   [Symbol.asyncDispose](): Promise<void>;

package/dist/crates/miden_client_web.d.ts

@@ -129,16 +129,17 @@ export class AccountBuilder {
     [Symbol.dispose](): void;
     /**
      * Sets the account type (regular, faucet, etc.).
-     *
-     * Accepts either a numeric WASM enum value (0–3) or a string name
-     * (`"FungibleFaucet"`, `"NonFungibleFaucet"`,
-     * `"RegularAccountImmutableCode"`, `"RegularAccountUpdatableCode"`).
      */
-    accountType(account_type: any): AccountBuilder;
+    accountType(account_type: AccountType): AccountBuilder;
     /**
-     * Builds the account and returns it together with the derived seed.
+     * Builds the account (including merged storage schema commitment metadata) and returns it
+     * together with the derived seed.
      */
     build(): AccountBuilderResult;
+    /**
+     * Builds the account without adding the schema commitment component (legacy behavior).
+     */
+    buildWithoutSchemaCommitment(): AccountBuilderResult;
     /**
      * Creates a new account builder from a 32-byte initial seed.
      */
@@ -494,7 +495,7 @@ export class AccountProof {
      *
      * Each entry contains a `key` and `value` as `Word` objects.
      */
-    getStorageMapEntries(slot_name: string): StorageMapEntry[] | undefined;
+    getStorageMapEntries(slot_name: string): StorageMapEntryJs[] | undefined;
     /**
      * Returns the names of all storage slots that have map details available.
      *
@@ -524,6 +525,13 @@ export class AccountProof {
      * Returns the number of storage slots, if available (public accounts only).
      */
     numStorageSlots(): number | undefined;
+    /**
+     * Returns the fungible assets in the account's vault, if vault details were included
+     * in the proof response.
+     *
+     * Returns `undefined` if the account is private or vault data was not requested.
+     */
+    vaultFungibleAssets(): FungibleAsset[] | undefined;
 }
 
 /**
@@ -653,7 +661,7 @@ export class AccountStorage {
      * Returns `undefined` if the slot isn't a map or doesn't exist.
      * Returns `[]` if the map exists but is empty.
      */
-    getMapEntries(slot_name: string): JsStorageMapEntry[] | undefined;
+    getMapEntries(slot_name: string): StorageMapEntry[] | undefined;
     /**
      * Returns the value for a key in the map stored at the given slot, if any.
      */
@@ -1005,15 +1013,6 @@ export class BlockHeader {
      * Returns the commitment to the block contents.
      */
     commitment(): Word;
-    /**
-     * Returns the account ID of the fungible faucet whose assets are accepted as the native
-     * asset of the blockchain (i.e. the asset used for paying transaction verification fees).
-     *
-     * This is stored on-chain as part of the block's fee parameters, which means consumers can
-     * discover the native faucet by reading any block header rather than hardcoding it per
-     * network.
-     */
-    nativeAssetId(): AccountId;
     /**
      * Returns the note commitment root.
      */
@@ -1295,7 +1294,7 @@ export class Felt {
      */
     asInt(): bigint;
     /**
-     * Creates a new field element from a u64 value.
+     * Creates a new field element.
      */
     constructor(value: bigint);
     /**
@@ -2003,6 +2002,32 @@ export class NetworkId {
     static testnet(): NetworkId;
 }
 
+/**
+ * Status of a network note in the node.
+ */
+export class NetworkNoteStatusInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns the number of processing attempts.
+     */
+    readonly attemptCount: number;
+    /**
+     * Returns the block number of the last processing attempt, if any.
+     */
+    readonly lastAttemptBlockNum: number | undefined;
+    /**
+     * Returns the last error message, if any.
+     */
+    readonly lastError: string | undefined;
+    /**
+     * Returns the status as a string: `"Pending"`, `"NullifierInflight"`, `"Discarded"`, or
+     * `"NullifierCommitted"`.
+     */
+    readonly status: string;
+}
+
 /**
  * The type of a Miden network.
  */
@@ -3240,8 +3265,23 @@ export class RpcClient {
     getAccountProof(account_id: AccountId, storage_requirements?: AccountStorageRequirements | null, block_num?: number | null, known_vault_commitment?: Word | null): Promise<AccountProof>;
     /**
      * Fetches a block header by number. When `block_num` is undefined, returns the latest header.
+     *
+     * @param `block_num` - Optional block number. When `undefined`, returns the latest header.
+     * @param `include_mmr_proof` - When `true`, includes the MMR proof in the response. Defaults
+     *   to `false` when `undefined`.
+     */
+    getBlockHeaderByNumber(block_num?: number | null, include_mmr_proof?: boolean | null): Promise<BlockHeader>;
+    /**
+     * Fetches the processing status of a network note by its ID.
+     *
+     * Returns information about the note's current status in the network,
+     * including whether it is pending, processed, discarded, or committed,
+     * along with error details and attempt count.
+     *
+     * @param `note_id` - The ID of the note to query.
+     * @returns Promise that resolves to a `NetworkNoteStatusInfo` object.
      */
-    getBlockHeaderByNumber(block_num?: number | null): Promise<BlockHeader>;
+    getNetworkNoteStatus(note_id: NoteId): Promise<NetworkNoteStatusInfo>;
     /**
      * Fetches a note script by its root hash from the connected Miden node.
      *
@@ -3511,10 +3551,27 @@ export class StorageMap {
     constructor();
 }
 
+export class StorageMapEntry {
+    private constructor();
+    /**
+     ** Return copy of self without private attributes.
+     */
+    toJSON(): Object;
+    /**
+     * Return stringified version of self.
+     */
+    toString(): string;
+    free(): void;
+    [Symbol.dispose](): void;
+    key: string;
+    root: string;
+    value: string;
+}
+
 /**
  * A key-value entry from a storage map.
  */
-export class StorageMapEntry {
+export class StorageMapEntryJs {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
@@ -4203,7 +4260,8 @@ export class WebClient {
      * const balance = await reader.getBalance(faucetId);
      * ```
      */
-    accountReader(account_id: AccountId): AccountReader;
+    accountReader(account_id: AccountId): Promise<AccountReader>;
+    addAccountSecretKeyToWebStore(account_id: AccountId, secret_key: AuthSecretKey): Promise<void>;
     addTag(tag: string): Promise<void>;
     applyTransaction(transaction_result: TransactionResult, submission_height: number): Promise<TransactionStoreUpdate>;
     static buildSwapTag(note_type: NoteType, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint): NoteTag;
@@ -4217,6 +4275,9 @@ export class WebClient {
      * * `store_name`: Optional name for the web store. If `None`, the store name defaults to
      *   `MidenClientDB_{network_id}`, where `network_id` is derived from the `node_url`.
      *   Explicitly setting this allows for creating multiple isolated clients.
+     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. When enabled,
+     *   the transaction executor records additional information useful for debugging. Defaults to
+     *   disabled.
      */
     createClient(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, store_name?: string | null, debug_mode?: boolean | null): Promise<any>;
     /**
@@ -4232,14 +4293,16 @@ export class WebClient {
      * * `get_key_cb`: Callback to retrieve the secret key bytes for a given public key.
      * * `insert_key_cb`: Callback to persist a secret key.
      * * `sign_cb`: Callback to produce serialized signature bytes for the provided inputs.
+     * * `debug_mode`: Optional flag to enable debug mode for transaction execution. Defaults to
+     *   disabled.
      */
     createClientWithExternalKeystore(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, store_name?: string | null, get_key_cb?: Function | null, insert_key_cb?: Function | null, sign_cb?: Function | null, debug_mode?: boolean | null): Promise<any>;
-    createCodeBuilder(): CodeBuilder;
+    createCodeBuilder(): Promise<CodeBuilder>;
     /**
      * Creates a new client with a mock RPC API. Useful for testing purposes and proof-of-concept
      * applications as it uses a mock chain that simulates the behavior of a real node.
      */
-    createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<any>;
+    createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<string>;
     /**
      * Executes a transaction and returns the `TransactionSummary`.
      *
@@ -4290,6 +4353,18 @@ export class WebClient {
      * This method loads the complete account state including vault, storage, and code.
      */
     getAccount(account_id: AccountId): Promise<Account | undefined>;
+    /**
+     * Retrieves an authentication secret key from the keystore given a public key commitment.
+     *
+     * The public key commitment should correspond to one of the keys tracked by the keystore.
+     * Returns the associated [`AuthSecretKey`] if found, or an error if not found.
+     */
+    getAccountAuthByPubKeyCommitment(pub_key_commitment: Word): Promise<AuthSecretKey>;
+    /**
+     * Retrieves the full account data for the account associated with the given public key
+     * commitment, returning `null` if no account is found.
+     */
+    getAccountByKeyCommitment(pub_key_commitment: Word): Promise<Account | undefined>;
     /**
      * Retrieves the account code for a specific account.
      *
@@ -4315,46 +4390,28 @@ export class WebClient {
     getOutputNote(note_id: string): Promise<OutputNoteRecord>;
     getOutputNotes(filter: NoteFilter): Promise<OutputNoteRecord[]>;
     /**
-     * Retrieves the setting value for `key`, or `None` if it hasn’t been set.
+     * Returns all public key commitments associated with the given account ID.
+     *
+     * These commitments can be used with [`getAccountAuthByPubKeyCommitment`]
+     * to retrieve the corresponding secret keys from the keystore.
+     */
+    getPublicKeyCommitmentsOfAccount(account_id: AccountId): Promise<Word[]>;
+    /**
+     * Retrieves the setting value for `key`, or `None` if it hasn't been set.
      */
     getSetting(key: string): Promise<any | undefined>;
     getSyncHeight(): Promise<number>;
     getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
-    importAccountById(account_id: AccountId): Promise<any>;
-    importAccountFile(account_file: AccountFile): Promise<any>;
+    importAccountById(account_id: AccountId): Promise<void>;
+    importAccountFile(account_file: AccountFile): Promise<string>;
     importNoteFile(note_file: NoteFile): Promise<NoteId>;
     importPublicAccountFromSeed(init_seed: Uint8Array, mutable: boolean, auth_scheme: AuthScheme): Promise<Account>;
     insertAccountAddress(account_id: AccountId, address: Address): Promise<void>;
-    /**
-     * Returns the raw JS value that the most recent sign-callback invocation
-     * threw, or `null` if the last sign call succeeded (or no call has
-     * happened yet).
-     *
-     * Combined with the serialized-call discipline enforced at the JS
-     * `WebClient` wrapper, this lets a caller that caught a failed
-     * `executeTransaction` / `submitNewTransaction` recover the original
-     * JS error the signing callback threw — preserving any structured
-     * metadata (e.g. a `reason: 'locked'` property) that the kernel-level
-     * `auth::request` diagnostic would otherwise have erased.
-     *
-     * # Usage (TS)
-     * ```ts
-     * try {
-     *   await client.submitNewTransaction(acc, req);
-     * } catch (e) {
-     *   const authErr = client.lastAuthError();
-     *   if (authErr && authErr.reason === 'locked') {
-     *     // wait for unlock, then retry
-     *   }
-     * }
-     * ```
-     */
-    lastAuthError(): any;
     /**
      * Returns all the existing setting keys from the store.
      */
     listSettingKeys(): Promise<string[]>;
-    listTags(): Promise<any>;
+    listTags(): Promise<string[]>;
     constructor();
     newAccount(account: Account, overwrite: boolean): Promise<void>;
     /**
@@ -4366,26 +4423,16 @@ export class WebClient {
     newAccountWithSecretKey(account: Account, secret_key: AuthSecretKey): Promise<void>;
     newConsumeTransactionRequest(list_of_notes: Note[]): TransactionRequest;
     newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme: AuthScheme): Promise<Account>;
-    newMintTransactionRequest(target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint): TransactionRequest;
-    newSendTransactionRequest(sender_account_id: AccountId, target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint, recall_height?: number | null, timelock_height?: number | null): TransactionRequest;
-    newSwapTransactionRequest(sender_account_id: AccountId, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint, note_type: NoteType, payback_note_type: NoteType): TransactionRequest;
+    newMintTransactionRequest(target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint): Promise<TransactionRequest>;
+    newSendTransactionRequest(sender_account_id: AccountId, target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint, recall_height?: number | null, timelock_height?: number | null): Promise<TransactionRequest>;
+    newSwapTransactionRequest(sender_account_id: AccountId, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint, note_type: NoteType, payback_note_type: NoteType): Promise<TransactionRequest>;
     newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme: AuthScheme, init_seed?: Uint8Array | null): Promise<Account>;
-    proveBlock(): void;
+    proveBlock(): Promise<void>;
     /**
-     * Generates a transaction proof using the client's default (local) prover.
-     */
-    proveTransaction(transaction_result: TransactionResult): Promise<ProvenTransaction>;
-    /**
-     * Generates a transaction proof using the provided prover.
-     *
-     * Takes the prover by reference so the JS-side handle is NOT consumed
-     * by wasm-bindgen. Taking `TransactionProver` by value would transfer
-     * ownership on each call, invalidating the JS object's internal WASM
-     * handle; after one use, subsequent calls from JS would pass a dangling
-     * handle that wasm-bindgen interprets as `None`, silently falling back
-     * to the local prover.
+     * Generates a transaction proof using either the provided prover or the client's default
+     * prover if none is supplied.
      */
-    proveTransactionWithProver(transaction_result: TransactionResult, prover: TransactionProver): Promise<ProvenTransaction>;
+    proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
     /**
      * Prunes historical account states for the specified account up to the given nonce.
      *
@@ -4409,11 +4456,11 @@ export class WebClient {
     /**
      * Returns the inner serialized mock chain if it exists.
      */
-    serializeMockChain(): Uint8Array;
+    serializeMockChain(): Promise<Uint8Array>;
     /**
      * Returns the inner serialized mock note transport node if it exists.
      */
-    serializeMockNoteTransportNode(): Uint8Array;
+    serializeMockNoteTransportNode(): Promise<Uint8Array>;
     /**
      * Sets a setting key-value in the store. It can then be retrieved using `get_setting`.
      */
@@ -4421,7 +4468,7 @@ export class WebClient {
     /**
      * Returns the identifier of the underlying store (e.g. `IndexedDB` database name, file path).
      */
-    storeIdentifier(): string;
+    storeIdentifier(): Promise<string>;
     /**
      * Executes a transaction specified by the request against the specified account,
      * proves it, submits it to the network, and updates the local database.
@@ -4453,7 +4500,7 @@ export class WebClient {
      * which provides proper coordination for concurrent calls.
      */
     syncStateImpl(): Promise<SyncSummary>;
-    usesMockChain(): boolean;
+    usesMockChain(): Promise<boolean>;
     /**
      * Returns a `WebKeystoreApi` handle for managing secret keys.
      *
@@ -4506,11 +4553,10 @@ export class Word {
     static deserialize(bytes: Uint8Array): Word;
     /**
      * Creates a Word from a hex string.
-     * Fails if the provided string is not a valid hex representation of a Word.
      */
     static fromHex(hex: string): Word;
     /**
-     * Creates a word from four u64 values.
+     * Creates a word from four numeric values.
      */
     constructor(u64_vec: BigUint64Array);
     /**
@@ -4530,7 +4576,7 @@ export class Word {
      */
     toHex(): string;
     /**
-     * Returns the word as an array of u64 values.
+     * Returns the word as an array of numeric values.
      */
     toU64s(): BigUint64Array;
 }

package/dist/docs-entry.d.ts

@@ -29,7 +29,10 @@ export {
   TransactionRequest,
   TransactionSummary,
   Word,
-} from "./crates/miden_client_web";
+} from "./crates/miden_client_web.js";
 
 // All simplified API types
-export * from "./api-types";
+export * from "./api-types.js";
+
+// Storage utilities
+export { StorageView, StorageResult, wordToBigInt } from "./index.js";

package/dist/eager.js

@@ -1,9 +1,9 @@
 import { getWasmOrThrow } from './index.js';
-export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWasmWebClient, NoteVisibility, StorageMode, WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote } from './index.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, setupLogging } from './Cargo-Bwjf7IkR.js';
+export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWasmWebClient, MockWasmWebClient as MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, wordToBigInt } from './index.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, setupLogging } from './Cargo-CVlXCH_2.js';
 import './wasm.js';
 
-// Eager entry point for @miden-sdk/miden-sdk.
+// Eager entry point for @miden-sdk/miden-sdk (browser builds).
 //
 // Awaits WASM initialization at module top level, so importing this module
 // guarantees that any wasm-bindgen constructor (`new RpcClient(...)`,
@@ -11,7 +11,10 @@ import './wasm.js';
 // is safe to call synchronously on the next line. No explicit
 // `await MidenClient.ready()` / `isReady` gate is required.
 //
-// This is the default entry (`@miden-sdk/miden-sdk` → `./dist/eager.js`).
+// This is the default entry for browser bundlers (`@miden-sdk/miden-sdk`
+// → `./dist/eager.js`). Node.js consumers resolve the `node` exports
+// condition instead and get the napi binding via `./js/node-index.js`,
+// bypassing this file entirely.
 //
 // When NOT to use this entry:
 // - **Capacitor mobile apps** (Miden Wallet iOS/Android): Capacitor's

package/dist/eager.js.map

@@ -1 +1 @@
-{"version":3,"file":"eager.js","sources":["../js/eager.js"],"sourcesContent":["// Eager entry point for @miden-sdk/miden-sdk.\n//\n// Awaits WASM initialization at module top level, so importing this module\n// guarantees that any wasm-bindgen constructor (`new RpcClient(...)`,\n// `AccountId.fromHex(...)`, `TransactionProver.newRemoteProver(...)`, etc.)\n// is safe to call synchronously on the next line. No explicit\n// `await MidenClient.ready()` / `isReady` gate is required.\n//\n// This is the default entry (`@miden-sdk/miden-sdk` → `./dist/eager.js`).\n//\n// When NOT to use this entry:\n// - **Capacitor mobile apps** (Miden Wallet iOS/Android): Capacitor's\n//   `capacitor://localhost` scheme handler interacts poorly with top-level\n//   await in the main WKWebView. Verified empirically: TLA in a Capacitor\n//   host WKWebView hangs module evaluation indefinitely, while the same\n//   TLA in the dApp-browser WKWebView (vanilla HTTPS) resolves in <100ms.\n// - **Next.js / SSR**: TLA blocks server-side module evaluation.\n// - **Framework adapters (@miden-sdk/react, etc.)**: they manage readiness\n//   via their own state machine (e.g. `isReady`) and should not impose\n//   TLA on consumer bundles.\n//\n// For those contexts, import from `@miden-sdk/miden-sdk/lazy` — identical\n// API surface, no top-level await, callers are responsible for awaiting\n// `MidenClient.ready()` (or the equivalent) before touching wasm-bindgen\n// types.\nimport { getWasmOrThrow } from \"./index.js\";\n\nawait getWasmOrThrow();\n\nexport * from \"./index.js\";\n"],"names":[],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,MAAM,cAAc,EAAE;;;;"}
+{"version":3,"file":"eager.js","sources":["../js/eager.js"],"sourcesContent":["// Eager entry point for @miden-sdk/miden-sdk (browser builds).\n//\n// Awaits WASM initialization at module top level, so importing this module\n// guarantees that any wasm-bindgen constructor (`new RpcClient(...)`,\n// `AccountId.fromHex(...)`, `TransactionProver.newRemoteProver(...)`, etc.)\n// is safe to call synchronously on the next line. No explicit\n// `await MidenClient.ready()` / `isReady` gate is required.\n//\n// This is the default entry for browser bundlers (`@miden-sdk/miden-sdk`\n// → `./dist/eager.js`). Node.js consumers resolve the `node` exports\n// condition instead and get the napi binding via `./js/node-index.js`,\n// bypassing this file entirely.\n//\n// When NOT to use this entry:\n// - **Capacitor mobile apps** (Miden Wallet iOS/Android): Capacitor's\n//   `capacitor://localhost` scheme handler interacts poorly with top-level\n//   await in the main WKWebView. Verified empirically: TLA in a Capacitor\n//   host WKWebView hangs module evaluation indefinitely, while the same\n//   TLA in the dApp-browser WKWebView (vanilla HTTPS) resolves in <100ms.\n// - **Next.js / SSR**: TLA blocks server-side module evaluation.\n// - **Framework adapters (@miden-sdk/react, etc.)**: they manage readiness\n//   via their own state machine (e.g. `isReady`) and should not impose\n//   TLA on consumer bundles.\n//\n// For those contexts, import from `@miden-sdk/miden-sdk/lazy` — identical\n// API surface, no top-level await, callers are responsible for awaiting\n// `MidenClient.ready()` (or the equivalent) before touching wasm-bindgen\n// types.\nimport { getWasmOrThrow } from \"./index.js\";\n\nawait getWasmOrThrow();\n\nexport * from \"./index.js\";\n"],"names":[],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,MAAM,cAAc,EAAE;;;;"}