@naculus/connect-appkit-vue 0.2.5 → 0.2.7

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -55,25 +65,50 @@ __export(index_exports, {
   useChain: () => useChain,
   useCompareCosts: () => useCompareCosts,
   useConnect: () => useConnect,
+  useCreateSessionKey: () => useCreateSessionKey,
+  useDelegate: () => useDelegate,
   useDelegation: () => useDelegation,
+  useDelegationPolicy: () => useDelegationPolicy,
   useDisconnect: () => useDisconnect,
+  useERC20Approve: () => useERC20Approve,
+  useERC20Transfer: () => useERC20Transfer,
+  useERC20TransferSimulation: () => useERC20TransferSimulation,
+  useEmbeddedWallet: () => useEmbeddedWallet,
+  useExecuteCalls: () => useExecuteCalls,
   useExecuteRoute: () => useExecuteRoute,
   useLastTx: () => useLastTx,
   useLookupAddress: () => useLookupAddress,
   useNotification: () => useNotification,
   usePassphraseGate: () => usePassphraseGate,
   useResolveName: () => useResolveName,
+  useRevokeSession: () => useRevokeSession,
   useRouteQuote: () => useRouteQuote,
+  useSIWxLogin: () => useSIWxLogin,
+  useSIWxSession: () => useSIWxSession,
+  useSendCalls: () => useSendCalls,
+  useSendTransaction: () => useSendTransaction,
+  useSendUserOperation: () => useSendUserOperation,
+  useSendWithSession: () => useSendWithSession,
   useSession: () => useSession,
+  useSessionKeys: () => useSessionKeys,
+  useSignInWithEthereum: () => useSignInWithEthereum,
+  useSignInWithX: () => useSignInWithX,
+  useSignMessage: () => useSignMessage,
+  useSimulateTransfer: () => useSimulateTransfer,
+  useSiwxAuthSession: () => useSiwxAuthSession,
+  useSmartAccount: () => useSmartAccount,
   useSolanaAccount: () => useSolanaAccount,
   useSolanaBalance: () => useSolanaBalance,
   useSolanaRoles: () => useSolanaRoles,
+  useSolanaTransaction: () => useSolanaTransaction,
   useSwitchChain: () => useSwitchChain,
   useTokenBalance: () => useTokenBalance,
   useTokenList: () => useTokenList,
   useTokenSearch: () => useTokenSearch,
+  useTransactionSimulation: () => useTransactionSimulation,
   useTxHistory: () => useTxHistory,
   useTxMonitor: () => useTxMonitor,
+  useUserOpStatus: () => useUserOpStatus,
   useValidateDestination: () => useValidateDestination
 });
 module.exports = __toCommonJS(index_exports);
@@ -355,27 +390,473 @@ function useNotification(options = {}) {
   };
 }
 
-// src/useAccount.ts
+// src/useSimulateTransfer.ts
+var import_connect_appkit_core2 = require("@naculus/connect-appkit-core");
+var import_connect_core3 = require("@naculus/connect-core");
 var import_vue3 = require("vue");
+function useSimulateTransfer(options = {}) {
+  const result = (0, import_vue3.shallowRef)(null);
+  const loading = (0, import_vue3.shallowRef)(false);
+  const error = (0, import_vue3.shallowRef)(null);
+  let manager;
+  let generation = 0;
+  let disposed = false;
+  const simulate = async (tokenAddress, from, to, amount, callOptions) => {
+    const own = ++generation;
+    loading.value = true;
+    error.value = null;
+    try {
+      const fallbackRpcUrl = (0, import_vue3.unref)(options.rpcUrl);
+      const endpoint = (0, import_connect_appkit_core2.resolveSimulationEndpoint)(
+        callOptions?.chainId,
+        (0, import_vue3.unref)(options.chainId),
+        callOptions?.rpcUrl,
+        fallbackRpcUrl
+      );
+      manager ??= new import_connect_core3.SimulationManager({
+        enabled: true,
+        rpcUrl: fallbackRpcUrl,
+        autoSimulate: false
+      });
+      const value = await manager.simulateERC20Transfer(
+        tokenAddress,
+        from,
+        to,
+        amount,
+        endpoint.chainId,
+        callOptions?.decimals,
+        endpoint.rpcUrl
+      );
+      if (!disposed && own === generation) result.value = value;
+      return value;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error(String(cause));
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      if (!disposed && own === generation) loading.value = false;
+    }
+  };
+  const reset = () => {
+    generation++;
+    result.value = null;
+    error.value = null;
+    loading.value = false;
+  };
+  (0, import_vue3.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return { result, loading, error, simulate, reset };
+}
+
+// src/useTransactionSimulation.ts
+var import_connect_appkit_core3 = require("@naculus/connect-appkit-core");
+var import_vue4 = require("vue");
+function useTransactionSimulation(tx, options = {}) {
+  const result = (0, import_vue4.shallowRef)(void 0);
+  const isSimulating = (0, import_vue4.shallowRef)(false);
+  const error = (0, import_vue4.shallowRef)(null);
+  let timer;
+  let generation = 0;
+  let disposed = false;
+  const simulate = async () => {
+    const own = ++generation;
+    const transaction = (0, import_vue4.toValue)(tx);
+    if (transaction) {
+      isSimulating.value = true;
+      error.value = null;
+    }
+    try {
+      const value = await (0, import_connect_appkit_core3.simulateTransactionPreview)(transaction, {
+        chainId: (0, import_vue4.unref)(options.chainId),
+        currentChain: (0, import_vue4.unref)(options.currentChain),
+        publicClient: (0, import_vue4.unref)(options.publicClient),
+        evmAccount: (0, import_vue4.unref)(options.evmAccount)
+      });
+      if (!disposed && own === generation) result.value = value;
+      return value;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Simulation failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      if (transaction && !disposed && own === generation)
+        isSimulating.value = false;
+    }
+  };
+  (0, import_vue4.watch)(
+    [
+      () => (0, import_vue4.toValue)(tx),
+      () => (0, import_vue4.unref)(options.chainId),
+      () => (0, import_vue4.unref)(options.currentChain),
+      () => (0, import_vue4.unref)(options.publicClient),
+      () => (0, import_vue4.unref)(options.evmAccount)
+    ],
+    ([transaction]) => {
+      generation++;
+      if (timer) clearTimeout(timer);
+      if (!transaction) return;
+      timer = setTimeout(() => {
+        timer = void 0;
+        void simulate().catch(() => {
+        });
+      }, 300);
+    },
+    { immediate: true }
+  );
+  const reset = () => {
+    generation++;
+    result.value = void 0;
+    error.value = null;
+    isSimulating.value = false;
+  };
+  (0, import_vue4.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    if (timer) clearTimeout(timer);
+  });
+  return { result, isSimulating, error, simulate, reset };
+}
+
+// src/useERC20Transfer.ts
+var import_connect_appkit_core5 = require("@naculus/connect-appkit-core");
+var import_connect_core5 = require("@naculus/connect-core");
+var import_vue5 = require("vue");
+
+// src/erc20.ts
+var import_connect_appkit_core4 = require("@naculus/connect-appkit-core");
+var import_connect_core4 = require("@naculus/connect-core");
+function assertErc20Context(token, chainId, account, connected) {
+  if (!connected || !account) {
+    throw new import_connect_core4.WalletError("wallet_unavailable", "No connected account");
+  }
+  const mismatch = (0, import_connect_appkit_core4.tokenChainMismatch)(token, chainId);
+  if (mismatch) throw mismatch;
+  const bare = (0, import_connect_appkit_core4.bareEvmAddress)(account);
+  if (!bare) {
+    throw new import_connect_core4.WalletError("wallet_unavailable", "No valid EVM account");
+  }
+  return bare;
+}
+
+// src/useERC20Transfer.ts
+function useERC20Transfer(options) {
+  const initialToken = (0, import_vue5.toValue)(options.token);
+  const decimals = (0, import_connect_appkit_core5.createDecimalsCache)(initialToken, initialToken.decimals);
+  const isSending = (0, import_vue5.shallowRef)(false);
+  const error = (0, import_vue5.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  (0, import_vue5.watch)(
+    [
+      () => (0, import_vue5.toValue)(options.token).address,
+      () => (0, import_vue5.toValue)(options.token).chainId,
+      () => (0, import_vue5.toValue)(options.token).decimals,
+      () => (0, import_vue5.toValue)(options.account),
+      () => (0, import_vue5.toValue)(options.chainId),
+      () => (0, import_vue5.toValue)(options.connected),
+      () => (0, import_vue5.toValue)(options.publicClient),
+      () => (0, import_vue5.unref)(options.sendTransaction)
+    ],
+    () => {
+      generation++;
+      isSending.value = false;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  const sendTransfer = async (to, amount) => {
+    const own = ++generation;
+    const token = (0, import_vue5.toValue)(options.token);
+    const reader = (0, import_vue5.toValue)(options.publicClient);
+    const stillCurrent = () => !disposed && own === generation;
+    error.value = null;
+    isSending.value = true;
+    try {
+      assertErc20Context(
+        token,
+        (0, import_vue5.toValue)(options.chainId),
+        (0, import_vue5.toValue)(options.account),
+        (0, import_vue5.toValue)(options.connected)
+      );
+      if (!reader) {
+        throw new import_connect_core5.WalletError(
+          "wallet_unavailable",
+          "No public client available"
+        );
+      }
+      let precision = (0, import_connect_appkit_core5.readDecimals)(decimals, token, token.decimals);
+      if (precision === void 0) {
+        precision = Number(
+          await reader.readContract({
+            address: token.address,
+            abi: import_connect_core5.ERC20_MIN_ABI,
+            functionName: "decimals"
+          })
+        );
+        if (!stillCurrent()) {
+          throw new import_connect_core5.WalletError(
+            "session_inactive",
+            "Wallet or token context changed. Retry the transfer."
+          );
+        }
+        (0, import_connect_appkit_core5.writeDecimals)(decimals, token, precision);
+      }
+      const data = (0, import_connect_appkit_core5.encodeErc20Transfer)(to, (0, import_connect_core5.parseUnits)(amount, precision));
+      return await (0, import_vue5.unref)(options.sendTransaction)({
+        to: token.address,
+        data,
+        value: "0"
+      });
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Transfer failed");
+      if (stillCurrent()) error.value = normalized;
+      throw normalized;
+    } finally {
+      if (stillCurrent()) isSending.value = false;
+    }
+  };
+  (0, import_vue5.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return { sendTransfer, isSending, error };
+}
+
+// src/useERC20Approve.ts
+var import_connect_appkit_core6 = require("@naculus/connect-appkit-core");
+var import_connect_core6 = require("@naculus/connect-core");
+var import_vue6 = require("vue");
+var MAX_UINT256 = (1n << 256n) - 1n;
+function useERC20Approve(options) {
+  const initialToken = (0, import_vue6.toValue)(options.token);
+  const decimals = (0, import_connect_appkit_core6.createDecimalsCache)(initialToken, initialToken.decimals);
+  const allowanceRaw = (0, import_vue6.shallowRef)(null);
+  const isApproving = (0, import_vue6.shallowRef)(false);
+  const isFetchingAllowance = (0, import_vue6.shallowRef)(false);
+  const error = (0, import_vue6.shallowRef)(null);
+  let generation = 0;
+  let allowanceGeneration = 0;
+  let disposed = false;
+  (0, import_vue6.watch)(
+    [
+      () => (0, import_vue6.toValue)(options.token).address,
+      () => (0, import_vue6.toValue)(options.token).chainId,
+      () => (0, import_vue6.toValue)(options.token).decimals,
+      () => (0, import_vue6.toValue)(options.spender),
+      () => (0, import_vue6.toValue)(options.account),
+      () => (0, import_vue6.toValue)(options.chainId),
+      () => (0, import_vue6.toValue)(options.connected),
+      () => (0, import_vue6.toValue)(options.publicClient),
+      () => (0, import_vue6.unref)(options.sendTransaction)
+    ],
+    () => {
+      generation++;
+      allowanceGeneration++;
+      allowanceRaw.value = null;
+      isApproving.value = false;
+      isFetchingAllowance.value = false;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  const context = () => {
+    const token = (0, import_vue6.toValue)(options.token);
+    const account = assertErc20Context(
+      token,
+      (0, import_vue6.toValue)(options.chainId),
+      (0, import_vue6.toValue)(options.account),
+      (0, import_vue6.toValue)(options.connected)
+    );
+    const reader = (0, import_vue6.toValue)(options.publicClient);
+    if (!reader)
+      throw new import_connect_core6.WalletError("wallet_unavailable", "No public client");
+    return { token, account, reader, spender: (0, import_vue6.toValue)(options.spender) };
+  };
+  const readPrecision = async () => {
+    const { token, reader } = context();
+    let precision = (0, import_connect_appkit_core6.readDecimals)(decimals, token, token.decimals);
+    if (precision === void 0) {
+      precision = Number(
+        await reader.readContract({
+          address: token.address,
+          abi: import_connect_core6.ERC20_MIN_ABI,
+          functionName: "decimals"
+        })
+      );
+      (0, import_connect_appkit_core6.writeDecimals)(decimals, token, precision);
+    }
+    return precision;
+  };
+  const refetchAllowance = async () => {
+    const own = ++allowanceGeneration;
+    allowanceRaw.value = null;
+    error.value = null;
+    isFetchingAllowance.value = true;
+    try {
+      const { token, account, reader, spender } = context();
+      const raw = BigInt(
+        await reader.readContract({
+          address: token.address,
+          abi: import_connect_core6.ERC20_MIN_ABI,
+          functionName: "allowance",
+          args: [account, spender]
+        })
+      );
+      if (disposed || own !== allowanceGeneration) return null;
+      allowanceRaw.value = raw;
+      return raw;
+    } catch (cause) {
+      if (!disposed && own === allowanceGeneration) {
+        error.value = cause instanceof Error ? cause : new Error("Failed to fetch allowance");
+      }
+      return null;
+    } finally {
+      if (!disposed && own === allowanceGeneration)
+        isFetchingAllowance.value = false;
+    }
+  };
+  const doApprove = async (rawAmount) => {
+    const own = ++generation;
+    error.value = null;
+    isApproving.value = true;
+    try {
+      const { token, spender } = context();
+      const hash = await (0, import_vue6.unref)(options.sendTransaction)({
+        to: token.address,
+        data: (0, import_connect_appkit_core6.encodeErc20Approve)(spender, rawAmount),
+        value: "0"
+      });
+      if (!disposed && own === generation) void refetchAllowance();
+      return hash;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Approve failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      if (!disposed && own === generation) isApproving.value = false;
+    }
+  };
+  const approve = async (amount) => {
+    const contextGeneration = generation;
+    let rawAmount;
+    try {
+      const precision = await readPrecision();
+      if (contextGeneration !== generation || disposed) {
+        throw new import_connect_core6.WalletError(
+          "session_inactive",
+          "Wallet or token context changed. Retry the approval."
+        );
+      }
+      rawAmount = (0, import_connect_core6.parseUnits)(amount, precision);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Approve failed");
+      if (!disposed && contextGeneration === generation)
+        error.value = normalized;
+      throw normalized;
+    }
+    return doApprove(rawAmount);
+  };
+  const approveMax = () => doApprove(MAX_UINT256);
+  const hasAllowance = async (required) => {
+    const raw = allowanceRaw.value ?? await refetchAllowance();
+    if (raw === null) return false;
+    return raw >= (0, import_connect_core6.parseUnits)(required, await readPrecision());
+  };
+  const allowance = (0, import_vue6.computed)(() => {
+    if (allowanceRaw.value === null) return null;
+    const token = (0, import_vue6.toValue)(options.token);
+    const precision = (0, import_connect_appkit_core6.readDecimals)(decimals, token, token.decimals);
+    return precision === void 0 ? null : (0, import_connect_core6.formatUnits)(allowanceRaw.value, precision);
+  });
+  (0, import_vue6.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    allowanceGeneration++;
+  });
+  return {
+    approve,
+    approveMax,
+    allowanceRaw,
+    allowance,
+    hasAllowance,
+    isApproving,
+    isFetchingAllowance,
+    error,
+    refetchAllowance
+  };
+}
+
+// src/useERC20TransferSimulation.ts
+var import_connect_appkit_core7 = require("@naculus/connect-appkit-core");
+var import_connect_core7 = require("@naculus/connect-core");
+var import_vue7 = require("vue");
+function useERC20TransferSimulation(options) {
+  const transaction = (0, import_vue7.computed)(() => {
+    const token = (0, import_vue7.toValue)(options.token);
+    if (!(0, import_vue7.toValue)(options.connected) || !(0, import_vue7.toValue)(options.evmAccount))
+      return void 0;
+    try {
+      if (token.decimals === void 0) return void 0;
+      return {
+        to: token.address,
+        data: (0, import_connect_appkit_core7.encodeErc20Transfer)(
+          (0, import_vue7.toValue)(options.to),
+          (0, import_connect_core7.parseUnits)((0, import_vue7.toValue)(options.amount), token.decimals)
+        ),
+        value: "0"
+      };
+    } catch {
+      return void 0;
+    }
+  });
+  const chainId = (0, import_vue7.computed)(() => {
+    const token = (0, import_vue7.toValue)(options.token);
+    if (token.chainId !== void 0) return token.chainId;
+    const currentChain = (0, import_vue7.toValue)(options.currentChain);
+    return currentChain ? (0, import_connect_appkit_core7.chainNumber)(currentChain) ?? void 0 : void 0;
+  });
+  const simulation = useTransactionSimulation(transaction, {
+    chainId,
+    currentChain: options.currentChain,
+    publicClient: options.publicClient,
+    evmAccount: options.evmAccount
+  });
+  return {
+    result: (0, import_vue7.computed)(
+      () => transaction.value ? simulation.result.value : void 0
+    ),
+    isSimulating: (0, import_vue7.computed)(
+      () => !!transaction.value && simulation.isSimulating.value
+    ),
+    error: (0, import_vue7.computed)(() => transaction.value ? simulation.error.value : null),
+    reSimulate: simulation.simulate,
+    reset: simulation.reset
+  };
+}
+
+// src/useAccount.ts
+var import_vue8 = require("vue");
 function useAccount(accounts, connected) {
   const parsed = useAccounts(accounts);
-  const isConnected = (0, import_vue3.computed)(() => (0, import_vue3.toValue)(connected));
-  const accountList = (0, import_vue3.computed)(() => (0, import_vue3.toValue)(accounts) ?? []);
+  const isConnected = (0, import_vue8.computed)(() => (0, import_vue8.toValue)(connected));
+  const accountList = (0, import_vue8.computed)(() => (0, import_vue8.toValue)(accounts) ?? []);
   return {
-    accounts: (0, import_vue3.computed)(
+    accounts: (0, import_vue8.computed)(
       () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
     ),
-    evmAccount: (0, import_vue3.computed)(
+    evmAccount: (0, import_vue8.computed)(
       () => isConnected.value ? parsed.evmAccount.value : null
     ),
-    primaryAccount: (0, import_vue3.computed)(() => accountList.value[0] ?? null),
+    primaryAccount: (0, import_vue8.computed)(() => accountList.value[0] ?? null),
     isConnected,
-    count: (0, import_vue3.computed)(() => accountList.value.length)
+    count: (0, import_vue8.computed)(() => accountList.value.length)
   };
 }
 
 // src/useSession.ts
-var import_vue4 = require("vue");
+var import_vue9 = require("vue");
 function readSession(manager) {
   const bundle = manager?.getActiveBundle();
   if (!bundle) {
@@ -394,9 +875,9 @@ function readSession(manager) {
   };
 }
 function useSession(manager) {
-  const snapshot = (0, import_vue4.shallowRef)(readSession((0, import_vue4.toValue)(manager)));
-  (0, import_vue4.watch)(
-    () => (0, import_vue4.toValue)(manager),
+  const snapshot = (0, import_vue9.shallowRef)(readSession((0, import_vue9.toValue)(manager)));
+  (0, import_vue9.watch)(
+    () => (0, import_vue9.toValue)(manager),
     (current, _previous, onCleanup) => {
       const update = () => {
         snapshot.value = readSession(current);
@@ -406,145 +887,1067 @@ 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 }
+  );
+  return {
+    session: (0, import_vue9.computed)(() => snapshot.value.session),
+    chainSessions: (0, import_vue9.computed)(() => snapshot.value.chainSessions),
+    activeChainId: (0, import_vue9.computed)(() => snapshot.value.activeChainId),
+    isConnected: (0, import_vue9.computed)(() => snapshot.value.session !== null),
+    connectorId: (0, import_vue9.computed)(() => snapshot.value.connectorId)
+  };
+}
+
+// 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 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_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;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  return {
+    connect,
+    isConnecting: (0, import_vue11.computed)(
+      () => guard.busy.value || (0, import_vue11.toValue)(status) === "connecting"
+    ),
+    error: guard.error
+  };
+}
+
+// src/useDisconnect.ts
+var import_vue12 = require("vue");
+function useDisconnect(action, status) {
+  const guard = useActionGuard();
+  let inFlight = null;
+  const disconnect = () => {
+    if (inFlight) return inFlight;
+    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;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  const cleanup = () => {
+    guard.dispose();
+  };
+  return {
+    disconnect,
+    isDisconnecting: guard.busy,
+    error: guard.error,
+    cleanup
+  };
+}
+
+// src/useSwitchChain.ts
+var import_connect_appkit_core8 = require("@naculus/connect-appkit-core");
+var import_vue13 = require("vue");
+function useSwitchChain(action, chainId) {
+  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");
+  };
+  return {
+    switchChain,
+    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_vue14 = require("vue");
+function useSignMessage(action) {
+  const guard = useActionGuard();
+  const signMessage = (message) => {
+    const invoke = (0, import_vue14.unref)(action);
+    return guard.run(() => invoke(message), "Signing failed");
+  };
+  return {
+    signMessage,
+    isSigning: guard.busy,
+    error: guard.error,
+    reset: guard.reset
+  };
+}
+
+// src/useSendTransaction.ts
+var import_vue15 = require("vue");
+function useSendTransaction(action) {
+  const guard = useActionGuard();
+  const status = (0, import_vue15.shallowRef)("idle");
+  const sendTransaction = (transaction) => {
+    const invoke = (0, import_vue15.unref)(action);
+    status.value = "awaiting_approval";
+    return guard.run(async (commit) => {
+      const hash = await invoke(transaction);
+      commit(() => {
+        status.value = "submitted";
+      });
+      return hash;
+    }, "Transaction failed").catch((cause) => {
+      if (guard.error.value === cause) status.value = "failed";
+      throw cause;
+    });
+  };
+  const reset = () => {
+    guard.reset();
+    status.value = "idle";
+  };
+  return {
+    sendTransaction,
+    status,
+    error: guard.error,
+    reset,
+    isSending: (0, import_vue15.computed)(() => status.value === "awaiting_approval")
+  };
+}
+
+// src/useSolanaTransaction.ts
+var import_vue16 = require("vue");
+function useSolanaTransaction(options) {
+  const guard = useActionGuard();
+  const isSigning = (0, import_vue16.shallowRef)(false);
+  const isSending = (0, import_vue16.shallowRef)(false);
+  let signing = 0;
+  let sending = 0;
+  const signTransaction = (transaction) => {
+    const invoke = (0, import_vue16.unref)(options.signTransaction);
+    signing++;
+    isSigning.value = true;
+    return guard.run(() => invoke(transaction), "Signing failed").finally(() => {
+      signing--;
+      isSigning.value = signing > 0;
+    });
+  };
+  const sendTransaction = (transaction) => {
+    const invoke = (0, import_vue16.unref)(options.sendTransaction);
+    sending++;
+    isSending.value = true;
+    return guard.run(() => invoke(transaction), "Send failed").finally(() => {
+      sending--;
+      isSending.value = sending > 0;
+    });
+  };
+  const getStatus = (signature) => (0, import_vue16.unref)(options.getStatus)(signature);
+  return {
+    signTransaction,
+    sendTransaction,
+    getStatus,
+    isSigning,
+    isSending,
+    error: guard.error,
+    reset: guard.reset
+  };
+}
+
+// src/useSignInWithX.ts
+var import_vue17 = require("vue");
+function useSignInWithX(action) {
+  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_vue17.unref)(action);
+    const own = ++generation;
+    active++;
+    isSigningIn.value = true;
+    error.value = null;
+    try {
+      const next = await invoke(options);
+      if (!disposed && own === generation) result.value = next;
+      return next;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("SIWX sign-in failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) isSigningIn.value = active > 0;
+    }
+  };
+  const clearError = () => {
+    error.value = null;
+  };
+  const reset = () => {
+    generation++;
+    result.value = null;
+    error.value = null;
+  };
+  (0, import_vue17.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return { signIn, isSigningIn, result, error, clearError, reset };
+}
+
+// src/useSignInWithEthereum.ts
+function useSignInWithEthereum(action) {
+  return useSignInWithX(action);
+}
+
+// src/useExecuteCalls.ts
+var import_vue18 = require("vue");
+function useExecuteCalls(options) {
+  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 = () => {
+    guard.reset();
+    (0, import_vue18.unref)(options.reset)();
+  };
+  return {
+    preview,
+    execute,
+    isExecuting: guard.busy,
+    error: guard.error,
+    lastRoute: (0, import_vue18.computed)(() => (0, import_vue18.toValue)(options.lastRoute)),
+    reset
+  };
+}
+
+// src/useDelegationPolicy.ts
+var import_connect_appkit_core10 = require("@naculus/connect-appkit-core");
+var import_vue20 = require("vue");
+
+// src/useSessionKeys.ts
+var import_connect_appkit_core9 = require("@naculus/connect-appkit-core");
+var import_vue19 = require("vue");
+function resolveManager(config, options) {
+  return options.manager ?? (0, import_connect_appkit_core9.getSharedSessionKeyManager)(config);
+}
+function useSessionKeys(connected, config, options = {}) {
+  const manager = resolveManager(config, options);
+  const sessions = (0, import_vue19.shallowRef)([]);
+  const loading = (0, import_vue19.shallowRef)(false);
+  const error = (0, import_vue19.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const refresh = async () => {
+    const own = ++generation;
+    if (!(0, import_vue19.toValue)(connected)) {
+      sessions.value = [];
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const keys = await manager.listSessions();
+      if (!disposed && own === generation) sessions.value = keys;
+    } catch (cause) {
+      if (!disposed && own === generation) {
+        error.value = cause instanceof Error ? cause : new Error("Failed to load session keys");
+      }
+    } finally {
+      if (!disposed && own === generation) loading.value = false;
+    }
+  };
+  (0, import_vue19.watch)(
+    () => (0, import_vue19.toValue)(connected),
+    () => {
+      void refresh();
+    },
+    { immediate: true }
+  );
+  (0, import_vue19.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    sessions,
+    activeSessions: (0, import_vue19.computed)(
+      () => sessions.value.filter((s) => s.status === "active")
+    ),
+    loading,
+    error,
+    refresh,
+    clearError: () => {
+      error.value = null;
+    },
+    storageAvailable: manager.isStorageAvailable()
+  };
+}
+function useCreateSessionKey(config, options = {}) {
+  const manager = resolveManager(config, options);
+  const guard = useActionGuard();
+  const lastCreated = (0, import_vue19.shallowRef)(null);
+  return {
+    createSessionKey: (scope, signerAddress) => guard.run(async () => {
+      const info = await manager.createSessionKey(scope, signerAddress);
+      lastCreated.value = info;
+      return info;
+    }, "Failed to create session key"),
+    lastCreated,
+    isCreating: guard.busy,
+    error: guard.error,
+    clearError: guard.reset
+  };
+}
+function useRevokeSession(config, options = {}) {
+  const manager = resolveManager(config, options);
+  const guard = useActionGuard();
+  return {
+    revokeSession: (sessionId) => guard.run(
+      () => manager.revokeSession(sessionId),
+      "Failed to revoke session key"
+    ),
+    isRevoking: guard.busy,
+    error: guard.error,
+    clearError: guard.reset
+  };
+}
+function useSendWithSession(config, options = {}) {
+  const manager = resolveManager(config, options);
+  const guard = useActionGuard();
+  return {
+    signWithSession: (sessionId, messageHash, tx) => guard.run(
+      () => manager.signWithSessionKey(sessionId, messageHash, tx),
+      "Failed to sign with session key"
+    ),
+    checkScope: (sessionId, tx) => guard.run(
+      () => manager.checkSessionScope(sessionId, tx),
+      "Failed to check session scope"
+    ),
+    isBusy: guard.busy,
+    error: guard.error,
+    clearError: guard.reset
+  };
+}
+
+// src/useDelegationPolicy.ts
+function useDelegationPolicy(options) {
+  const manager = options.manager ?? (0, import_connect_appkit_core10.getSharedSessionKeyManager)(options.managerConfig);
+  const sessionKeys = useSessionKeys(options.connected, options.managerConfig, {
+    manager
+  });
+  const guard = useActionGuard();
+  const verifiedIds = (0, import_vue20.shallowRef)(/* @__PURE__ */ new Set());
+  const isVerifying = (0, import_vue20.shallowRef)(false);
+  const verifyError = (0, import_vue20.shallowRef)(null);
+  let verifyGeneration = 0;
+  let disposed = false;
+  const origin = options.origin ?? (typeof window !== "undefined" ? window.location.origin : "unknown");
+  const flow = (0, import_connect_appkit_core10.createDelegationPolicyFlow)({
+    manager,
+    origin,
+    signer: () => (0, import_connect_appkit_core10.bareEvmAddress)((0, import_vue20.toValue)(options.account)),
+    signMessage: (message) => (0, import_vue20.unref)(options.signMessage)(message),
+    verifySignature: (input) => (0, import_vue20.unref)(options.verifySignature)(input),
+    previewExecution: (callCount, atomicity) => (0, import_vue20.unref)(options.previewExecution)(callCount, atomicity),
+    sponsorship: options.sponsorship,
+    adapter: options.adapter,
+    delegation: () => (0, import_vue20.toValue)(options.delegation),
+    encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
+    storageAvailable: () => sessionKeys.storageAvailable,
+    refresh: sessionKeys.refresh
+  });
+  (0, import_vue20.watch)(
+    () => sessionKeys.sessions.value,
+    (sessions) => {
+      const own = ++verifyGeneration;
+      const candidates = sessions.filter(import_connect_appkit_core10.isVerifiablePolicy);
+      if (candidates.length === 0) {
+        verifiedIds.value = /* @__PURE__ */ new Set();
+        isVerifying.value = false;
+        return;
+      }
+      isVerifying.value = true;
+      void Promise.all(
+        candidates.map(
+          async (policy) => [policy.id, await flow.verifyStoredPolicy(policy)]
+        )
+      ).then((results) => {
+        if (disposed || own !== verifyGeneration) return;
+        verifiedIds.value = new Set(
+          results.filter(([, ok]) => ok).map(([id]) => id)
+        );
+      }).catch((cause) => {
+        if (disposed || own !== verifyGeneration) return;
+        verifiedIds.value = /* @__PURE__ */ new Set();
+        verifyError.value = cause instanceof Error ? cause : new Error("Policy verification failed");
+      }).finally(() => {
+        if (!disposed && own === verifyGeneration) isVerifying.value = false;
       });
     },
     { immediate: true }
   );
+  (0, import_vue20.onScopeDispose)(() => {
+    disposed = true;
+    verifyGeneration++;
+  });
   return {
-    session: (0, import_vue4.computed)(() => snapshot.value.session),
-    chainSessions: (0, import_vue4.computed)(() => snapshot.value.chainSessions),
-    activeChainId: (0, import_vue4.computed)(() => snapshot.value.activeChainId),
-    isConnected: (0, import_vue4.computed)(() => snapshot.value.session !== null),
-    connectorId: (0, import_vue4.computed)(() => snapshot.value.connectorId)
+    policies: sessionKeys.sessions,
+    activePolicies: (0, import_vue20.computed)(
+      () => sessionKeys.activeSessions.value.filter(
+        (p) => verifiedIds.value.has(p.id)
+      )
+    ),
+    storageAvailable: sessionKeys.storageAvailable,
+    loading: (0, import_vue20.computed)(() => sessionKeys.loading.value || isVerifying.value),
+    isBusy: guard.busy,
+    error: (0, import_vue20.computed)(
+      () => guard.error.value ?? verifyError.value ?? sessionKeys.error.value
+    ),
+    createPolicy: (scope) => guard.run(() => flow.createPolicy(scope), "Policy creation failed"),
+    revokePolicy: (policyId) => guard.run(() => flow.revokePolicy(policyId), "Policy revocation failed"),
+    previewPolicyExecution: flow.previewPolicyExecution,
+    signPolicyDigest: flow.signPolicyDigest,
+    executePolicy: (policyId, tx) => guard.run(
+      () => flow.executePolicy(policyId, tx),
+      "Policy execution failed"
+    ),
+    refresh: sessionKeys.refresh,
+    clearError: () => {
+      guard.reset();
+      verifyError.value = null;
+      sessionKeys.clearError();
+    }
   };
 }
 
-// src/useConnect.ts
-var import_connect_core3 = require("@naculus/connect-core");
-var import_vue5 = require("vue");
-function useConnect(action, status) {
-  const isLoading = (0, import_vue5.shallowRef)(false);
-  const error = (0, import_vue5.shallowRef)(null);
+// src/useSmartAccount.ts
+var import_connect_appkit_core11 = require("@naculus/connect-appkit-core");
+var import_connect_core9 = require("@naculus/connect-core");
+var import_vue21 = require("vue");
+function useSmartAccount(options) {
+  const address = (0, import_vue21.shallowRef)(null);
+  const isDeployed = (0, import_vue21.shallowRef)(false);
+  const accountInfo = (0, import_vue21.shallowRef)(null);
+  const guard = useActionGuard();
+  const managerRef = (0, import_vue21.shallowRef)(null);
+  let generation = 0;
+  let inFlight = false;
   let disposed = false;
-  let inFlight = null;
-  const connect = () => {
-    if (inFlight) return inFlight;
-    const invoke = (0, import_vue5.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_core3.WalletError ? cause : new Error(message);
-    }).finally(() => {
-      if (inFlight === pending) inFlight = null;
-      if (!disposed) isLoading.value = false;
+  const chainId = (0, import_vue21.computed)(
+    () => (0, import_connect_appkit_core11.resolveEvmChainId)(
+      (0, import_vue21.toValue)(options.chainId),
+      (0, import_vue21.toValue)(options.connectedChainId)
+    )
+  );
+  (0, import_vue21.watch)(
+    [
+      () => (0, import_vue21.toValue)(options.manager),
+      () => (0, import_vue21.toValue)(options.rpcUrl),
+      () => (0, import_vue21.toValue)(options.bundlerUrl),
+      () => chainId.value
+    ],
+    ([supplied, rpcUrl, bundlerUrl, chain]) => {
+      const own = ++generation;
+      managerRef.value = null;
+      if (supplied) {
+        managerRef.value = supplied;
+        return;
+      }
+      if (!rpcUrl || !chain) return;
+      import("@naculus/connect-core").then(({ SmartAccountManager }) => {
+        if (disposed || own !== generation) return;
+        managerRef.value = new SmartAccountManager({
+          rpcUrl,
+          chainId: chain,
+          bundlerClient: { url: bundlerUrl ?? "" }
+        });
+      }).catch((cause) => {
+        if (disposed || own !== generation) return;
+        guard.error.value = cause instanceof Error ? cause : new Error("Failed to load account-abstraction module");
+      });
+    },
+    { immediate: true }
+  );
+  const config = (0, import_vue21.computed)(() => {
+    const owner = (0, import_connect_appkit_core11.bareEvmAddress)((0, import_vue21.toValue)(options.account));
+    const chain = chainId.value;
+    if (!owner || !chain || !managerRef.value) return null;
+    return (0, import_connect_appkit_core11.buildSmartAccountConfig)(owner, chain, {
+      accountType: options.accountType,
+      entryPoint: options.entryPoint,
+      salt: options.salt
     });
-    inFlight = pending;
-    return pending;
+  });
+  const apply = (info) => {
+    address.value = info.address;
+    isDeployed.value = info.isDeployed;
+    accountInfo.value = info;
   };
-  (0, import_vue5.onScopeDispose)(() => {
+  const operate = async (action, fallback) => {
+    const cfg = config.value;
+    const manager = managerRef.value;
+    if (!cfg || !manager) {
+      guard.error.value = new Error("Smart account not configured");
+      return null;
+    }
+    if (inFlight) {
+      guard.error.value = new Error(
+        "Smart account operation already in progress"
+      );
+      return null;
+    }
+    inFlight = true;
+    const own = generation;
+    const current = () => !disposed && own === generation;
+    const commit = (write) => {
+      if (current()) write();
+    };
+    try {
+      return await guard.run(async () => {
+        const result = await action(manager, cfg, commit);
+        return current() ? result : null;
+      }, fallback);
+    } catch {
+      return null;
+    } finally {
+      inFlight = false;
+    }
+  };
+  const createWallet = () => operate(async (manager, cfg, commit) => {
+    const info = await manager.createAccount(cfg);
+    commit(() => apply(info));
+    return info;
+  }, "Failed to create smart account");
+  const deployWallet = () => operate(async (manager, cfg, commit) => {
+    const send = (0, import_vue21.unref)(options.sendTransaction);
+    if (!send) {
+      throw new import_connect_core9.WalletError(
+        "wallet_unavailable",
+        "deployWallet needs the connected wallet's sendTransaction"
+      );
+    }
+    const before = await manager.createAccount(cfg);
+    if (before.isDeployed) {
+      commit(() => apply(before));
+      return before.address;
+    }
+    const deployTx = await manager.getDeployCallData(cfg);
+    const hash = await send({
+      to: deployTx.to,
+      data: deployTx.data,
+      value: deployTx.value.toString(),
+      chainId: cfg.chainId
+    });
+    const after = await manager.createAccount(cfg);
+    commit(() => apply(after));
+    return hash;
+  }, "Failed to deploy smart account");
+  const getAddress = () => operate(async (manager, cfg, commit) => {
+    const addr = await manager.getAccountAddress(cfg);
+    commit(() => {
+      address.value = addr;
+    });
+    return addr;
+  }, "Failed to get smart account address");
+  (0, import_vue21.onScopeDispose)(() => {
     disposed = true;
+    generation++;
   });
   return {
-    connect,
-    isConnecting: (0, import_vue5.computed)(
-      () => isLoading.value || (0, import_vue5.toValue)(status) === "connecting"
-    ),
-    error
+    address,
+    isDeployed,
+    accountInfo,
+    isLoading: guard.busy,
+    error: guard.error,
+    config,
+    createWallet,
+    deployWallet,
+    getAddress
   };
 }
 
-// src/useDisconnect.ts
-var import_vue6 = require("vue");
-function useDisconnect(action, status) {
-  const isDisconnecting = (0, import_vue6.shallowRef)(false);
-  const error = (0, import_vue6.shallowRef)(null);
+// src/useSendUserOperation.ts
+var import_connect_appkit_core12 = require("@naculus/connect-appkit-core");
+var import_connect_core10 = require("@naculus/connect-core");
+var import_vue22 = require("vue");
+function useSendUserOperation(options) {
+  const userOpHash = (0, import_vue22.shallowRef)(null);
+  const receipt = (0, import_vue22.shallowRef)(null);
+  const isPending = (0, import_vue22.shallowRef)(false);
+  const isEstimating = (0, import_vue22.shallowRef)(false);
+  const error = (0, import_vue22.shallowRef)(null);
+  let requestId = 0;
+  let inFlight = false;
   let disposed = false;
-  let inFlight = null;
-  const disconnect = () => {
-    if (inFlight) return inFlight;
-    if ((0, import_vue6.toValue)(status) === "disconnected") return Promise.resolve();
-    const invoke = (0, import_vue6.unref)(action);
-    isDisconnecting.value = true;
+  const fail = (cause) => {
+    error.value = cause;
+    return null;
+  };
+  const sendUserOp = async (calls, opts) => {
+    const rpcUrl = (0, import_vue22.toValue)(options.rpcUrl);
+    const bundlerUrl = (0, import_vue22.toValue)(options.bundlerUrl);
+    if (!rpcUrl) return fail(new Error("RPC URL not configured"));
+    if (!bundlerUrl) return fail(new Error("Bundler URL not configured"));
+    if (!calls.length) return fail(new Error("At least one call is required"));
+    if (inFlight) {
+      return fail(new Error("A UserOperation is already in progress"));
+    }
+    const owner = (0, import_connect_appkit_core12.bareEvmAddress)(
+      (0, import_vue22.toValue)(options.owner) ?? (0, import_vue22.toValue)(options.account)
+    );
+    if (!owner) {
+      return fail(
+        new import_connect_core10.WalletError("wallet_unavailable", "No EVM account found")
+      );
+    }
+    let targetChainId;
+    try {
+      targetChainId = (0, import_connect_appkit_core12.resolveUserOpChain)(
+        (0, import_vue22.toValue)(options.chainId),
+        (0, import_vue22.toValue)(options.connectedChainId)
+      );
+    } catch (chainError) {
+      return fail(chainError);
+    }
+    const signer = (0, import_vue22.unref)(options.signer);
+    const own = ++requestId;
+    inFlight = true;
+    isPending.value = true;
+    isEstimating.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");
+    userOpHash.value = null;
+    receipt.value = null;
+    try {
+      const { SmartAccountManager } = await import("@naculus/connect-core");
+      const manager = new SmartAccountManager({
+        rpcUrl,
+        bundlerClient: { url: bundlerUrl },
+        chainId: targetChainId,
+        signer,
+        signerMode: options.signerMode ?? "eip191"
+      });
+      const config = (0, import_connect_appkit_core12.buildSmartAccountConfig)(owner, targetChainId, {
+        accountType: options.accountType,
+        entryPoint: options.entryPoint,
+        salt: options.salt
+      });
+      const response = await manager.sendUserOperation(config, calls, opts);
+      if (disposed || own !== requestId) return null;
+      isEstimating.value = false;
+      userOpHash.value = response.userOpHash;
+      void manager.getUserOperationReceipt(response.userOpHash).then((next) => {
+        if (!disposed && own === requestId) receipt.value = next;
+      }).catch(() => void 0);
+      return response;
+    } catch (cause) {
+      if (disposed || own !== requestId) return null;
+      return fail(
+        cause instanceof Error ? cause : new Error("Failed to send UserOperation")
+      );
+    } finally {
+      inFlight = false;
+      if (!disposed && own === requestId) {
+        isPending.value = false;
+        isEstimating.value = false;
       }
-    }).finally(() => {
-      if (inFlight === pending) inFlight = null;
-      if (!disposed) isDisconnecting.value = false;
-    });
-    inFlight = pending;
-    return pending;
+    }
   };
-  const cleanup = () => {
+  const reset = () => {
+    requestId++;
+    userOpHash.value = null;
+    receipt.value = null;
+    isPending.value = false;
+    isEstimating.value = false;
+    error.value = null;
+  };
+  (0, import_vue22.onScopeDispose)(() => {
     disposed = true;
+    requestId++;
+  });
+  return {
+    sendUserOp,
+    userOpHash,
+    receipt,
+    isPending,
+    isEstimating,
+    error,
+    reset
   };
-  (0, import_vue6.onScopeDispose)(cleanup);
-  return { disconnect, isDisconnecting, error, cleanup };
 }
 
-// src/useSwitchChain.ts
-var import_connect_appkit_core2 = require("@naculus/connect-appkit-core");
-var import_vue7 = require("vue");
-function useSwitchChain(action, chainId) {
-  const isSwitching = (0, import_vue7.shallowRef)(false);
-  const error = (0, import_vue7.shallowRef)(null);
+// src/useUserOpStatus.ts
+var import_connect_appkit_core13 = require("@naculus/connect-appkit-core");
+var import_vue23 = require("vue");
+function useUserOpStatus(options) {
+  const status = (0, import_vue23.shallowRef)("idle");
+  const receipt = (0, import_vue23.shallowRef)(null);
+  const userOpHash = (0, import_vue23.shallowRef)(null);
+  const error = (0, import_vue23.shallowRef)(null);
+  const isPolling = (0, import_vue23.shallowRef)(false);
+  const elapsedMs = (0, import_vue23.shallowRef)(0);
+  const attempts = (0, import_vue23.shallowRef)(0);
+  const pollInterval = options.pollInterval ?? 2e3;
+  const maxRetries = options.maxRetries ?? 30;
   let generation = 0;
-  let active = 0;
+  let startedAt = 0;
+  let ticker = null;
+  let timer = null;
+  let controller = null;
+  const clearTimers = () => {
+    if (ticker) clearInterval(ticker);
+    if (timer) clearTimeout(timer);
+    ticker = null;
+    timer = null;
+  };
+  const finish = (next, cause) => {
+    status.value = next;
+    error.value = cause;
+    isPolling.value = false;
+    clearTimers();
+  };
+  const poll = async (hash, own) => {
+    const bundlerUrl = (0, import_vue23.toValue)(options.bundlerUrl);
+    if (!bundlerUrl || own !== generation) return;
+    const attempt = ++attempts.value;
+    const abort = new AbortController();
+    controller = abort;
+    try {
+      const next = await (0, import_connect_appkit_core13.fetchUserOperationReceipt)(
+        bundlerUrl,
+        hash,
+        abort.signal
+      );
+      if (own !== generation) return;
+      if (next) {
+        receipt.value = next;
+        finish(next.success ? "confirmed" : "failed", null);
+        return;
+      }
+      status.value = "pending";
+      if (attempt <= maxRetries) {
+        timer = setTimeout(() => void poll(hash, own), pollInterval);
+      } else {
+        finish(
+          "not_found",
+          new Error("UserOperation not included after maximum retries")
+        );
+      }
+    } catch (cause) {
+      if (own !== generation || abort.signal.aborted) return;
+      const next = cause instanceof Error ? cause : new Error("Unknown bundler response failure");
+      if (next instanceof import_connect_appkit_core13.InvalidUserOperationReceiptError) {
+        finish("not_found", next);
+        return;
+      }
+      if (attempt <= maxRetries) {
+        timer = setTimeout(() => void poll(hash, own), pollInterval);
+      } else {
+        finish(
+          "not_found",
+          new Error(
+            `UserOperation status unavailable after ${attempt} attempt${attempt === 1 ? "" : "s"}: ${next.message}`
+          )
+        );
+      }
+    } finally {
+      if (controller === abort) controller = null;
+    }
+  };
+  const start = (hash) => {
+    const own = ++generation;
+    controller?.abort();
+    controller = null;
+    clearTimers();
+    userOpHash.value = hash;
+    receipt.value = null;
+    error.value = null;
+    attempts.value = 0;
+    elapsedMs.value = 0;
+    if (!(0, import_vue23.toValue)(options.bundlerUrl)) {
+      finish("not_found", new Error("Bundler URL not configured"));
+      return;
+    }
+    status.value = "pending";
+    isPolling.value = true;
+    startedAt = Date.now();
+    ticker = setInterval(() => {
+      elapsedMs.value = Date.now() - startedAt;
+    }, 1e3);
+    void poll(hash, own);
+  };
+  const stop = () => {
+    generation++;
+    controller?.abort();
+    controller = null;
+    clearTimers();
+    isPolling.value = false;
+  };
+  const reset = () => {
+    stop();
+    status.value = "idle";
+    receipt.value = null;
+    userOpHash.value = null;
+    error.value = null;
+    attempts.value = 0;
+    elapsedMs.value = 0;
+  };
+  (0, import_vue23.onScopeDispose)(stop);
+  return {
+    status,
+    receipt,
+    userOpHash,
+    error,
+    isPolling,
+    elapsedMs,
+    attempts,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/useSendCalls.ts
+var import_vue24 = require("vue");
+function useSendCalls(options) {
+  const status = (0, import_vue24.shallowRef)("idle");
+  const error = (0, import_vue24.shallowRef)(null);
+  const batchHash = (0, import_vue24.shallowRef)(null);
+  const callsStatus = (0, import_vue24.shallowRef)(null);
+  let sendGeneration = 0;
+  let statusGeneration = 0;
   let disposed = false;
-  const switchChain = async (targetChainId) => {
-    const invoke = (0, import_vue7.unref)(action);
-    const mine = ++generation;
-    active++;
-    isSwitching.value = true;
+  const sendCalls = async (calls, input) => {
+    const invoke = (0, import_vue24.unref)(options.sendCalls);
+    const own = ++sendGeneration;
+    status.value = "awaiting_approval";
     error.value = null;
+    batchHash.value = null;
     try {
-      await invoke(targetChainId);
+      const hash = await invoke(calls, input);
+      if (!disposed && own === sendGeneration) {
+        status.value = "submitted";
+        batchHash.value = hash;
+      }
+      return hash;
     } catch (cause) {
-      const walletError = (0, import_connect_appkit_core2.toChainSwitchError)(cause);
-      if (!disposed && mine === generation) error.value = walletError;
-      throw walletError;
-    } finally {
-      active--;
-      if (!disposed) isSwitching.value = active > 0;
+      const normalized = cause instanceof Error ? cause : new Error("sendCalls failed");
+      if (!disposed && own === sendGeneration) {
+        status.value = "failed";
+        error.value = normalized;
+      }
+      throw normalized;
     }
   };
-  (0, import_vue7.onScopeDispose)(() => {
+  const getCallsStatus = async (hash) => {
+    const invoke = (0, import_vue24.unref)(options.getCallsStatus);
+    const own = ++statusGeneration;
+    const result = await invoke(hash);
+    if (!disposed && own === statusGeneration) callsStatus.value = result;
+    return result;
+  };
+  const showCallsStatus = (hash) => (0, import_vue24.unref)(options.showCallsStatus)(hash);
+  const reset = () => {
+    sendGeneration++;
+    statusGeneration++;
+    status.value = "idle";
+    error.value = null;
+    batchHash.value = null;
+    callsStatus.value = null;
+  };
+  (0, import_vue24.onScopeDispose)(() => {
     disposed = true;
-    generation++;
+    sendGeneration++;
+    statusGeneration++;
   });
   return {
-    switchChain,
-    isSwitching,
-    currentChainId: (0, import_vue7.computed)(() => (0, import_vue7.toValue)(chainId) ?? null),
+    sendCalls,
+    getCallsStatus,
+    showCallsStatus,
+    status,
     error,
-    clearError: () => {
-      error.value = null;
-    }
+    batchHash,
+    callsStatus,
+    execution: (0, import_vue24.computed)(() => (0, import_vue24.toValue)(options.execution) ?? null),
+    isSending: (0, import_vue24.computed)(() => status.value === "awaiting_approval"),
+    reset
+  };
+}
+
+// src/useEmbeddedWallet.ts
+var import_vue25 = require("vue");
+function useEmbeddedWallet(options) {
+  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));
+  return {
+    wallet,
+    hasWallet: (0, import_vue25.computed)(() => wallet.value !== null),
+    address: (0, import_vue25.computed)(() => wallet.value?.address ?? null),
+    accounts: (0, import_vue25.computed)(() => wallet.value?.accounts ?? []),
+    activeNamespace: (0, import_vue25.computed)(() => wallet.value?.activeNamespace ?? null),
+    backupPending: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.backupPending)),
+    storageSecurityLevel: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.storageSecurityLevel)),
+    securityReport: (0, import_vue25.computed)(() => (0, import_vue25.toValue)(options.securityReport)),
+    connectEmbedded: () => run(() => (0, import_vue25.unref)(options.connectEmbedded)()),
+    restoreWallet: () => run(() => (0, import_vue25.unref)(options.restoreWallet)()),
+    generateWallet: () => run(() => (0, import_vue25.unref)(options.generateWallet)()),
+    importFromMnemonic: (value) => run(() => (0, import_vue25.unref)(options.importFromMnemonic)(value)),
+    importFromPrivateKey: (value) => run(() => (0, import_vue25.unref)(options.importFromPrivateKey)(value)),
+    wipe: () => run(() => (0, import_vue25.unref)(options.wipe)()),
+    setActiveNamespace: (value) => (0, import_vue25.unref)(options.setActiveNamespace)(value),
+    backfillAccounts: () => run(() => (0, import_vue25.unref)(options.backfillAccounts)()),
+    getSeedPhrase: () => (0, import_vue25.unref)(options.getSeedPhrase)(),
+    getPrivateKey: () => (0, import_vue25.unref)(options.getPrivateKey)(),
+    confirmBackup: () => (0, import_vue25.unref)(options.confirmBackup)(),
+    isBusy: guard.busy,
+    error: guard.error,
+    clearError: guard.clearError
+  };
+}
+
+// src/useSIWxLogin.ts
+function useSIWxLogin(action) {
+  const state = useSignInWithX(action);
+  return {
+    signIn: state.signIn,
+    isSigningIn: state.isSigningIn,
+    error: state.error,
+    clearError: state.clearError
+  };
+}
+
+// src/useSIWxSession.ts
+var import_vue26 = require("vue");
+function useSIWxSession(options) {
+  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: 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) => guard.run(() => (0, import_vue26.unref)(options.signIn)(input), "SIWX sign-in failed"),
+    signOut: async () => {
+      await (0, import_vue26.unref)(options.signOut)();
+      guard.clearError();
+    },
+    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 guard = useActionGuard();
+  const signIn = (input) => guard.run(() => (0, import_vue27.unref)(options.signIn)(input), "SIWX sign-in failed");
+  const signOut = async () => {
+    guard.reset();
+    await (0, import_vue27.unref)(options.signOut)();
+    guard.clearError();
+  };
+  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: guard.busy,
+    error: guard.error,
+    signIn,
+    signOut,
+    clearError: guard.clearError
   };
 }
 
 // src/useBalance.ts
-var import_connect_appkit_core3 = require("@naculus/connect-appkit-core");
-var import_connect_core4 = require("@naculus/connect-core");
-var import_vue8 = require("vue");
+var import_connect_appkit_core14 = require("@naculus/connect-appkit-core");
+var import_connect_core11 = require("@naculus/connect-core");
+var import_vue28 = require("vue");
 function useBalance(account, client, options = {}) {
-  const balance = (0, import_vue8.shallowRef)(null);
-  const isFetching = (0, import_vue8.shallowRef)(false);
-  const error = (0, import_vue8.shallowRef)(null);
+  const balance = (0, import_vue28.shallowRef)(null);
+  const isFetching = (0, import_vue28.shallowRef)(false);
+  const error = (0, import_vue28.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
   const refetch = async () => {
-    const reader = (0, import_vue8.toValue)(client);
-    const address = (0, import_connect_appkit_core3.bareEvmAddress)((0, import_vue8.toValue)(account));
+    const reader = (0, import_vue28.toValue)(client);
+    const address = (0, import_connect_appkit_core14.bareEvmAddress)((0, import_vue28.toValue)(account));
     const own = ++generation;
     if (!reader || !address) {
       balance.value = null;
@@ -570,11 +1973,11 @@ function useBalance(account, client, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  (0, import_vue8.watch)(
+  (0, import_vue28.watch)(
     [
-      () => (0, import_vue8.toValue)(account),
-      () => (0, import_vue8.toValue)(client),
-      () => (0, import_vue8.toValue)(options.refreshInterval) ?? 0
+      () => (0, import_vue28.toValue)(account),
+      () => (0, import_vue28.toValue)(client),
+      () => (0, import_vue28.toValue)(options.refreshInterval) ?? 0
     ],
     ([, , interval]) => {
       stopTimer();
@@ -583,17 +1986,17 @@ function useBalance(account, client, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue8.onScopeDispose)(() => {
+  (0, import_vue28.onScopeDispose)(() => {
     disposed = true;
     generation++;
     stopTimer();
   });
   return {
     balance,
-    formatted: (0, import_vue8.computed)(
-      () => balance.value === null ? null : (0, import_connect_core4.formatUnits)(BigInt(balance.value), (0, import_vue8.toValue)(options.decimals) ?? 18)
+    formatted: (0, import_vue28.computed)(
+      () => balance.value === null ? null : (0, import_connect_core11.formatUnits)(BigInt(balance.value), (0, import_vue28.toValue)(options.decimals) ?? 18)
     ),
-    symbol: (0, import_vue8.computed)(() => (0, import_vue8.toValue)(options.symbol) ?? null),
+    symbol: (0, import_vue28.computed)(() => (0, import_vue28.toValue)(options.symbol) ?? null),
     isFetching,
     error,
     refetch
@@ -601,12 +2004,12 @@ function useBalance(account, client, options = {}) {
 }
 
 // src/useRouteQuote.ts
-var import_connect_appkit_core4 = require("@naculus/connect-appkit-core");
-var import_vue9 = require("vue");
+var import_connect_appkit_core15 = require("@naculus/connect-appkit-core");
+var import_vue29 = require("vue");
 function useRouteQuote(input, getQuotes, options = {}) {
-  const quotes = (0, import_vue9.shallowRef)([]);
-  const loading = (0, import_vue9.shallowRef)(false);
-  const error = (0, import_vue9.shallowRef)(null);
+  const quotes = (0, import_vue29.shallowRef)([]);
+  const loading = (0, import_vue29.shallowRef)(false);
+  const error = (0, import_vue29.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
@@ -615,10 +2018,10 @@ function useRouteQuote(input, getQuotes, options = {}) {
     timer = null;
   };
   const fetchQuotes = async () => {
-    const current = (0, import_vue9.toValue)(input);
-    const fn = (0, import_vue9.unref)(getQuotes);
+    const current = (0, import_vue29.toValue)(input);
+    const fn = (0, import_vue29.unref)(getQuotes);
     const own = ++generation;
-    if (!(0, import_connect_appkit_core4.isQuotableInput)(current)) {
+    if (!(0, import_connect_appkit_core15.isQuotableInput)(current)) {
       quotes.value = [];
       return;
     }
@@ -644,14 +2047,14 @@ function useRouteQuote(input, getQuotes, options = {}) {
       if (!disposed && own === generation) loading.value = false;
     }
   };
-  (0, import_vue9.watch)(
+  (0, import_vue29.watch)(
     [
-      () => (0, import_vue9.toValue)(input).fromChain,
-      () => (0, import_vue9.toValue)(input).toChain,
-      () => (0, import_vue9.toValue)(input).fromToken,
-      () => (0, import_vue9.toValue)(input).toToken,
-      () => (0, import_vue9.toValue)(input).amount,
-      () => (0, import_vue9.unref)(getQuotes)
+      () => (0, import_vue29.toValue)(input).fromChain,
+      () => (0, import_vue29.toValue)(input).toChain,
+      () => (0, import_vue29.toValue)(input).fromToken,
+      () => (0, import_vue29.toValue)(input).toToken,
+      () => (0, import_vue29.toValue)(input).amount,
+      () => (0, import_vue29.unref)(getQuotes)
     ],
     ([fromChain, toChain, fromToken, , amount]) => {
       clearTimer();
@@ -666,7 +2069,7 @@ function useRouteQuote(input, getQuotes, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue9.onScopeDispose)(() => {
+  (0, import_vue29.onScopeDispose)(() => {
     disposed = true;
     generation++;
     clearTimer();
@@ -687,17 +2090,17 @@ function useRouteQuote(input, getQuotes, options = {}) {
 }
 
 // src/useCompareCosts.ts
-var import_connect_appkit_core5 = require("@naculus/connect-appkit-core");
-var import_vue10 = require("vue");
+var import_connect_appkit_core16 = require("@naculus/connect-appkit-core");
+var import_vue30 = require("vue");
 function useCompareCosts(input, compareCosts) {
-  const comparisons = (0, import_vue10.shallowRef)([]);
-  const loading = (0, import_vue10.shallowRef)(false);
-  const error = (0, import_vue10.shallowRef)(null);
+  const comparisons = (0, import_vue30.shallowRef)([]);
+  const loading = (0, import_vue30.shallowRef)(false);
+  const error = (0, import_vue30.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const fetchComparisons = async () => {
-    const { operation, chains, options } = (0, import_vue10.toValue)(input);
-    const fn = (0, import_vue10.unref)(compareCosts);
+    const { operation, chains, options } = (0, import_vue30.toValue)(input);
+    const fn = (0, import_vue30.unref)(compareCosts);
     const own = ++generation;
     if (!chains || chains.length === 0) {
       comparisons.value = [];
@@ -718,14 +2121,14 @@ function useCompareCosts(input, compareCosts) {
       if (!disposed && own === generation) loading.value = false;
     }
   };
-  (0, import_vue10.watch)(
-    [() => (0, import_connect_appkit_core5.compareCostsKey)((0, import_vue10.toValue)(input)), () => (0, import_vue10.unref)(compareCosts)],
+  (0, import_vue30.watch)(
+    [() => (0, import_connect_appkit_core16.compareCostsKey)((0, import_vue30.toValue)(input)), () => (0, import_vue30.unref)(compareCosts)],
     () => {
       void fetchComparisons();
     },
     { immediate: true }
   );
-  (0, import_vue10.onScopeDispose)(() => {
+  (0, import_vue30.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -733,16 +2136,16 @@ function useCompareCosts(input, compareCosts) {
 }
 
 // src/useExecuteRoute.ts
-var import_connect_appkit_core6 = require("@naculus/connect-appkit-core");
-var import_vue11 = require("vue");
+var import_connect_appkit_core17 = require("@naculus/connect-appkit-core");
+var import_vue31 = require("vue");
 function useExecuteRoute(executeRoute) {
-  const executing = (0, import_vue11.shallowRef)(false);
-  const result = (0, import_vue11.shallowRef)(null);
-  const error = (0, import_vue11.shallowRef)(null);
+  const executing = (0, import_vue31.shallowRef)(false);
+  const result = (0, import_vue31.shallowRef)(null);
+  const error = (0, import_vue31.shallowRef)(null);
   let inFlight = false;
   let disposed = false;
   const execute = async (quote, recipient, options) => {
-    const fn = (0, import_vue11.unref)(executeRoute);
+    const fn = (0, import_vue31.unref)(executeRoute);
     if (!fn) {
       error.value = {
         code: "no_executor",
@@ -751,7 +2154,7 @@ function useExecuteRoute(executeRoute) {
       result.value = null;
       return null;
     }
-    const recipientError = (0, import_connect_appkit_core6.validateRouteRecipient)(quote, recipient);
+    const recipientError = (0, import_connect_appkit_core17.validateRouteRecipient)(quote, recipient);
     if (recipientError) {
       error.value = recipientError;
       result.value = null;
@@ -773,14 +2176,14 @@ function useExecuteRoute(executeRoute) {
       if (!disposed) result.value = execResult;
       return execResult;
     } catch (cause) {
-      if (!disposed) error.value = (0, import_connect_appkit_core6.toExecuteRouteError)(cause);
+      if (!disposed) error.value = (0, import_connect_appkit_core17.toExecuteRouteError)(cause);
       return null;
     } finally {
       inFlight = false;
       if (!disposed) executing.value = false;
     }
   };
-  (0, import_vue11.onScopeDispose)(() => {
+  (0, import_vue31.onScopeDispose)(() => {
     disposed = true;
   });
   return {
@@ -797,22 +2200,22 @@ function useExecuteRoute(executeRoute) {
 }
 
 // src/useTokenList.ts
-var import_connect_appkit_core7 = require("@naculus/connect-appkit-core");
-var import_connect_core5 = require("@naculus/connect-core");
-var import_vue12 = require("vue");
+var import_connect_appkit_core18 = require("@naculus/connect-appkit-core");
+var import_connect_core12 = require("@naculus/connect-core");
+var import_vue32 = require("vue");
 function useTokenList(chainId, options = {}) {
   const config = {};
   if (options.sources) config.sources = options.sources;
-  const manager = options.manager ?? new import_connect_core5.TokenListManager(config);
-  const tokens = (0, import_vue12.shallowRef)([]);
-  const isLoading = (0, import_vue12.shallowRef)(options.autoLoad !== false);
-  const isLoaded = (0, import_vue12.shallowRef)(false);
-  const error = (0, import_vue12.shallowRef)(null);
+  const manager = options.manager ?? new import_connect_core12.TokenListManager(config);
+  const tokens = (0, import_vue32.shallowRef)([]);
+  const isLoading = (0, import_vue32.shallowRef)(options.autoLoad !== false);
+  const isLoaded = (0, import_vue32.shallowRef)(false);
+  const error = (0, import_vue32.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const select = () => {
-    const id = (0, import_vue12.toValue)(chainId);
-    const numeric = id ? (0, import_connect_appkit_core7.eip155ChainIdToNumber)(id) : void 0;
+    const id = (0, import_vue32.toValue)(chainId);
+    const numeric = id ? (0, import_connect_appkit_core18.eip155ChainIdToNumber)(id) : void 0;
     return manager.getTokens(
       numeric !== void 0 ? { chainId: numeric } : void 0
     );
@@ -833,14 +2236,14 @@ function useTokenList(chainId, options = {}) {
       if (!disposed && own === generation) isLoading.value = false;
     }
   };
-  (0, import_vue12.watch)(
-    () => (0, import_vue12.toValue)(chainId),
+  (0, import_vue32.watch)(
+    () => (0, import_vue32.toValue)(chainId),
     () => {
       if (options.autoLoad !== false) void run(() => manager.load());
     },
     { immediate: true }
   );
-  (0, import_vue12.onScopeDispose)(() => {
+  (0, import_vue32.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
@@ -854,30 +2257,30 @@ function useTokenList(chainId, options = {}) {
 }
 
 // src/useTokenSearch.ts
-var import_connect_appkit_core8 = require("@naculus/connect-appkit-core");
-var import_connect_core6 = require("@naculus/connect-core");
-var import_vue13 = require("vue");
+var import_connect_appkit_core19 = require("@naculus/connect-appkit-core");
+var import_connect_core13 = require("@naculus/connect-core");
+var import_vue33 = require("vue");
 var DEBOUNCE_MS = 300;
 var EMPTY = { exact: [], fuzzy: [], hasMore: false };
 var sharedManager = null;
 function getSharedManager() {
   if (!sharedManager) {
-    sharedManager = new import_connect_core6.TokenListManager();
+    sharedManager = new import_connect_core13.TokenListManager();
     sharedManager.load().catch(() => {
     });
   }
   return sharedManager;
 }
 function useTokenSearch(query, chainId, options = {}) {
-  const results = (0, import_vue13.shallowRef)(EMPTY);
-  const isSearching = (0, import_vue13.shallowRef)(false);
+  const results = (0, import_vue33.shallowRef)(EMPTY);
+  const isSearching = (0, import_vue33.shallowRef)(false);
   let timer = null;
   const clear = () => {
     if (timer) clearTimeout(timer);
     timer = null;
   };
-  (0, import_vue13.watch)(
-    [() => ((0, import_vue13.toValue)(query) ?? "").trim(), () => (0, import_vue13.toValue)(chainId)],
+  (0, import_vue33.watch)(
+    [() => ((0, import_vue33.toValue)(query) ?? "").trim(), () => (0, import_vue33.toValue)(chainId)],
     ([q, id]) => {
       clear();
       if (!q) {
@@ -889,7 +2292,7 @@ function useTokenSearch(query, chainId, options = {}) {
       timer = setTimeout(() => {
         timer = null;
         const manager = options.manager ?? getSharedManager();
-        const numeric = id ? (0, import_connect_appkit_core8.eip155ChainIdToNumber)(id) : void 0;
+        const numeric = id ? (0, import_connect_appkit_core19.eip155ChainIdToNumber)(id) : void 0;
         results.value = manager.search(q, {
           chainId: numeric,
           limit: options.limit ?? 20
@@ -899,37 +2302,37 @@ function useTokenSearch(query, chainId, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue13.onScopeDispose)(clear);
+  (0, import_vue33.onScopeDispose)(clear);
   return { results, isSearching };
 }
 
 // src/useValidateDestination.ts
-var import_connect_appkit_core9 = require("@naculus/connect-appkit-core");
-var import_vue14 = require("vue");
+var import_connect_appkit_core20 = require("@naculus/connect-appkit-core");
+var import_vue34 = require("vue");
 function useValidateDestination(address) {
   return {
-    validation: (0, import_vue14.computed)(() => (0, import_connect_appkit_core9.validateDestination)((0, import_vue14.toValue)(address) ?? ""))
+    validation: (0, import_vue34.computed)(() => (0, import_connect_appkit_core20.validateDestination)((0, import_vue34.toValue)(address) ?? ""))
   };
 }
 
 // src/useTokenBalance.ts
-var import_connect_appkit_core10 = require("@naculus/connect-appkit-core");
-var import_connect_core7 = require("@naculus/connect-core");
-var import_vue15 = require("vue");
+var import_connect_appkit_core21 = require("@naculus/connect-appkit-core");
+var import_connect_core14 = require("@naculus/connect-core");
+var import_vue35 = require("vue");
 function tokensKey(tokens) {
   return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
 }
 function useTokenBalance(account, client, tokens, options = {}) {
-  const tokenBalances = (0, import_vue15.shallowRef)([]);
-  const isFetching = (0, import_vue15.shallowRef)(false);
-  const error = (0, import_vue15.shallowRef)(null);
+  const tokenBalances = (0, import_vue35.shallowRef)([]);
+  const isFetching = (0, import_vue35.shallowRef)(false);
+  const error = (0, import_vue35.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   let timer = null;
   const refetch = async () => {
-    const reader = (0, import_vue15.toValue)(client);
-    const address = (0, import_connect_appkit_core10.bareEvmAddress)((0, import_vue15.toValue)(account));
-    const list = (0, import_vue15.toValue)(tokens) ?? [];
+    const reader = (0, import_vue35.toValue)(client);
+    const address = (0, import_connect_appkit_core21.bareEvmAddress)((0, import_vue35.toValue)(account));
+    const list = (0, import_vue35.toValue)(tokens) ?? [];
     const own = ++generation;
     if (!reader || !address || list.length === 0) {
       tokenBalances.value = [];
@@ -945,7 +2348,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
           try {
             const raw = await reader.readContract({
               address: token.address,
-              abi: import_connect_core7.ERC20_MIN_ABI,
+              abi: import_connect_core14.ERC20_MIN_ABI,
               functionName: "balanceOf",
               args: [address]
             });
@@ -953,7 +2356,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
             return {
               ...token,
               balance: value.toString(),
-              formatted: (0, import_connect_core7.formatUnits)(value, token.decimals)
+              formatted: (0, import_connect_core14.formatUnits)(value, token.decimals)
             };
           } catch {
             return { ...token, balance: null, formatted: null };
@@ -974,12 +2377,12 @@ function useTokenBalance(account, client, tokens, options = {}) {
     if (timer) clearInterval(timer);
     timer = null;
   };
-  (0, import_vue15.watch)(
+  (0, import_vue35.watch)(
     [
-      () => (0, import_vue15.toValue)(account),
-      () => (0, import_vue15.toValue)(client),
-      () => tokensKey((0, import_vue15.toValue)(tokens) ?? []),
-      () => (0, import_vue15.toValue)(options.refreshInterval) ?? 0
+      () => (0, import_vue35.toValue)(account),
+      () => (0, import_vue35.toValue)(client),
+      () => tokensKey((0, import_vue35.toValue)(tokens) ?? []),
+      () => (0, import_vue35.toValue)(options.refreshInterval) ?? 0
     ],
     ([, , , interval]) => {
       stopTimer();
@@ -988,7 +2391,7 @@ function useTokenBalance(account, client, tokens, options = {}) {
     },
     { immediate: true }
   );
-  (0, import_vue15.onScopeDispose)(() => {
+  (0, import_vue35.onScopeDispose)(() => {
     disposed = true;
     generation++;
     stopTimer();
@@ -1004,21 +2407,113 @@ function useTokenBalance(account, client, tokens, options = {}) {
   };
 }
 
+// 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 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_core11 = require("@naculus/connect-appkit-core");
-var import_connect_core8 = require("@naculus/connect-core");
-var import_vue16 = require("vue");
+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_vue16.shallowRef)(import_connect_core8.UNKNOWN_DELEGATION);
-  const isFetching = (0, import_vue16.shallowRef)(false);
-  const error = (0, import_vue16.shallowRef)(null);
+  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_vue16.toValue)(client);
-    const address = (0, import_connect_appkit_core11.bareEvmAddress)((0, import_vue16.toValue)(account));
-    status.value = import_connect_core8.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;
@@ -1028,31 +2523,31 @@ function useDelegation(account, client, chainId) {
     try {
       const code = await reader.getCode({ address });
       if (!disposed && mine === generation) {
-        status.value = (0, import_connect_core8.readDelegation)(code ?? "0x");
+        status.value = (0, import_connect_core16.readDelegation)(code ?? "0x");
       }
     } catch (cause) {
       if (!disposed && mine === generation) {
-        status.value = import_connect_core8.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_vue16.watch)(
-    () => [(0, import_vue16.toValue)(account), (0, import_vue16.toValue)(client), (0, import_vue16.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_vue16.onScopeDispose)(() => {
+  (0, import_vue37.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
   return {
-    delegated: (0, import_vue16.computed)(() => status.value.delegated),
-    delegate: (0, import_vue16.computed)(() => status.value.delegate),
+    delegated: (0, import_vue37.computed)(() => status.value.delegated),
+    delegate: (0, import_vue37.computed)(() => status.value.delegate),
     isFetching,
     error,
     refetch
@@ -1060,19 +2555,19 @@ function useDelegation(account, client, chainId) {
 }
 
 // src/name-lookup.ts
-var import_connect_appkit_core12 = require("@naculus/connect-appkit-core");
-var import_vue17 = require("vue");
+var import_connect_appkit_core24 = require("@naculus/connect-appkit-core");
+var import_vue38 = require("vue");
 function useNameLookup(options) {
-  const data = (0, import_vue17.shallowRef)(null);
-  const loading = (0, import_vue17.shallowRef)(false);
-  const error = (0, import_vue17.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_vue17.toValue)(options.input).trim();
-    const skip = (0, import_vue17.toValue)(options.skip) ?? false;
-    const scope = (0, import_vue17.toValue)(options.scope);
-    const config = (0, import_vue17.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;
@@ -1083,7 +2578,7 @@ function useNameLookup(options) {
     data.value = null;
     loading.value = true;
     error.value = null;
-    Promise.resolve().then(() => options.query((0, import_connect_appkit_core12.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;
@@ -1094,23 +2589,23 @@ function useNameLookup(options) {
       loading.value = false;
     });
   };
-  (0, import_vue17.watch)(
+  (0, import_vue38.watch)(
     () => [
-      (0, import_vue17.toValue)(options.input),
-      (0, import_vue17.toValue)(options.skip),
-      (0, import_vue17.toValue)(options.scope),
-      (0, import_vue17.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_vue17.onScopeDispose)(() => {
+  (0, import_vue38.onScopeDispose)(() => {
     disposed = true;
     generation++;
   });
   return {
     data,
-    isLoading: (0, import_vue17.computed)(() => loading.value),
+    isLoading: (0, import_vue38.computed)(() => loading.value),
     error,
     refetch: run
   };
@@ -1138,21 +2633,21 @@ function useLookupAddress(address, options) {
 }
 
 // src/useSolanaAccount.ts
-var import_vue18 = require("vue");
+var import_vue39 = require("vue");
 function useSolanaAccount(accounts, connected) {
-  const isConnected = (0, import_vue18.computed)(() => (0, import_vue18.toValue)(connected));
-  const caip10 = (0, import_vue18.computed)(
-    () => isConnected.value ? ((0, import_vue18.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_vue18.computed)(() => caip10.value?.split(":") ?? []);
+  const parts = (0, import_vue39.computed)(() => caip10.value?.split(":") ?? []);
   return {
-    address: (0, import_vue18.computed)(
+    address: (0, import_vue39.computed)(
       () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
     ),
     caip10,
-    chainId: (0, import_vue18.computed)(
+    chainId: (0, import_vue39.computed)(
       () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
     ),
     isConnected
@@ -1160,35 +2655,35 @@ function useSolanaAccount(accounts, connected) {
 }
 
 // src/useChain.ts
-var import_connect_appkit_core13 = require("@naculus/connect-appkit-core");
-var import_vue19 = 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_vue19.computed)(() => (0, import_vue19.toValue)(chains) ?? []);
-  const id = (0, import_vue19.computed)(() => (0, import_vue19.toValue)(chainId) ?? null);
-  const currentChain = (0, import_vue19.computed)(() => (0, import_connect_appkit_core13.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_vue19.computed)(() => (0, import_connect_appkit_core13.describeChain)(list.value, id.value)),
-    availableChains: (0, import_vue19.computed)(() => (0, import_connect_appkit_core13.chainsForNamespace)(list.value, id.value)),
-    currentChainNumber: (0, import_vue19.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core13.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_vue19.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core13.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_vue20 = require("vue");
+var import_vue41 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue20.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue41.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue20.onScopeDispose)(unsubscribe);
+  (0, import_vue41.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue20.readonly)(request),
+    request: (0, import_vue41.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -1196,17 +2691,17 @@ function usePassphraseGate(gate) {
 }
 
 // src/useSolanaBalance.ts
-var import_connect_core9 = require("@naculus/connect-core");
-var import_vue21 = require("vue");
+var import_connect_core17 = require("@naculus/connect-core");
+var import_vue42 = require("vue");
 function useSolanaBalance(address, rpcUrl) {
-  const balance = (0, import_vue21.shallowRef)(null);
-  const isFetching = (0, import_vue21.ref)(false);
-  const error = (0, import_vue21.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_vue21.toValue)(address);
-    const url = (0, import_vue21.toValue)(rpcUrl);
+    const addr = (0, import_vue42.toValue)(address);
+    const url = (0, import_vue42.toValue)(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -1215,7 +2710,7 @@ function useSolanaBalance(address, rpcUrl) {
     isFetching.value = true;
     error.value = null;
     try {
-      const next = await (0, import_connect_core9.getSolanaBalance)(url, addr);
+      const next = await (0, import_connect_core17.getSolanaBalance)(url, addr);
       if (disposed || own !== generation) return;
       balance.value = next;
     } catch (err) {
@@ -1226,25 +2721,25 @@ function useSolanaBalance(address, rpcUrl) {
       if (!disposed && own === generation) isFetching.value = false;
     }
   };
-  (0, import_vue21.watchEffect)(() => {
-    (0, import_vue21.toValue)(address);
-    (0, import_vue21.toValue)(rpcUrl);
+  (0, import_vue42.watchEffect)(() => {
+    (0, import_vue42.toValue)(address);
+    (0, import_vue42.toValue)(rpcUrl);
     void refetch();
   });
-  (0, import_vue21.onScopeDispose)(() => {
+  (0, import_vue42.onScopeDispose)(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
 
 // src/useLastTx.ts
-var import_vue22 = require("vue");
+var import_vue43 = require("vue");
 function useLastTx(monitor) {
-  const lastTx = (0, import_vue22.shallowRef)(null);
-  const lastConfirmedTx = (0, import_vue22.shallowRef)(null);
-  const lastFailedTx = (0, import_vue22.shallowRef)(null);
-  (0, import_vue22.watch)(
-    () => (0, import_vue22.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) => {
@@ -1282,15 +2777,15 @@ function useLastTx(monitor) {
 }
 
 // src/useTxHistory.ts
-var import_vue23 = require("vue");
+var import_vue44 = require("vue");
 function useTxHistory(address, chainId, monitor) {
-  const entries = (0, import_vue23.shallowRef)([]);
-  const isLoading = (0, import_vue23.shallowRef)(false);
-  const error = (0, import_vue23.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_vue23.toValue)(monitor);
+    const activeMonitor = (0, import_vue44.toValue)(monitor);
     if (!activeMonitor) {
       entries.value = [];
       isLoading.value = false;
@@ -1301,8 +2796,8 @@ function useTxHistory(address, chainId, monitor) {
     error.value = null;
     try {
       const result = await activeMonitor.getTxHistory(
-        (0, import_vue23.toValue)(address) ?? void 0,
-        (0, import_vue23.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) {
@@ -1312,8 +2807,8 @@ function useTxHistory(address, chainId, monitor) {
       if (mine === generation) isLoading.value = false;
     }
   };
-  (0, import_vue23.watch)(
-    () => [(0, import_vue23.toValue)(monitor), (0, import_vue23.toValue)(address), (0, import_vue23.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();
@@ -1333,7 +2828,7 @@ function useTxHistory(address, chainId, monitor) {
     isLoading,
     error,
     refresh,
-    summary: (0, import_vue23.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
@@ -1342,17 +2837,17 @@ function useTxHistory(address, chainId, monitor) {
 }
 
 // src/useTxMonitor.ts
-var import_vue24 = require("vue");
+var import_vue45 = require("vue");
 function useTxMonitor(hash, chainId, monitor) {
-  const entry = (0, import_vue24.shallowRef)(null);
-  const isLoading = (0, import_vue24.shallowRef)(false);
-  const isWatching = (0, import_vue24.shallowRef)(false);
-  const error = (0, import_vue24.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_vue24.toValue)(monitor);
-    const activeHash = (0, import_vue24.toValue)(hash);
-    const activeChainId = (0, import_vue24.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;
@@ -1370,15 +2865,15 @@ function useTxMonitor(hash, chainId, monitor) {
     }
   };
   const stopWatching = () => {
-    const activeMonitor = (0, import_vue24.toValue)(monitor);
-    const activeHash = (0, import_vue24.toValue)(hash);
-    const activeChainId = (0, import_vue24.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_vue24.watch)(
-    () => [(0, import_vue24.toValue)(monitor), (0, import_vue24.toValue)(hash), (0, import_vue24.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) {
@@ -1418,7 +2913,7 @@ function useTxMonitor(hash, chainId, monitor) {
   );
   return {
     entry,
-    status: (0, import_vue24.computed)(() => entry.value?.status ?? "idle"),
+    status: (0, import_vue45.computed)(() => entry.value?.status ?? "idle"),
     isLoading,
     isWatching,
     error,
@@ -1428,19 +2923,19 @@ function useTxMonitor(hash, chainId, monitor) {
 }
 
 // src/useCapabilities.ts
-var import_connect_appkit_core14 = require("@naculus/connect-appkit-core");
-var import_vue25 = 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_vue25.shallowRef)(
+  const capabilities = (0, import_vue46.shallowRef)(
     null
   );
-  const isFetching = (0, import_vue25.shallowRef)(false);
-  const error = (0, import_vue25.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_vue25.toValue)(client);
-    const activeSession = (0, import_vue25.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;
@@ -1452,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_core14.normalizeCapabilities)(raw);
+      capabilities.value = (0, import_connect_appkit_core26.normalizeCapabilities)(raw);
     } catch (err) {
       if (mine !== generation) return;
       capabilities.value = null;
@@ -1461,18 +2956,18 @@ function useCapabilities(client, session, chainId) {
       if (mine === generation) isFetching.value = false;
     }
   };
-  (0, import_vue25.watchEffect)(() => {
-    void (0, import_vue25.toValue)(client);
-    void (0, import_vue25.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_vue25.computed)(
-      () => (0, import_connect_appkit_core14.selectChainCapabilities)(capabilities.value, (0, import_vue25.toValue)(chainId))
+    current: (0, import_vue46.computed)(
+      () => (0, import_connect_appkit_core26.selectChainCapabilities)(capabilities.value, (0, import_vue46.toValue)(chainId))
     ),
-    atomic: (0, import_vue25.computed)(
-      () => (0, import_connect_appkit_core14.atomicSupportFor)(capabilities.value, (0, import_vue25.toValue)(chainId))
+    atomic: (0, import_vue46.computed)(
+      () => (0, import_connect_appkit_core26.atomicSupportFor)(capabilities.value, (0, import_vue46.toValue)(chainId))
     ),
     isFetching,
     error,
@@ -1481,18 +2976,18 @@ function useCapabilities(client, session, chainId) {
 }
 
 // src/useSolanaRoles.ts
-var import_connect_appkit_core15 = require("@naculus/connect-appkit-core");
-var import_vue26 = 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_vue26.computed)(
-    () => (0, import_connect_appkit_core15.readSolanaRoles)((0, import_vue26.toValue)(connector), (0, import_vue26.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_vue26.computed)(() => state.value.roles),
-    absence: (0, import_vue26.computed)(() => state.value.absence),
-    identity: (0, import_vue26.computed)(() => state.value.roles?.identity ?? null),
-    signer: (0, import_vue26.computed)(() => state.value.roles?.signer ?? null),
-    payer: (0, import_vue26.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:
@@ -1532,25 +3027,50 @@ function useSolanaRoles(connector, session) {
   useChain,
   useCompareCosts,
   useConnect,
+  useCreateSessionKey,
+  useDelegate,
   useDelegation,
+  useDelegationPolicy,
   useDisconnect,
+  useERC20Approve,
+  useERC20Transfer,
+  useERC20TransferSimulation,
+  useEmbeddedWallet,
+  useExecuteCalls,
   useExecuteRoute,
   useLastTx,
   useLookupAddress,
   useNotification,
   usePassphraseGate,
   useResolveName,
+  useRevokeSession,
   useRouteQuote,
+  useSIWxLogin,
+  useSIWxSession,
+  useSendCalls,
+  useSendTransaction,
+  useSendUserOperation,
+  useSendWithSession,
   useSession,
+  useSessionKeys,
+  useSignInWithEthereum,
+  useSignInWithX,
+  useSignMessage,
+  useSimulateTransfer,
+  useSiwxAuthSession,
+  useSmartAccount,
   useSolanaAccount,
   useSolanaBalance,
   useSolanaRoles,
+  useSolanaTransaction,
   useSwitchChain,
   useTokenBalance,
   useTokenList,
   useTokenSearch,
+  useTransactionSimulation,
   useTxHistory,
   useTxMonitor,
+  useUserOpStatus,
   useValidateDestination
 });
 //# sourceMappingURL=index.cjs.map