@naculus/connect-appkit-vue 0.2.4 → 0.2.6

package/dist/index.js

@@ -209,40 +209,2536 @@ function useAccounts(accounts) {
   };
 }
 
+// src/useNotification.ts
+import {
+  addInAppNotification,
+  channelsUpdate,
+  clearOneInAppNotification,
+  createNotificationSettingsStorage,
+  DEFAULT_NOTIFICATION_SETTINGS,
+  loadNotificationSettings,
+  mutedChainSettings,
+  saveNotificationSettings,
+  updateNotificationSettings
+} from "@naculus/connect-appkit-core";
+import {
+  InAppChannel
+} from "@naculus/connect-core";
+import { computed as computed2, onScopeDispose, shallowRef, unref } from "vue";
+function useNotification(options = {}) {
+  const channel = unref(options.channel) ?? new InAppChannel();
+  const storage = unref(options.storage) ?? createNotificationSettingsStorage();
+  const notifications = shallowRef(channel.getHistory());
+  const settings = shallowRef(
+    DEFAULT_NOTIFICATION_SETTINGS
+  );
+  const unreadCount = computed2(
+    () => notifications.value.filter((item) => !item.read).length
+  );
+  let disposed = false;
+  void loadNotificationSettings(storage).then((saved) => {
+    if (!disposed && saved) settings.value = saved;
+  });
+  channel.onNotification = (item) => {
+    if (!disposed) notifications.value = [...notifications.value, item];
+  };
+  void channel.restore().then(() => {
+    if (!disposed) notifications.value = channel.getHistory();
+  });
+  onScopeDispose(() => {
+    disposed = true;
+    channel.onNotification = void 0;
+  });
+  const updateSettings = (update) => {
+    settings.value = updateNotificationSettings(settings.value, update);
+    saveNotificationSettings(storage, settings.value);
+  };
+  return {
+    notifications,
+    unreadCount,
+    settings,
+    addNotification: (item) => addInAppNotification(channel, item),
+    clear: () => {
+      channel.clear();
+      notifications.value = [];
+    },
+    clearOne: (id) => {
+      void clearOneInAppNotification(channel, id).then(() => {
+        if (!disposed) notifications.value = channel.getHistory();
+      });
+    },
+    markAsRead: (id) => {
+      channel.markAsRead(id);
+      notifications.value = notifications.value.map(
+        (item) => item.id === id ? { ...item, read: true } : item
+      );
+    },
+    markAllAsRead: () => {
+      channel.markAllAsRead();
+      notifications.value = notifications.value.map((item) => ({
+        ...item,
+        read: true
+      }));
+    },
+    updateSettings,
+    setChannels: (channels) => updateSettings(channelsUpdate(channels)),
+    muteChain: (chainId) => updateSettings(mutedChainSettings(settings.value, chainId, true)),
+    unmuteChain: (chainId) => updateSettings(mutedChainSettings(settings.value, chainId, false))
+  };
+}
+
+// src/useSimulateTransfer.ts
+import { resolveSimulationEndpoint } from "@naculus/connect-appkit-core";
+import {
+  SimulationManager
+} from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose2, shallowRef as shallowRef2, unref as unref2 } from "vue";
+function useSimulateTransfer(options = {}) {
+  const result = shallowRef2(null);
+  const loading = shallowRef2(false);
+  const error = shallowRef2(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 = unref2(options.rpcUrl);
+      const endpoint = resolveSimulationEndpoint(
+        callOptions?.chainId,
+        unref2(options.chainId),
+        callOptions?.rpcUrl,
+        fallbackRpcUrl
+      );
+      manager ??= new 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;
+  };
+  onScopeDispose2(() => {
+    disposed = true;
+    generation++;
+  });
+  return { result, loading, error, simulate, reset };
+}
+
+// src/useTransactionSimulation.ts
+import {
+  simulateTransactionPreview
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef3, toValue as toValue2, unref as unref3, watch } from "vue";
+function useTransactionSimulation(tx, options = {}) {
+  const result = shallowRef3(void 0);
+  const isSimulating = shallowRef3(false);
+  const error = shallowRef3(null);
+  let timer;
+  let generation = 0;
+  let disposed = false;
+  const simulate = async () => {
+    const own = ++generation;
+    const transaction = toValue2(tx);
+    if (transaction) {
+      isSimulating.value = true;
+      error.value = null;
+    }
+    try {
+      const value = await simulateTransactionPreview(transaction, {
+        chainId: unref3(options.chainId),
+        currentChain: unref3(options.currentChain),
+        publicClient: unref3(options.publicClient),
+        evmAccount: unref3(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;
+    }
+  };
+  watch(
+    [
+      () => toValue2(tx),
+      () => unref3(options.chainId),
+      () => unref3(options.currentChain),
+      () => unref3(options.publicClient),
+      () => unref3(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;
+  };
+  onScopeDispose3(() => {
+    disposed = true;
+    generation++;
+    if (timer) clearTimeout(timer);
+  });
+  return { result, isSimulating, error, simulate, reset };
+}
+
+// src/useERC20Transfer.ts
+import {
+  createDecimalsCache,
+  encodeErc20Transfer,
+  readDecimals,
+  writeDecimals
+} from "@naculus/connect-appkit-core";
+import {
+  ERC20_MIN_ABI,
+  parseUnits,
+  WalletError as WalletError2
+} from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose4, shallowRef as shallowRef4, toValue as toValue3, unref as unref4, watch as watch2 } from "vue";
+
+// src/erc20.ts
+import {
+  bareEvmAddress,
+  tokenChainMismatch
+} from "@naculus/connect-appkit-core";
+import { WalletError } from "@naculus/connect-core";
+function assertErc20Context(token, chainId, account, connected) {
+  if (!connected || !account) {
+    throw new WalletError("wallet_unavailable", "No connected account");
+  }
+  const mismatch = tokenChainMismatch(token, chainId);
+  if (mismatch) throw mismatch;
+  const bare = bareEvmAddress(account);
+  if (!bare) {
+    throw new WalletError("wallet_unavailable", "No valid EVM account");
+  }
+  return bare;
+}
+
+// src/useERC20Transfer.ts
+function useERC20Transfer(options) {
+  const initialToken = toValue3(options.token);
+  const decimals = createDecimalsCache(initialToken, initialToken.decimals);
+  const isSending = shallowRef4(false);
+  const error = shallowRef4(null);
+  let generation = 0;
+  let disposed = false;
+  watch2(
+    [
+      () => toValue3(options.token).address,
+      () => toValue3(options.token).chainId,
+      () => toValue3(options.token).decimals,
+      () => toValue3(options.account),
+      () => toValue3(options.chainId),
+      () => toValue3(options.connected),
+      () => toValue3(options.publicClient),
+      () => unref4(options.sendTransaction)
+    ],
+    () => {
+      generation++;
+      isSending.value = false;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  const sendTransfer = async (to, amount) => {
+    const own = ++generation;
+    const token = toValue3(options.token);
+    const reader = toValue3(options.publicClient);
+    const stillCurrent = () => !disposed && own === generation;
+    error.value = null;
+    isSending.value = true;
+    try {
+      assertErc20Context(
+        token,
+        toValue3(options.chainId),
+        toValue3(options.account),
+        toValue3(options.connected)
+      );
+      if (!reader) {
+        throw new WalletError2(
+          "wallet_unavailable",
+          "No public client available"
+        );
+      }
+      let precision = readDecimals(decimals, token, token.decimals);
+      if (precision === void 0) {
+        precision = Number(
+          await reader.readContract({
+            address: token.address,
+            abi: ERC20_MIN_ABI,
+            functionName: "decimals"
+          })
+        );
+        if (!stillCurrent()) {
+          throw new WalletError2(
+            "session_inactive",
+            "Wallet or token context changed. Retry the transfer."
+          );
+        }
+        writeDecimals(decimals, token, precision);
+      }
+      const data = encodeErc20Transfer(to, parseUnits(amount, precision));
+      return await unref4(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;
+    }
+  };
+  onScopeDispose4(() => {
+    disposed = true;
+    generation++;
+  });
+  return { sendTransfer, isSending, error };
+}
+
+// src/useERC20Approve.ts
+import {
+  createDecimalsCache as createDecimalsCache2,
+  encodeErc20Approve,
+  readDecimals as readDecimals2,
+  writeDecimals as writeDecimals2
+} from "@naculus/connect-appkit-core";
+import {
+  ERC20_MIN_ABI as ERC20_MIN_ABI2,
+  formatUnits,
+  parseUnits as parseUnits2,
+  WalletError as WalletError3
+} from "@naculus/connect-core";
+import {
+  computed as computed3,
+  onScopeDispose as onScopeDispose5,
+  shallowRef as shallowRef5,
+  toValue as toValue4,
+  unref as unref5,
+  watch as watch3
+} from "vue";
+var MAX_UINT256 = (1n << 256n) - 1n;
+function useERC20Approve(options) {
+  const initialToken = toValue4(options.token);
+  const decimals = createDecimalsCache2(initialToken, initialToken.decimals);
+  const allowanceRaw = shallowRef5(null);
+  const isApproving = shallowRef5(false);
+  const isFetchingAllowance = shallowRef5(false);
+  const error = shallowRef5(null);
+  let generation = 0;
+  let allowanceGeneration = 0;
+  let disposed = false;
+  watch3(
+    [
+      () => toValue4(options.token).address,
+      () => toValue4(options.token).chainId,
+      () => toValue4(options.token).decimals,
+      () => toValue4(options.spender),
+      () => toValue4(options.account),
+      () => toValue4(options.chainId),
+      () => toValue4(options.connected),
+      () => toValue4(options.publicClient),
+      () => unref5(options.sendTransaction)
+    ],
+    () => {
+      generation++;
+      allowanceGeneration++;
+      allowanceRaw.value = null;
+      isApproving.value = false;
+      isFetchingAllowance.value = false;
+      error.value = null;
+    },
+    { flush: "sync" }
+  );
+  const context = () => {
+    const token = toValue4(options.token);
+    const account = assertErc20Context(
+      token,
+      toValue4(options.chainId),
+      toValue4(options.account),
+      toValue4(options.connected)
+    );
+    const reader = toValue4(options.publicClient);
+    if (!reader)
+      throw new WalletError3("wallet_unavailable", "No public client");
+    return { token, account, reader, spender: toValue4(options.spender) };
+  };
+  const readPrecision = async () => {
+    const { token, reader } = context();
+    let precision = readDecimals2(decimals, token, token.decimals);
+    if (precision === void 0) {
+      precision = Number(
+        await reader.readContract({
+          address: token.address,
+          abi: ERC20_MIN_ABI2,
+          functionName: "decimals"
+        })
+      );
+      writeDecimals2(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: ERC20_MIN_ABI2,
+          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 unref5(options.sendTransaction)({
+        to: token.address,
+        data: 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 WalletError3(
+          "session_inactive",
+          "Wallet or token context changed. Retry the approval."
+        );
+      }
+      rawAmount = parseUnits2(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 >= parseUnits2(required, await readPrecision());
+  };
+  const allowance = computed3(() => {
+    if (allowanceRaw.value === null) return null;
+    const token = toValue4(options.token);
+    const precision = readDecimals2(decimals, token, token.decimals);
+    return precision === void 0 ? null : formatUnits(allowanceRaw.value, precision);
+  });
+  onScopeDispose5(() => {
+    disposed = true;
+    generation++;
+    allowanceGeneration++;
+  });
+  return {
+    approve,
+    approveMax,
+    allowanceRaw,
+    allowance,
+    hasAllowance,
+    isApproving,
+    isFetchingAllowance,
+    error,
+    refetchAllowance
+  };
+}
+
+// src/useERC20TransferSimulation.ts
+import { chainNumber, encodeErc20Transfer as encodeErc20Transfer2 } from "@naculus/connect-appkit-core";
+import { parseUnits as parseUnits3 } from "@naculus/connect-core";
+import { computed as computed4, toValue as toValue5 } from "vue";
+function useERC20TransferSimulation(options) {
+  const transaction = computed4(() => {
+    const token = toValue5(options.token);
+    if (!toValue5(options.connected) || !toValue5(options.evmAccount))
+      return void 0;
+    try {
+      if (token.decimals === void 0) return void 0;
+      return {
+        to: token.address,
+        data: encodeErc20Transfer2(
+          toValue5(options.to),
+          parseUnits3(toValue5(options.amount), token.decimals)
+        ),
+        value: "0"
+      };
+    } catch {
+      return void 0;
+    }
+  });
+  const chainId = computed4(() => {
+    const token = toValue5(options.token);
+    if (token.chainId !== void 0) return token.chainId;
+    const currentChain = toValue5(options.currentChain);
+    return currentChain ? chainNumber(currentChain) ?? void 0 : void 0;
+  });
+  const simulation = useTransactionSimulation(transaction, {
+    chainId,
+    currentChain: options.currentChain,
+    publicClient: options.publicClient,
+    evmAccount: options.evmAccount
+  });
+  return {
+    result: computed4(
+      () => transaction.value ? simulation.result.value : void 0
+    ),
+    isSimulating: computed4(
+      () => !!transaction.value && simulation.isSimulating.value
+    ),
+    error: computed4(() => transaction.value ? simulation.error.value : null),
+    reSimulate: simulation.simulate,
+    reset: simulation.reset
+  };
+}
+
+// src/useAccount.ts
+import { computed as computed5, toValue as toValue6 } from "vue";
+function useAccount(accounts, connected) {
+  const parsed = useAccounts(accounts);
+  const isConnected = computed5(() => toValue6(connected));
+  const accountList = computed5(() => toValue6(accounts) ?? []);
+  return {
+    accounts: computed5(
+      () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
+    ),
+    evmAccount: computed5(
+      () => isConnected.value ? parsed.evmAccount.value : null
+    ),
+    primaryAccount: computed5(() => accountList.value[0] ?? null),
+    isConnected,
+    count: computed5(() => accountList.value.length)
+  };
+}
+
+// src/useSession.ts
+import { computed as computed6, shallowRef as shallowRef6, toValue as toValue7, watch as watch4 } from "vue";
+function readSession(manager) {
+  const bundle = manager?.getActiveBundle();
+  if (!bundle) {
+    return {
+      session: null,
+      chainSessions: [],
+      activeChainId: null,
+      connectorId: null
+    };
+  }
+  return {
+    session: bundle.walletSession,
+    chainSessions: Array.from(bundle.chainSessions.values()),
+    activeChainId: bundle.activeChainId,
+    connectorId: bundle.walletSession.walletType
+  };
+}
+function useSession(manager) {
+  const snapshot = shallowRef6(readSession(toValue7(manager)));
+  watch4(
+    () => toValue7(manager),
+    (current, _previous, onCleanup) => {
+      const update = () => {
+        snapshot.value = readSession(current);
+      };
+      update();
+      if (!current) return;
+      current.on("sessionConnected", update);
+      current.on("sessionDisconnected", update);
+      current.on("chainChanged", update);
+      onCleanup(() => {
+        current.off("sessionConnected", update);
+        current.off("sessionDisconnected", update);
+        current.off("chainChanged", update);
+      });
+    },
+    { immediate: true }
+  );
+  return {
+    session: computed6(() => snapshot.value.session),
+    chainSessions: computed6(() => snapshot.value.chainSessions),
+    activeChainId: computed6(() => snapshot.value.activeChainId),
+    isConnected: computed6(() => snapshot.value.session !== null),
+    connectorId: computed6(() => snapshot.value.connectorId)
+  };
+}
+
+// src/useConnect.ts
+import { WalletError as WalletError4 } from "@naculus/connect-core";
+import { computed as computed7, onScopeDispose as onScopeDispose6, shallowRef as shallowRef7, toValue as toValue8, unref as unref6 } from "vue";
+function useConnect(action, status) {
+  const isLoading = shallowRef7(false);
+  const error = shallowRef7(null);
+  let disposed = false;
+  let inFlight = null;
+  const connect = () => {
+    if (inFlight) return inFlight;
+    const invoke = unref6(action);
+    isLoading.value = true;
+    error.value = null;
+    const pending = Promise.resolve().then(() => invoke()).catch((cause) => {
+      if (disposed) return;
+      const message = cause instanceof Error ? cause.message : "Connection failed";
+      error.value = cause instanceof WalletError4 ? cause : new Error(message);
+    }).finally(() => {
+      if (inFlight === pending) inFlight = null;
+      if (!disposed) isLoading.value = false;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  onScopeDispose6(() => {
+    disposed = true;
+  });
+  return {
+    connect,
+    isConnecting: computed7(
+      () => isLoading.value || toValue8(status) === "connecting"
+    ),
+    error
+  };
+}
+
+// src/useDisconnect.ts
+import { onScopeDispose as onScopeDispose7, shallowRef as shallowRef8, toValue as toValue9, unref as unref7 } from "vue";
+function useDisconnect(action, status) {
+  const isDisconnecting = shallowRef8(false);
+  const error = shallowRef8(null);
+  let disposed = false;
+  let inFlight = null;
+  const disconnect = () => {
+    if (inFlight) return inFlight;
+    if (toValue9(status) === "disconnected") return Promise.resolve();
+    const invoke = unref7(action);
+    isDisconnecting.value = true;
+    error.value = null;
+    const pending = Promise.resolve().then(() => invoke()).catch((cause) => {
+      if (!disposed) {
+        error.value = cause instanceof Error ? cause : new Error("Disconnect failed");
+      }
+    }).finally(() => {
+      if (inFlight === pending) inFlight = null;
+      if (!disposed) isDisconnecting.value = false;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  const cleanup = () => {
+    disposed = true;
+  };
+  onScopeDispose7(cleanup);
+  return { disconnect, isDisconnecting, error, cleanup };
+}
+
+// src/useSwitchChain.ts
+import { toChainSwitchError } from "@naculus/connect-appkit-core";
+import { computed as computed8, onScopeDispose as onScopeDispose8, shallowRef as shallowRef9, toValue as toValue10, unref as unref8 } from "vue";
+function useSwitchChain(action, chainId) {
+  const isSwitching = shallowRef9(false);
+  const error = shallowRef9(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const switchChain = async (targetChainId) => {
+    const invoke = unref8(action);
+    const mine = ++generation;
+    active++;
+    isSwitching.value = true;
+    error.value = null;
+    try {
+      await invoke(targetChainId);
+    } catch (cause) {
+      const walletError = toChainSwitchError(cause);
+      if (!disposed && mine === generation) error.value = walletError;
+      throw walletError;
+    } finally {
+      active--;
+      if (!disposed) isSwitching.value = active > 0;
+    }
+  };
+  onScopeDispose8(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    switchChain,
+    isSwitching,
+    currentChainId: computed8(() => toValue10(chainId) ?? null),
+    error,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/useSignMessage.ts
+import { onScopeDispose as onScopeDispose9, shallowRef as shallowRef10, unref as unref9 } from "vue";
+function useSignMessage(action) {
+  const isSigning = shallowRef10(false);
+  const error = shallowRef10(null);
+  let active = 0;
+  let generation = 0;
+  let disposed = false;
+  const signMessage = async (message) => {
+    const invoke = unref9(action);
+    const own = ++generation;
+    active++;
+    isSigning.value = true;
+    error.value = null;
+    try {
+      return await invoke(message);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Signing failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) isSigning.value = active > 0;
+    }
+  };
+  const reset = () => {
+    generation++;
+    error.value = null;
+  };
+  onScopeDispose9(() => {
+    disposed = true;
+    generation++;
+  });
+  return { signMessage, isSigning, error, reset };
+}
+
+// src/useSendTransaction.ts
+import { computed as computed9, onScopeDispose as onScopeDispose10, shallowRef as shallowRef11, unref as unref10 } from "vue";
+function useSendTransaction(action) {
+  const status = shallowRef11("idle");
+  const error = shallowRef11(null);
+  let generation = 0;
+  let disposed = false;
+  const sendTransaction = async (transaction) => {
+    const invoke = unref10(action);
+    const own = ++generation;
+    status.value = "awaiting_approval";
+    error.value = null;
+    try {
+      const hash = await invoke(transaction);
+      if (!disposed && own === generation) status.value = "submitted";
+      return hash;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Transaction failed");
+      if (!disposed && own === generation) {
+        status.value = "failed";
+        error.value = normalized;
+      }
+      throw normalized;
+    }
+  };
+  const reset = () => {
+    generation++;
+    status.value = "idle";
+    error.value = null;
+  };
+  onScopeDispose10(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    sendTransaction,
+    status,
+    error,
+    reset,
+    isSending: computed9(() => status.value === "awaiting_approval")
+  };
+}
+
+// src/useSolanaTransaction.ts
+import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef12, unref as unref11 } from "vue";
+function useSolanaTransaction(options) {
+  const isSigning = shallowRef12(false);
+  const isSending = shallowRef12(false);
+  const error = shallowRef12(null);
+  let signing = 0;
+  let sending = 0;
+  let generation = 0;
+  let disposed = false;
+  const signTransaction = async (transaction) => {
+    const invoke = unref11(options.signTransaction);
+    const own = ++generation;
+    signing++;
+    isSigning.value = true;
+    error.value = null;
+    try {
+      return await invoke(transaction);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Signing failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      signing--;
+      if (!disposed) isSigning.value = signing > 0;
+    }
+  };
+  const sendTransaction = async (transaction) => {
+    const invoke = unref11(options.sendTransaction);
+    const own = ++generation;
+    sending++;
+    isSending.value = true;
+    error.value = null;
+    try {
+      return await invoke(transaction);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Send failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      sending--;
+      if (!disposed) isSending.value = sending > 0;
+    }
+  };
+  const getStatus = (signature) => unref11(options.getStatus)(signature);
+  const reset = () => {
+    generation++;
+    error.value = null;
+  };
+  onScopeDispose11(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    signTransaction,
+    sendTransaction,
+    getStatus,
+    isSigning,
+    isSending,
+    error,
+    reset
+  };
+}
+
+// src/useSignInWithX.ts
+import { onScopeDispose as onScopeDispose12, shallowRef as shallowRef13, unref as unref12 } from "vue";
+function useSignInWithX(action) {
+  const isSigningIn = shallowRef13(false);
+  const result = shallowRef13(null);
+  const error = shallowRef13(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const signIn = async (options) => {
+    const invoke = unref12(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;
+  };
+  onScopeDispose12(() => {
+    disposed = true;
+    generation++;
+  });
+  return { signIn, isSigningIn, result, error, clearError, reset };
+}
+
+// src/useSignInWithEthereum.ts
+function useSignInWithEthereum(action) {
+  return useSignInWithX(action);
+}
+
+// src/useExecuteCalls.ts
+import { computed as computed10, onScopeDispose as onScopeDispose13, shallowRef as shallowRef14, toValue as toValue11, unref as unref13 } from "vue";
+function useExecuteCalls(options) {
+  const isExecuting = shallowRef14(false);
+  const error = shallowRef14(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const preview = (callCount, atomicity) => unref13(options.preview)(callCount, atomicity);
+  const execute = async (calls, atomicity) => {
+    const invoke = unref13(options.execute);
+    const own = ++generation;
+    active++;
+    isExecuting.value = true;
+    error.value = null;
+    try {
+      return await invoke(calls, atomicity);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Execution failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) isExecuting.value = active > 0;
+    }
+  };
+  const reset = () => {
+    generation++;
+    error.value = null;
+    unref13(options.reset)();
+  };
+  onScopeDispose13(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    preview,
+    execute,
+    isExecuting,
+    error,
+    lastRoute: computed10(() => toValue11(options.lastRoute)),
+    reset
+  };
+}
+
+// src/useDelegationPolicy.ts
+import {
+  bareEvmAddress as bareEvmAddress2,
+  createDelegationPolicyFlow,
+  getSharedSessionKeyManager as getSharedSessionKeyManager2,
+  isVerifiablePolicy
+} from "@naculus/connect-appkit-core";
+import {
+  computed as computed12,
+  onScopeDispose as onScopeDispose16,
+  shallowRef as shallowRef17,
+  toValue as toValue13,
+  unref as unref14,
+  watch as watch6
+} from "vue";
+
+// src/internal/action-guard.ts
+import { onScopeDispose as onScopeDispose14, shallowRef as shallowRef15 } from "vue";
+function useActionGuard() {
+  const busy = shallowRef15(false);
+  const error = shallowRef15(null);
+  let active = 0;
+  let generation = 0;
+  let disposed = false;
+  const run = async (action, fallbackMessage) => {
+    const own = ++generation;
+    active++;
+    busy.value = true;
+    error.value = null;
+    try {
+      return await action();
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error(fallbackMessage);
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) busy.value = active > 0;
+    }
+  };
+  const reset = () => {
+    generation++;
+    error.value = null;
+  };
+  onScopeDispose14(() => {
+    disposed = true;
+    generation++;
+  });
+  return { busy, error, run, reset };
+}
+
+// src/useSessionKeys.ts
+import { getSharedSessionKeyManager } from "@naculus/connect-appkit-core";
+import { computed as computed11, onScopeDispose as onScopeDispose15, shallowRef as shallowRef16, toValue as toValue12, watch as watch5 } from "vue";
+function resolveManager(config, options) {
+  return options.manager ?? getSharedSessionKeyManager(config);
+}
+function useSessionKeys(connected, config, options = {}) {
+  const manager = resolveManager(config, options);
+  const sessions = shallowRef16([]);
+  const loading = shallowRef16(false);
+  const error = shallowRef16(null);
+  let generation = 0;
+  let disposed = false;
+  const refresh = async () => {
+    const own = ++generation;
+    if (!toValue12(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;
+    }
+  };
+  watch5(
+    () => toValue12(connected),
+    () => {
+      void refresh();
+    },
+    { immediate: true }
+  );
+  onScopeDispose15(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    sessions,
+    activeSessions: computed11(
+      () => 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 = shallowRef16(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 ?? getSharedSessionKeyManager2(options.managerConfig);
+  const sessionKeys = useSessionKeys(options.connected, options.managerConfig, {
+    manager
+  });
+  const guard = useActionGuard();
+  const verifiedIds = shallowRef17(/* @__PURE__ */ new Set());
+  const isVerifying = shallowRef17(false);
+  const verifyError = shallowRef17(null);
+  let verifyGeneration = 0;
+  let disposed = false;
+  const origin = options.origin ?? (typeof window !== "undefined" ? window.location.origin : "unknown");
+  const flow = createDelegationPolicyFlow({
+    manager,
+    origin,
+    signer: () => bareEvmAddress2(toValue13(options.account)),
+    signMessage: (message) => unref14(options.signMessage)(message),
+    verifySignature: (input) => unref14(options.verifySignature)(input),
+    previewExecution: (callCount, atomicity) => unref14(options.previewExecution)(callCount, atomicity),
+    sponsorship: options.sponsorship,
+    adapter: options.adapter,
+    delegation: () => toValue13(options.delegation),
+    encryptionKeyConfigured: Boolean(options.managerConfig?.encryptionKey),
+    storageAvailable: () => sessionKeys.storageAvailable,
+    refresh: sessionKeys.refresh
+  });
+  watch6(
+    () => sessionKeys.sessions.value,
+    (sessions) => {
+      const own = ++verifyGeneration;
+      const candidates = sessions.filter(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 }
+  );
+  onScopeDispose16(() => {
+    disposed = true;
+    verifyGeneration++;
+  });
+  return {
+    policies: sessionKeys.sessions,
+    activePolicies: computed12(
+      () => sessionKeys.activeSessions.value.filter(
+        (p) => verifiedIds.value.has(p.id)
+      )
+    ),
+    storageAvailable: sessionKeys.storageAvailable,
+    loading: computed12(() => sessionKeys.loading.value || isVerifying.value),
+    isBusy: guard.busy,
+    error: computed12(
+      () => 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/useSmartAccount.ts
+import {
+  bareEvmAddress as bareEvmAddress3,
+  buildSmartAccountConfig,
+  resolveEvmChainId
+} from "@naculus/connect-appkit-core";
+import { WalletError as WalletError5 } from "@naculus/connect-core";
+import {
+  computed as computed13,
+  onScopeDispose as onScopeDispose17,
+  shallowRef as shallowRef18,
+  toValue as toValue14,
+  unref as unref15,
+  watch as watch7
+} from "vue";
+function useSmartAccount(options) {
+  const address = shallowRef18(null);
+  const isDeployed = shallowRef18(false);
+  const accountInfo = shallowRef18(null);
+  const guard = useActionGuard();
+  const managerRef = shallowRef18(null);
+  let generation = 0;
+  let inFlight = false;
+  let disposed = false;
+  const chainId = computed13(
+    () => resolveEvmChainId(
+      toValue14(options.chainId),
+      toValue14(options.connectedChainId)
+    )
+  );
+  watch7(
+    [
+      () => toValue14(options.manager),
+      () => toValue14(options.rpcUrl),
+      () => toValue14(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 = computed13(() => {
+    const owner = bareEvmAddress3(toValue14(options.account));
+    const chain = chainId.value;
+    if (!owner || !chain || !managerRef.value) return null;
+    return buildSmartAccountConfig(owner, chain, {
+      accountType: options.accountType,
+      entryPoint: options.entryPoint,
+      salt: options.salt
+    });
+  });
+  const apply = (info) => {
+    address.value = info.address;
+    isDeployed.value = info.isDeployed;
+    accountInfo.value = info;
+  };
+  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 = unref15(options.sendTransaction);
+    if (!send) {
+      throw new WalletError5(
+        "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");
+  onScopeDispose17(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    address,
+    isDeployed,
+    accountInfo,
+    isLoading: guard.busy,
+    error: guard.error,
+    config,
+    createWallet,
+    deployWallet,
+    getAddress
+  };
+}
+
+// src/useSendUserOperation.ts
+import {
+  bareEvmAddress as bareEvmAddress4,
+  buildSmartAccountConfig as buildSmartAccountConfig2,
+  resolveUserOpChain
+} from "@naculus/connect-appkit-core";
+import { WalletError as WalletError6 } from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose18, shallowRef as shallowRef19, toValue as toValue15, unref as unref16 } from "vue";
+function useSendUserOperation(options) {
+  const userOpHash = shallowRef19(null);
+  const receipt = shallowRef19(null);
+  const isPending = shallowRef19(false);
+  const isEstimating = shallowRef19(false);
+  const error = shallowRef19(null);
+  let requestId = 0;
+  let inFlight = false;
+  let disposed = false;
+  const fail = (cause) => {
+    error.value = cause;
+    return null;
+  };
+  const sendUserOp = async (calls, opts) => {
+    const rpcUrl = toValue15(options.rpcUrl);
+    const bundlerUrl = toValue15(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 = bareEvmAddress4(
+      toValue15(options.owner) ?? toValue15(options.account)
+    );
+    if (!owner) {
+      return fail(
+        new WalletError6("wallet_unavailable", "No EVM account found")
+      );
+    }
+    let targetChainId;
+    try {
+      targetChainId = resolveUserOpChain(
+        toValue15(options.chainId),
+        toValue15(options.connectedChainId)
+      );
+    } catch (chainError) {
+      return fail(chainError);
+    }
+    const signer = unref16(options.signer);
+    const own = ++requestId;
+    inFlight = true;
+    isPending.value = true;
+    isEstimating.value = true;
+    error.value = null;
+    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 = buildSmartAccountConfig2(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;
+      }
+    }
+  };
+  const reset = () => {
+    requestId++;
+    userOpHash.value = null;
+    receipt.value = null;
+    isPending.value = false;
+    isEstimating.value = false;
+    error.value = null;
+  };
+  onScopeDispose18(() => {
+    disposed = true;
+    requestId++;
+  });
+  return {
+    sendUserOp,
+    userOpHash,
+    receipt,
+    isPending,
+    isEstimating,
+    error,
+    reset
+  };
+}
+
+// src/useUserOpStatus.ts
+import {
+  fetchUserOperationReceipt,
+  InvalidUserOperationReceiptError
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose19, shallowRef as shallowRef20, toValue as toValue16 } from "vue";
+function useUserOpStatus(options) {
+  const status = shallowRef20("idle");
+  const receipt = shallowRef20(null);
+  const userOpHash = shallowRef20(null);
+  const error = shallowRef20(null);
+  const isPolling = shallowRef20(false);
+  const elapsedMs = shallowRef20(0);
+  const attempts = shallowRef20(0);
+  const pollInterval = options.pollInterval ?? 2e3;
+  const maxRetries = options.maxRetries ?? 30;
+  let generation = 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 = toValue16(options.bundlerUrl);
+    if (!bundlerUrl || own !== generation) return;
+    const attempt = ++attempts.value;
+    const abort = new AbortController();
+    controller = abort;
+    try {
+      const next = await 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 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 (!toValue16(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;
+  };
+  onScopeDispose19(stop);
+  return {
+    status,
+    receipt,
+    userOpHash,
+    error,
+    isPolling,
+    elapsedMs,
+    attempts,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/useSendCalls.ts
+import { computed as computed14, onScopeDispose as onScopeDispose20, shallowRef as shallowRef21, toValue as toValue17, unref as unref17 } from "vue";
+function useSendCalls(options) {
+  const status = shallowRef21("idle");
+  const error = shallowRef21(null);
+  const batchHash = shallowRef21(null);
+  const callsStatus = shallowRef21(null);
+  let sendGeneration = 0;
+  let statusGeneration = 0;
+  let disposed = false;
+  const sendCalls = async (calls, input) => {
+    const invoke = unref17(options.sendCalls);
+    const own = ++sendGeneration;
+    status.value = "awaiting_approval";
+    error.value = null;
+    batchHash.value = null;
+    try {
+      const hash = await invoke(calls, input);
+      if (!disposed && own === sendGeneration) {
+        status.value = "submitted";
+        batchHash.value = hash;
+      }
+      return hash;
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("sendCalls failed");
+      if (!disposed && own === sendGeneration) {
+        status.value = "failed";
+        error.value = normalized;
+      }
+      throw normalized;
+    }
+  };
+  const getCallsStatus = async (hash) => {
+    const invoke = unref17(options.getCallsStatus);
+    const own = ++statusGeneration;
+    const result = await invoke(hash);
+    if (!disposed && own === statusGeneration) callsStatus.value = result;
+    return result;
+  };
+  const showCallsStatus = (hash) => unref17(options.showCallsStatus)(hash);
+  const reset = () => {
+    sendGeneration++;
+    statusGeneration++;
+    status.value = "idle";
+    error.value = null;
+    batchHash.value = null;
+    callsStatus.value = null;
+  };
+  onScopeDispose20(() => {
+    disposed = true;
+    sendGeneration++;
+    statusGeneration++;
+  });
+  return {
+    sendCalls,
+    getCallsStatus,
+    showCallsStatus,
+    status,
+    error,
+    batchHash,
+    callsStatus,
+    execution: computed14(() => toValue17(options.execution) ?? null),
+    isSending: computed14(() => status.value === "awaiting_approval"),
+    reset
+  };
+}
+
+// src/useEmbeddedWallet.ts
+import { computed as computed15, onScopeDispose as onScopeDispose21, shallowRef as shallowRef22, toValue as toValue18, unref as unref18 } from "vue";
+function useEmbeddedWallet(options) {
+  const isBusy = shallowRef22(false);
+  const error = shallowRef22(null);
+  let active = 0;
+  let generation = 0;
+  let disposed = false;
+  const run = async (action) => {
+    const own = ++generation;
+    active++;
+    isBusy.value = true;
+    error.value = null;
+    try {
+      return await action();
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("Embedded wallet action failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) isBusy.value = active > 0;
+    }
+  };
+  const wallet = computed15(() => toValue18(options.wallet));
+  onScopeDispose21(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    wallet,
+    hasWallet: computed15(() => wallet.value !== null),
+    address: computed15(() => wallet.value?.address ?? null),
+    accounts: computed15(() => wallet.value?.accounts ?? []),
+    activeNamespace: computed15(() => wallet.value?.activeNamespace ?? null),
+    backupPending: computed15(() => toValue18(options.backupPending)),
+    storageSecurityLevel: computed15(() => toValue18(options.storageSecurityLevel)),
+    securityReport: computed15(() => toValue18(options.securityReport)),
+    connectEmbedded: () => run(() => unref18(options.connectEmbedded)()),
+    restoreWallet: () => run(() => unref18(options.restoreWallet)()),
+    generateWallet: () => run(() => unref18(options.generateWallet)()),
+    importFromMnemonic: (value) => run(() => unref18(options.importFromMnemonic)(value)),
+    importFromPrivateKey: (value) => run(() => unref18(options.importFromPrivateKey)(value)),
+    wipe: () => run(() => unref18(options.wipe)()),
+    setActiveNamespace: (value) => unref18(options.setActiveNamespace)(value),
+    backfillAccounts: () => run(() => unref18(options.backfillAccounts)()),
+    getSeedPhrase: () => unref18(options.getSeedPhrase)(),
+    getPrivateKey: () => unref18(options.getPrivateKey)(),
+    confirmBackup: () => unref18(options.confirmBackup)(),
+    isBusy,
+    error,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// 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
+import { computed as computed16, onScopeDispose as onScopeDispose22, shallowRef as shallowRef23, toValue as toValue19, unref as unref19 } from "vue";
+function useSIWxSession(options) {
+  const isSigningIn = shallowRef23(false);
+  const error = shallowRef23(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const run = async (action, message) => {
+    const own = ++generation;
+    active++;
+    isSigningIn.value = true;
+    error.value = null;
+    try {
+      return await action();
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error(message);
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      active--;
+      if (!disposed) isSigningIn.value = active > 0;
+    }
+  };
+  onScopeDispose22(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    session: computed16(() => toValue19(options.session)),
+    isAuthenticated: computed16(
+      () => toValue19(options.session) !== null && !toValue19(options.isExpired)
+    ),
+    isRestoring: computed16(() => toValue19(options.isRestoring)),
+    isSigningIn,
+    isExpired: computed16(() => toValue19(options.isExpired)),
+    timeUntilExpiry: computed16(() => toValue19(options.timeUntilExpiry)),
+    signIn: (input) => run(() => unref19(options.signIn)(input), "SIWX sign-in failed"),
+    signOut: async () => {
+      await unref19(options.signOut)();
+      error.value = null;
+    },
+    refresh: () => run(() => unref19(options.refresh)(), "Session refresh failed"),
+    error,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/useSiwxAuthSession.ts
+import { computed as computed17, onScopeDispose as onScopeDispose23, shallowRef as shallowRef24, toValue as toValue20, unref as unref20 } from "vue";
+function useSiwxAuthSession(options) {
+  const isSigningIn = shallowRef24(false);
+  const error = shallowRef24(null);
+  let generation = 0;
+  let disposed = false;
+  const signIn = async (input) => {
+    const own = ++generation;
+    isSigningIn.value = true;
+    error.value = null;
+    try {
+      return await unref20(options.signIn)(input);
+    } catch (cause) {
+      const normalized = cause instanceof Error ? cause : new Error("SIWX sign-in failed");
+      if (!disposed && own === generation) error.value = normalized;
+      throw normalized;
+    } finally {
+      if (!disposed && own === generation) isSigningIn.value = false;
+    }
+  };
+  const signOut = async () => {
+    generation++;
+    await unref20(options.signOut)();
+    if (!disposed) {
+      isSigningIn.value = false;
+      error.value = null;
+    }
+  };
+  onScopeDispose23(() => {
+    disposed = true;
+    generation++;
+  });
+  const siwxResult = computed17(() => toValue20(options.result));
+  return {
+    isSignedIn: computed17(() => siwxResult.value !== null),
+    isRestoring: computed17(() => toValue20(options.isRestoring)),
+    siwxResult,
+    isSigningIn,
+    error,
+    signIn,
+    signOut,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/useBalance.ts
+import { bareEvmAddress as bareEvmAddress5 } from "@naculus/connect-appkit-core";
+import { formatUnits as formatUnits2 } from "@naculus/connect-core";
+import { computed as computed18, onScopeDispose as onScopeDispose24, shallowRef as shallowRef25, toValue as toValue21, watch as watch8 } from "vue";
+function useBalance(account, client, options = {}) {
+  const balance = shallowRef25(null);
+  const isFetching = shallowRef25(false);
+  const error = shallowRef25(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = toValue21(client);
+    const address = bareEvmAddress5(toValue21(account));
+    const own = ++generation;
+    if (!reader || !address) {
+      balance.value = null;
+      error.value = null;
+      isFetching.value = false;
+      return;
+    }
+    isFetching.value = true;
+    error.value = null;
+    try {
+      const next = await reader.getBalance({ address });
+      if (disposed || own !== generation) return;
+      balance.value = next.toString();
+    } catch (cause) {
+      if (disposed || own !== generation) return;
+      balance.value = null;
+      error.value = cause instanceof Error ? cause : new Error("Balance read failed");
+    } finally {
+      if (!disposed && own === generation) isFetching.value = false;
+    }
+  };
+  const stopTimer = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+  };
+  watch8(
+    [
+      () => toValue21(account),
+      () => toValue21(client),
+      () => toValue21(options.refreshInterval) ?? 0
+    ],
+    ([, , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  onScopeDispose24(() => {
+    disposed = true;
+    generation++;
+    stopTimer();
+  });
+  return {
+    balance,
+    formatted: computed18(
+      () => balance.value === null ? null : formatUnits2(BigInt(balance.value), toValue21(options.decimals) ?? 18)
+    ),
+    symbol: computed18(() => toValue21(options.symbol) ?? null),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/useRouteQuote.ts
+import {
+  isQuotableInput
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose25, shallowRef as shallowRef26, toValue as toValue22, unref as unref21, watch as watch9 } from "vue";
+function useRouteQuote(input, getQuotes, options = {}) {
+  const quotes = shallowRef26([]);
+  const loading = shallowRef26(false);
+  const error = shallowRef26(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const clearTimer = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  const fetchQuotes = async () => {
+    const current = toValue22(input);
+    const fn = unref21(getQuotes);
+    const own = ++generation;
+    if (!isQuotableInput(current)) {
+      quotes.value = [];
+      return;
+    }
+    if (!fn) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await fn(
+        current.fromChain,
+        current.toChain,
+        current.fromToken,
+        current.amount,
+        current.options,
+        current.toToken
+      );
+      if (disposed || own !== generation) return;
+      quotes.value = result;
+    } catch (cause) {
+      if (disposed || own !== generation) return;
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+      quotes.value = [];
+    } finally {
+      if (!disposed && own === generation) loading.value = false;
+    }
+  };
+  watch9(
+    [
+      () => toValue22(input).fromChain,
+      () => toValue22(input).toChain,
+      () => toValue22(input).fromToken,
+      () => toValue22(input).toToken,
+      () => toValue22(input).amount,
+      () => unref21(getQuotes)
+    ],
+    ([fromChain, toChain, fromToken, , amount]) => {
+      clearTimer();
+      if (!fromChain || !toChain || !fromToken || !amount) {
+        quotes.value = [];
+        return;
+      }
+      timer = setTimeout(() => {
+        timer = null;
+        void fetchQuotes();
+      }, options.debounceMs ?? 300);
+    },
+    { immediate: true }
+  );
+  onScopeDispose25(() => {
+    disposed = true;
+    generation++;
+    clearTimer();
+  });
+  return {
+    quotes,
+    loading,
+    error,
+    refresh: fetchQuotes,
+    clear: () => {
+      clearTimer();
+      generation++;
+      quotes.value = [];
+      error.value = null;
+      loading.value = false;
+    }
+  };
+}
+
+// src/useCompareCosts.ts
+import {
+  compareCostsKey
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose26, shallowRef as shallowRef27, toValue as toValue23, unref as unref22, watch as watch10 } from "vue";
+function useCompareCosts(input, compareCosts) {
+  const comparisons = shallowRef27([]);
+  const loading = shallowRef27(false);
+  const error = shallowRef27(null);
+  let generation = 0;
+  let disposed = false;
+  const fetchComparisons = async () => {
+    const { operation, chains, options } = toValue23(input);
+    const fn = unref22(compareCosts);
+    const own = ++generation;
+    if (!chains || chains.length === 0) {
+      comparisons.value = [];
+      return;
+    }
+    if (!fn) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await fn(operation, chains, options);
+      if (disposed || own !== generation) return;
+      comparisons.value = result;
+    } catch (cause) {
+      if (disposed || own !== generation) return;
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+      comparisons.value = [];
+    } finally {
+      if (!disposed && own === generation) loading.value = false;
+    }
+  };
+  watch10(
+    [() => compareCostsKey(toValue23(input)), () => unref22(compareCosts)],
+    () => {
+      void fetchComparisons();
+    },
+    { immediate: true }
+  );
+  onScopeDispose26(() => {
+    disposed = true;
+    generation++;
+  });
+  return { comparisons, loading, error, refresh: fetchComparisons };
+}
+
+// src/useExecuteRoute.ts
+import {
+  toExecuteRouteError,
+  validateRouteRecipient
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose27, shallowRef as shallowRef28, unref as unref23 } from "vue";
+function useExecuteRoute(executeRoute) {
+  const executing = shallowRef28(false);
+  const result = shallowRef28(null);
+  const error = shallowRef28(null);
+  let inFlight = false;
+  let disposed = false;
+  const execute = async (quote, recipient, options) => {
+    const fn = unref23(executeRoute);
+    if (!fn) {
+      error.value = {
+        code: "no_executor",
+        message: "No executeRoute function provided"
+      };
+      result.value = null;
+      return null;
+    }
+    const recipientError = validateRouteRecipient(quote, recipient);
+    if (recipientError) {
+      error.value = recipientError;
+      result.value = null;
+      return null;
+    }
+    if (inFlight) {
+      error.value = {
+        code: "execution_in_progress",
+        message: "A route execution is already in progress"
+      };
+      return null;
+    }
+    inFlight = true;
+    executing.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const execResult = await fn(quote, recipient, options);
+      if (!disposed) result.value = execResult;
+      return execResult;
+    } catch (cause) {
+      if (!disposed) error.value = toExecuteRouteError(cause);
+      return null;
+    } finally {
+      inFlight = false;
+      if (!disposed) executing.value = false;
+    }
+  };
+  onScopeDispose27(() => {
+    disposed = true;
+  });
+  return {
+    execute,
+    executing,
+    result,
+    error,
+    reset: () => {
+      result.value = null;
+      error.value = null;
+      executing.value = false;
+    }
+  };
+}
+
+// src/useTokenList.ts
+import { eip155ChainIdToNumber } from "@naculus/connect-appkit-core";
+import {
+  TokenListManager
+} from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose28, shallowRef as shallowRef29, toValue as toValue24, watch as watch11 } from "vue";
+function useTokenList(chainId, options = {}) {
+  const config = {};
+  if (options.sources) config.sources = options.sources;
+  const manager = options.manager ?? new TokenListManager(config);
+  const tokens = shallowRef29([]);
+  const isLoading = shallowRef29(options.autoLoad !== false);
+  const isLoaded = shallowRef29(false);
+  const error = shallowRef29(null);
+  let generation = 0;
+  let disposed = false;
+  const select = () => {
+    const id = toValue24(chainId);
+    const numeric = id ? eip155ChainIdToNumber(id) : void 0;
+    return manager.getTokens(
+      numeric !== void 0 ? { chainId: numeric } : void 0
+    );
+  };
+  const run = async (op) => {
+    const own = ++generation;
+    isLoading.value = true;
+    error.value = null;
+    try {
+      await op();
+      if (disposed || own !== generation) return;
+      tokens.value = select();
+      isLoaded.value = true;
+    } catch (cause) {
+      if (disposed || own !== generation) return;
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+    } finally {
+      if (!disposed && own === generation) isLoading.value = false;
+    }
+  };
+  watch11(
+    () => toValue24(chainId),
+    () => {
+      if (options.autoLoad !== false) void run(() => manager.load());
+    },
+    { immediate: true }
+  );
+  onScopeDispose28(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    tokens,
+    isLoading,
+    isLoaded,
+    error,
+    refetch: () => run(() => manager.refresh())
+  };
+}
+
+// src/useTokenSearch.ts
+import { eip155ChainIdToNumber as eip155ChainIdToNumber2 } from "@naculus/connect-appkit-core";
+import {
+  TokenListManager as TokenListManager2
+} from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose29, shallowRef as shallowRef30, toValue as toValue25, watch as watch12 } from "vue";
+var DEBOUNCE_MS = 300;
+var EMPTY = { exact: [], fuzzy: [], hasMore: false };
+var sharedManager = null;
+function getSharedManager() {
+  if (!sharedManager) {
+    sharedManager = new TokenListManager2();
+    sharedManager.load().catch(() => {
+    });
+  }
+  return sharedManager;
+}
+function useTokenSearch(query, chainId, options = {}) {
+  const results = shallowRef30(EMPTY);
+  const isSearching = shallowRef30(false);
+  let timer = null;
+  const clear = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  watch12(
+    [() => (toValue25(query) ?? "").trim(), () => toValue25(chainId)],
+    ([q, id]) => {
+      clear();
+      if (!q) {
+        results.value = EMPTY;
+        isSearching.value = false;
+        return;
+      }
+      isSearching.value = true;
+      timer = setTimeout(() => {
+        timer = null;
+        const manager = options.manager ?? getSharedManager();
+        const numeric = id ? eip155ChainIdToNumber2(id) : void 0;
+        results.value = manager.search(q, {
+          chainId: numeric,
+          limit: options.limit ?? 20
+        });
+        isSearching.value = false;
+      }, options.debounceMs ?? DEBOUNCE_MS);
+    },
+    { immediate: true }
+  );
+  onScopeDispose29(clear);
+  return { results, isSearching };
+}
+
+// src/useValidateDestination.ts
+import {
+  validateDestination
+} from "@naculus/connect-appkit-core";
+import { computed as computed19, toValue as toValue26 } from "vue";
+function useValidateDestination(address) {
+  return {
+    validation: computed19(() => validateDestination(toValue26(address) ?? ""))
+  };
+}
+
+// src/useTokenBalance.ts
+import { bareEvmAddress as bareEvmAddress6 } from "@naculus/connect-appkit-core";
+import { ERC20_MIN_ABI as ERC20_MIN_ABI3, formatUnits as formatUnits3 } from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose30, shallowRef as shallowRef31, toValue as toValue27, watch as watch13 } from "vue";
+function tokensKey(tokens) {
+  return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
+}
+function useTokenBalance(account, client, tokens, options = {}) {
+  const tokenBalances = shallowRef31([]);
+  const isFetching = shallowRef31(false);
+  const error = shallowRef31(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = toValue27(client);
+    const address = bareEvmAddress6(toValue27(account));
+    const list = toValue27(tokens) ?? [];
+    const own = ++generation;
+    if (!reader || !address || list.length === 0) {
+      tokenBalances.value = [];
+      error.value = null;
+      isFetching.value = false;
+      return;
+    }
+    isFetching.value = true;
+    error.value = null;
+    try {
+      const results = await Promise.all(
+        list.map(async (token) => {
+          try {
+            const raw = await reader.readContract({
+              address: token.address,
+              abi: ERC20_MIN_ABI3,
+              functionName: "balanceOf",
+              args: [address]
+            });
+            const value = BigInt(raw);
+            return {
+              ...token,
+              balance: value.toString(),
+              formatted: formatUnits3(value, token.decimals)
+            };
+          } catch {
+            return { ...token, balance: null, formatted: null };
+          }
+        })
+      );
+      if (disposed || own !== generation) return;
+      tokenBalances.value = results;
+    } catch (cause) {
+      if (disposed || own !== generation) return;
+      tokenBalances.value = [];
+      error.value = cause instanceof Error ? cause : new Error("Failed to fetch token balances");
+    } finally {
+      if (!disposed && own === generation) isFetching.value = false;
+    }
+  };
+  const stopTimer = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+  };
+  watch13(
+    [
+      () => toValue27(account),
+      () => toValue27(client),
+      () => tokensKey(toValue27(tokens) ?? []),
+      () => toValue27(options.refreshInterval) ?? 0
+    ],
+    ([, , , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  onScopeDispose30(() => {
+    disposed = true;
+    generation++;
+    stopTimer();
+  });
+  return {
+    tokenBalances,
+    isFetching,
+    error,
+    refetch,
+    getTokenBalance: (tokenAddress) => tokenBalances.value.find(
+      (t) => t.address.toLowerCase() === tokenAddress.toLowerCase()
+    )
+  };
+}
+
+// src/useDelegation.ts
+import { bareEvmAddress as bareEvmAddress7 } from "@naculus/connect-appkit-core";
+import {
+  readDelegation,
+  UNKNOWN_DELEGATION
+} from "@naculus/connect-core";
+import { computed as computed20, onScopeDispose as onScopeDispose31, shallowRef as shallowRef32, toValue as toValue28, watch as watch14 } from "vue";
+function useDelegation(account, client, chainId) {
+  const status = shallowRef32(UNKNOWN_DELEGATION);
+  const isFetching = shallowRef32(false);
+  const error = shallowRef32(null);
+  let generation = 0;
+  let disposed = false;
+  const refetch = async () => {
+    const mine = ++generation;
+    const reader = toValue28(client);
+    const address = bareEvmAddress7(toValue28(account));
+    status.value = UNKNOWN_DELEGATION;
+    error.value = null;
+    if (!reader || !address) {
+      isFetching.value = false;
+      return;
+    }
+    isFetching.value = true;
+    try {
+      const code = await reader.getCode({ address });
+      if (!disposed && mine === generation) {
+        status.value = readDelegation(code ?? "0x");
+      }
+    } catch (cause) {
+      if (!disposed && mine === generation) {
+        status.value = UNKNOWN_DELEGATION;
+        error.value = cause instanceof Error ? cause : new Error("Code read failed");
+      }
+    } finally {
+      if (!disposed && mine === generation) isFetching.value = false;
+    }
+  };
+  watch14(
+    [() => toValue28(account), () => toValue28(client), () => toValue28(chainId)],
+    () => {
+      void refetch();
+    },
+    { immediate: true, flush: "sync" }
+  );
+  onScopeDispose31(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    delegated: computed20(() => status.value.delegated),
+    delegate: computed20(() => status.value.delegate),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/name-lookup.ts
+import { getResolver } from "@naculus/connect-appkit-core";
+import { computed as computed21, onScopeDispose as onScopeDispose32, shallowRef as shallowRef33, toValue as toValue29, watch as watch15 } from "vue";
+function useNameLookup(options) {
+  const data = shallowRef33(null);
+  const loading = shallowRef33(false);
+  const error = shallowRef33(null);
+  let generation = 0;
+  let disposed = false;
+  const run = () => {
+    const input = toValue29(options.input).trim();
+    const skip = toValue29(options.skip) ?? false;
+    const scope = toValue29(options.scope);
+    const config = toValue29(options.resolverConfig);
+    const mine = ++generation;
+    if (!input || skip) {
+      data.value = null;
+      loading.value = false;
+      error.value = null;
+      return;
+    }
+    data.value = null;
+    loading.value = true;
+    error.value = null;
+    Promise.resolve().then(() => options.query(getResolver(config), input, scope)).then((result) => {
+      if (disposed || mine !== generation) return;
+      data.value = result;
+      loading.value = false;
+    }).catch((cause) => {
+      if (disposed || mine !== generation) return;
+      data.value = null;
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+      loading.value = false;
+    });
+  };
+  watch15(
+    () => [
+      toValue29(options.input),
+      toValue29(options.skip),
+      toValue29(options.scope),
+      toValue29(options.resolverConfig)
+    ],
+    run,
+    { immediate: true, flush: "sync", deep: true }
+  );
+  onScopeDispose32(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    data,
+    isLoading: computed21(() => loading.value),
+    error,
+    refetch: run
+  };
+}
+
+// src/useResolveName.ts
+function useResolveName(name, options) {
+  return useNameLookup({
+    input: name,
+    skip: options?.skip,
+    resolverConfig: options?.resolverConfig,
+    query: (resolver, input) => resolver.resolveName(input)
+  });
+}
+
+// src/useLookupAddress.ts
+function useLookupAddress(address, options) {
+  return useNameLookup({
+    input: address,
+    scope: options?.chainId,
+    skip: options?.skip,
+    resolverConfig: options?.resolverConfig,
+    query: (resolver, input, scope) => resolver.lookupAddress(input, scope)
+  });
+}
+
+// src/useSolanaAccount.ts
+import { computed as computed22, toValue as toValue30 } from "vue";
+function useSolanaAccount(accounts, connected) {
+  const isConnected = computed22(() => toValue30(connected));
+  const caip10 = computed22(
+    () => isConnected.value ? (toValue30(accounts) ?? []).find(
+      (account) => account.startsWith("solana:")
+    ) ?? null : null
+  );
+  const parts = computed22(() => caip10.value?.split(":") ?? []);
+  return {
+    address: computed22(
+      () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
+    ),
+    caip10,
+    chainId: computed22(
+      () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
+    ),
+    isConnected
+  };
+}
+
 // src/useChain.ts
 import {
   chainNamespace,
-  chainNumber,
+  chainNumber as chainNumber2,
   chainsForNamespace,
   describeChain,
   resolveChain
 } from "@naculus/connect-appkit-core";
-import { computed as computed2, toValue as toValue2 } from "vue";
+import { computed as computed23, toValue as toValue31 } from "vue";
 function useChain(chains, chainId) {
-  const list = computed2(() => toValue2(chains) ?? []);
-  const id = computed2(() => toValue2(chainId) ?? null);
-  const currentChain = computed2(() => resolveChain(list.value, id.value));
+  const list = computed23(() => toValue31(chains) ?? []);
+  const id = computed23(() => toValue31(chainId) ?? null);
+  const currentChain = computed23(() => resolveChain(list.value, id.value));
   return {
     currentChain,
-    chainInfo: computed2(() => describeChain(list.value, id.value)),
-    availableChains: computed2(() => chainsForNamespace(list.value, id.value)),
-    currentChainNumber: computed2(
-      () => currentChain.value ? chainNumber(currentChain.value) : null
+    chainInfo: computed23(() => describeChain(list.value, id.value)),
+    availableChains: computed23(() => chainsForNamespace(list.value, id.value)),
+    currentChainNumber: computed23(
+      () => currentChain.value ? chainNumber2(currentChain.value) : null
     ),
-    namespace: computed2(
+    namespace: computed23(
       () => currentChain.value ? chainNamespace(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-import { onScopeDispose, readonly, shallowRef } from "vue";
+import { onScopeDispose as onScopeDispose33, readonly, shallowRef as shallowRef34 } from "vue";
 function usePassphraseGate(gate) {
-  const request = shallowRef(gate.getSnapshot());
+  const request = shallowRef34(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  onScopeDispose(unsubscribe);
+  onScopeDispose33(unsubscribe);
   return {
     request: readonly(request),
     submit: (passphrase) => gate.submit(passphrase),
@@ -255,16 +2751,16 @@ function usePassphraseGate(gate) {
 import {
   getSolanaBalance
 } from "@naculus/connect-core";
-import { onScopeDispose as onScopeDispose2, ref, shallowRef as shallowRef2, toValue as toValue3, watchEffect } from "vue";
+import { onScopeDispose as onScopeDispose34, ref, shallowRef as shallowRef35, toValue as toValue32, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
-  const balance = shallowRef2(null);
+  const balance = shallowRef35(null);
   const isFetching = ref(false);
-  const error = shallowRef2(null);
+  const error = shallowRef35(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
-    const addr = toValue3(address);
-    const url = toValue3(rpcUrl);
+    const addr = toValue32(address);
+    const url = toValue32(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -285,34 +2781,224 @@ function useSolanaBalance(address, rpcUrl) {
     }
   };
   watchEffect(() => {
-    toValue3(address);
-    toValue3(rpcUrl);
+    toValue32(address);
+    toValue32(rpcUrl);
     void refetch();
   });
-  onScopeDispose2(() => {
+  onScopeDispose34(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
 
+// src/useLastTx.ts
+import { shallowRef as shallowRef36, toValue as toValue33, watch as watch16 } from "vue";
+function useLastTx(monitor) {
+  const lastTx = shallowRef36(null);
+  const lastConfirmedTx = shallowRef36(null);
+  const lastFailedTx = shallowRef36(null);
+  watch16(
+    () => toValue33(monitor),
+    (activeMonitor, _previous, onCleanup) => {
+      if (!activeMonitor) return;
+      const recordLatest = (entry) => {
+        if (!lastTx.value || entry.createdAt >= lastTx.value.createdAt) {
+          lastTx.value = entry;
+        }
+      };
+      const onConfirmed = (entry) => {
+        lastConfirmedTx.value = entry;
+        recordLatest(entry);
+      };
+      const onFailed = (entry) => {
+        lastFailedTx.value = entry;
+        recordLatest(entry);
+      };
+      activeMonitor.on("confirmed", onConfirmed);
+      activeMonitor.on("failed", onFailed);
+      onCleanup(() => {
+        activeMonitor.off("confirmed", onConfirmed);
+        activeMonitor.off("failed", onFailed);
+      });
+    },
+    { immediate: true }
+  );
+  return {
+    lastTx,
+    lastConfirmedTx,
+    lastFailedTx,
+    clear: () => {
+      lastTx.value = null;
+      lastConfirmedTx.value = null;
+      lastFailedTx.value = null;
+    }
+  };
+}
+
+// src/useTxHistory.ts
+import { computed as computed24, shallowRef as shallowRef37, toValue as toValue34, watch as watch17 } from "vue";
+function useTxHistory(address, chainId, monitor) {
+  const entries = shallowRef37([]);
+  const isLoading = shallowRef37(false);
+  const error = shallowRef37(null);
+  let generation = 0;
+  const refresh = async () => {
+    const mine = ++generation;
+    const activeMonitor = toValue34(monitor);
+    if (!activeMonitor) {
+      entries.value = [];
+      isLoading.value = false;
+      error.value = null;
+      return;
+    }
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const result = await activeMonitor.getTxHistory(
+        toValue34(address) ?? void 0,
+        toValue34(chainId) ?? void 0
+      );
+      if (mine === generation) entries.value = result;
+    } catch (err) {
+      if (mine !== generation) return;
+      error.value = err instanceof Error ? err : new Error("Failed to load transaction history");
+    } finally {
+      if (mine === generation) isLoading.value = false;
+    }
+  };
+  watch17(
+    [() => toValue34(monitor), () => toValue34(address), () => toValue34(chainId)],
+    ([activeMonitor], _previous, onCleanup) => {
+      if (!activeMonitor) {
+        void refresh();
+        return;
+      }
+      const onStatusChange = () => {
+        void refresh();
+      };
+      activeMonitor.on("statusChange", onStatusChange);
+      onCleanup(() => activeMonitor.off("statusChange", onStatusChange));
+      void refresh();
+    },
+    { immediate: true }
+  );
+  return {
+    entries,
+    isLoading,
+    error,
+    refresh,
+    summary: computed24(() => ({
+      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
+    }))
+  };
+}
+
+// src/useTxMonitor.ts
+import { computed as computed25, shallowRef as shallowRef38, toValue as toValue35, watch as watch18 } from "vue";
+function useTxMonitor(hash, chainId, monitor) {
+  const entry = shallowRef38(null);
+  const isLoading = shallowRef38(false);
+  const isWatching = shallowRef38(false);
+  const error = shallowRef38(null);
+  let generation = 0;
+  const refresh = async () => {
+    const activeMonitor = toValue35(monitor);
+    const activeHash = toValue35(hash);
+    const activeChainId = toValue35(chainId);
+    if (!activeMonitor || !activeHash) return;
+    isLoading.value = true;
+    error.value = null;
+    try {
+      await activeMonitor.refreshTx(activeHash, activeChainId ?? void 0);
+      const current = activeMonitor.getTxStatus(
+        activeHash,
+        activeChainId ?? void 0
+      );
+      if (current) entry.value = current;
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error("Failed to refresh transaction");
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const stopWatching = () => {
+    const activeMonitor = toValue35(monitor);
+    const activeHash = toValue35(hash);
+    const activeChainId = toValue35(chainId);
+    if (!activeMonitor || !activeHash) return;
+    activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
+    isWatching.value = false;
+  };
+  watch18(
+    [() => toValue35(monitor), () => toValue35(hash), () => toValue35(chainId)],
+    ([activeMonitor, activeHash, activeChainId], _previous, onCleanup) => {
+      const mine = ++generation;
+      if (!activeMonitor || !activeHash || !activeChainId) {
+        entry.value = null;
+        isLoading.value = false;
+        isWatching.value = false;
+        error.value = null;
+        return;
+      }
+      let cancelled = false;
+      const onStatusChange = (updated) => {
+        if (!cancelled && updated.hash === activeHash && updated.chainId === activeChainId) {
+          entry.value = { ...updated };
+        }
+      };
+      activeMonitor.on("statusChange", onStatusChange);
+      onCleanup(() => {
+        cancelled = true;
+        activeMonitor.off("statusChange", onStatusChange);
+      });
+      isWatching.value = true;
+      isLoading.value = true;
+      error.value = null;
+      const current = activeMonitor.getTxStatus(activeHash, activeChainId);
+      if (current) entry.value = current;
+      activeMonitor.watchTx(activeHash, activeChainId, {}).then((initial) => {
+        if (cancelled || mine !== generation) return;
+        entry.value = initial;
+        isLoading.value = false;
+      }).catch((err) => {
+        if (cancelled || mine !== generation) return;
+        error.value = err instanceof Error ? err : new Error("Failed to watch transaction");
+        isLoading.value = false;
+      });
+    },
+    { immediate: true }
+  );
+  return {
+    entry,
+    status: computed25(() => entry.value?.status ?? "idle"),
+    isLoading,
+    isWatching,
+    error,
+    refresh,
+    stopWatching
+  };
+}
+
 // src/useCapabilities.ts
 import {
   atomicSupportFor,
   normalizeCapabilities,
   selectChainCapabilities
 } from "@naculus/connect-appkit-core";
-import { computed as computed3, shallowRef as shallowRef3, toValue as toValue4, watchEffect as watchEffect2 } from "vue";
+import { computed as computed26, shallowRef as shallowRef39, toValue as toValue36, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
-  const capabilities = shallowRef3(
+  const capabilities = shallowRef39(
     null
   );
-  const isFetching = shallowRef3(false);
-  const error = shallowRef3(null);
+  const isFetching = shallowRef39(false);
+  const error = shallowRef39(null);
   let generation = 0;
   const refetch = async () => {
     const mine = ++generation;
-    const activeClient = toValue4(client);
-    const activeSession = toValue4(session);
+    const activeClient = toValue36(client);
+    const activeSession = toValue36(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       capabilities.value = null;
       isFetching.value = false;
@@ -334,17 +3020,17 @@ function useCapabilities(client, session, chainId) {
     }
   };
   watchEffect2(() => {
-    void toValue4(client);
-    void toValue4(session);
+    void toValue36(client);
+    void toValue36(session);
     void refetch();
   });
   return {
     capabilities,
-    current: computed3(
-      () => selectChainCapabilities(capabilities.value, toValue4(chainId))
+    current: computed26(
+      () => selectChainCapabilities(capabilities.value, toValue36(chainId))
     ),
-    atomic: computed3(
-      () => atomicSupportFor(capabilities.value, toValue4(chainId))
+    atomic: computed26(
+      () => atomicSupportFor(capabilities.value, toValue36(chainId))
     ),
     isFetching,
     error,
@@ -356,17 +3042,17 @@ function useCapabilities(client, session, chainId) {
 import {
   readSolanaRoles
 } from "@naculus/connect-appkit-core";
-import { computed as computed4, toValue as toValue5 } from "vue";
+import { computed as computed27, toValue as toValue37 } from "vue";
 function useSolanaRoles(connector, session) {
-  const state = computed4(
-    () => readSolanaRoles(toValue5(connector), toValue5(session))
+  const state = computed27(
+    () => readSolanaRoles(toValue37(connector), toValue37(session))
   );
   return {
-    roles: computed4(() => state.value.roles),
-    absence: computed4(() => state.value.absence),
-    identity: computed4(() => state.value.roles?.identity ?? null),
-    signer: computed4(() => state.value.roles?.signer ?? null),
-    payer: computed4(() => state.value.roles?.payer ?? null)
+    roles: computed27(() => state.value.roles),
+    absence: computed27(() => state.value.absence),
+    identity: computed27(() => state.value.roles?.identity ?? null),
+    signer: computed27(() => state.value.roles?.signer ?? null),
+    payer: computed27(() => state.value.roles?.payer ?? null)
   };
 }
 export {
@@ -398,11 +3084,56 @@ export {
   AppkitTabs,
   AppkitToggleGroup,
   AppkitTooltip,
+  useAccount,
   useAccounts,
+  useBalance,
   useCapabilities,
   useChain,
+  useCompareCosts,
+  useConnect,
+  useCreateSessionKey,
+  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
+  useSolanaRoles,
+  useSolanaTransaction,
+  useSwitchChain,
+  useTokenBalance,
+  useTokenList,
+  useTokenSearch,
+  useTransactionSimulation,
+  useTxHistory,
+  useTxMonitor,
+  useUserOpStatus,
+  useValidateDestination
 };
 //# sourceMappingURL=index.js.map