@naculus/connect-appkit-vue 0.2.6 → 0.2.7

package/dist/index.js

@@ -817,10 +817,14 @@ function useSession(manager) {
       current.on("sessionConnected", update);
       current.on("sessionDisconnected", update);
       current.on("chainChanged", update);
+      current.on("sessionScopeChanged", update);
+      current.on("sessionRevoked", update);
       onCleanup(() => {
         current.off("sessionConnected", update);
         current.off("sessionDisconnected", update);
         current.off("chainChanged", update);
+        current.off("sessionScopeChanged", update);
+        current.off("sessionRevoked", update);
       });
     },
     { immediate: true }
@@ -836,261 +840,223 @@ function useSession(manager) {
 
 // src/useConnect.ts
 import { WalletError as WalletError4 } from "@naculus/connect-core";
-import { computed as computed7, onScopeDispose as onScopeDispose6, shallowRef as shallowRef7, toValue as toValue8, unref as unref6 } from "vue";
-function useConnect(action, status) {
-  const isLoading = shallowRef7(false);
+import { computed as computed7, toValue as toValue8, unref as unref6 } from "vue";
+
+// src/internal/action-guard.ts
+import { onScopeDispose as onScopeDispose6, shallowRef as shallowRef7 } from "vue";
+function useActionGuard() {
+  const busy = shallowRef7(false);
   const error = shallowRef7(null);
+  let active = 0;
+  let generation = 0;
   let disposed = false;
+  const run = async (action, fallbackMessage, normalizeError) => {
+    const own = ++generation;
+    const commit = (write) => {
+      if (!disposed && own === generation) write();
+    };
+    active++;
+    busy.value = true;
+    error.value = null;
+    try {
+      return await action(commit);
+    } catch (cause) {
+      const normalized = normalizeError ? normalizeError(cause) : cause instanceof Error ? cause : new Error(fallbackMessage);
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) busy.value = active > 0;
+    }
+  };
+  const reset = () => {
+    generation++;
+    error.value = null;
+  };
+  const clearError = () => {
+    error.value = null;
+  };
+  const dispose = () => {
+    disposed = true;
+    generation++;
+  };
+  onScopeDispose6(dispose);
+  return { busy, error, run, clearError, reset, dispose };
+}
+
+// src/useConnect.ts
+function useConnect(action, status) {
+  const guard = useActionGuard();
   let inFlight = null;
   const connect = () => {
     if (inFlight) return inFlight;
     const invoke = unref6(action);
-    isLoading.value = true;
-    error.value = null;
-    const pending = Promise.resolve().then(() => invoke()).catch((cause) => {
-      if (disposed) return;
-      const message = cause instanceof Error ? cause.message : "Connection failed";
-      error.value = cause instanceof WalletError4 ? cause : new Error(message);
+    const pending = guard.run(
+      () => Promise.resolve().then(() => invoke()),
+      "Connection failed",
+      (cause) => {
+        const message = cause instanceof Error ? cause.message : "Connection failed";
+        return cause instanceof WalletError4 ? cause : new Error(message);
+      }
+    ).catch(() => {
     }).finally(() => {
       if (inFlight === pending) inFlight = null;
-      if (!disposed) isLoading.value = false;
     });
     inFlight = pending;
     return pending;
   };
-  onScopeDispose6(() => {
-    disposed = true;
-  });
   return {
     connect,
     isConnecting: computed7(
-      () => isLoading.value || toValue8(status) === "connecting"
+      () => guard.busy.value || toValue8(status) === "connecting"
     ),
-    error
+    error: guard.error
   };
 }
 
 // src/useDisconnect.ts
-import { onScopeDispose as onScopeDispose7, shallowRef as shallowRef8, toValue as toValue9, unref as unref7 } from "vue";
+import { toValue as toValue9, unref as unref7 } from "vue";
 function useDisconnect(action, status) {
-  const isDisconnecting = shallowRef8(false);
-  const error = shallowRef8(null);
-  let disposed = false;
+  const guard = useActionGuard();
   let inFlight = null;
   const disconnect = () => {
     if (inFlight) return inFlight;
     if (toValue9(status) === "disconnected") return Promise.resolve();
     const invoke = unref7(action);
-    isDisconnecting.value = true;
-    error.value = null;
-    const pending = Promise.resolve().then(() => invoke()).catch((cause) => {
-      if (!disposed) {
-        error.value = cause instanceof Error ? cause : new Error("Disconnect failed");
-      }
+    const pending = guard.run(() => Promise.resolve().then(() => invoke()), "Disconnect failed").catch(() => {
     }).finally(() => {
       if (inFlight === pending) inFlight = null;
-      if (!disposed) isDisconnecting.value = false;
     });
     inFlight = pending;
     return pending;
   };
   const cleanup = () => {
-    disposed = true;
+    guard.dispose();
+  };
+  return {
+    disconnect,
+    isDisconnecting: guard.busy,
+    error: guard.error,
+    cleanup
   };
-  onScopeDispose7(cleanup);
-  return { disconnect, isDisconnecting, error, cleanup };
 }
 
 // src/useSwitchChain.ts
 import { toChainSwitchError } from "@naculus/connect-appkit-core";
-import { computed as computed8, onScopeDispose as onScopeDispose8, shallowRef as shallowRef9, toValue as toValue10, unref as unref8 } from "vue";
+import { computed as computed8, toValue as toValue10, unref as unref8 } from "vue";
 function useSwitchChain(action, chainId) {
-  const isSwitching = shallowRef9(false);
-  const error = shallowRef9(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const switchChain = async (targetChainId) => {
+  const guard = useActionGuard();
+  const switchChain = (targetChainId) => {
     const invoke = unref8(action);
-    const mine = ++generation;
-    active++;
-    isSwitching.value = true;
-    error.value = null;
-    try {
-      await invoke(targetChainId);
-    } catch (cause) {
-      const walletError = toChainSwitchError(cause);
-      if (!disposed && mine === generation) error.value = walletError;
-      throw walletError;
-    } finally {
-      active--;
-      if (!disposed) isSwitching.value = active > 0;
-    }
+    return guard.run(async () => {
+      try {
+        await invoke(targetChainId);
+      } catch (cause) {
+        throw toChainSwitchError(cause);
+      }
+    }, "Failed to switch chain");
   };
-  onScopeDispose8(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     switchChain,
-    isSwitching,
+    isSwitching: guard.busy,
     currentChainId: computed8(() => toValue10(chainId) ?? null),
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
 // src/useSignMessage.ts
-import { onScopeDispose as onScopeDispose9, shallowRef as shallowRef10, unref as unref9 } from "vue";
+import { unref as unref9 } from "vue";
 function useSignMessage(action) {
-  const isSigning = shallowRef10(false);
-  const error = shallowRef10(null);
-  let active = 0;
-  let generation = 0;
-  let disposed = false;
-  const signMessage = async (message) => {
+  const guard = useActionGuard();
+  const signMessage = (message) => {
     const invoke = unref9(action);
-    const own = ++generation;
-    active++;
-    isSigning.value = true;
-    error.value = null;
-    try {
-      return await invoke(message);
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Signing failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) isSigning.value = active > 0;
-    }
+    return guard.run(() => invoke(message), "Signing failed");
   };
-  const reset = () => {
-    generation++;
-    error.value = null;
+  return {
+    signMessage,
+    isSigning: guard.busy,
+    error: guard.error,
+    reset: guard.reset
   };
-  onScopeDispose9(() => {
-    disposed = true;
-    generation++;
-  });
-  return { signMessage, isSigning, error, reset };
 }
 
 // src/useSendTransaction.ts
-import { computed as computed9, onScopeDispose as onScopeDispose10, shallowRef as shallowRef11, unref as unref10 } from "vue";
+import { computed as computed9, shallowRef as shallowRef8, unref as unref10 } from "vue";
 function useSendTransaction(action) {
-  const status = shallowRef11("idle");
-  const error = shallowRef11(null);
-  let generation = 0;
-  let disposed = false;
-  const sendTransaction = async (transaction) => {
+  const guard = useActionGuard();
+  const status = shallowRef8("idle");
+  const sendTransaction = (transaction) => {
     const invoke = unref10(action);
-    const own = ++generation;
     status.value = "awaiting_approval";
-    error.value = null;
-    try {
+    return guard.run(async (commit) => {
       const hash = await invoke(transaction);
-      if (!disposed && own === generation) status.value = "submitted";
+      commit(() => {
+        status.value = "submitted";
+      });
       return hash;
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Transaction failed");
-      if (!disposed && own === generation) {
-        status.value = "failed";
-        error.value = normalized;
-      }
-      throw normalized;
-    }
+    }, "Transaction failed").catch((cause) => {
+      if (guard.error.value === cause) status.value = "failed";
+      throw cause;
+    });
   };
   const reset = () => {
-    generation++;
+    guard.reset();
     status.value = "idle";
-    error.value = null;
   };
-  onScopeDispose10(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     sendTransaction,
     status,
-    error,
+    error: guard.error,
     reset,
     isSending: computed9(() => status.value === "awaiting_approval")
   };
 }
 
 // src/useSolanaTransaction.ts
-import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef12, unref as unref11 } from "vue";
+import { shallowRef as shallowRef9, unref as unref11 } from "vue";
 function useSolanaTransaction(options) {
-  const isSigning = shallowRef12(false);
-  const isSending = shallowRef12(false);
-  const error = shallowRef12(null);
+  const guard = useActionGuard();
+  const isSigning = shallowRef9(false);
+  const isSending = shallowRef9(false);
   let signing = 0;
   let sending = 0;
-  let generation = 0;
-  let disposed = false;
-  const signTransaction = async (transaction) => {
+  const signTransaction = (transaction) => {
     const invoke = unref11(options.signTransaction);
-    const own = ++generation;
     signing++;
     isSigning.value = true;
-    error.value = null;
-    try {
-      return await invoke(transaction);
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Signing failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
+    return guard.run(() => invoke(transaction), "Signing failed").finally(() => {
       signing--;
-      if (!disposed) isSigning.value = signing > 0;
-    }
+      isSigning.value = signing > 0;
+    });
   };
-  const sendTransaction = async (transaction) => {
+  const sendTransaction = (transaction) => {
     const invoke = unref11(options.sendTransaction);
-    const own = ++generation;
     sending++;
     isSending.value = true;
-    error.value = null;
-    try {
-      return await invoke(transaction);
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Send failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
+    return guard.run(() => invoke(transaction), "Send failed").finally(() => {
       sending--;
-      if (!disposed) isSending.value = sending > 0;
-    }
+      isSending.value = sending > 0;
+    });
   };
   const getStatus = (signature) => unref11(options.getStatus)(signature);
-  const reset = () => {
-    generation++;
-    error.value = null;
-  };
-  onScopeDispose11(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     signTransaction,
     sendTransaction,
     getStatus,
     isSigning,
     isSending,
-    error,
-    reset
+    error: guard.error,
+    reset: guard.reset
   };
 }
 
 // src/useSignInWithX.ts
-import { onScopeDispose as onScopeDispose12, shallowRef as shallowRef13, unref as unref12 } from "vue";
+import { onScopeDispose as onScopeDispose7, shallowRef as shallowRef10, unref as unref12 } from "vue";
 function useSignInWithX(action) {
-  const isSigningIn = shallowRef13(false);
-  const result = shallowRef13(null);
-  const error = shallowRef13(null);
+  const isSigningIn = shallowRef10(false);
+  const result = shallowRef10(null);
+  const error = shallowRef10(null);
   let generation = 0;
   let active = 0;
   let disposed = false;
@@ -1121,7 +1087,7 @@ function useSignInWithX(action) {
     result.value = null;
     error.value = null;
   };
-  onScopeDispose12(() => {
+  onScopeDispose7(() => {
     disposed = true;
     generation++;
   });
@@ -1134,45 +1100,23 @@ function useSignInWithEthereum(action) {
 }
 
 // src/useExecuteCalls.ts
-import { computed as computed10, onScopeDispose as onScopeDispose13, shallowRef as shallowRef14, toValue as toValue11, unref as unref13 } from "vue";
+import { computed as computed10, toValue as toValue11, unref as unref13 } from "vue";
 function useExecuteCalls(options) {
-  const isExecuting = shallowRef14(false);
-  const error = shallowRef14(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
+  const guard = useActionGuard();
   const preview = (callCount, atomicity) => unref13(options.preview)(callCount, atomicity);
-  const execute = async (calls, atomicity) => {
+  const execute = (calls, atomicity) => {
     const invoke = unref13(options.execute);
-    const own = ++generation;
-    active++;
-    isExecuting.value = true;
-    error.value = null;
-    try {
-      return await invoke(calls, atomicity);
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Execution failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) isExecuting.value = active > 0;
-    }
+    return guard.run(() => invoke(calls, atomicity), "Execution failed");
   };
   const reset = () => {
-    generation++;
-    error.value = null;
+    guard.reset();
     unref13(options.reset)();
   };
-  onScopeDispose13(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     preview,
     execute,
-    isExecuting,
-    error,
+    isExecuting: guard.busy,
+    error: guard.error,
     lastRoute: computed10(() => toValue11(options.lastRoute)),
     reset
   };
@@ -1187,59 +1131,24 @@ import {
 } from "@naculus/connect-appkit-core";
 import {
   computed as computed12,
-  onScopeDispose as onScopeDispose16,
-  shallowRef as shallowRef17,
+  onScopeDispose as onScopeDispose9,
+  shallowRef as shallowRef12,
   toValue as toValue13,
   unref as unref14,
   watch as watch6
 } from "vue";
 
-// src/internal/action-guard.ts
-import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef15 } from "vue";
-function useActionGuard() {
-  const busy = shallowRef15(false);
-  const error = shallowRef15(null);
-  let active = 0;
-  let generation = 0;
-  let disposed = false;
-  const run = async (action, fallbackMessage) => {
-    const own = ++generation;
-    active++;
-    busy.value = true;
-    error.value = null;
-    try {
-      return await action();
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error(fallbackMessage);
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) busy.value = active > 0;
-    }
-  };
-  const reset = () => {
-    generation++;
-    error.value = null;
-  };
-  onScopeDispose14(() => {
-    disposed = true;
-    generation++;
-  });
-  return { busy, error, run, reset };
-}
-
 // src/useSessionKeys.ts
 import { getSharedSessionKeyManager } from "@naculus/connect-appkit-core";
-import { computed as computed11, onScopeDispose as onScopeDispose15, shallowRef as shallowRef16, toValue as toValue12, watch as watch5 } from "vue";
+import { computed as computed11, onScopeDispose as onScopeDispose8, shallowRef as shallowRef11, toValue as toValue12, watch as watch5 } from "vue";
 function resolveManager(config, options) {
   return options.manager ?? getSharedSessionKeyManager(config);
 }
 function useSessionKeys(connected, config, options = {}) {
   const manager = resolveManager(config, options);
-  const sessions = shallowRef16([]);
-  const loading = shallowRef16(false);
-  const error = shallowRef16(null);
+  const sessions = shallowRef11([]);
+  const loading = shallowRef11(false);
+  const error = shallowRef11(null);
   let generation = 0;
   let disposed = false;
   const refresh = async () => {
@@ -1268,7 +1177,7 @@ function useSessionKeys(connected, config, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose15(() => {
+  onScopeDispose8(() => {
     disposed = true;
     generation++;
   });
@@ -1289,7 +1198,7 @@ function useSessionKeys(connected, config, options = {}) {
 function useCreateSessionKey(config, options = {}) {
   const manager = resolveManager(config, options);
   const guard = useActionGuard();
-  const lastCreated = shallowRef16(null);
+  const lastCreated = shallowRef11(null);
   return {
     createSessionKey: (scope, signerAddress) => guard.run(async () => {
       const info = await manager.createSessionKey(scope, signerAddress);
@@ -1340,9 +1249,9 @@ function useDelegationPolicy(options) {
     manager
   });
   const guard = useActionGuard();
-  const verifiedIds = shallowRef17(/* @__PURE__ */ new Set());
-  const isVerifying = shallowRef17(false);
-  const verifyError = shallowRef17(null);
+  const verifiedIds = shallowRef12(/* @__PURE__ */ new Set());
+  const isVerifying = shallowRef12(false);
+  const verifyError = shallowRef12(null);
   let verifyGeneration = 0;
   let disposed = false;
   const origin = options.origin ?? (typeof window !== "undefined" ? window.location.origin : "unknown");
@@ -1390,7 +1299,7 @@ function useDelegationPolicy(options) {
     },
     { immediate: true }
   );
-  onScopeDispose16(() => {
+  onScopeDispose9(() => {
     disposed = true;
     verifyGeneration++;
   });
@@ -1433,18 +1342,18 @@ import {
 import { WalletError as WalletError5 } from "@naculus/connect-core";
 import {
   computed as computed13,
-  onScopeDispose as onScopeDispose17,
-  shallowRef as shallowRef18,
+  onScopeDispose as onScopeDispose10,
+  shallowRef as shallowRef13,
   toValue as toValue14,
   unref as unref15,
   watch as watch7
 } from "vue";
 function useSmartAccount(options) {
-  const address = shallowRef18(null);
-  const isDeployed = shallowRef18(false);
-  const accountInfo = shallowRef18(null);
+  const address = shallowRef13(null);
+  const isDeployed = shallowRef13(false);
+  const accountInfo = shallowRef13(null);
   const guard = useActionGuard();
-  const managerRef = shallowRef18(null);
+  const managerRef = shallowRef13(null);
   let generation = 0;
   let inFlight = false;
   let disposed = false;
@@ -1564,7 +1473,7 @@ function useSmartAccount(options) {
     });
     return addr;
   }, "Failed to get smart account address");
-  onScopeDispose17(() => {
+  onScopeDispose10(() => {
     disposed = true;
     generation++;
   });
@@ -1588,13 +1497,13 @@ import {
   resolveUserOpChain
 } from "@naculus/connect-appkit-core";
 import { WalletError as WalletError6 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef19, toValue as toValue15, unref as unref16 } from "vue";
+import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef14, toValue as toValue15, unref as unref16 } from "vue";
 function useSendUserOperation(options) {
-  const userOpHash = shallowRef19(null);
-  const receipt = shallowRef19(null);
-  const isPending = shallowRef19(false);
-  const isEstimating = shallowRef19(false);
-  const error = shallowRef19(null);
+  const userOpHash = shallowRef14(null);
+  const receipt = shallowRef14(null);
+  const isPending = shallowRef14(false);
+  const isEstimating = shallowRef14(false);
+  const error = shallowRef14(null);
   let requestId = 0;
   let inFlight = false;
   let disposed = false;
@@ -1679,7 +1588,7 @@ function useSendUserOperation(options) {
     isEstimating.value = false;
     error.value = null;
   };
-  onScopeDispose18(() => {
+  onScopeDispose11(() => {
     disposed = true;
     requestId++;
   });
@@ -1699,15 +1608,15 @@ import {
   fetchUserOperationReceipt,
   InvalidUserOperationReceiptError
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef20, toValue as toValue16 } from "vue";
+import { onScopeDispose as onScopeDispose12, shallowRef as shallowRef15, toValue as toValue16 } from "vue";
 function useUserOpStatus(options) {
-  const status = shallowRef20("idle");
-  const receipt = shallowRef20(null);
-  const userOpHash = shallowRef20(null);
-  const error = shallowRef20(null);
-  const isPolling = shallowRef20(false);
-  const elapsedMs = shallowRef20(0);
-  const attempts = shallowRef20(0);
+  const status = shallowRef15("idle");
+  const receipt = shallowRef15(null);
+  const userOpHash = shallowRef15(null);
+  const error = shallowRef15(null);
+  const isPolling = shallowRef15(false);
+  const elapsedMs = shallowRef15(0);
+  const attempts = shallowRef15(0);
   const pollInterval = options.pollInterval ?? 2e3;
   const maxRetries = options.maxRetries ?? 30;
   let generation = 0;
@@ -1813,7 +1722,7 @@ function useUserOpStatus(options) {
     attempts.value = 0;
     elapsedMs.value = 0;
   };
-  onScopeDispose19(stop);
+  onScopeDispose12(stop);
   return {
     status,
     receipt,
@@ -1829,12 +1738,12 @@ function useUserOpStatus(options) {
 }
 
 // src/useSendCalls.ts
-import { computed as computed14, onScopeDispose as onScopeDispose20, shallowRef as shallowRef21, toValue as toValue17, unref as unref17 } from "vue";
+import { computed as computed14, onScopeDispose as onScopeDispose13, shallowRef as shallowRef16, toValue as toValue17, unref as unref17 } from "vue";
 function useSendCalls(options) {
-  const status = shallowRef21("idle");
-  const error = shallowRef21(null);
-  const batchHash = shallowRef21(null);
-  const callsStatus = shallowRef21(null);
+  const status = shallowRef16("idle");
+  const error = shallowRef16(null);
+  const batchHash = shallowRef16(null);
+  const callsStatus = shallowRef16(null);
   let sendGeneration = 0;
   let statusGeneration = 0;
   let disposed = false;
@@ -1876,7 +1785,7 @@ function useSendCalls(options) {
     batchHash.value = null;
     callsStatus.value = null;
   };
-  onScopeDispose20(() => {
+  onScopeDispose13(() => {
     disposed = true;
     sendGeneration++;
     statusGeneration++;
@@ -1896,34 +1805,11 @@ function useSendCalls(options) {
 }
 
 // src/useEmbeddedWallet.ts
-import { computed as computed15, onScopeDispose as onScopeDispose21, shallowRef as shallowRef22, toValue as toValue18, unref as unref18 } from "vue";
+import { computed as computed15, toValue as toValue18, unref as unref18 } from "vue";
 function useEmbeddedWallet(options) {
-  const isBusy = shallowRef22(false);
-  const error = shallowRef22(null);
-  let active = 0;
-  let generation = 0;
-  let disposed = false;
-  const run = async (action) => {
-    const own = ++generation;
-    active++;
-    isBusy.value = true;
-    error.value = null;
-    try {
-      return await action();
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("Embedded wallet action failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) isBusy.value = active > 0;
-    }
-  };
+  const guard = useActionGuard();
+  const run = (action) => guard.run(action, "Embedded wallet action failed");
   const wallet = computed15(() => toValue18(options.wallet));
-  onScopeDispose21(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     wallet,
     hasWallet: computed15(() => wallet.value !== null),
@@ -1944,11 +1830,9 @@ function useEmbeddedWallet(options) {
     getSeedPhrase: () => unref18(options.getSeedPhrase)(),
     getPrivateKey: () => unref18(options.getPrivateKey)(),
     confirmBackup: () => unref18(options.confirmBackup)(),
-    isBusy,
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    isBusy: guard.busy,
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
@@ -1964,111 +1848,60 @@ function useSIWxLogin(action) {
 }
 
 // src/useSIWxSession.ts
-import { computed as computed16, onScopeDispose as onScopeDispose22, shallowRef as shallowRef23, toValue as toValue19, unref as unref19 } from "vue";
+import { computed as computed16, toValue as toValue19, unref as unref19 } from "vue";
 function useSIWxSession(options) {
-  const isSigningIn = shallowRef23(false);
-  const error = shallowRef23(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const run = async (action, message) => {
-    const own = ++generation;
-    active++;
-    isSigningIn.value = true;
-    error.value = null;
-    try {
-      return await action();
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error(message);
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      active--;
-      if (!disposed) isSigningIn.value = active > 0;
-    }
-  };
-  onScopeDispose22(() => {
-    disposed = true;
-    generation++;
-  });
+  const guard = useActionGuard();
   return {
     session: computed16(() => toValue19(options.session)),
     isAuthenticated: computed16(
       () => toValue19(options.session) !== null && !toValue19(options.isExpired)
     ),
     isRestoring: computed16(() => toValue19(options.isRestoring)),
-    isSigningIn,
+    isSigningIn: guard.busy,
     isExpired: computed16(() => toValue19(options.isExpired)),
     timeUntilExpiry: computed16(() => toValue19(options.timeUntilExpiry)),
-    signIn: (input) => run(() => unref19(options.signIn)(input), "SIWX sign-in failed"),
+    signIn: (input) => guard.run(() => unref19(options.signIn)(input), "SIWX sign-in failed"),
     signOut: async () => {
       await unref19(options.signOut)();
-      error.value = null;
+      guard.clearError();
     },
-    refresh: () => run(() => unref19(options.refresh)(), "Session refresh failed"),
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    refresh: () => guard.run(() => unref19(options.refresh)(), "Session refresh failed"),
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
 // src/useSiwxAuthSession.ts
-import { computed as computed17, onScopeDispose as onScopeDispose23, shallowRef as shallowRef24, toValue as toValue20, unref as unref20 } from "vue";
+import { computed as computed17, toValue as toValue20, unref as unref20 } from "vue";
 function useSiwxAuthSession(options) {
-  const isSigningIn = shallowRef24(false);
-  const error = shallowRef24(null);
-  let generation = 0;
-  let disposed = false;
-  const signIn = async (input) => {
-    const own = ++generation;
-    isSigningIn.value = true;
-    error.value = null;
-    try {
-      return await unref20(options.signIn)(input);
-    } catch (cause) {
-      const normalized = cause instanceof Error ? cause : new Error("SIWX sign-in failed");
-      if (!disposed && own === generation) error.value = normalized;
-      throw normalized;
-    } finally {
-      if (!disposed && own === generation) isSigningIn.value = false;
-    }
-  };
+  const guard = useActionGuard();
+  const signIn = (input) => guard.run(() => unref20(options.signIn)(input), "SIWX sign-in failed");
   const signOut = async () => {
-    generation++;
+    guard.reset();
     await unref20(options.signOut)();
-    if (!disposed) {
-      isSigningIn.value = false;
-      error.value = null;
-    }
+    guard.clearError();
   };
-  onScopeDispose23(() => {
-    disposed = true;
-    generation++;
-  });
   const siwxResult = computed17(() => toValue20(options.result));
   return {
     isSignedIn: computed17(() => siwxResult.value !== null),
     isRestoring: computed17(() => toValue20(options.isRestoring)),
     siwxResult,
-    isSigningIn,
-    error,
+    isSigningIn: guard.busy,
+    error: guard.error,
     signIn,
     signOut,
-    clearError: () => {
-      error.value = null;
-    }
+    clearError: guard.clearError
   };
 }
 
 // src/useBalance.ts
 import { bareEvmAddress as bareEvmAddress5 } from "@naculus/connect-appkit-core";
 import { formatUnits as formatUnits2 } from "@naculus/connect-core";
-import { computed as computed18, onScopeDispose as onScopeDispose24, shallowRef as shallowRef25, toValue as toValue21, watch as watch8 } from "vue";
+import { computed as computed18, onScopeDispose as onScopeDispose14, shallowRef as shallowRef17, toValue as toValue21, watch as watch8 } from "vue";
 function useBalance(account, client, options = {}) {
-  const balance = shallowRef25(null);
-  const isFetching = shallowRef25(false);
-  const error = shallowRef25(null);
+  const balance = shallowRef17(null);
+  const isFetching = shallowRef17(false);
+  const error = shallowRef17(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
@@ -2113,7 +1946,7 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose24(() => {
+  onScopeDispose14(() => {
     disposed = true;
     generation++;
     stopTimer();
@@ -2134,11 +1967,11 @@ function useBalance(account, client, options = {}) {
 import {
   isQuotableInput
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose25, shallowRef as shallowRef26, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
+import { onScopeDispose as onScopeDispose15, shallowRef as shallowRef18, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
 function useRouteQuote(input, getQuotes, options = {}) {
-  const quotes = shallowRef26([]);
-  const loading = shallowRef26(false);
-  const error = shallowRef26(null);
+  const quotes = shallowRef18([]);
+  const loading = shallowRef18(false);
+  const error = shallowRef18(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
@@ -2198,7 +2031,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose25(() => {
+  onScopeDispose15(() => {
     disposed = true;
     generation++;
     clearTimer();
@@ -2222,11 +2055,11 @@ function useRouteQuote(input, getQuotes, options = {}) {
 import {
   compareCostsKey
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose26, shallowRef as shallowRef27, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
+import { onScopeDispose as onScopeDispose16, shallowRef as shallowRef19, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
 function useCompareCosts(input, compareCosts) {
-  const comparisons = shallowRef27([]);
-  const loading = shallowRef27(false);
-  const error = shallowRef27(null);
+  const comparisons = shallowRef19([]);
+  const loading = shallowRef19(false);
+  const error = shallowRef19(null);
   let generation = 0;
   let disposed = false;
   const fetchComparisons = async () => {
@@ -2259,7 +2092,7 @@ function useCompareCosts(input, compareCosts) {
     },
     { immediate: true }
   );
-  onScopeDispose26(() => {
+  onScopeDispose16(() => {
     disposed = true;
     generation++;
   });
@@ -2271,11 +2104,11 @@ import {
   toExecuteRouteError,
   validateRouteRecipient
 } from "@naculus/connect-appkit-core";
-import { onScopeDispose as onScopeDispose27, shallowRef as shallowRef28, unref as unref23 } from "vue";
+import { onScopeDispose as onScopeDispose17, shallowRef as shallowRef20, unref as unref23 } from "vue";
 function useExecuteRoute(executeRoute) {
-  const executing = shallowRef28(false);
-  const result = shallowRef28(null);
-  const error = shallowRef28(null);
+  const executing = shallowRef20(false);
+  const result = shallowRef20(null);
+  const error = shallowRef20(null);
   let inFlight = false;
   let disposed = false;
   const execute = async (quote, recipient, options) => {
@@ -2317,7 +2150,7 @@ function useExecuteRoute(executeRoute) {
       if (!disposed) executing.value = false;
     }
   };
-  onScopeDispose27(() => {
+  onScopeDispose17(() => {
     disposed = true;
   });
   return {
@@ -2338,15 +2171,15 @@ import { eip155ChainIdToNumber } from "@naculus/connect-appkit-core";
 import {
   TokenListManager
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose28, shallowRef as shallowRef29, toValue as toValue24, watch as watch11 } from "vue";
+import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef21, toValue as toValue24, watch as watch11 } from "vue";
 function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
   const manager = options.manager ?? new TokenListManager(config);
-  const tokens = shallowRef29([]);
-  const isLoading = shallowRef29(options.autoLoad !== false);
-  const isLoaded = shallowRef29(false);
-  const error = shallowRef29(null);
+  const tokens = shallowRef21([]);
+  const isLoading = shallowRef21(options.autoLoad !== false);
+  const isLoaded = shallowRef21(false);
+  const error = shallowRef21(null);
   let generation = 0;
   let disposed = false;
   const select = () => {
@@ -2379,7 +2212,7 @@ function useTokenList(chainId, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose28(() => {
+  onScopeDispose18(() => {
     disposed = true;
     generation++;
   });
@@ -2397,7 +2230,7 @@ import { eip155ChainIdToNumber as eip155ChainIdToNumber2 } from "@naculus/connec
 import {
   TokenListManager as TokenListManager2
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose29, shallowRef as shallowRef30, toValue as toValue25, watch as watch12 } from "vue";
+import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef22, toValue as toValue25, watch as watch12 } from "vue";
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
@@ -2410,8 +2243,8 @@ function getSharedManager() {
   return sharedManager;
 }
 function useTokenSearch(query, chainId, options = {}) {
-  const results = shallowRef30(EMPTY);
-  const isSearching = shallowRef30(false);
+  const results = shallowRef22(EMPTY);
+  const isSearching = shallowRef22(false);
   let timer = null;
   const clear = () => {
     if (timer) clearTimeout(timer);
@@ -2440,7 +2273,7 @@ function useTokenSearch(query, chainId, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose29(clear);
+  onScopeDispose19(clear);
   return { results, isSearching };
 }
 
@@ -2458,14 +2291,14 @@ function useValidateDestination(address) {
 // src/useTokenBalance.ts
 import { bareEvmAddress as bareEvmAddress6 } from "@naculus/connect-appkit-core";
 import { ERC20_MIN_ABI as ERC20_MIN_ABI3, formatUnits as formatUnits3 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose30, shallowRef as shallowRef31, toValue as toValue27, watch as watch13 } from "vue";
+import { onScopeDispose as onScopeDispose20, shallowRef as shallowRef23, toValue as toValue27, watch as watch13 } from "vue";
 function tokensKey(tokens) {
   return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
 }
 function useTokenBalance(account, client, tokens, options = {}) {
-  const tokenBalances = shallowRef31([]);
-  const isFetching = shallowRef31(false);
-  const error = shallowRef31(null);
+  const tokenBalances = shallowRef23([]);
+  const isFetching = shallowRef23(false);
+  const error = shallowRef23(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
@@ -2531,7 +2364,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  onScopeDispose30(() => {
+  onScopeDispose20(() => {
     disposed = true;
     generation++;
     stopTimer();
@@ -2547,23 +2380,120 @@ function useTokenBalance(account, client, tokens, options = {}) {
   };
 }
 
-// src/useDelegation.ts
+// src/useDelegate.ts
 import { bareEvmAddress as bareEvmAddress7 } from "@naculus/connect-appkit-core";
+import {
+  delegateAccount,
+  eip155Reference,
+  REVOKE_DELEGATE,
+  WalletError as WalletError7
+} from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose21, shallowRef as shallowRef24, toValue as toValue28, watch as watch14 } from "vue";
+function useDelegate(options) {
+  const result = shallowRef24(null);
+  const isPending = shallowRef24(false);
+  const error = shallowRef24(null);
+  let requestId = 0;
+  let inFlight = false;
+  let disposed = false;
+  const fail = (cause) => {
+    error.value = cause;
+    return null;
+  };
+  const run = async (target, allowlist) => {
+    if (inFlight) return fail(new Error("A delegation is already in progress"));
+    const session = toValue28(options.session);
+    const account = bareEvmAddress7(toValue28(options.account));
+    const chainId = toValue28(options.chainId);
+    if (!session || !account || !chainId) {
+      return fail(
+        new WalletError7("wallet_unavailable", "No connected EVM account")
+      );
+    }
+    const reader = toValue28(options.client);
+    if (!reader || reader.chain?.id !== eip155Reference(chainId)) {
+      return fail(
+        new WalletError7(
+          "chain_mismatch",
+          `No RPC client for ${chainId}; refusing to read the nonce elsewhere.`
+        )
+      );
+    }
+    const connector = toValue28(options.connector) ?? {};
+    const own = ++requestId;
+    inFlight = true;
+    isPending.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const sent = await delegateAccount({
+        connector,
+        session,
+        account,
+        chainId,
+        delegate: target,
+        allowlist,
+        getTransactionCount: (address, blockTag) => reader.getTransactionCount({ address, blockTag })
+      });
+      if (disposed || own !== requestId) return null;
+      result.value = sent;
+      return sent;
+    } catch (cause) {
+      if (disposed || own !== requestId) return null;
+      return fail(
+        cause instanceof Error ? cause : new Error("Failed to send delegation")
+      );
+    } finally {
+      inFlight = false;
+      if (!disposed && own === requestId) isPending.value = false;
+    }
+  };
+  const reset = () => {
+    requestId++;
+    result.value = null;
+    isPending.value = false;
+    error.value = null;
+  };
+  watch14(
+    [
+      () => toValue28(options.session),
+      () => toValue28(options.account),
+      () => toValue28(options.chainId)
+    ],
+    reset,
+    { flush: "sync" }
+  );
+  onScopeDispose21(() => {
+    disposed = true;
+    requestId++;
+  });
+  return {
+    delegate: (target) => run(target, toValue28(options.allowlist)),
+    revoke: () => run(REVOKE_DELEGATE, []),
+    result,
+    isPending,
+    error,
+    reset
+  };
+}
+
+// src/useDelegation.ts
+import { bareEvmAddress as bareEvmAddress8 } from "@naculus/connect-appkit-core";
 import {
   readDelegation,
   UNKNOWN_DELEGATION
 } from "@naculus/connect-core";
-import { computed as computed20, onScopeDispose as onScopeDispose31, shallowRef as shallowRef32, toValue as toValue28, watch as watch14 } from "vue";
+import { computed as computed20, onScopeDispose as onScopeDispose22, shallowRef as shallowRef25, toValue as toValue29, watch as watch15 } from "vue";
 function useDelegation(account, client, chainId) {
-  const status = shallowRef32(UNKNOWN_DELEGATION);
-  const isFetching = shallowRef32(false);
-  const error = shallowRef32(null);
+  const status = shallowRef25(UNKNOWN_DELEGATION);
+  const isFetching = shallowRef25(false);
+  const error = shallowRef25(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
     const mine = ++generation;
-    const reader = toValue28(client);
-    const address = bareEvmAddress7(toValue28(account));
+    const reader = toValue29(client);
+    const address = bareEvmAddress8(toValue29(account));
     status.value = UNKNOWN_DELEGATION;
     error.value = null;
     if (!reader || !address) {
@@ -2585,14 +2515,14 @@ function useDelegation(account, client, chainId) {
       if (!disposed && mine === generation) isFetching.value = false;
     }
   };
-  watch14(
-    [() => toValue28(account), () => toValue28(client), () => toValue28(chainId)],
+  watch15(
+    [() => toValue29(account), () => toValue29(client), () => toValue29(chainId)],
     () => {
       void refetch();
     },
     { immediate: true, flush: "sync" }
   );
-  onScopeDispose31(() => {
+  onScopeDispose22(() => {
     disposed = true;
     generation++;
   });
@@ -2607,18 +2537,18 @@ function useDelegation(account, client, chainId) {
 
 // src/name-lookup.ts
 import { getResolver } from "@naculus/connect-appkit-core";
-import { computed as computed21, onScopeDispose as onScopeDispose32, shallowRef as shallowRef33, toValue as toValue29, watch as watch15 } from "vue";
+import { computed as computed21, onScopeDispose as onScopeDispose23, shallowRef as shallowRef26, toValue as toValue30, watch as watch16 } from "vue";
 function useNameLookup(options) {
-  const data = shallowRef33(null);
-  const loading = shallowRef33(false);
-  const error = shallowRef33(null);
+  const data = shallowRef26(null);
+  const loading = shallowRef26(false);
+  const error = shallowRef26(null);
   let generation = 0;
   let disposed = false;
   const run = () => {
-    const input = toValue29(options.input).trim();
-    const skip = toValue29(options.skip) ?? false;
-    const scope = toValue29(options.scope);
-    const config = toValue29(options.resolverConfig);
+    const input = toValue30(options.input).trim();
+    const skip = toValue30(options.skip) ?? false;
+    const scope = toValue30(options.scope);
+    const config = toValue30(options.resolverConfig);
     const mine = ++generation;
     if (!input || skip) {
       data.value = null;
@@ -2640,17 +2570,17 @@ function useNameLookup(options) {
       loading.value = false;
     });
   };
-  watch15(
+  watch16(
     () => [
-      toValue29(options.input),
-      toValue29(options.skip),
-      toValue29(options.scope),
-      toValue29(options.resolverConfig)
+      toValue30(options.input),
+      toValue30(options.skip),
+      toValue30(options.scope),
+      toValue30(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
-  onScopeDispose32(() => {
+  onScopeDispose23(() => {
     disposed = true;
     generation++;
   });
@@ -2684,11 +2614,11 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-import { computed as computed22, toValue as toValue30 } from "vue";
+import { computed as computed22, toValue as toValue31 } from "vue";
 function useSolanaAccount(accounts, connected) {
-  const isConnected = computed22(() => toValue30(connected));
+  const isConnected = computed22(() => toValue31(connected));
   const caip10 = computed22(
-    () => isConnected.value ? (toValue30(accounts) ?? []).find(
+    () => isConnected.value ? (toValue31(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
@@ -2713,10 +2643,10 @@ import {
   describeChain,
   resolveChain
 } from "@naculus/connect-appkit-core";
-import { computed as computed23, toValue as toValue31 } from "vue";
+import { computed as computed23, toValue as toValue32 } from "vue";
 function useChain(chains, chainId) {
-  const list = computed23(() => toValue31(chains) ?? []);
-  const id = computed23(() => toValue31(chainId) ?? null);
+  const list = computed23(() => toValue32(chains) ?? []);
+  const id = computed23(() => toValue32(chainId) ?? null);
   const currentChain = computed23(() => resolveChain(list.value, id.value));
   return {
     currentChain,
@@ -2732,13 +2662,13 @@ function useChain(chains, chainId) {
 }
 
 // src/usePassphraseGate.ts
-import { onScopeDispose as onScopeDispose33, readonly, shallowRef as shallowRef34 } from "vue";
+import { onScopeDispose as onScopeDispose24, readonly, shallowRef as shallowRef27 } from "vue";
 function usePassphraseGate(gate) {
-  const request = shallowRef34(gate.getSnapshot());
+  const request = shallowRef27(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  onScopeDispose33(unsubscribe);
+  onScopeDispose24(unsubscribe);
   return {
     request: readonly(request),
     submit: (passphrase) => gate.submit(passphrase),
@@ -2751,16 +2681,16 @@ function usePassphraseGate(gate) {
 import {
   getSolanaBalance
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose34, ref, shallowRef as shallowRef35, toValue as toValue32, watchEffect } from "vue";
+import { onScopeDispose as onScopeDispose25, ref, shallowRef as shallowRef28, toValue as toValue33, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
-  const balance = shallowRef35(null);
+  const balance = shallowRef28(null);
   const isFetching = ref(false);
-  const error = shallowRef35(null);
+  const error = shallowRef28(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
-    const addr = toValue32(address);
-    const url = toValue32(rpcUrl);
+    const addr = toValue33(address);
+    const url = toValue33(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -2781,24 +2711,24 @@ function useSolanaBalance(address, rpcUrl) {
     }
   };
   watchEffect(() => {
-    toValue32(address);
-    toValue32(rpcUrl);
+    toValue33(address);
+    toValue33(rpcUrl);
     void refetch();
   });
-  onScopeDispose34(() => {
+  onScopeDispose25(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
 
 // src/useLastTx.ts
-import { shallowRef as shallowRef36, toValue as toValue33, watch as watch16 } from "vue";
+import { shallowRef as shallowRef29, toValue as toValue34, watch as watch17 } from "vue";
 function useLastTx(monitor) {
-  const lastTx = shallowRef36(null);
-  const lastConfirmedTx = shallowRef36(null);
-  const lastFailedTx = shallowRef36(null);
-  watch16(
-    () => toValue33(monitor),
+  const lastTx = shallowRef29(null);
+  const lastConfirmedTx = shallowRef29(null);
+  const lastFailedTx = shallowRef29(null);
+  watch17(
+    () => toValue34(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -2836,15 +2766,15 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-import { computed as computed24, shallowRef as shallowRef37, toValue as toValue34, watch as watch17 } from "vue";
+import { computed as computed24, shallowRef as shallowRef30, toValue as toValue35, watch as watch18 } from "vue";
 function useTxHistory(address, chainId, monitor) {
-  const entries = shallowRef37([]);
-  const isLoading = shallowRef37(false);
-  const error = shallowRef37(null);
+  const entries = shallowRef30([]);
+  const isLoading = shallowRef30(false);
+  const error = shallowRef30(null);
   let generation = 0;
   const refresh = async () => {
     const mine = ++generation;
-    const activeMonitor = toValue34(monitor);
+    const activeMonitor = toValue35(monitor);
     if (!activeMonitor) {
       entries.value = [];
       isLoading.value = false;
@@ -2855,8 +2785,8 @@ function useTxHistory(address, chainId, monitor) {
     error.value = null;
     try {
       const result = await activeMonitor.getTxHistory(
-        toValue34(address) ?? void 0,
-        toValue34(chainId) ?? void 0
+        toValue35(address) ?? void 0,
+        toValue35(chainId) ?? void 0
       );
       if (mine === generation) entries.value = result;
     } catch (err) {
@@ -2866,8 +2796,8 @@ function useTxHistory(address, chainId, monitor) {
       if (mine === generation) isLoading.value = false;
     }
   };
-  watch17(
-    [() => toValue34(monitor), () => toValue34(address), () => toValue34(chainId)],
+  watch18(
+    [() => toValue35(monitor), () => toValue35(address), () => toValue35(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -2896,17 +2826,17 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-import { computed as computed25, shallowRef as shallowRef38, toValue as toValue35, watch as watch18 } from "vue";
+import { computed as computed25, shallowRef as shallowRef31, toValue as toValue36, watch as watch19 } from "vue";
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = shallowRef38(null);
-  const isLoading = shallowRef38(false);
-  const isWatching = shallowRef38(false);
-  const error = shallowRef38(null);
+  const entry = shallowRef31(null);
+  const isLoading = shallowRef31(false);
+  const isWatching = shallowRef31(false);
+  const error = shallowRef31(null);
   let generation = 0;
   const refresh = async () => {
-    const activeMonitor = toValue35(monitor);
-    const activeHash = toValue35(hash);
-    const activeChainId = toValue35(chainId);
+    const activeMonitor = toValue36(monitor);
+    const activeHash = toValue36(hash);
+    const activeChainId = toValue36(chainId);
     if (!activeMonitor || !activeHash) return;
     isLoading.value = true;
     error.value = null;
@@ -2924,15 +2854,15 @@ function useTxMonitor(hash, chainId, monitor) {
     }
   };
   const stopWatching = () => {
-    const activeMonitor = toValue35(monitor);
-    const activeHash = toValue35(hash);
-    const activeChainId = toValue35(chainId);
+    const activeMonitor = toValue36(monitor);
+    const activeHash = toValue36(hash);
+    const activeChainId = toValue36(chainId);
     if (!activeMonitor || !activeHash) return;
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  watch18(
-    [() => toValue35(monitor), () => toValue35(hash), () => toValue35(chainId)],
+  watch19(
+    [() => toValue36(monitor), () => toValue36(hash), () => toValue36(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
       if (!activeMonitor || !activeHash || !activeChainId) {
@@ -2987,18 +2917,18 @@ import {
   normalizeCapabilities,
   selectChainCapabilities
 } from "@naculus/connect-appkit-core";
-import { computed as computed26, shallowRef as shallowRef39, toValue as toValue36, watchEffect as watchEffect2 } from "vue";
+import { computed as computed26, shallowRef as shallowRef32, toValue as toValue37, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
-  const capabilities = shallowRef39(
+  const capabilities = shallowRef32(
     null
   );
-  const isFetching = shallowRef39(false);
-  const error = shallowRef39(null);
+  const isFetching = shallowRef32(false);
+  const error = shallowRef32(null);
   let generation = 0;
   const refetch = async () => {
     const mine = ++generation;
-    const activeClient = toValue36(client);
-    const activeSession = toValue36(session);
+    const activeClient = toValue37(client);
+    const activeSession = toValue37(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       capabilities.value = null;
       isFetching.value = false;
@@ -3020,17 +2950,17 @@ function useCapabilities(client, session, chainId) {
     }
   };
   watchEffect2(() => {
-    void toValue36(client);
-    void toValue36(session);
+    void toValue37(client);
+    void toValue37(session);
     void refetch();
   });
   return {
     capabilities,
     current: computed26(
-      () => selectChainCapabilities(capabilities.value, toValue36(chainId))
+      () => selectChainCapabilities(capabilities.value, toValue37(chainId))
     ),
     atomic: computed26(
-      () => atomicSupportFor(capabilities.value, toValue36(chainId))
+      () => atomicSupportFor(capabilities.value, toValue37(chainId))
     ),
     isFetching,
     error,
@@ -3042,10 +2972,10 @@ function useCapabilities(client, session, chainId) {
 import {
   readSolanaRoles
 } from "@naculus/connect-appkit-core";
-import { computed as computed27, toValue as toValue37 } from "vue";
+import { computed as computed27, toValue as toValue38 } from "vue";
 function useSolanaRoles(connector, session) {
   const state = computed27(
-    () => readSolanaRoles(toValue37(connector), toValue37(session))
+    () => readSolanaRoles(toValue38(connector), toValue38(session))
   );
   return {
     roles: computed27(() => state.value.roles),
@@ -3092,6 +3022,7 @@ export {
   useCompareCosts,
   useConnect,
   useCreateSessionKey,
+  useDelegate,
   useDelegation,
   useDelegationPolicy,
   useDisconnect,