@naculus/connect-appkit-vue 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -66,6 +66,7 @@ __export(index_exports, {
   useCompareCosts: () => useCompareCosts,
   useConnect: () => useConnect,
   useCreateSessionKey: () => useCreateSessionKey,
+  useDelegate: () => useDelegate,
   useDelegation: () => useDelegation,
   useDelegationPolicy: () => useDelegationPolicy,
   useDisconnect: () => useDisconnect,
@@ -886,10 +887,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 }
@@ -905,266 +910,228 @@ function useSession(manager) {
 
 // src/useConnect.ts
 var import_connect_core8 = require("@naculus/connect-core");
+var import_vue11 = require("vue");
+
+// src/internal/action-guard.ts
 var import_vue10 = require("vue");
-function useConnect(action, status) {
-  const isLoading = (0, import_vue10.shallowRef)(false);
+function useActionGuard() {
+  const busy = (0, import_vue10.shallowRef)(false);
   const error = (0, import_vue10.shallowRef)(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++;
+  };
+  (0, import_vue10.onScopeDispose)(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 = (0, import_vue10.unref)(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 import_connect_core8.WalletError ? cause : new Error(message);
+    const invoke = (0, import_vue11.unref)(action);
+    const pending = guard.run(
+      () => Promise.resolve().then(() => invoke()),
+      "Connection failed",
+      (cause) => {
+        const message = cause instanceof Error ? cause.message : "Connection failed";
+        return cause instanceof import_connect_core8.WalletError ? cause : new Error(message);
+      }
+    ).catch(() => {
     }).finally(() => {
       if (inFlight === pending) inFlight = null;
-      if (!disposed) isLoading.value = false;
     });
     inFlight = pending;
     return pending;
   };
-  (0, import_vue10.onScopeDispose)(() => {
-    disposed = true;
-  });
   return {
     connect,
-    isConnecting: (0, import_vue10.computed)(
-      () => isLoading.value || (0, import_vue10.toValue)(status) === "connecting"
+    isConnecting: (0, import_vue11.computed)(
+      () => guard.busy.value || (0, import_vue11.toValue)(status) === "connecting"
     ),
-    error
+    error: guard.error
   };
 }
 
 // src/useDisconnect.ts
-var import_vue11 = require("vue");
+var import_vue12 = require("vue");
 function useDisconnect(action, status) {
-  const isDisconnecting = (0, import_vue11.shallowRef)(false);
-  const error = (0, import_vue11.shallowRef)(null);
-  let disposed = false;
+  const guard = useActionGuard();
   let inFlight = null;
   const disconnect = () => {
     if (inFlight) return inFlight;
-    if ((0, import_vue11.toValue)(status) === "disconnected") return Promise.resolve();
-    const invoke = (0, import_vue11.unref)(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");
-      }
+    if ((0, import_vue12.toValue)(status) === "disconnected") return Promise.resolve();
+    const invoke = (0, import_vue12.unref)(action);
+    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
   };
-  (0, import_vue11.onScopeDispose)(cleanup);
-  return { disconnect, isDisconnecting, error, cleanup };
 }
 
 // src/useSwitchChain.ts
 var import_connect_appkit_core8 = require("@naculus/connect-appkit-core");
-var import_vue12 = require("vue");
+var import_vue13 = require("vue");
 function useSwitchChain(action, chainId) {
-  const isSwitching = (0, import_vue12.shallowRef)(false);
-  const error = (0, import_vue12.shallowRef)(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const switchChain = async (targetChainId) => {
-    const invoke = (0, import_vue12.unref)(action);
-    const mine = ++generation;
-    active++;
-    isSwitching.value = true;
-    error.value = null;
-    try {
-      await invoke(targetChainId);
-    } catch (cause) {
-      const walletError = (0, import_connect_appkit_core8.toChainSwitchError)(cause);
-      if (!disposed && mine === generation) error.value = walletError;
-      throw walletError;
-    } finally {
-      active--;
-      if (!disposed) isSwitching.value = active > 0;
-    }
+  const guard = useActionGuard();
+  const switchChain = (targetChainId) => {
+    const invoke = (0, import_vue13.unref)(action);
+    return guard.run(async () => {
+      try {
+        await invoke(targetChainId);
+      } catch (cause) {
+        throw (0, import_connect_appkit_core8.toChainSwitchError)(cause);
+      }
+    }, "Failed to switch chain");
   };
-  (0, import_vue12.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     switchChain,
-    isSwitching,
-    currentChainId: (0, import_vue12.computed)(() => (0, import_vue12.toValue)(chainId) ?? null),
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    isSwitching: guard.busy,
+    currentChainId: (0, import_vue13.computed)(() => (0, import_vue13.toValue)(chainId) ?? null),
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
 // src/useSignMessage.ts
-var import_vue13 = require("vue");
+var import_vue14 = require("vue");
 function useSignMessage(action) {
-  const isSigning = (0, import_vue13.shallowRef)(false);
-  const error = (0, import_vue13.shallowRef)(null);
-  let active = 0;
-  let generation = 0;
-  let disposed = false;
-  const signMessage = async (message) => {
-    const invoke = (0, import_vue13.unref)(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;
-    }
+  const guard = useActionGuard();
+  const signMessage = (message) => {
+    const invoke = (0, import_vue14.unref)(action);
+    return guard.run(() => invoke(message), "Signing failed");
   };
-  const reset = () => {
-    generation++;
-    error.value = null;
+  return {
+    signMessage,
+    isSigning: guard.busy,
+    error: guard.error,
+    reset: guard.reset
   };
-  (0, import_vue13.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
-  return { signMessage, isSigning, error, reset };
 }
 
 // src/useSendTransaction.ts
-var import_vue14 = require("vue");
+var import_vue15 = require("vue");
 function useSendTransaction(action) {
-  const status = (0, import_vue14.shallowRef)("idle");
-  const error = (0, import_vue14.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
-  const sendTransaction = async (transaction) => {
-    const invoke = (0, import_vue14.unref)(action);
-    const own = ++generation;
+  const guard = useActionGuard();
+  const status = (0, import_vue15.shallowRef)("idle");
+  const sendTransaction = (transaction) => {
+    const invoke = (0, import_vue15.unref)(action);
     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;
   };
-  (0, import_vue14.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     sendTransaction,
     status,
-    error,
+    error: guard.error,
     reset,
-    isSending: (0, import_vue14.computed)(() => status.value === "awaiting_approval")
+    isSending: (0, import_vue15.computed)(() => status.value === "awaiting_approval")
   };
 }
 
 // src/useSolanaTransaction.ts
-var import_vue15 = require("vue");
+var import_vue16 = require("vue");
 function useSolanaTransaction(options) {
-  const isSigning = (0, import_vue15.shallowRef)(false);
-  const isSending = (0, import_vue15.shallowRef)(false);
-  const error = (0, import_vue15.shallowRef)(null);
+  const guard = useActionGuard();
+  const isSigning = (0, import_vue16.shallowRef)(false);
+  const isSending = (0, import_vue16.shallowRef)(false);
   let signing = 0;
   let sending = 0;
-  let generation = 0;
-  let disposed = false;
-  const signTransaction = async (transaction) => {
-    const invoke = (0, import_vue15.unref)(options.signTransaction);
-    const own = ++generation;
+  const signTransaction = (transaction) => {
+    const invoke = (0, import_vue16.unref)(options.signTransaction);
     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 invoke = (0, import_vue15.unref)(options.sendTransaction);
-    const own = ++generation;
+  const sendTransaction = (transaction) => {
+    const invoke = (0, import_vue16.unref)(options.sendTransaction);
     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;
-    }
-  };
-  const getStatus = (signature) => (0, import_vue15.unref)(options.getStatus)(signature);
-  const reset = () => {
-    generation++;
-    error.value = null;
+      isSending.value = sending > 0;
+    });
   };
-  (0, import_vue15.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
+  const getStatus = (signature) => (0, import_vue16.unref)(options.getStatus)(signature);
   return {
     signTransaction,
     sendTransaction,
     getStatus,
     isSigning,
     isSending,
-    error,
-    reset
+    error: guard.error,
+    reset: guard.reset
   };
 }
 
 // src/useSignInWithX.ts
-var import_vue16 = require("vue");
+var import_vue17 = require("vue");
 function useSignInWithX(action) {
-  const isSigningIn = (0, import_vue16.shallowRef)(false);
-  const result = (0, import_vue16.shallowRef)(null);
-  const error = (0, import_vue16.shallowRef)(null);
+  const isSigningIn = (0, import_vue17.shallowRef)(false);
+  const result = (0, import_vue17.shallowRef)(null);
+  const error = (0, import_vue17.shallowRef)(null);
   let generation = 0;
   let active = 0;
   let disposed = false;
   const signIn = async (options) => {
-    const invoke = (0, import_vue16.unref)(action);
+    const invoke = (0, import_vue17.unref)(action);
     const own = ++generation;
     active++;
     isSigningIn.value = true;
@@ -1190,7 +1157,7 @@ function useSignInWithX(action) {
     result.value = null;
     error.value = null;
   };
-  (0, import_vue16.onScopeDispose)(() => {
+  (0, import_vue17.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -1203,46 +1170,24 @@ function useSignInWithEthereum(action) {
 }
 
 // src/useExecuteCalls.ts
-var import_vue17 = require("vue");
+var import_vue18 = require("vue");
 function useExecuteCalls(options) {
-  const isExecuting = (0, import_vue17.shallowRef)(false);
-  const error = (0, import_vue17.shallowRef)(null);
-  let generation = 0;
-  let active = 0;
-  let disposed = false;
-  const preview = (callCount, atomicity) => (0, import_vue17.unref)(options.preview)(callCount, atomicity);
-  const execute = async (calls, atomicity) => {
-    const invoke = (0, import_vue17.unref)(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;
-    }
+  const guard = useActionGuard();
+  const preview = (callCount, atomicity) => (0, import_vue18.unref)(options.preview)(callCount, atomicity);
+  const execute = (calls, atomicity) => {
+    const invoke = (0, import_vue18.unref)(options.execute);
+    return guard.run(() => invoke(calls, atomicity), "Execution failed");
   };
   const reset = () => {
-    generation++;
-    error.value = null;
-    (0, import_vue17.unref)(options.reset)();
+    guard.reset();
+    (0, import_vue18.unref)(options.reset)();
   };
-  (0, import_vue17.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     preview,
     execute,
-    isExecuting,
-    error,
-    lastRoute: (0, import_vue17.computed)(() => (0, import_vue17.toValue)(options.lastRoute)),
+    isExecuting: guard.busy,
+    error: guard.error,
+    lastRoute: (0, import_vue18.computed)(() => (0, import_vue18.toValue)(options.lastRoute)),
     reset
   };
 }
@@ -1251,41 +1196,6 @@ function useExecuteCalls(options) {
 var import_connect_appkit_core10 = require("@naculus/connect-appkit-core");
 var import_vue20 = require("vue");
 
-// src/internal/action-guard.ts
-var import_vue18 = require("vue");
-function useActionGuard() {
-  const busy = (0, import_vue18.shallowRef)(false);
-  const error = (0, import_vue18.shallowRef)(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;
-  };
-  (0, import_vue18.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
-  return { busy, error, run, reset };
-}
-
 // src/useSessionKeys.ts
 var import_connect_appkit_core9 = require("@naculus/connect-appkit-core");
 var import_vue19 = require("vue");
@@ -1937,32 +1847,9 @@ function useSendCalls(options) {
 // src/useEmbeddedWallet.ts
 var import_vue25 = require("vue");
 function useEmbeddedWallet(options) {
-  const isBusy = (0, import_vue25.shallowRef)(false);
-  const error = (0, import_vue25.shallowRef)(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 = (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.wallet));
-  (0, import_vue25.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   return {
     wallet,
     hasWallet: (0, import_vue25.computed)(() => wallet.value !== null),
@@ -1983,11 +1870,9 @@ function useEmbeddedWallet(options) {
     getSeedPhrase: () => (0, import_vue25.unref)(options.getSeedPhrase)(),
     getPrivateKey: () => (0, import_vue25.unref)(options.getPrivateKey)(),
     confirmBackup: () => (0, import_vue25.unref)(options.confirmBackup)(),
-    isBusy,
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    isBusy: guard.busy,
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
@@ -2005,98 +1890,47 @@ function useSIWxLogin(action) {
 // src/useSIWxSession.ts
 var import_vue26 = require("vue");
 function useSIWxSession(options) {
-  const isSigningIn = (0, import_vue26.shallowRef)(false);
-  const error = (0, import_vue26.shallowRef)(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;
-    }
-  };
-  (0, import_vue26.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
+  const guard = useActionGuard();
   return {
     session: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.session)),
     isAuthenticated: (0, import_vue26.computed)(
       () => (0, import_vue26.toValue)(options.session) !== null && !(0, import_vue26.toValue)(options.isExpired)
     ),
     isRestoring: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.isRestoring)),
-    isSigningIn,
+    isSigningIn: guard.busy,
     isExpired: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.isExpired)),
     timeUntilExpiry: (0, import_vue26.computed)(() => (0, import_vue26.toValue)(options.timeUntilExpiry)),
-    signIn: (input) => run(() => (0, import_vue26.unref)(options.signIn)(input), "SIWX sign-in failed"),
+    signIn: (input) => guard.run(() => (0, import_vue26.unref)(options.signIn)(input), "SIWX sign-in failed"),
     signOut: async () => {
       await (0, import_vue26.unref)(options.signOut)();
-      error.value = null;
+      guard.clearError();
     },
-    refresh: () => run(() => (0, import_vue26.unref)(options.refresh)(), "Session refresh failed"),
-    error,
-    clearError: () => {
-      error.value = null;
-    }
+    refresh: () => guard.run(() => (0, import_vue26.unref)(options.refresh)(), "Session refresh failed"),
+    error: guard.error,
+    clearError: guard.clearError
   };
 }
 
 // src/useSiwxAuthSession.ts
 var import_vue27 = require("vue");
 function useSiwxAuthSession(options) {
-  const isSigningIn = (0, import_vue27.shallowRef)(false);
-  const error = (0, import_vue27.shallowRef)(null);
-  let generation = 0;
-  let disposed = false;
-  const signIn = async (input) => {
-    const own = ++generation;
-    isSigningIn.value = true;
-    error.value = null;
-    try {
-      return await (0, import_vue27.unref)(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(() => (0, import_vue27.unref)(options.signIn)(input), "SIWX sign-in failed");
   const signOut = async () => {
-    generation++;
+    guard.reset();
     await (0, import_vue27.unref)(options.signOut)();
-    if (!disposed) {
-      isSigningIn.value = false;
-      error.value = null;
-    }
+    guard.clearError();
   };
-  (0, import_vue27.onScopeDispose)(() => {
-    disposed = true;
-    generation++;
-  });
   const siwxResult = (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.result));
   return {
     isSignedIn: (0, import_vue27.computed)(() => siwxResult.value !== null),
     isRestoring: (0, import_vue27.computed)(() => (0, import_vue27.toValue)(options.isRestoring)),
     siwxResult,
-    isSigningIn,
-    error,
+    isSigningIn: guard.busy,
+    error: guard.error,
     signIn,
     signOut,
-    clearError: () => {
-      error.value = null;
-    }
+    clearError: guard.clearError
   };
 }
 
@@ -2573,21 +2407,113 @@ function useTokenBalance(account, client, tokens, options = {}) {
   };
 }
 
-// src/useDelegation.ts
+// src/useDelegate.ts
 var import_connect_appkit_core22 = require("@naculus/connect-appkit-core");
 var import_connect_core15 = require("@naculus/connect-core");
 var import_vue36 = require("vue");
-function useDelegation(account, client, chainId) {
-  const status = (0, import_vue36.shallowRef)(import_connect_core15.UNKNOWN_DELEGATION);
-  const isFetching = (0, import_vue36.shallowRef)(false);
+function useDelegate(options) {
+  const result = (0, import_vue36.shallowRef)(null);
+  const isPending = (0, import_vue36.shallowRef)(false);
   const error = (0, import_vue36.shallowRef)(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 = (0, import_vue36.toValue)(options.session);
+    const account = (0, import_connect_appkit_core22.bareEvmAddress)((0, import_vue36.toValue)(options.account));
+    const chainId = (0, import_vue36.toValue)(options.chainId);
+    if (!session || !account || !chainId) {
+      return fail(
+        new import_connect_core15.WalletError("wallet_unavailable", "No connected EVM account")
+      );
+    }
+    const reader = (0, import_vue36.toValue)(options.client);
+    if (!reader || reader.chain?.id !== (0, import_connect_core15.eip155Reference)(chainId)) {
+      return fail(
+        new import_connect_core15.WalletError(
+          "chain_mismatch",
+          `No RPC client for ${chainId}; refusing to read the nonce elsewhere.`
+        )
+      );
+    }
+    const connector = (0, import_vue36.toValue)(options.connector) ?? {};
+    const own = ++requestId;
+    inFlight = true;
+    isPending.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const sent = await (0, import_connect_core15.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;
+  };
+  (0, import_vue36.watch)(
+    [
+      () => (0, import_vue36.toValue)(options.session),
+      () => (0, import_vue36.toValue)(options.account),
+      () => (0, import_vue36.toValue)(options.chainId)
+    ],
+    reset,
+    { flush: "sync" }
+  );
+  (0, import_vue36.onScopeDispose)(() => {
+    disposed = true;
+    requestId++;
+  });
+  return {
+    delegate: (target) => run(target, (0, import_vue36.toValue)(options.allowlist)),
+    revoke: () => run(import_connect_core15.REVOKE_DELEGATE, []),
+    result,
+    isPending,
+    error,
+    reset
+  };
+}
+
+// src/useDelegation.ts
+var import_connect_appkit_core23 = require("@naculus/connect-appkit-core");
+var import_connect_core16 = require("@naculus/connect-core");
+var import_vue37 = require("vue");
+function useDelegation(account, client, chainId) {
+  const status = (0, import_vue37.shallowRef)(import_connect_core16.UNKNOWN_DELEGATION);
+  const isFetching = (0, import_vue37.shallowRef)(false);
+  const error = (0, import_vue37.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
     const mine = ++generation;
-    const reader = (0, import_vue36.toValue)(client);
-    const address = (0, import_connect_appkit_core22.bareEvmAddress)((0, import_vue36.toValue)(account));
-    status.value = import_connect_core15.UNKNOWN_DELEGATION;
+    const reader = (0, import_vue37.toValue)(client);
+    const address = (0, import_connect_appkit_core23.bareEvmAddress)((0, import_vue37.toValue)(account));
+    status.value = import_connect_core16.UNKNOWN_DELEGATION;
     error.value = null;
     if (!reader || !address) {
       isFetching.value = false;
@@ -2597,31 +2523,31 @@ function useDelegation(account, client, chainId) {
     try {
       const code = await reader.getCode({ address });
       if (!disposed && mine === generation) {
-        status.value = (0, import_connect_core15.readDelegation)(code ?? "0x");
+        status.value = (0, import_connect_core16.readDelegation)(code ?? "0x");
       }
     } catch (cause) {
       if (!disposed && mine === generation) {
-        status.value = import_connect_core15.UNKNOWN_DELEGATION;
+        status.value = import_connect_core16.UNKNOWN_DELEGATION;
         error.value = cause instanceof Error ? cause : new Error("Code read failed");
       }
     } finally {
       if (!disposed && mine === generation) isFetching.value = false;
     }
   };
-  (0, import_vue36.watch)(
-    [() => (0, import_vue36.toValue)(account), () => (0, import_vue36.toValue)(client), () => (0, import_vue36.toValue)(chainId)],
+  (0, import_vue37.watch)(
+    [() => (0, import_vue37.toValue)(account), () => (0, import_vue37.toValue)(client), () => (0, import_vue37.toValue)(chainId)],
     () => {
       void refetch();
     },
     { immediate: true, flush: "sync" }
   );
-  (0, import_vue36.onScopeDispose)(() => {
+  (0, import_vue37.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
   return {
-    delegated: (0, import_vue36.computed)(() => status.value.delegated),
-    delegate: (0, import_vue36.computed)(() => status.value.delegate),
+    delegated: (0, import_vue37.computed)(() => status.value.delegated),
+    delegate: (0, import_vue37.computed)(() => status.value.delegate),
     isFetching,
     error,
     refetch
@@ -2629,19 +2555,19 @@ function useDelegation(account, client, chainId) {
 }
 
 // src/name-lookup.ts
-var import_connect_appkit_core23 = require("@naculus/connect-appkit-core");
-var import_vue37 = require("vue");
+var import_connect_appkit_core24 = require("@naculus/connect-appkit-core");
+var import_vue38 = require("vue");
 function useNameLookup(options) {
-  const data = (0, import_vue37.shallowRef)(null);
-  const loading = (0, import_vue37.shallowRef)(false);
-  const error = (0, import_vue37.shallowRef)(null);
+  const data = (0, import_vue38.shallowRef)(null);
+  const loading = (0, import_vue38.shallowRef)(false);
+  const error = (0, import_vue38.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const run = () => {
-    const input = (0, import_vue37.toValue)(options.input).trim();
-    const skip = (0, import_vue37.toValue)(options.skip) ?? false;
-    const scope = (0, import_vue37.toValue)(options.scope);
-    const config = (0, import_vue37.toValue)(options.resolverConfig);
+    const input = (0, import_vue38.toValue)(options.input).trim();
+    const skip = (0, import_vue38.toValue)(options.skip) ?? false;
+    const scope = (0, import_vue38.toValue)(options.scope);
+    const config = (0, import_vue38.toValue)(options.resolverConfig);
     const mine = ++generation;
     if (!input || skip) {
       data.value = null;
@@ -2652,7 +2578,7 @@ function useNameLookup(options) {
     data.value = null;
     loading.value = true;
     error.value = null;
-    Promise.resolve().then(() => options.query((0, import_connect_appkit_core23.getResolver)(config), input, scope)).then((result) => {
+    Promise.resolve().then(() => options.query((0, import_connect_appkit_core24.getResolver)(config), input, scope)).then((result) => {
       if (disposed || mine !== generation) return;
       data.value = result;
       loading.value = false;
@@ -2663,23 +2589,23 @@ function useNameLookup(options) {
       loading.value = false;
     });
   };
-  (0, import_vue37.watch)(
+  (0, import_vue38.watch)(
     () => [
-      (0, import_vue37.toValue)(options.input),
-      (0, import_vue37.toValue)(options.skip),
-      (0, import_vue37.toValue)(options.scope),
-      (0, import_vue37.toValue)(options.resolverConfig)
+      (0, import_vue38.toValue)(options.input),
+      (0, import_vue38.toValue)(options.skip),
+      (0, import_vue38.toValue)(options.scope),
+      (0, import_vue38.toValue)(options.resolverConfig)
     ],
     run,
     { immediate: true, flush: "sync", deep: true }
   );
-  (0, import_vue37.onScopeDispose)(() => {
+  (0, import_vue38.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
   return {
     data,
-    isLoading: (0, import_vue37.computed)(() => loading.value),
+    isLoading: (0, import_vue38.computed)(() => loading.value),
     error,
     refetch: run
   };
@@ -2707,21 +2633,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-var import_vue38 = require("vue");
+var import_vue39 = require("vue");
 function useSolanaAccount(accounts, connected) {
-  const isConnected = (0, import_vue38.computed)(() => (0, import_vue38.toValue)(connected));
-  const caip10 = (0, import_vue38.computed)(
-    () => isConnected.value ? ((0, import_vue38.toValue)(accounts) ?? []).find(
+  const isConnected = (0, import_vue39.computed)(() => (0, import_vue39.toValue)(connected));
+  const caip10 = (0, import_vue39.computed)(
+    () => isConnected.value ? ((0, import_vue39.toValue)(accounts) ?? []).find(
       (account) => account.startsWith("solana:")
     ) ?? null : null
   );
-  const parts = (0, import_vue38.computed)(() => caip10.value?.split(":") ?? []);
+  const parts = (0, import_vue39.computed)(() => caip10.value?.split(":") ?? []);
   return {
-    address: (0, import_vue38.computed)(
+    address: (0, import_vue39.computed)(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: (0, import_vue38.computed)(
+    chainId: (0, import_vue39.computed)(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -2729,35 +2655,35 @@ function useSolanaAccount(accounts, connected) {
 }
 
 // src/useChain.ts
-var import_connect_appkit_core24 = require("@naculus/connect-appkit-core");
-var import_vue39 = require("vue");
+var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
+var import_vue40 = require("vue");
 function useChain(chains, chainId) {
-  const list = (0, import_vue39.computed)(() => (0, import_vue39.toValue)(chains) ?? []);
-  const id = (0, import_vue39.computed)(() => (0, import_vue39.toValue)(chainId) ?? null);
-  const currentChain = (0, import_vue39.computed)(() => (0, import_connect_appkit_core24.resolveChain)(list.value, id.value));
+  const list = (0, import_vue40.computed)(() => (0, import_vue40.toValue)(chains) ?? []);
+  const id = (0, import_vue40.computed)(() => (0, import_vue40.toValue)(chainId) ?? null);
+  const currentChain = (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.resolveChain)(list.value, id.value));
   return {
     currentChain,
-    chainInfo: (0, import_vue39.computed)(() => (0, import_connect_appkit_core24.describeChain)(list.value, id.value)),
-    availableChains: (0, import_vue39.computed)(() => (0, import_connect_appkit_core24.chainsForNamespace)(list.value, id.value)),
-    currentChainNumber: (0, import_vue39.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core24.chainNumber)(currentChain.value) : null
+    chainInfo: (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.describeChain)(list.value, id.value)),
+    availableChains: (0, import_vue40.computed)(() => (0, import_connect_appkit_core25.chainsForNamespace)(list.value, id.value)),
+    currentChainNumber: (0, import_vue40.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core25.chainNumber)(currentChain.value) : null
     ),
-    namespace: (0, import_vue39.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core24.chainNamespace)(currentChain.value) : null
+    namespace: (0, import_vue40.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core25.chainNamespace)(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-var import_vue40 = require("vue");
+var import_vue41 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue40.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue41.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue40.onScopeDispose)(unsubscribe);
+  (0, import_vue41.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue40.readonly)(request),
+    request: (0, import_vue41.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -2765,17 +2691,17 @@ function usePassphraseGate(gate) {
 }
 
 // src/useSolanaBalance.ts
-var import_connect_core16 = require("@naculus/connect-core");
-var import_vue41 = require("vue");
+var import_connect_core17 = require("@naculus/connect-core");
+var import_vue42 = require("vue");
 function useSolanaBalance(address, rpcUrl) {
-  const balance = (0, import_vue41.shallowRef)(null);
-  const isFetching = (0, import_vue41.ref)(false);
-  const error = (0, import_vue41.shallowRef)(null);
+  const balance = (0, import_vue42.shallowRef)(null);
+  const isFetching = (0, import_vue42.ref)(false);
+  const error = (0, import_vue42.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
-    const addr = (0, import_vue41.toValue)(address);
-    const url = (0, import_vue41.toValue)(rpcUrl);
+    const addr = (0, import_vue42.toValue)(address);
+    const url = (0, import_vue42.toValue)(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -2784,7 +2710,7 @@ function useSolanaBalance(address, rpcUrl) {
     isFetching.value = true;
     error.value = null;
     try {
-      const next = await (0, import_connect_core16.getSolanaBalance)(url, addr);
+      const next = await (0, import_connect_core17.getSolanaBalance)(url, addr);
       if (disposed || own !== generation) return;
       balance.value = next;
     } catch (err) {
@@ -2795,25 +2721,25 @@ function useSolanaBalance(address, rpcUrl) {
       if (!disposed && own === generation) isFetching.value = false;
     }
   };
-  (0, import_vue41.watchEffect)(() => {
-    (0, import_vue41.toValue)(address);
-    (0, import_vue41.toValue)(rpcUrl);
+  (0, import_vue42.watchEffect)(() => {
+    (0, import_vue42.toValue)(address);
+    (0, import_vue42.toValue)(rpcUrl);
     void refetch();
   });
-  (0, import_vue41.onScopeDispose)(() => {
+  (0, import_vue42.onScopeDispose)(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
 
 // src/useLastTx.ts
-var import_vue42 = require("vue");
+var import_vue43 = require("vue");
 function useLastTx(monitor) {
-  const lastTx = (0, import_vue42.shallowRef)(null);
-  const lastConfirmedTx = (0, import_vue42.shallowRef)(null);
-  const lastFailedTx = (0, import_vue42.shallowRef)(null);
-  (0, import_vue42.watch)(
-    () => (0, import_vue42.toValue)(monitor),
+  const lastTx = (0, import_vue43.shallowRef)(null);
+  const lastConfirmedTx = (0, import_vue43.shallowRef)(null);
+  const lastFailedTx = (0, import_vue43.shallowRef)(null);
+  (0, import_vue43.watch)(
+    () => (0, import_vue43.toValue)(monitor),
     (activeMonitor, _previous, onCleanup) => {
       if (!activeMonitor) return;
       const recordLatest = (entry) => {
@@ -2851,15 +2777,15 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-var import_vue43 = require("vue");
+var import_vue44 = require("vue");
 function useTxHistory(address, chainId, monitor) {
-  const entries = (0, import_vue43.shallowRef)([]);
-  const isLoading = (0, import_vue43.shallowRef)(false);
-  const error = (0, import_vue43.shallowRef)(null);
+  const entries = (0, import_vue44.shallowRef)([]);
+  const isLoading = (0, import_vue44.shallowRef)(false);
+  const error = (0, import_vue44.shallowRef)(null);
   let generation = 0;
   const refresh = async () => {
     const mine = ++generation;
-    const activeMonitor = (0, import_vue43.toValue)(monitor);
+    const activeMonitor = (0, import_vue44.toValue)(monitor);
     if (!activeMonitor) {
       entries.value = [];
       isLoading.value = false;
@@ -2870,8 +2796,8 @@ function useTxHistory(address, chainId, monitor) {
     error.value = null;
     try {
       const result = await activeMonitor.getTxHistory(
-        (0, import_vue43.toValue)(address) ?? void 0,
-        (0, import_vue43.toValue)(chainId) ?? void 0
+        (0, import_vue44.toValue)(address) ?? void 0,
+        (0, import_vue44.toValue)(chainId) ?? void 0
       );
       if (mine === generation) entries.value = result;
     } catch (err) {
@@ -2881,8 +2807,8 @@ function useTxHistory(address, chainId, monitor) {
       if (mine === generation) isLoading.value = false;
     }
   };
-  (0, import_vue43.watch)(
-    [() => (0, import_vue43.toValue)(monitor), () => (0, import_vue43.toValue)(address), () => (0, import_vue43.toValue)(chainId)],
+  (0, import_vue44.watch)(
+    [() => (0, import_vue44.toValue)(monitor), () => (0, import_vue44.toValue)(address), () => (0, import_vue44.toValue)(chainId)],
     ([activeMonitor], _previous, onCleanup) => {
       if (!activeMonitor) {
         void refresh();
@@ -2902,7 +2828,7 @@ function useTxHistory(address, chainId, monitor) {
     isLoading,
     error,
     refresh,
-    summary: (0, import_vue43.computed)(() => ({
+    summary: (0, import_vue44.computed)(() => ({
       pending: entries.value.filter((item) => item.status === "pending").length,
       confirmed: entries.value.filter((item) => item.status === "confirmed").length,
       failed: entries.value.filter((item) => item.status === "failed").length
@@ -2911,17 +2837,17 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-var import_vue44 = require("vue");
+var import_vue45 = require("vue");
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = (0, import_vue44.shallowRef)(null);
-  const isLoading = (0, import_vue44.shallowRef)(false);
-  const isWatching = (0, import_vue44.shallowRef)(false);
-  const error = (0, import_vue44.shallowRef)(null);
+  const entry = (0, import_vue45.shallowRef)(null);
+  const isLoading = (0, import_vue45.shallowRef)(false);
+  const isWatching = (0, import_vue45.shallowRef)(false);
+  const error = (0, import_vue45.shallowRef)(null);
   let generation = 0;
   const refresh = async () => {
-    const activeMonitor = (0, import_vue44.toValue)(monitor);
-    const activeHash = (0, import_vue44.toValue)(hash);
-    const activeChainId = (0, import_vue44.toValue)(chainId);
+    const activeMonitor = (0, import_vue45.toValue)(monitor);
+    const activeHash = (0, import_vue45.toValue)(hash);
+    const activeChainId = (0, import_vue45.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     isLoading.value = true;
     error.value = null;
@@ -2939,15 +2865,15 @@ function useTxMonitor(hash, chainId, monitor) {
     }
   };
   const stopWatching = () => {
-    const activeMonitor = (0, import_vue44.toValue)(monitor);
-    const activeHash = (0, import_vue44.toValue)(hash);
-    const activeChainId = (0, import_vue44.toValue)(chainId);
+    const activeMonitor = (0, import_vue45.toValue)(monitor);
+    const activeHash = (0, import_vue45.toValue)(hash);
+    const activeChainId = (0, import_vue45.toValue)(chainId);
     if (!activeMonitor || !activeHash) return;
     activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
     isWatching.value = false;
   };
-  (0, import_vue44.watch)(
-    [() => (0, import_vue44.toValue)(monitor), () => (0, import_vue44.toValue)(hash), () => (0, import_vue44.toValue)(chainId)],
+  (0, import_vue45.watch)(
+    [() => (0, import_vue45.toValue)(monitor), () => (0, import_vue45.toValue)(hash), () => (0, import_vue45.toValue)(chainId)],
     ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
       const mine = ++generation;
       if (!activeMonitor || !activeHash || !activeChainId) {
@@ -2987,7 +2913,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: (0, import_vue44.computed)(() => entry.value?.status ?? "idle"),
+    status: (0, import_vue45.computed)(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -2997,19 +2923,19 @@ function useTxMonitor(hash, chainId, monitor) {
 }
 
 // src/useCapabilities.ts
-var import_connect_appkit_core25 = require("@naculus/connect-appkit-core");
-var import_vue45 = require("vue");
+var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
+var import_vue46 = require("vue");
 function useCapabilities(client, session, chainId) {
-  const capabilities = (0, import_vue45.shallowRef)(
+  const capabilities = (0, import_vue46.shallowRef)(
     null
   );
-  const isFetching = (0, import_vue45.shallowRef)(false);
-  const error = (0, import_vue45.shallowRef)(null);
+  const isFetching = (0, import_vue46.shallowRef)(false);
+  const error = (0, import_vue46.shallowRef)(null);
   let generation = 0;
   const refetch = async () => {
     const mine = ++generation;
-    const activeClient = (0, import_vue45.toValue)(client);
-    const activeSession = (0, import_vue45.toValue)(session);
+    const activeClient = (0, import_vue46.toValue)(client);
+    const activeSession = (0, import_vue46.toValue)(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       capabilities.value = null;
       isFetching.value = false;
@@ -3021,7 +2947,7 @@ function useCapabilities(client, session, chainId) {
     try {
       const raw = await activeClient.getCapabilities(activeSession);
       if (mine !== generation) return;
-      capabilities.value = (0, import_connect_appkit_core25.normalizeCapabilities)(raw);
+      capabilities.value = (0, import_connect_appkit_core26.normalizeCapabilities)(raw);
     } catch (err) {
       if (mine !== generation) return;
       capabilities.value = null;
@@ -3030,18 +2956,18 @@ function useCapabilities(client, session, chainId) {
       if (mine === generation) isFetching.value = false;
     }
   };
-  (0, import_vue45.watchEffect)(() => {
-    void (0, import_vue45.toValue)(client);
-    void (0, import_vue45.toValue)(session);
+  (0, import_vue46.watchEffect)(() => {
+    void (0, import_vue46.toValue)(client);
+    void (0, import_vue46.toValue)(session);
     void refetch();
   });
   return {
     capabilities,
-    current: (0, import_vue45.computed)(
-      () => (0, import_connect_appkit_core25.selectChainCapabilities)(capabilities.value, (0, import_vue45.toValue)(chainId))
+    current: (0, import_vue46.computed)(
+      () => (0, import_connect_appkit_core26.selectChainCapabilities)(capabilities.value, (0, import_vue46.toValue)(chainId))
     ),
-    atomic: (0, import_vue45.computed)(
-      () => (0, import_connect_appkit_core25.atomicSupportFor)(capabilities.value, (0, import_vue45.toValue)(chainId))
+    atomic: (0, import_vue46.computed)(
+      () => (0, import_connect_appkit_core26.atomicSupportFor)(capabilities.value, (0, import_vue46.toValue)(chainId))
     ),
     isFetching,
     error,
@@ -3050,18 +2976,18 @@ function useCapabilities(client, session, chainId) {
 }
 
 // src/useSolanaRoles.ts
-var import_connect_appkit_core26 = require("@naculus/connect-appkit-core");
-var import_vue46 = require("vue");
+var import_connect_appkit_core27 = require("@naculus/connect-appkit-core");
+var import_vue47 = require("vue");
 function useSolanaRoles(connector, session) {
-  const state = (0, import_vue46.computed)(
-    () => (0, import_connect_appkit_core26.readSolanaRoles)((0, import_vue46.toValue)(connector), (0, import_vue46.toValue)(session))
+  const state = (0, import_vue47.computed)(
+    () => (0, import_connect_appkit_core27.readSolanaRoles)((0, import_vue47.toValue)(connector), (0, import_vue47.toValue)(session))
   );
   return {
-    roles: (0, import_vue46.computed)(() => state.value.roles),
-    absence: (0, import_vue46.computed)(() => state.value.absence),
-    identity: (0, import_vue46.computed)(() => state.value.roles?.identity ?? null),
-    signer: (0, import_vue46.computed)(() => state.value.roles?.signer ?? null),
-    payer: (0, import_vue46.computed)(() => state.value.roles?.payer ?? null)
+    roles: (0, import_vue47.computed)(() => state.value.roles),
+    absence: (0, import_vue47.computed)(() => state.value.absence),
+    identity: (0, import_vue47.computed)(() => state.value.roles?.identity ?? null),
+    signer: (0, import_vue47.computed)(() => state.value.roles?.signer ?? null),
+    payer: (0, import_vue47.computed)(() => state.value.roles?.payer ?? null)
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3102,6 +3028,7 @@ function useSolanaRoles(connector, session) {
   useCompareCosts,
   useConnect,
   useCreateSessionKey,
+  useDelegate,
   useDelegation,
   useDelegationPolicy,
   useDisconnect,