@miden-sdk/react 0.15.3 → 0.15.5

package/dist/mt/lazy.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/mt/lazy";
-function useConsume() {
+import { EthAddress } from "@miden-sdk/miden-sdk/mt/lazy";
+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/mt/lazy";
+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");
@@ -3230,11 +3305,124 @@ function usePswapCancelByOrder() {
   };
 }
 
+// src/hooks/useCreateNetworkNote.ts
+import { useCallback as useCallback27, useState as useState23 } from "react";
+import {
+  Felt,
+  FeltArray,
+  FungibleAsset as FungibleAsset3,
+  Note as Note3,
+  NoteArray as NoteArray3,
+  NoteAssets as NoteAssets3,
+  NoteMetadata,
+  NoteStorage,
+  NoteRecipient,
+  NoteTag,
+  NoteType as NoteType4,
+  NetworkAccountTarget,
+  TransactionRequestBuilder as TransactionRequestBuilder3
+} from "@miden-sdk/miden-sdk/mt/lazy";
+function useCreateNetworkNote() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState23(null);
+  const [isLoading, setIsLoading] = useState23(false);
+  const [stage, setStage] = useState23("idle");
+  const [error, setError] = useState23(null);
+  const createNetworkNote = useCallback27(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      if (options.recipient && options.script) {
+        throw new Error(
+          "createNetworkNote requires exactly one of `recipient` or `script`, not both."
+        );
+      }
+      if (!options.recipient && !options.script) {
+        throw new Error(
+          "createNetworkNote requires either `recipient` or `script`."
+        );
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const built = await runExclusiveSafe(async () => {
+          const senderId = parseAccountId(options.accountId);
+          const targetId = parseAccountId(options.target);
+          const target = new NetworkAccountTarget(
+            targetId,
+            options.executionHint
+          );
+          const noteAssets = options.assetId != null ? new NoteAssets3([
+            new FungibleAsset3(
+              parseAccountId(options.assetId),
+              BigInt(options.amount ?? 0)
+            )
+          ]) : new NoteAssets3();
+          const metadata = new NoteMetadata(
+            senderId,
+            NoteType4.Public,
+            NoteTag.withAccountTarget(target.targetId())
+          );
+          const recipient = options.recipient ?? NoteRecipient.fromScript(
+            options.script,
+            new NoteStorage(
+              new FeltArray(
+                (options.inputs ?? []).map((value) => new Felt(value))
+              )
+            )
+          );
+          const attachments = [target.toAttachment()];
+          if (options.attachment) {
+            attachments.push(createNoteAttachment(options.attachment));
+          }
+          const note = Note3.withAttachments(
+            noteAssets,
+            metadata,
+            recipient,
+            attachments
+          );
+          const ownOutputs = new NoteArray3();
+          ownOutputs.push(note);
+          const txRequest = new TransactionRequestBuilder3().withOwnOutputNotes(ownOutputs).build();
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            senderId,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(senderId, txRequest);
+          return { txId: txId.toHex(), note };
+        });
+        setStage("complete");
+        setResult(built);
+        await sync();
+        return built;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        setStage("idle");
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback27(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return { createNetworkNote, result, isLoading, stage, error, reset };
+}
+
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback26, useRef as useRef9, useState as useState22 } from "react";
+import { useCallback as useCallback28, useRef as useRef9, useState as useState24 } from "react";
 
 // src/utils/transactions.ts
-import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/mt/lazy";
+import { NoteType as NoteType5, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/mt/lazy";
 async function waitForTransactionCommit2(client, runExclusiveSafe, txId, maxWaitMs = 1e4, delayMs = 1e3) {
   let waited = 0;
   while (waited < maxWaitMs) {
@@ -3262,7 +3450,7 @@ function extractFullNotes(txResult) {
     const notes = executedTx?.outputNotes?.().notes?.() ?? [];
     const result = [];
     for (const note of notes) {
-      if (note.noteType?.() === NoteType4.Private) {
+      if (note.noteType?.() === NoteType5.Private) {
         const full = note.intoFull?.();
         if (full) result.push(full);
       }
@@ -3278,11 +3466,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] = useState24(null);
+  const [isLoading, setIsLoading] = useState24(false);
+  const [stage, setStage] = useState24("idle");
+  const [error, setError] = useState24(null);
+  const execute = useCallback28(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3349,7 +3537,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback26(() => {
+  const reset = useCallback28(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3372,7 +3560,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 useCallback29, useRef as useRef10, useState as useState25 } from "react";
 import {
   AdviceInputs,
   ForeignAccount,
@@ -3386,10 +3574,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] = useState25(null);
+  const [isLoading, setIsLoading] = useState25(false);
+  const [error, setError] = useState25(null);
+  const execute = useCallback29(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3448,7 +3636,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback27(() => {
+  const reset = useCallback29(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3463,7 +3651,7 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-import { useCallback as useCallback28, useMemo as useMemo9 } from "react";
+import { useCallback as useCallback30, useMemo as useMemo9 } from "react";
 import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk/mt/lazy";
 function useCompile() {
   const { client, isReady } = useMiden();
@@ -3471,21 +3659,21 @@ function useCompile() {
     () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = useCallback28(() => {
+  const requireResource = useCallback30(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = useCallback28(
+  const component = useCallback30(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = useCallback28(
+  const txScript = useCallback30(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = useCallback28(
+  const noteScript = useCallback30(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3493,14 +3681,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 useCallback31, useEffect as useEffect12, useRef as useRef11, useState as useState26 } from "react";
 import { AccountStorageMode as AccountStorageMode3 } from "@miden-sdk/miden-sdk/mt/lazy";
 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] = useState26(null);
+  const [step, setStep] = useState26("idle");
+  const [error, setError] = useState26(null);
   const cancelledRef = useRef11(false);
   const isBusyRef = useRef11(false);
   const storagePrefix = options.storagePrefix ?? "miden-session";
@@ -3527,7 +3715,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback29(async () => {
+  const initialize = useCallback31(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3591,7 +3779,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback29(() => {
+  const reset = useCallback31(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3640,13 +3828,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 useCallback32, useState as useState27 } from "react";
 import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk/mt/lazy";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState25(false);
-  const [error, setError] = useState25(null);
-  const exportStore = useCallback30(async () => {
+  const [isExporting, setIsExporting] = useState27(false);
+  const [error, setError] = useState27(null);
+  const exportStore = useCallback32(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3664,7 +3852,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback30(() => {
+  const reset = useCallback32(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3677,13 +3865,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-import { useCallback as useCallback31, useState as useState26 } from "react";
+import { useCallback as useCallback33, useState as useState28 } from "react";
 import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk/mt/lazy";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState26(false);
-  const [error, setError] = useState26(null);
-  const importStore = useCallback31(
+  const [isImporting, setIsImporting] = useState28(false);
+  const [error, setError] = useState28(null);
+  const importStore = useCallback33(
     async (storeDump, storeName, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3705,7 +3893,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback31(() => {
+  const reset = useCallback33(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3718,13 +3906,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-import { useCallback as useCallback32, useState as useState27 } from "react";
+import { useCallback as useCallback34, useState as useState29 } from "react";
 import { NoteFile } from "@miden-sdk/miden-sdk/mt/lazy";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState27(false);
-  const [error, setError] = useState27(null);
-  const importNote = useCallback32(
+  const [isImporting, setIsImporting] = useState29(false);
+  const [error, setError] = useState29(null);
+  const importNote = useCallback34(
     async (noteBytes) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3748,7 +3936,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback32(() => {
+  const reset = useCallback34(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3761,13 +3949,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-import { useCallback as useCallback33, useState as useState28 } from "react";
+import { useCallback as useCallback35, useState as useState30 } from "react";
 import { NoteExportFormat } from "@miden-sdk/miden-sdk/mt/lazy";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState28(false);
-  const [error, setError] = useState28(null);
-  const exportNote = useCallback33(
+  const [isExporting, setIsExporting] = useState30(false);
+  const [error, setError] = useState30(null);
+  const exportNote = useCallback35(
     async (noteId) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3789,7 +3977,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback33(() => {
+  const reset = useCallback35(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3802,12 +3990,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-import { useCallback as useCallback34 } from "react";
+import { useCallback as useCallback36 } 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 = useCallback36(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback36(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -3992,9 +4180,11 @@ export {
   useAccount,
   useAccounts,
   useAssetMetadata,
+  useBridge,
   useCompile,
   useConsume,
   useCreateFaucet,
+  useCreateNetworkNote,
   useCreateWallet,
   useExecuteProgram,
   useExportNote,