@miden-sdk/miden-sdk 0.15.3 → 0.15.4

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

@@ -374,6 +374,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 +399,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 +566,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 +623,7 @@ export interface PreviewCustomOptions {
 export type PreviewOptions =
   | PreviewSendOptions
   | PreviewMintOptions
+  | PreviewBridgeOptions
   | PreviewConsumeOptions
   | PreviewSwapOptions
   | PreviewPswapCreateOptions
@@ -730,6 +823,15 @@ export interface TransactionsResource {
    * @param options - Mint options including the faucet, recipient, and amount.
    */
   mint(options: MintOptions): Promise<TransactionSubmitResult>;
+  /**
+   * 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 +905,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>;
 

package/dist/mt/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.
  *
@@ -2142,6 +2202,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.
      */
@@ -4669,6 +4739,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 +4824,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/mt/docs-entry.d.ts

@@ -14,6 +14,8 @@ export {
   AccountStorage,
   AdviceMap,
   AssetVault,
+  BasicFungibleFaucetComponent,
+  EthAddress,
   Felt,
   InputNoteRecord,
   Note,

package/dist/mt/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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-D2qNRrNR.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, 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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-DjVnfWKi.js';
 import './wasm.js';
 
 // Eager entry point for @miden-sdk/miden-sdk (browser builds).

package/dist/mt/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;
 

package/dist/mt/index.js

@@ -1,5 +1,5 @@
 import loadWasm from './wasm.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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-D2qNRrNR.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, 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, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-DjVnfWKi.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -640,6 +640,24 @@ class TransactionsResource {
     return { txId, result };
   }
 
+  async bridge(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildB2AggRequest(opts, wasm);
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
   async consume(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -802,6 +820,10 @@ class TransactionsResource {
         ({ accountId, request } = await this.#buildMintRequest(opts, wasm));
         break;
       }
+      case "bridge": {
+        ({ accountId, request } = await this.#buildB2AggRequest(opts, wasm));
+        break;
+      }
       case "consume": {
         ({ accountId, request } = await this.#buildConsumeRequest(opts, wasm));
         break;
@@ -846,6 +868,163 @@ class TransactionsResource {
   async execute(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
+    const { accountId, request } = this.#buildExecuteRequest(opts, wasm);
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
+  /**
+   * Submit a heterogeneous batch of operations against a single account. All
+   * operations are executed, proven individually and as a batch, and submitted
+   * atomically — either every tx in the batch lands or none does.
+   *
+   * @param {BatchOptions} opts - Batch options including the account, operations array, and confirmation settings.
+   * @returns {Promise<BatchSubmitResult>} The block number the batch was accepted into.
+   */
+  async batch(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    if (!opts || !opts.account) {
+      throw new Error("batch: `account` is required");
+    }
+    if (!Array.isArray(opts.operations) || opts.operations.length === 0) {
+      throw new Error("batch: `operations` must be a non-empty array");
+    }
+
+    // Build each TransactionRequest. Per-op builders all use the batch-level
+    // `account` — V1 only supports same-account batches, mirroring the Rust
+    // constraint. We forward `opts.account` into each per-op options object so
+    // the existing builders' `resolveAccountRef` produces fresh AccountIds
+    // when needed.
+    const requests = [];
+    for (let i = 0; i < opts.operations.length; i++) {
+      const op = opts.operations[i];
+      let built;
+      switch (op?.kind) {
+        case "send":
+          built = await this.#buildSendRequest(
+            { ...op, account: opts.account },
+            wasm
+          );
+          break;
+        case "mint":
+          built = await this.#buildMintRequest(
+            { ...op, account: opts.account },
+            wasm
+          );
+          break;
+        case "consume":
+          built = await this.#buildConsumeRequest(
+            { ...op, account: opts.account },
+            wasm
+          );
+          break;
+        case "swap":
+          built = await this.#buildSwapRequest(
+            { ...op, account: opts.account },
+            wasm
+          );
+          break;
+        case "execute":
+          built = this.#buildExecuteRequest(
+            { ...op, account: opts.account },
+            wasm
+          );
+          break;
+        case "custom":
+          if (!op.request) {
+            throw new Error(
+              `batch: operation[${i}] of kind "custom" is missing \`request\``
+            );
+          }
+          built = { request: op.request };
+          break;
+        default:
+          throw new Error(
+            `batch: operation[${i}] has unknown kind "${op?.kind}"`
+          );
+      }
+      requests.push(built.request);
+    }
+
+    return this.submitBatch(opts.account, requests, opts);
+  }
+
+  /**
+   * Submit pre-built TransactionRequests as an atomic batch. Lower-level
+   * counterpart of `batch()` — for callers that already have built requests in
+   * hand. Equivalent to `submit()` but plural.
+   *
+   * @param {AccountRef} account - The account executing the batch.
+   * @param {TransactionRequest[]} requests - Pre-built transaction requests.
+   * @param {object} [options] - Optional settings (waitForConfirmation, timeout).
+   *   The batch is proved with the client's configured prover; the V1 batch API
+   *   has no per-call prover override.
+   * @returns {Promise<BatchSubmitResult>} The block number the batch was accepted into.
+   */
+  async submitBatch(account, requests, options) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    if (!Array.isArray(requests) || requests.length === 0) {
+      throw new Error("submitBatch: `requests` must be a non-empty array");
+    }
+
+    const accountId = resolveAccountRef(account, wasm);
+    const blockNumber = await this.#inner.submitNewTransactionBatch(
+      accountId,
+      requests.map((r) => r.serialize())
+    );
+
+    if (options?.waitForConfirmation) {
+      await this.#waitForBlock(blockNumber, options);
+    }
+
+    return { blockNumber };
+  }
+
+  /**
+   * Polls until the local sync height reaches `blockNumber` or the timeout
+   * expires. The Rust V1 batch API returns only a block number — there are no
+   * per-tx ids to poll on, so we wait on the chain height instead.
+   *
+   * @param {number} blockNumber - The block height to wait for.
+   * @param {object} [opts] - Polling options (timeout, interval).
+   */
+  async #waitForBlock(blockNumber, opts) {
+    const timeout = opts?.timeout ?? 60_000;
+    const interval = opts?.interval ?? 5_000;
+    const start = Date.now();
+
+    while (true) {
+      if (timeout > 0 && Date.now() - start >= timeout) {
+        throw new Error(
+          `Batch confirmation timed out after ${timeout}ms (waiting for block ${blockNumber})`
+        );
+      }
+      try {
+        await this.#inner.syncStateWithTimeout(0);
+      } catch {
+        // sync may fail transiently; continue polling
+      }
+      const height = await this.#inner.getSyncHeight();
+      if (height >= blockNumber) return;
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+
+  #buildExecuteRequest(opts, wasm) {
     const accountId = resolveAccountRef(opts.account, wasm);
 
     let builder = new wasm.TransactionRequestBuilder().withCustomScript(
@@ -873,18 +1052,7 @@ class TransactionsResource {
       );
     }
 
-    const request = builder.build();
-    const { txId, result } = await this.#submitOrSubmitWithProver(
-      accountId,
-      request,
-      opts.prover
-    );
-
-    if (opts.waitForConfirmation) {
-      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
-    }
-
-    return { txId, result };
+    return { accountId, request: builder.build() };
   }
 
   async executeProgram(opts) {
@@ -1057,6 +1225,24 @@ class TransactionsResource {
     return { accountId, request };
   }
 
+  async #buildB2AggRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const bridgeAccountId = resolveAccountRef(opts.bridgeAccount, wasm);
+    const faucetId = resolveAccountRef(opts.token, wasm);
+    const amount = BigInt(opts.amount);
+    const destinationAddress = wasm.EthAddress.fromHex(opts.destinationAddress);
+
+    const request = await this.#inner.newB2AggTransactionRequest(
+      accountId,
+      bridgeAccountId,
+      faucetId,
+      amount,
+      opts.destinationNetwork,
+      destinationAddress
+    );
+    return { accountId, request };
+  }
+
   async #buildConsumeRequest(opts, wasm) {
     const accountId = resolveAccountRef(opts.account, wasm);
     const noteInputs = Array.isArray(opts.notes) ? opts.notes : [opts.notes];
@@ -2487,6 +2673,17 @@ class StorageResult {
     return this.#word.toFelts();
   }
 
+  /**
+   * Returns all four elements of the stored Word as a BigUint64Array.
+   * Pass-through to Word.toU64s() — ensures code that expects a Word-like
+   * object (e.g., `result.toU64s()[0]`) works on StorageResult.
+   * @returns {BigUint64Array}
+   */
+  toU64s() {
+    if (!this.#word) return new BigUint64Array();
+    return this.#word.toU64s();
+  }
+
   /**
    * The first Felt of the stored Word.
    * Returns the WASM Felt object — use .asInt() to get its BigInt value.
@@ -2639,6 +2836,7 @@ const SYNC_METHODS = new Set([
   "buildSwapTag",
   "createCodeBuilder",
   "lastAuthError",
+  "newB2AggTransactionRequest",
   "newConsumeTransactionRequest",
   "newMintTransactionRequest",
   "newPswapCancelTransactionRequest",