@miden-sdk/miden-sdk 0.15.3 → 0.15.5

package/dist/st/api-types.d.ts

@@ -30,6 +30,9 @@ import type {
   AccountStorageRequirements,
   TransactionScript,
   NoteScript,
+  NoteRecipient,
+  NoteExecutionHint,
+  NetworkAccountTarget,
   AdviceInputs,
   FeltArray,
   PswapLineageRecord,
@@ -357,6 +360,48 @@ export interface SendResult {
   result: TransactionResult;
 }
 
+/**
+ * Options for {@link TransactionsResource.createNetworkNote} and the standalone
+ * {@link buildNetworkNote}. Builds a Public, custom-script note carrying a
+ * `NetworkAccountTarget` attachment so a public network account auto-consumes it.
+ *
+ * Provide exactly one of `recipient` or `script`.
+ */
+export interface NetworkNoteOptions extends TransactionOptions {
+  /** Account that creates, funds, and submits the note (the executing sender). */
+  account: AccountRef;
+  /**
+   * The network account the note targets. Any account reference, or a pre-built
+   * `NetworkAccountTarget`. Encoded as the note's `NetworkAccountTarget`
+   * attachment — this is what makes `isNetworkNote()` true.
+   */
+  target: AccountRef | NetworkAccountTarget;
+  /** Execution hint when `target` is an account reference. Defaults to `always`. */
+  executionHint?: NoteExecutionHint;
+  /**
+   * Recipient carrying the note's custom consumption script. Build with
+   * `new NoteRecipient(serialNum, noteScript, noteStorage)`, or omit and pass
+   * `script` to have the recipient built for you.
+   */
+  recipient?: NoteRecipient;
+  /** Custom consumption script; the recipient is built with a fresh serial number. */
+  script?: NoteScript;
+  /** Note storage / inputs the script reads (used with `script`). */
+  inputs?: bigint[];
+  /** Assets locked into the note. Optional — a note may carry no assets. */
+  assets?: Asset | Asset[];
+  /** Extra attachment payload appended AFTER the required `NetworkAccountTarget`. */
+  attachment?: bigint[];
+}
+
+/** Result of {@link TransactionsResource.createNetworkNote}. */
+export interface NetworkNoteResult {
+  txId: TransactionId;
+  /** The built network note (read its id / attachments). */
+  note: Note;
+  result: TransactionResult;
+}
+
 /** Result of methods that previously returned bare TransactionId. */
 export interface TransactionSubmitResult {
   txId: TransactionId;
@@ -374,6 +419,21 @@ export interface MintOptions extends TransactionOptions {
   type?: NoteVisibility;
 }
 
+export interface BridgeOptions extends TransactionOptions {
+  /** Account that creates and funds the bridge note (the sender / executing account). */
+  account: AccountRef;
+  /** Bridge account that consumes the note and burns the bridged asset. */
+  bridgeAccount: AccountRef;
+  /** Faucet / token ID of the fungible asset to bridge. */
+  token: AccountRef;
+  /** Amount of the asset to bridge. */
+  amount: number | bigint;
+  /** AggLayer-assigned network ID of the destination chain. */
+  destinationNetwork: number;
+  /** Destination Ethereum address on the destination network (0x-prefixed hex). */
+  destinationAddress: string;
+}
+
 export interface ConsumeOptions extends TransactionOptions {
   account: AccountRef;
   notes: NoteInput | NoteInput[];
@@ -384,6 +444,73 @@ export interface ConsumeAllOptions extends TransactionOptions {
   maxNotes?: number;
 }
 
+/**
+ * A single operation inside a transaction batch. The shape mirrors the
+ * singular options types (`SendOptions`, `MintOptions`, ...) minus the
+ * `account` field — the executing account is set once at the batch level
+ * and shared by every operation (V1 single-account constraint).
+ */
+export type BatchOperation =
+  | {
+      kind: "send";
+      to: AccountRef;
+      token: AccountRef;
+      amount: number | bigint;
+      type?: NoteVisibility;
+      reclaimAfter?: number;
+      timelockUntil?: number;
+    }
+  | {
+      kind: "mint";
+      to: AccountRef;
+      amount: number | bigint;
+      type?: NoteVisibility;
+    }
+  | {
+      kind: "consume";
+      notes: NoteInput | NoteInput[];
+    }
+  | {
+      kind: "swap";
+      offer: Asset;
+      request: Asset;
+      type?: NoteVisibility;
+      paybackType?: NoteVisibility;
+    }
+  | {
+      kind: "execute";
+      script: TransactionScript;
+      foreignAccounts?: (
+        | AccountRef
+        | { id: AccountRef; storage?: AccountStorageRequirements }
+      )[];
+    }
+  | {
+      /** Escape hatch for pre-built TransactionRequests. */
+      kind: "custom";
+      request: TransactionRequest;
+    };
+
+export interface BatchOptions {
+  /** The account executing every operation in the batch (single-account in V1). */
+  account: AccountRef;
+  /** Operations to execute atomically as a batch. Must be non-empty. */
+  operations: BatchOperation[];
+  /**
+   * Wait until the batch's block has been observed in the local sync height.
+   * Differs from singular `waitForConfirmation`: the V1 batch API returns
+   * only a block number, so we poll chain height rather than per-tx status.
+   */
+  waitForConfirmation?: boolean;
+  /** Wall-clock polling timeout for `waitForConfirmation` (default 60_000ms). */
+  timeout?: number;
+}
+
+export interface BatchSubmitResult {
+  /** The block number the batch was accepted into. */
+  blockNumber: number;
+}
+
 export interface SwapOptions extends TransactionOptions {
   account: AccountRef;
   offer: Asset;
@@ -484,6 +611,16 @@ export interface PreviewMintOptions {
   type?: NoteVisibility;
 }
 
+export interface PreviewBridgeOptions {
+  operation: "bridge";
+  account: AccountRef;
+  bridgeAccount: AccountRef;
+  token: AccountRef;
+  amount: number | bigint;
+  destinationNetwork: number;
+  destinationAddress: string;
+}
+
 export interface PreviewConsumeOptions {
   operation: "consume";
   account: AccountRef;
@@ -531,6 +668,7 @@ export interface PreviewCustomOptions {
 export type PreviewOptions =
   | PreviewSendOptions
   | PreviewMintOptions
+  | PreviewBridgeOptions
   | PreviewConsumeOptions
   | PreviewSwapOptions
   | PreviewPswapCreateOptions
@@ -730,6 +868,22 @@ export interface TransactionsResource {
    * @param options - Mint options including the faucet, recipient, and amount.
    */
   mint(options: MintOptions): Promise<TransactionSubmitResult>;
+  /**
+   * Builds a Public custom-script note carrying a `NetworkAccountTarget`
+   * attachment, submits it as an own output note, and (optionally) waits for
+   * confirmation. The submitted note satisfies `Note.isNetworkNote()`, so a
+   * public network account will auto-consume it.
+   */
+  createNetworkNote(options: NetworkNoteOptions): Promise<NetworkNoteResult>;
+  /**
+   * Bridge a fungible asset out to another network via the AggLayer. Emits a
+   * single public B2AGG (Bridge-to-AggLayer) note that the bridge account
+   * consumes, burning the asset so it can be claimed at the destination
+   * Ethereum address on the destination network.
+   *
+   * @param options - Sender, bridge account, token, amount, and destination.
+   */
+  bridge(options: BridgeOptions): Promise<TransactionSubmitResult>;
   /**
    * Consume one or more notes for an account.
    *
@@ -803,6 +957,34 @@ export interface TransactionsResource {
     options?: TransactionOptions
   ): Promise<TransactionSubmitResult>;
 
+  /**
+   * Execute a heterogeneous batch of operations against a single account.
+   * Each operation is built, proven individually and as a batch, and all
+   * operations are submitted atomically — either every tx in the batch
+   * lands or none does.
+   *
+   * V1 supports only same-account batches (mirrors the underlying Rust
+   * `Client::new_transaction_batch()` constraint).
+   *
+   * @param options - Batch options including the account and operations.
+   */
+  batch(options: BatchOptions): Promise<BatchSubmitResult>;
+
+  /**
+   * Submit pre-built TransactionRequests as an atomic batch. Plural
+   * counterpart of {@link submit} — for callers that already have built
+   * requests in hand and want to skip the high-level operation builders.
+   *
+   * @param account - The account executing every transaction in the batch.
+   * @param requests - Pre-built transaction requests (must be non-empty).
+   * @param options - Optional batch settings (waitForConfirmation, timeout, prover).
+   */
+  submitBatch(
+    account: AccountRef,
+    requests: TransactionRequest[],
+    options?: Omit<BatchOptions, "account" | "operations">
+  ): Promise<BatchSubmitResult>;
+
   /** Execute a program (view call) and return the resulting stack output. */
   executeProgram(options: ExecuteProgramOptions): Promise<FeltArray>;
 
@@ -1173,6 +1355,13 @@ export declare function createP2IDENote(
   options: P2IDEOptions
 ): ReturnType<WasmModule["Note"]["createP2IDENote"]>;
 
+/**
+ * Builds (without submitting) a Public custom-script note carrying a
+ * `NetworkAccountTarget` attachment. Provide exactly one of `recipient` or
+ * `script`.
+ */
+export declare function buildNetworkNote(opts: NetworkNoteOptions): Note;
+
 /** Builds a swap tag for note matching. Returns a NoteTag (use `.asU32()` for the numeric value). */
 export declare function buildSwapTag(
   options: BuildSwapTagOptions

package/dist/st/crates/miden_client_web.d.ts

@@ -967,10 +967,13 @@ export class AuthSecretKey {
 }
 
 /**
- * Provides metadata for a basic fungible faucet account component.
+ * Provides metadata for a fungible faucet account component.
  *
- * Reads the on-chain [`FungibleFaucet`] component for the account, which holds the
- * per-token info (symbol/decimals/maxSupply).
+ * Reads the on-chain `FungibleFaucet` component for the account, which holds the per-token
+ * info (symbol, decimals, supply, and the descriptive metadata). The same component backs both
+ * "basic" public faucets and network-style faucets — in the current protocol the distinction is
+ * a function of the surrounding account configuration (account type, auth, access control), not
+ * of the faucet component itself — so this reads metadata from either kind of faucet account.
  */
 export class BasicFungibleFaucetComponent {
     private constructor();
@@ -980,10 +983,22 @@ export class BasicFungibleFaucetComponent {
      * Returns the number of decimal places for the token.
      */
     decimals(): number;
+    /**
+     * Returns the optional free-form token description, or `undefined` when unset.
+     */
+    description(): string | undefined;
+    /**
+     * Returns the optional external link (e.g. project website), or `undefined` when unset.
+     */
+    externalLink(): string | undefined;
     /**
      * Extracts faucet metadata from an account.
      */
     static fromAccount(account: Account): BasicFungibleFaucetComponent;
+    /**
+     * Returns the optional token logo URI, or `undefined` when unset.
+     */
+    logoUri(): string | undefined;
     /**
      * Returns the maximum token supply.
      */
@@ -992,6 +1007,14 @@ export class BasicFungibleFaucetComponent {
      * Returns the faucet's token symbol.
      */
     symbol(): TokenSymbol;
+    /**
+     * Returns the human-readable token name.
+     */
+    tokenName(): string;
+    /**
+     * Returns the current token supply (the amount minted so far).
+     */
+    tokenSupply(): Felt;
 }
 
 /**
@@ -1242,6 +1265,43 @@ export class Endpoint {
     readonly protocol: string;
 }
 
+/**
+ * A 20-byte Ethereum address, used as the destination of an `AggLayer` bridge-out (B2AGG) note.
+ *
+ * Construct one from a hex string with [`EthAddress::from_hex`] (the `0x` prefix is optional) or
+ * from raw bytes with [`EthAddress::from_bytes`]. The canonical lowercase, `0x`-prefixed hex form
+ * is available via [`EthAddress::to_hex`] (also exposed as `toString`).
+ */
+export class EthAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Builds an Ethereum address from its raw 20-byte big-endian representation.
+     *
+     * Returns an error if the input is not exactly 20 bytes long.
+     */
+    static fromBytes(bytes: Uint8Array): EthAddress;
+    /**
+     * Builds an Ethereum address from a hex string (with or without the `0x` prefix).
+     *
+     * Returns an error if the string is not valid hex or does not encode exactly 20 bytes.
+     */
+    static fromHex(hex: string): EthAddress;
+    /**
+     * Returns the raw 20-byte big-endian representation of the address.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the canonical lowercase, `0x`-prefixed hex representation of the address.
+     */
+    toHex(): string;
+    /**
+     * Returns the canonical lowercase, `0x`-prefixed hex representation of the address.
+     */
+    toString(): string;
+}
+
 /**
  * Describes the result of executing a transaction program for the Miden protocol.
  *
@@ -2053,6 +2113,44 @@ export class MerklePath {
     verify(index: bigint, node: Word, root: Word): boolean;
 }
 
+/**
+ * Targets a note at a public network account so the operator auto-consumes it.
+ *
+ * A note is a network note when it is `Public` and carries a valid
+ * `NetworkAccountTarget` attachment (see `Note.isNetworkNote`).
+ */
+export class NetworkAccountTarget {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns the note execution hint.
+     */
+    executionHint(): NoteExecutionHint;
+    /**
+     * Decodes a `NoteAttachment` back into a `NetworkAccountTarget`.
+     *
+     * # Errors
+     * Errors if the attachment is not a valid network-account-target attachment.
+     */
+    static fromAttachment(attachment: NoteAttachment): NetworkAccountTarget;
+    /**
+     * Creates a target for the given network account. `executionHint` defaults
+     * to `NoteExecutionHint.always()`.
+     *
+     * # Errors
+     * Errors if `account_id` is not a public account.
+     */
+    constructor(account_id: AccountId, execution_hint?: NoteExecutionHint | null);
+    /**
+     * Returns the targeted network account id.
+     */
+    targetId(): AccountId;
+    /**
+     * Encodes this target as a `NoteAttachment`.
+     */
+    toAttachment(): NoteAttachment;
+}
+
 /**
  * The identifier of a Miden network.
  */
@@ -2133,6 +2231,10 @@ export class Note {
      * Returns the assets locked inside the note.
      */
     assets(): NoteAssets;
+    /**
+     * Returns the note's attachments.
+     */
+    attachments(): NoteAttachment[];
     /**
      * Returns the commitment to the note (its ID).
      *
@@ -2142,6 +2244,16 @@ export class Note {
      * unchanged.
      */
     commitment(): Word;
+    /**
+     * Builds a B2AGG (Bridge-to-AggLayer) note that bridges the given assets out to another
+     * network via the `AggLayer`.
+     *
+     * The note is always public and is consumed by `bridge_account`, which burns the assets so
+     * they can be claimed on the destination network at `destination_address` (an Ethereum
+     * address on the AggLayer-assigned `destination_network`). The assets must be fungible assets
+     * issued by a network faucet.
+     */
+    static createB2AggNote(sender: AccountId, bridge_account: AccountId, assets: NoteAssets, destination_network: number, destination_address: EthAddress): Note;
     /**
      * Builds a P2IDE note that can be reclaimed or timelocked based on block heights.
      */
@@ -2158,6 +2270,11 @@ export class Note {
      * Returns the unique identifier of the note.
      */
     id(): NoteId;
+    /**
+     * Returns true if the note is a network note (public + a valid
+     * `NetworkAccountTarget` attachment).
+     */
+    isNetworkNote(): boolean;
     /**
      * Returns the public metadata associated with the note.
      */
@@ -2186,6 +2303,14 @@ export class Note {
      * Serializes the note into bytes.
      */
     serialize(): Uint8Array;
+    /**
+     * Creates a note carrying the provided attachments, using the metadata's
+     * sender / note type / tag (attachments on the metadata itself are ignored).
+     *
+     * # Errors
+     * Errors if the attachment set is invalid (too many attachments or words).
+     */
+    static withAttachments(note_assets: NoteAssets, note_metadata: NoteMetadata, note_recipient: NoteRecipient, attachments: NoteAttachment[]): Note;
 }
 
 export class NoteAndArgs {
@@ -2792,6 +2917,11 @@ export class NoteRecipient {
      * Returns the digest of the recipient data (used in the note commitment).
      */
     digest(): Word;
+    /**
+     * Creates a recipient from a script and storage, generating a fresh random
+     * serial number (the secret that prevents double-spends).
+     */
+    static fromScript(note_script: NoteScript, storage: NoteStorage): NoteRecipient;
     /**
      * Creates a note recipient from its serial number, script, and storage.
      */
@@ -4669,6 +4799,16 @@ export class WebClient {
      * but callers only need a single await instead of two.
      */
     newAccountWithSecretKey(account: Account, secret_key: AuthSecretKey): Promise<void>;
+    /**
+     * Builds a transaction request that bridges a fungible asset out to another network via the
+     * `AggLayer`.
+     *
+     * The request emits a single public B2AGG (Bridge-to-AggLayer) note holding `amount` units of
+     * the `faucet_id` asset. The note is consumed by `bridge_account_id`, which burns the asset so
+     * it can be claimed at `destination_address` (an Ethereum address) on the AggLayer-assigned
+     * `destination_network`.
+     */
+    newB2AggTransactionRequest(sender_account_id: AccountId, bridge_account_id: AccountId, faucet_id: AccountId, amount: bigint, destination_network: number, destination_address: EthAddress): Promise<TransactionRequest>;
     newConsumeTransactionRequest(list_of_notes: Note[]): TransactionRequest;
     /**
      * Creates, persists, and returns a new fungible faucet account.
@@ -4744,6 +4884,16 @@ export class WebClient {
      * the chain tip is performed, and the required block header is retrieved.
      */
     submitNewTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionId>;
+    /**
+     * Executes a batch of transactions against the specified account, proves them individually
+     * and as a batch, submits the batch to the network, and atomically applies the per-tx
+     * updates to the local store. Returns the block number the batch was accepted into.
+     *
+     * All transactions must target the same local account — the `account_id` argument.
+     * Each element of `transaction_requests` is the serialized-bytes form of a
+     * `TransactionRequest` (obtained via `tx_request.serialize()`)
+     */
+    submitNewTransactionBatch(account_id: AccountId, transaction_requests: Uint8Array[]): Promise<number>;
     /**
      * 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.

package/dist/st/docs-entry.d.ts

@@ -14,8 +14,11 @@ export {
   AccountStorage,
   AdviceMap,
   AssetVault,
+  BasicFungibleFaucetComponent,
+  EthAddress,
   Felt,
   InputNoteRecord,
+  NetworkAccountTarget,
   Note,
   NoteExportFormat,
   NoteFile,

package/dist/st/eager.js

@@ -1,6 +1,6 @@
 import { getWasmOrThrow } from './index.js';
 export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWasmWebClient, MockWasmWebClient as MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, withSyncLock, 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, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, 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, PswapLineageRecord, PswapLineageState, 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, sequentialSumBench, setupLogging } from './Cargo-BP7-0qVT.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, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, 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, PswapLineageRecord, PswapLineageState, 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, sequentialSumBench, setupLogging } from './Cargo-CR1mzjgg.js';
 import './wasm.js';
 
 // Eager entry point for @miden-sdk/miden-sdk (browser builds).

package/dist/st/index.d.ts

@@ -62,6 +62,9 @@ export declare class StorageResult {
   /** Returns all four Felts of the stored Word. Pass-through to Word.toFelts(). */
   toFelts(): Felt[];
 
+  /** Returns all four elements of the stored Word as a BigUint64Array. Pass-through to Word.toU64s(). */
+  toU64s(): BigUint64Array;
+
   /** The first Felt of the stored Word. */
   felt(): Felt | undefined;