@miden-sdk/react 0.15.2 → 0.15.4

package/CLAUDE.md

@@ -149,6 +149,22 @@ await mint({
 });
 ```
 
+### Bridge Out (AggLayer)
+```tsx
+const { bridge } = useBridge();
+
+// Emits a public B2AGG note that the bridge account consumes, burning the
+// asset so it can be claimed at the destination Ethereum address.
+await bridge({
+  from: senderAccountId,
+  bridgeAccount: bridgeAccountId,
+  assetId: tokenFaucetId,
+  amount: 100n,
+  destinationNetwork: 1, // AggLayer-assigned network id
+  destinationAddress: "0x000000000000000000000000000000000000dEaD",
+});
+```
+
 ### Create Faucet
 ```tsx
 const { createFaucet } = useCreateFaucet();
@@ -410,6 +426,7 @@ Query hooks return `{ ...data, isLoading, error, refetch }`. Mutation hooks retu
 | `useSend()` | `send({ from, to, assetId, amount, noteType })` | `SendResult` (with `txId`, `note`) |
 | `useMultiSend()` | `multiSend({ from, recipients })` | `TransactionResult` |
 | `useMint()` | `mint({ faucetId, to, amount })` | `TransactionResult` |
+| `useBridge()` | `bridge({ from, bridgeAccount, assetId, amount, destinationNetwork, destinationAddress })` | `TransactionResult` (emits an AggLayer B2AGG bridge-out note) |
 | `useConsume()` | `consume({ accountId, notes })` | `TransactionResult` |
 | `useSwap()` | `swap({ ... })` | `TransactionResult` |
 | `usePswapCreate()` | `pswapCreate({ accountId, offeredFaucetId, offeredAmount, requestedFaucetId, requestedAmount, ... })` | `TransactionResult` (creates partial-swap note) |

package/README.md

@@ -12,6 +12,7 @@ React hooks library for the Miden Web Client. Provides a simple, ergonomic inter
 - **Note Attachments** - Send and read arbitrary data payloads on notes via `useSend()` and `readNoteAttachment()`
 - **Temporal Note Tracking** - `useNoteStream()` tracks when notes first appear, with built-in filtering, handled-note exclusion, and phase snapshots
 - **Session Wallets** - `useSessionAccount()` manages the create-fund-consume lifecycle for temporary wallets
+- **AggLayer Bridge-Out** - `useBridge()` emits a B2AGG note to bridge a fungible asset out to another network via the AggLayer
 - **Concurrency Safety** - Transaction hooks prevent double-sends with built-in concurrency guards
 - **Auto Pre-Sync** - Transaction hooks sync before executing by default (opt out with `skipSync`)
 - **WASM Error Wrapping** - Cryptic WASM errors are intercepted and replaced with actionable messages

package/dist/index.d.ts

@@ -392,6 +392,22 @@ interface MintOptions {
     /** Note type. Default: private */
     noteType?: NoteVisibility;
 }
+interface BridgeOptions {
+    /** Account that creates and funds the bridge note (the sender) */
+    from: AccountRef;
+    /** Bridge account that consumes the note and burns the bridged assets */
+    bridgeAccount: AccountRef;
+    /** Faucet/token ID of the fungible asset to bridge */
+    assetId: AccountRef;
+    /** Amount of the asset to bridge */
+    amount: bigint | number;
+    /** AggLayer-assigned network ID of the destination chain */
+    destinationNetwork: number;
+    /** Destination Ethereum address on the destination network (0x-prefixed hex) */
+    destinationAddress: string;
+    /** Skip auto-sync after bridging. Default: false */
+    skipSync?: boolean;
+}
 interface ConsumeOptions {
     /** Account ID that will consume the notes */
     accountId: string;
@@ -1174,6 +1190,61 @@ interface UseMintResult {
  */
 declare function useMint(): UseMintResult;
 
+interface UseBridgeResult {
+    /** Bridge a fungible asset out to another network via the AggLayer */
+    bridge: (options: BridgeOptions) => Promise<TransactionResult>;
+    /** The transaction result */
+    result: TransactionResult | null;
+    /** Whether the transaction is in progress */
+    isLoading: boolean;
+    /** Current stage of the transaction */
+    stage: TransactionStage;
+    /** Error if transaction failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to 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. The sender account executes the transaction that emits the note.
+ *
+ * Returns `{ bridge, result, isLoading, stage, error, reset }`. `bridge` resolves to a
+ * `TransactionResult` (`{ transactionId }`) and rejects on failure.
+ *
+ * @example
+ * ```tsx
+ * function BridgeButton({ from, bridgeAccount, assetId }: Props) {
+ *   const { bridge, isLoading, stage, error } = useBridge();
+ *
+ *   const handleBridge = async () => {
+ *     try {
+ *       const result = await bridge({
+ *         from,
+ *         bridgeAccount,
+ *         assetId,
+ *         amount: 100n,
+ *         destinationNetwork: 1,
+ *         destinationAddress: "0x000000000000000000000000000000000000dEaD",
+ *       });
+ *       console.log("Bridged! TX:", result.transactionId);
+ *     } catch (err) {
+ *       console.error("Bridge failed:", err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleBridge} disabled={isLoading}>
+ *       {isLoading ? stage : "Bridge"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBridge(): UseBridgeResult;
+
 interface UseConsumeResult {
     /** Consume one or more notes */
     consume: (options: ConsumeOptions) => Promise<TransactionResult>;
@@ -1840,4 +1911,4 @@ declare function createMidenStorage(prefix: string): {
     clear(): void;
 };
 
-export { type AccountRef, type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type ConsumeOptions, type CreateFaucetOptions, type CreateWalletOptions, DEFAULTS, type ExecuteProgramOptions, type ExecuteProgramResult, type ExecuteTransactionOptions, type ImportAccountOptions, type ImportStoreOptions, type MidenConfig, MidenError, type MidenErrorCode, MidenProvider, type MidenState, type MigrateStorageOptions, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MultiSignerContextValue, MultiSignerProvider, type MutationResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverTarget, type ProverUrls, type PswapCancelByOrderOptions, type PswapCancelOptions, type PswapConsumeOptions, type PswapCreateOptions, type PswapLineageResult, type PswapLineagesResult, type QueryResult, type RpcUrlConfig, type SendOptions, type SendResult, type SessionAccountStep, type SignCallback, type SignerAccountConfig, type SignerAccountType, SignerContext, type SignerContextValue, SignerSlot, type StreamedNote, type SwapOptions, type SyncState, type TransactionHistoryOptions, type TransactionHistoryResult, type TransactionResult, type TransactionStage, type TransactionStatus, type UseCompileResult, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateWalletResult, type UseExecuteProgramResult, type UseExportNoteResult, type UseExportStoreResult, type UseImportAccountResult, type UseImportNoteResult, type UseImportStoreResult, type UseMintResult, type UseMultiSendResult, type UseNoteStreamOptions, type UseNoteStreamReturn, type UsePswapCancelByOrderResult, type UsePswapCancelResult, type UsePswapConsumeResult, type UsePswapCreateResult, type UsePswapLineageResult, type UsePswapLineagesForResult, type UsePswapLineagesResult, type UseSendResult, type UseSessionAccountOptions, type UseSessionAccountReturn, type UseSwapResult, type UseSyncControlResult, type UseSyncStateResult, type UseTransactionHistoryResult, type UseTransactionResult, type UseWaitForCommitResult, type UseWaitForNotesResult, type WaitForCommitOptions, type WaitForNotesOptions, type WalletAdapterLike, accountIdsEqual, bigIntToBytes, bytesToBigInt, clearMidenStorage, concatBytes, createMidenStorage, createNoteAttachment, ensureAccountBech32, formatAssetAmount, formatNoteSummary, getNoteSummary, installAccountBech32, migrateStorage, normalizeAccountId, parseAssetAmount, readNoteAttachment, toBech32AccountId, useAccount, useAccounts, useAssetMetadata, useCompile, useConsume, useCreateFaucet, useCreateWallet, useExecuteProgram, useExportNote, useExportStore, useImportAccount, useImportNote, useImportStore, useMiden, useMidenClient, useMint, useMultiSend, useMultiSigner, useNoteStream, useNotes, usePswapCancel, usePswapCancelByOrder, usePswapConsume, usePswapCreate, usePswapLineage, usePswapLineages, usePswapLineagesFor, useSend, useSessionAccount, useSigner, useSwap, useSyncControl, useSyncState, useTransaction, useTransactionHistory, useWaitForCommit, useWaitForNotes, waitForWalletDetection, wrapWasmError };
+export { type AccountRef, type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type BridgeOptions, type ConsumeOptions, type CreateFaucetOptions, type CreateWalletOptions, DEFAULTS, type ExecuteProgramOptions, type ExecuteProgramResult, type ExecuteTransactionOptions, type ImportAccountOptions, type ImportStoreOptions, type MidenConfig, MidenError, type MidenErrorCode, MidenProvider, type MidenState, type MigrateStorageOptions, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MultiSignerContextValue, MultiSignerProvider, type MutationResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverTarget, type ProverUrls, type PswapCancelByOrderOptions, type PswapCancelOptions, type PswapConsumeOptions, type PswapCreateOptions, type PswapLineageResult, type PswapLineagesResult, type QueryResult, type RpcUrlConfig, type SendOptions, type SendResult, type SessionAccountStep, type SignCallback, type SignerAccountConfig, type SignerAccountType, SignerContext, type SignerContextValue, SignerSlot, type StreamedNote, type SwapOptions, type SyncState, type TransactionHistoryOptions, type TransactionHistoryResult, type TransactionResult, type TransactionStage, type TransactionStatus, type UseBridgeResult, type UseCompileResult, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateWalletResult, type UseExecuteProgramResult, type UseExportNoteResult, type UseExportStoreResult, type UseImportAccountResult, type UseImportNoteResult, type UseImportStoreResult, type UseMintResult, type UseMultiSendResult, type UseNoteStreamOptions, type UseNoteStreamReturn, type UsePswapCancelByOrderResult, type UsePswapCancelResult, type UsePswapConsumeResult, type UsePswapCreateResult, type UsePswapLineageResult, type UsePswapLineagesForResult, type UsePswapLineagesResult, type UseSendResult, type UseSessionAccountOptions, type UseSessionAccountReturn, type UseSwapResult, type UseSyncControlResult, type UseSyncStateResult, type UseTransactionHistoryResult, type UseTransactionResult, type UseWaitForCommitResult, type UseWaitForNotesResult, type WaitForCommitOptions, type WaitForNotesOptions, type WalletAdapterLike, accountIdsEqual, bigIntToBytes, bytesToBigInt, clearMidenStorage, concatBytes, createMidenStorage, createNoteAttachment, ensureAccountBech32, formatAssetAmount, formatNoteSummary, getNoteSummary, installAccountBech32, migrateStorage, normalizeAccountId, parseAssetAmount, readNoteAttachment, toBech32AccountId, useAccount, useAccounts, useAssetMetadata, useBridge, useCompile, useConsume, useCreateFaucet, useCreateWallet, useExecuteProgram, useExportNote, useExportStore, useImportAccount, useImportNote, useImportStore, useMiden, useMidenClient, useMint, useMultiSend, useMultiSigner, useNoteStream, useNotes, usePswapCancel, usePswapCancelByOrder, usePswapConsume, usePswapCreate, usePswapLineage, usePswapLineages, usePswapLineagesFor, useSend, useSessionAccount, useSigner, useSwap, useSyncControl, useSyncState, useTransaction, useTransactionHistory, useWaitForCommit, useWaitForNotes, waitForWalletDetection, wrapWasmError };

package/dist/index.mjs

@@ -2761,17 +2761,92 @@ function useMint() {
   };
 }
 
-// src/hooks/useConsume.ts
+// src/hooks/useBridge.ts
 import { useCallback as useCallback20, useState as useState16 } from "react";
-import { NoteFilter as NoteFilter3, NoteFilterTypes as NoteFilterTypes2, NoteId } from "@miden-sdk/miden-sdk";
-function useConsume() {
+import { EthAddress } from "@miden-sdk/miden-sdk";
+function useBridge() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const [result, setResult] = useState16(null);
   const [isLoading, setIsLoading] = useState16(false);
   const [stage, setStage] = useState16("idle");
   const [error, setError] = useState16(null);
-  const consume = useCallback20(
+  const bridge = useCallback20(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const senderId = parseAccountId(options.from);
+        const bridgeId = parseAccountId(options.bridgeAccount);
+        const assetId = parseAccountId(options.assetId);
+        const destinationAddress = EthAddress.fromHex(
+          options.destinationAddress
+        );
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const txRequest = await client.newB2AggTransactionRequest(
+            senderId,
+            bridgeId,
+            assetId,
+            BigInt(options.amount),
+            options.destinationNetwork,
+            destinationAddress
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            senderId,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(senderId, txRequest);
+          return { transactionId: txId.toHex() };
+        });
+        setStage("complete");
+        setResult(txResult);
+        if (!options.skipSync) {
+          await sync();
+        }
+        return txResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback20(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    bridge,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useConsume.ts
+import { useCallback as useCallback21, useState as useState17 } from "react";
+import { NoteFilter as NoteFilter3, NoteFilterTypes as NoteFilterTypes2, NoteId } from "@miden-sdk/miden-sdk";
+function useConsume() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState17(null);
+  const [isLoading, setIsLoading] = useState17(false);
+  const [stage, setStage] = useState17("idle");
+  const [error, setError] = useState17(null);
+  const consume = useCallback21(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2855,7 +2930,7 @@ function useConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback20(() => {
+  const reset = useCallback21(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2872,15 +2947,15 @@ function useConsume() {
 }
 
 // src/hooks/useSwap.ts
-import { useCallback as useCallback21, useState as useState17 } from "react";
+import { useCallback as useCallback22, useState as useState18 } from "react";
 function useSwap() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState17(null);
-  const [isLoading, setIsLoading] = useState17(false);
-  const [stage, setStage] = useState17("idle");
-  const [error, setError] = useState17(null);
-  const swap = useCallback21(
+  const [result, setResult] = useState18(null);
+  const [isLoading, setIsLoading] = useState18(false);
+  const [stage, setStage] = useState18("idle");
+  const [error, setError] = useState18(null);
+  const swap = useCallback22(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2929,7 +3004,7 @@ function useSwap() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback21(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2946,15 +3021,15 @@ function useSwap() {
 }
 
 // src/hooks/usePswapCreate.ts
-import { useCallback as useCallback22, useState as useState18 } from "react";
+import { useCallback as useCallback23, useState as useState19 } from "react";
 function usePswapCreate() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState18(null);
-  const [isLoading, setIsLoading] = useState18(false);
-  const [stage, setStage] = useState18("idle");
-  const [error, setError] = useState18(null);
-  const pswapCreate = useCallback22(
+  const [result, setResult] = useState19(null);
+  const [isLoading, setIsLoading] = useState19(false);
+  const [stage, setStage] = useState19("idle");
+  const [error, setError] = useState19(null);
+  const pswapCreate = useCallback23(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3011,7 +3086,7 @@ function usePswapCreate() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback22(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3028,15 +3103,15 @@ function usePswapCreate() {
 }
 
 // src/hooks/usePswapConsume.ts
-import { useCallback as useCallback23, useState as useState19 } from "react";
+import { useCallback as useCallback24, useState as useState20 } from "react";
 function usePswapConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState19(null);
-  const [isLoading, setIsLoading] = useState19(false);
-  const [stage, setStage] = useState19("idle");
-  const [error, setError] = useState19(null);
-  const pswapConsume = useCallback23(
+  const [result, setResult] = useState20(null);
+  const [isLoading, setIsLoading] = useState20(false);
+  const [stage, setStage] = useState20("idle");
+  const [error, setError] = useState20(null);
+  const pswapConsume = useCallback24(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3085,7 +3160,7 @@ function usePswapConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback23(() => {
+  const reset = useCallback24(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3102,15 +3177,15 @@ function usePswapConsume() {
 }
 
 // src/hooks/usePswapCancel.ts
-import { useCallback as useCallback24, useState as useState20 } from "react";
+import { useCallback as useCallback25, useState as useState21 } from "react";
 function usePswapCancel() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState20(null);
-  const [isLoading, setIsLoading] = useState20(false);
-  const [stage, setStage] = useState20("idle");
-  const [error, setError] = useState20(null);
-  const pswapCancel = useCallback24(
+  const [result, setResult] = useState21(null);
+  const [isLoading, setIsLoading] = useState21(false);
+  const [stage, setStage] = useState21("idle");
+  const [error, setError] = useState21(null);
+  const pswapCancel = useCallback25(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3149,7 +3224,7 @@ function usePswapCancel() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback24(() => {
+  const reset = useCallback25(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3166,15 +3241,15 @@ function usePswapCancel() {
 }
 
 // src/hooks/usePswapCancelByOrder.ts
-import { useCallback as useCallback25, useState as useState21 } from "react";
+import { useCallback as useCallback26, useState as useState22 } from "react";
 function usePswapCancelByOrder() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState21(null);
-  const [isLoading, setIsLoading] = useState21(false);
-  const [stage, setStage] = useState21("idle");
-  const [error, setError] = useState21(null);
-  const pswapCancelByOrder = useCallback25(
+  const [result, setResult] = useState22(null);
+  const [isLoading, setIsLoading] = useState22(false);
+  const [stage, setStage] = useState22("idle");
+  const [error, setError] = useState22(null);
+  const pswapCancelByOrder = useCallback26(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3214,7 +3289,7 @@ function usePswapCancelByOrder() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback25(() => {
+  const reset = useCallback26(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3231,7 +3306,7 @@ function usePswapCancelByOrder() {
 }
 
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback26, useRef as useRef9, useState as useState22 } from "react";
+import { useCallback as useCallback27, useRef as useRef9, useState as useState23 } from "react";
 
 // src/utils/transactions.ts
 import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk";
@@ -3278,11 +3353,11 @@ function useTransaction() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const isBusyRef = useRef9(false);
-  const [result, setResult] = useState22(null);
-  const [isLoading, setIsLoading] = useState22(false);
-  const [stage, setStage] = useState22("idle");
-  const [error, setError] = useState22(null);
-  const execute = useCallback26(
+  const [result, setResult] = useState23(null);
+  const [isLoading, setIsLoading] = useState23(false);
+  const [stage, setStage] = useState23("idle");
+  const [error, setError] = useState23(null);
+  const execute = useCallback27(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3349,7 +3424,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback26(() => {
+  const reset = useCallback27(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3372,7 +3447,7 @@ async function resolveRequest(request, client) {
 }
 
 // src/hooks/useExecuteProgram.ts
-import { useCallback as useCallback27, useRef as useRef10, useState as useState23 } from "react";
+import { useCallback as useCallback28, useRef as useRef10, useState as useState24 } from "react";
 import {
   AdviceInputs,
   ForeignAccount,
@@ -3386,10 +3461,10 @@ function useExecuteProgram() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const isBusyRef = useRef10(false);
-  const [result, setResult] = useState23(null);
-  const [isLoading, setIsLoading] = useState23(false);
-  const [error, setError] = useState23(null);
-  const execute = useCallback27(
+  const [result, setResult] = useState24(null);
+  const [isLoading, setIsLoading] = useState24(false);
+  const [error, setError] = useState24(null);
+  const execute = useCallback28(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3448,7 +3523,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback27(() => {
+  const reset = useCallback28(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3463,7 +3538,7 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-import { useCallback as useCallback28, useMemo as useMemo9 } from "react";
+import { useCallback as useCallback29, useMemo as useMemo9 } from "react";
 import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk";
 function useCompile() {
   const { client, isReady } = useMiden();
@@ -3471,21 +3546,21 @@ function useCompile() {
     () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = useCallback28(() => {
+  const requireResource = useCallback29(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = useCallback28(
+  const component = useCallback29(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = useCallback28(
+  const txScript = useCallback29(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = useCallback28(
+  const noteScript = useCallback29(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3493,14 +3568,14 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback29, useEffect as useEffect12, useRef as useRef11, useState as useState24 } from "react";
+import { useCallback as useCallback30, useEffect as useEffect12, useRef as useRef11, useState as useState25 } from "react";
 import { AccountStorageMode as AccountStorageMode3 } from "@miden-sdk/miden-sdk";
 function useSessionAccount(options) {
   const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = useState24(null);
-  const [step, setStep] = useState24("idle");
-  const [error, setError] = useState24(null);
+  const [sessionAccountId, setSessionAccountId] = useState25(null);
+  const [step, setStep] = useState25("idle");
+  const [error, setError] = useState25(null);
   const cancelledRef = useRef11(false);
   const isBusyRef = useRef11(false);
   const storagePrefix = options.storagePrefix ?? "miden-session";
@@ -3527,7 +3602,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback29(async () => {
+  const initialize = useCallback30(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3591,7 +3666,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback29(() => {
+  const reset = useCallback30(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3640,13 +3715,13 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 }
 
 // src/hooks/useExportStore.ts
-import { useCallback as useCallback30, useState as useState25 } from "react";
+import { useCallback as useCallback31, useState as useState26 } from "react";
 import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState25(false);
-  const [error, setError] = useState25(null);
-  const exportStore = useCallback30(async () => {
+  const [isExporting, setIsExporting] = useState26(false);
+  const [error, setError] = useState26(null);
+  const exportStore = useCallback31(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3664,7 +3739,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback30(() => {
+  const reset = useCallback31(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3677,13 +3752,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-import { useCallback as useCallback31, useState as useState26 } from "react";
+import { useCallback as useCallback32, useState as useState27 } from "react";
 import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState26(false);
-  const [error, setError] = useState26(null);
-  const importStore = useCallback31(
+  const [isImporting, setIsImporting] = useState27(false);
+  const [error, setError] = useState27(null);
+  const importStore = useCallback32(
     async (storeDump, storeName, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3705,7 +3780,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback31(() => {
+  const reset = useCallback32(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3718,13 +3793,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-import { useCallback as useCallback32, useState as useState27 } from "react";
+import { useCallback as useCallback33, useState as useState28 } from "react";
 import { NoteFile } from "@miden-sdk/miden-sdk";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState27(false);
-  const [error, setError] = useState27(null);
-  const importNote = useCallback32(
+  const [isImporting, setIsImporting] = useState28(false);
+  const [error, setError] = useState28(null);
+  const importNote = useCallback33(
     async (noteBytes) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3748,7 +3823,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback32(() => {
+  const reset = useCallback33(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3761,13 +3836,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-import { useCallback as useCallback33, useState as useState28 } from "react";
+import { useCallback as useCallback34, useState as useState29 } from "react";
 import { NoteExportFormat } from "@miden-sdk/miden-sdk";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState28(false);
-  const [error, setError] = useState28(null);
-  const exportNote = useCallback33(
+  const [isExporting, setIsExporting] = useState29(false);
+  const [error, setError] = useState29(null);
+  const exportNote = useCallback34(
     async (noteId) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3789,7 +3864,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback33(() => {
+  const reset = useCallback34(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3802,12 +3877,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-import { useCallback as useCallback34 } from "react";
+import { useCallback as useCallback35 } from "react";
 function useSyncControl() {
   const isPaused = useMidenStore((state) => state.syncPaused);
   const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
-  const pauseSync = useCallback34(() => setSyncPaused(true), [setSyncPaused]);
-  const resumeSync = useCallback34(() => setSyncPaused(false), [setSyncPaused]);
+  const pauseSync = useCallback35(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback35(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -3992,6 +4067,7 @@ export {
   useAccount,
   useAccounts,
   useAssetMetadata,
+  useBridge,
   useCompile,
   useConsume,
   useCreateFaucet,