@miden-sdk/miden-sdk 0.14.2 → 0.14.4

package/dist/api-types.d.ts

@@ -921,6 +921,15 @@ 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;
@@ -934,6 +943,30 @@ 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. */

package/dist/crates/miden_client_web.d.ts

@@ -1005,6 +1005,15 @@ export class BlockHeader {
      * Returns the commitment to the block contents.
      */
     commitment(): Word;
+    /**
+     * Returns the account ID of the fungible faucet whose assets are accepted as the native
+     * asset of the blockchain (i.e. the asset used for paying transaction verification fees).
+     *
+     * This is stored on-chain as part of the block's fee parameters, which means consumers can
+     * discover the native faucet by reading any block header rather than hardcoding it per
+     * network.
+     */
+    nativeAssetId(): AccountId;
     /**
      * Returns the note commitment root.
      */
@@ -4316,6 +4325,31 @@ export class WebClient {
     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.
      */
@@ -4338,10 +4372,20 @@ export class WebClient {
     newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme: AuthScheme, init_seed?: Uint8Array | null): Promise<Account>;
     proveBlock(): void;
     /**
-     * Generates a transaction proof using either the provided prover or the client's default
-     * prover if none is supplied.
+     * Generates a transaction proof using the client's default (local) prover.
      */
-    proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
+    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.
+     */
+    proveTransactionWithProver(transaction_result: TransactionResult, prover: TransactionProver): Promise<ProvenTransaction>;
     /**
      * Prunes historical account states for the specified account up to the given nonce.
      *

package/dist/eager.js

@@ -0,0 +1,35 @@
+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';
+import './wasm.js';
+
+// Eager entry point for @miden-sdk/miden-sdk.
+//
+// Awaits WASM initialization at module top level, so importing this module
+// guarantees that any wasm-bindgen constructor (`new RpcClient(...)`,
+// `AccountId.fromHex(...)`, `TransactionProver.newRemoteProver(...)`, etc.)
+// 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`).
+//
+// When NOT to use this entry:
+// - **Capacitor mobile apps** (Miden Wallet iOS/Android): Capacitor's
+//   `capacitor://localhost` scheme handler interacts poorly with top-level
+//   await in the main WKWebView. Verified empirically: TLA in a Capacitor
+//   host WKWebView hangs module evaluation indefinitely, while the same
+//   TLA in the dApp-browser WKWebView (vanilla HTTPS) resolves in <100ms.
+// - **Next.js / SSR**: TLA blocks server-side module evaluation.
+// - **Framework adapters (@miden-sdk/react, etc.)**: they manage readiness
+//   via their own state machine (e.g. `isReady`) and should not impose
+//   TLA on consumer bundles.
+//
+// For those contexts, import from `@miden-sdk/miden-sdk/lazy` — identical
+// API surface, no top-level await, callers are responsible for awaiting
+// `MidenClient.ready()` (or the equivalent) before touching wasm-bindgen
+// types.
+
+await getWasmOrThrow();
+
+export { getWasmOrThrow };
+//# sourceMappingURL=eager.js.map

package/dist/eager.js.map

@@ -0,0 +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;;;;"}