@naculus/connect-appkit-vue 0.2.4 → 0.2.5

package/dist/index.js

@@ -209,6 +209,904 @@ 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/useAccount.ts
+import { computed as computed3, toValue as toValue2 } from "vue";
+function useAccount(accounts, connected) {
+  const parsed = useAccounts(accounts);
+  const isConnected = computed3(() => toValue2(connected));
+  const accountList = computed3(() => toValue2(accounts) ?? []);
+  return {
+    accounts: computed3(
+      () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
+    ),
+    evmAccount: computed3(
+      () => isConnected.value ? parsed.evmAccount.value : null
+    ),
+    primaryAccount: computed3(() => accountList.value[0] ?? null),
+    isConnected,
+    count: computed3(() => accountList.value.length)
+  };
+}
+
+// src/useSession.ts
+import { computed as computed4, shallowRef as shallowRef2, toValue as toValue3, watch } 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 = shallowRef2(readSession(toValue3(manager)));
+  watch(
+    () => toValue3(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: computed4(() => snapshot.value.session),
+    chainSessions: computed4(() => snapshot.value.chainSessions),
+    activeChainId: computed4(() => snapshot.value.activeChainId),
+    isConnected: computed4(() => snapshot.value.session !== null),
+    connectorId: computed4(() => snapshot.value.connectorId)
+  };
+}
+
+// src/useConnect.ts
+import { WalletError } from "@naculus/connect-core";
+import { computed as computed5, onScopeDispose as onScopeDispose2, shallowRef as shallowRef3, toValue as toValue4, unref as unref2 } from "vue";
+function useConnect(action, status) {
+  const isLoading = shallowRef3(false);
+  const error = shallowRef3(null);
+  let disposed = false;
+  let inFlight = null;
+  const connect = () => {
+    if (inFlight) return inFlight;
+    const invoke = unref2(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 WalletError ? cause : new Error(message);
+    }).finally(() => {
+      if (inFlight === pending) inFlight = null;
+      if (!disposed) isLoading.value = false;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  onScopeDispose2(() => {
+    disposed = true;
+  });
+  return {
+    connect,
+    isConnecting: computed5(
+      () => isLoading.value || toValue4(status) === "connecting"
+    ),
+    error
+  };
+}
+
+// src/useDisconnect.ts
+import { onScopeDispose as onScopeDispose3, shallowRef as shallowRef4, toValue as toValue5, unref as unref3 } from "vue";
+function useDisconnect(action, status) {
+  const isDisconnecting = shallowRef4(false);
+  const error = shallowRef4(null);
+  let disposed = false;
+  let inFlight = null;
+  const disconnect = () => {
+    if (inFlight) return inFlight;
+    if (toValue5(status) === "disconnected") return Promise.resolve();
+    const invoke = unref3(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;
+  };
+  onScopeDispose3(cleanup);
+  return { disconnect, isDisconnecting, error, cleanup };
+}
+
+// src/useSwitchChain.ts
+import { toChainSwitchError } from "@naculus/connect-appkit-core";
+import { computed as computed6, onScopeDispose as onScopeDispose4, shallowRef as shallowRef5, toValue as toValue6, unref as unref4 } from "vue";
+function useSwitchChain(action, chainId) {
+  const isSwitching = shallowRef5(false);
+  const error = shallowRef5(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const switchChain = async (targetChainId) => {
+    const invoke = unref4(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;
+    }
+  };
+  onScopeDispose4(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    switchChain,
+    isSwitching,
+    currentChainId: computed6(() => toValue6(chainId) ?? null),
+    error,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/useBalance.ts
+import { bareEvmAddress } from "@naculus/connect-appkit-core";
+import { formatUnits } from "@naculus/connect-core";
+import { computed as computed7, onScopeDispose as onScopeDispose5, shallowRef as shallowRef6, toValue as toValue7, watch as watch2 } from "vue";
+function useBalance(account, client, options = {}) {
+  const balance = shallowRef6(null);
+  const isFetching = shallowRef6(false);
+  const error = shallowRef6(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = toValue7(client);
+    const address = bareEvmAddress(toValue7(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;
+  };
+  watch2(
+    [
+      () => toValue7(account),
+      () => toValue7(client),
+      () => toValue7(options.refreshInterval) ?? 0
+    ],
+    ([, , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  onScopeDispose5(() => {
+    disposed = true;
+    generation++;
+    stopTimer();
+  });
+  return {
+    balance,
+    formatted: computed7(
+      () => balance.value === null ? null : formatUnits(BigInt(balance.value), toValue7(options.decimals) ?? 18)
+    ),
+    symbol: computed7(() => toValue7(options.symbol) ?? null),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/useRouteQuote.ts
+import {
+  isQuotableInput
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose6, shallowRef as shallowRef7, toValue as toValue8, unref as unref5, watch as watch3 } from "vue";
+function useRouteQuote(input, getQuotes, options = {}) {
+  const quotes = shallowRef7([]);
+  const loading = shallowRef7(false);
+  const error = shallowRef7(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const clearTimer = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  const fetchQuotes = async () => {
+    const current = toValue8(input);
+    const fn = unref5(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;
+    }
+  };
+  watch3(
+    [
+      () => toValue8(input).fromChain,
+      () => toValue8(input).toChain,
+      () => toValue8(input).fromToken,
+      () => toValue8(input).toToken,
+      () => toValue8(input).amount,
+      () => unref5(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 }
+  );
+  onScopeDispose6(() => {
+    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 onScopeDispose7, shallowRef as shallowRef8, toValue as toValue9, unref as unref6, watch as watch4 } from "vue";
+function useCompareCosts(input, compareCosts) {
+  const comparisons = shallowRef8([]);
+  const loading = shallowRef8(false);
+  const error = shallowRef8(null);
+  let generation = 0;
+  let disposed = false;
+  const fetchComparisons = async () => {
+    const { operation, chains, options } = toValue9(input);
+    const fn = unref6(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;
+    }
+  };
+  watch4(
+    [() => compareCostsKey(toValue9(input)), () => unref6(compareCosts)],
+    () => {
+      void fetchComparisons();
+    },
+    { immediate: true }
+  );
+  onScopeDispose7(() => {
+    disposed = true;
+    generation++;
+  });
+  return { comparisons, loading, error, refresh: fetchComparisons };
+}
+
+// src/useExecuteRoute.ts
+import {
+  toExecuteRouteError,
+  validateRouteRecipient
+} from "@naculus/connect-appkit-core";
+import { onScopeDispose as onScopeDispose8, shallowRef as shallowRef9, unref as unref7 } from "vue";
+function useExecuteRoute(executeRoute) {
+  const executing = shallowRef9(false);
+  const result = shallowRef9(null);
+  const error = shallowRef9(null);
+  let inFlight = false;
+  let disposed = false;
+  const execute = async (quote, recipient, options) => {
+    const fn = unref7(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;
+    }
+  };
+  onScopeDispose8(() => {
+    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 onScopeDispose9, shallowRef as shallowRef10, toValue as toValue10, watch as watch5 } from "vue";
+function useTokenList(chainId, options = {}) {
+  const config = {};
+  if (options.sources) config.sources = options.sources;
+  const manager = options.manager ?? new TokenListManager(config);
+  const tokens = shallowRef10([]);
+  const isLoading = shallowRef10(options.autoLoad !== false);
+  const isLoaded = shallowRef10(false);
+  const error = shallowRef10(null);
+  let generation = 0;
+  let disposed = false;
+  const select = () => {
+    const id = toValue10(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;
+    }
+  };
+  watch5(
+    () => toValue10(chainId),
+    () => {
+      if (options.autoLoad !== false) void run(() => manager.load());
+    },
+    { immediate: true }
+  );
+  onScopeDispose9(() => {
+    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 onScopeDispose10, shallowRef as shallowRef11, toValue as toValue11, watch as watch6 } 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 = shallowRef11(EMPTY);
+  const isSearching = shallowRef11(false);
+  let timer = null;
+  const clear = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  watch6(
+    [() => (toValue11(query) ?? "").trim(), () => toValue11(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 }
+  );
+  onScopeDispose10(clear);
+  return { results, isSearching };
+}
+
+// src/useValidateDestination.ts
+import {
+  validateDestination
+} from "@naculus/connect-appkit-core";
+import { computed as computed8, toValue as toValue12 } from "vue";
+function useValidateDestination(address) {
+  return {
+    validation: computed8(() => validateDestination(toValue12(address) ?? ""))
+  };
+}
+
+// src/useTokenBalance.ts
+import { bareEvmAddress as bareEvmAddress2 } from "@naculus/connect-appkit-core";
+import { ERC20_MIN_ABI, formatUnits as formatUnits2 } from "@naculus/connect-core";
+import { onScopeDispose as onScopeDispose11, shallowRef as shallowRef12, toValue as toValue13, watch as watch7 } 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 = shallowRef12([]);
+  const isFetching = shallowRef12(false);
+  const error = shallowRef12(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = toValue13(client);
+    const address = bareEvmAddress2(toValue13(account));
+    const list = toValue13(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_ABI,
+              functionName: "balanceOf",
+              args: [address]
+            });
+            const value = BigInt(raw);
+            return {
+              ...token,
+              balance: value.toString(),
+              formatted: formatUnits2(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;
+  };
+  watch7(
+    [
+      () => toValue13(account),
+      () => toValue13(client),
+      () => tokensKey(toValue13(tokens) ?? []),
+      () => toValue13(options.refreshInterval) ?? 0
+    ],
+    ([, , , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  onScopeDispose11(() => {
+    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 bareEvmAddress3 } from "@naculus/connect-appkit-core";
+import {
+  readDelegation,
+  UNKNOWN_DELEGATION
+} from "@naculus/connect-core";
+import { computed as computed9, onScopeDispose as onScopeDispose12, shallowRef as shallowRef13, toValue as toValue14, watch as watch8 } from "vue";
+function useDelegation(account, client, chainId) {
+  const status = shallowRef13(UNKNOWN_DELEGATION);
+  const isFetching = shallowRef13(false);
+  const error = shallowRef13(null);
+  let generation = 0;
+  let disposed = false;
+  const refetch = async () => {
+    const mine = ++generation;
+    const reader = toValue14(client);
+    const address = bareEvmAddress3(toValue14(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;
+    }
+  };
+  watch8(
+    () => [toValue14(account), toValue14(client), toValue14(chainId)],
+    () => {
+      void refetch();
+    },
+    { immediate: true, flush: "sync" }
+  );
+  onScopeDispose12(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    delegated: computed9(() => status.value.delegated),
+    delegate: computed9(() => status.value.delegate),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/name-lookup.ts
+import { getResolver } from "@naculus/connect-appkit-core";
+import { computed as computed10, onScopeDispose as onScopeDispose13, shallowRef as shallowRef14, toValue as toValue15, watch as watch9 } from "vue";
+function useNameLookup(options) {
+  const data = shallowRef14(null);
+  const loading = shallowRef14(false);
+  const error = shallowRef14(null);
+  let generation = 0;
+  let disposed = false;
+  const run = () => {
+    const input = toValue15(options.input).trim();
+    const skip = toValue15(options.skip) ?? false;
+    const scope = toValue15(options.scope);
+    const config = toValue15(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;
+    });
+  };
+  watch9(
+    () => [
+      toValue15(options.input),
+      toValue15(options.skip),
+      toValue15(options.scope),
+      toValue15(options.resolverConfig)
+    ],
+    run,
+    { immediate: true, flush: "sync", deep: true }
+  );
+  onScopeDispose13(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    data,
+    isLoading: computed10(() => 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 computed11, toValue as toValue16 } from "vue";
+function useSolanaAccount(accounts, connected) {
+  const isConnected = computed11(() => toValue16(connected));
+  const caip10 = computed11(
+    () => isConnected.value ? (toValue16(accounts) ?? []).find(
+      (account) => account.startsWith("solana:")
+    ) ?? null : null
+  );
+  const parts = computed11(() => caip10.value?.split(":") ?? []);
+  return {
+    address: computed11(
+      () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
+    ),
+    caip10,
+    chainId: computed11(
+      () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
+    ),
+    isConnected
+  };
+}
+
 // src/useChain.ts
 import {
   chainNamespace,
@@ -217,32 +1115,32 @@ import {
   describeChain,
   resolveChain
 } from "@naculus/connect-appkit-core";
-import { computed as computed2, toValue as toValue2 } from "vue";
+import { computed as computed12, toValue as toValue17 } 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 = computed12(() => toValue17(chains) ?? []);
+  const id = computed12(() => toValue17(chainId) ?? null);
+  const currentChain = computed12(() => resolveChain(list.value, id.value));
   return {
     currentChain,
-    chainInfo: computed2(() => describeChain(list.value, id.value)),
-    availableChains: computed2(() => chainsForNamespace(list.value, id.value)),
-    currentChainNumber: computed2(
+    chainInfo: computed12(() => describeChain(list.value, id.value)),
+    availableChains: computed12(() => chainsForNamespace(list.value, id.value)),
+    currentChainNumber: computed12(
       () => currentChain.value ? chainNumber(currentChain.value) : null
     ),
-    namespace: computed2(
+    namespace: computed12(
       () => currentChain.value ? chainNamespace(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-import { onScopeDispose, readonly, shallowRef } from "vue";
+import { onScopeDispose as onScopeDispose14, readonly, shallowRef as shallowRef15 } from "vue";
 function usePassphraseGate(gate) {
-  const request = shallowRef(gate.getSnapshot());
+  const request = shallowRef15(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  onScopeDispose(unsubscribe);
+  onScopeDispose14(unsubscribe);
   return {
     request: readonly(request),
     submit: (passphrase) => gate.submit(passphrase),
@@ -255,16 +1153,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 onScopeDispose15, ref, shallowRef as shallowRef16, toValue as toValue18, watchEffect } from "vue";
 function useSolanaBalance(address, rpcUrl) {
-  const balance = shallowRef2(null);
+  const balance = shallowRef16(null);
   const isFetching = ref(false);
-  const error = shallowRef2(null);
+  const error = shallowRef16(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
-    const addr = toValue3(address);
-    const url = toValue3(rpcUrl);
+    const addr = toValue18(address);
+    const url = toValue18(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -285,34 +1183,229 @@ function useSolanaBalance(address, rpcUrl) {
     }
   };
   watchEffect(() => {
-    toValue3(address);
-    toValue3(rpcUrl);
+    toValue18(address);
+    toValue18(rpcUrl);
     void refetch();
   });
-  onScopeDispose2(() => {
+  onScopeDispose15(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
 
+// src/useLastTx.ts
+import { shallowRef as shallowRef17, toValue as toValue19, watch as watch10 } from "vue";
+function useLastTx(monitor) {
+  const lastTx = shallowRef17(null);
+  const lastConfirmedTx = shallowRef17(null);
+  const lastFailedTx = shallowRef17(null);
+  watch10(
+    () => toValue19(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 computed13, shallowRef as shallowRef18, toValue as toValue20, watch as watch11 } from "vue";
+function useTxHistory(address, chainId, monitor) {
+  const entries = shallowRef18([]);
+  const isLoading = shallowRef18(false);
+  const error = shallowRef18(null);
+  let generation = 0;
+  const refresh = async () => {
+    const mine = ++generation;
+    const activeMonitor = toValue20(monitor);
+    if (!activeMonitor) {
+      entries.value = [];
+      isLoading.value = false;
+      error.value = null;
+      return;
+    }
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const result = await activeMonitor.getTxHistory(
+        toValue20(address) ?? void 0,
+        toValue20(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;
+    }
+  };
+  watch11(
+    () => [toValue20(monitor), toValue20(address), toValue20(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: computed13(() => ({
+      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 computed14,
+  shallowRef as shallowRef19,
+  toValue as toValue21,
+  watch as watch12
+} from "vue";
+function useTxMonitor(hash, chainId, monitor) {
+  const entry = shallowRef19(null);
+  const isLoading = shallowRef19(false);
+  const isWatching = shallowRef19(false);
+  const error = shallowRef19(null);
+  let generation = 0;
+  const refresh = async () => {
+    const activeMonitor = toValue21(monitor);
+    const activeHash = toValue21(hash);
+    const activeChainId = toValue21(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 = toValue21(monitor);
+    const activeHash = toValue21(hash);
+    const activeChainId = toValue21(chainId);
+    if (!activeMonitor || !activeHash) return;
+    activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
+    isWatching.value = false;
+  };
+  watch12(
+    () => [toValue21(monitor), toValue21(hash), toValue21(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: computed14(() => 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 computed15, shallowRef as shallowRef20, toValue as toValue22, watchEffect as watchEffect2 } from "vue";
 function useCapabilities(client, session, chainId) {
-  const capabilities = shallowRef3(
+  const capabilities = shallowRef20(
     null
   );
-  const isFetching = shallowRef3(false);
-  const error = shallowRef3(null);
+  const isFetching = shallowRef20(false);
+  const error = shallowRef20(null);
   let generation = 0;
   const refetch = async () => {
     const mine = ++generation;
-    const activeClient = toValue4(client);
-    const activeSession = toValue4(session);
+    const activeClient = toValue22(client);
+    const activeSession = toValue22(session);
     if (!activeClient?.getCapabilities || !activeSession) {
       capabilities.value = null;
       isFetching.value = false;
@@ -334,17 +1427,17 @@ function useCapabilities(client, session, chainId) {
     }
   };
   watchEffect2(() => {
-    void toValue4(client);
-    void toValue4(session);
+    void toValue22(client);
+    void toValue22(session);
     void refetch();
   });
   return {
     capabilities,
-    current: computed3(
-      () => selectChainCapabilities(capabilities.value, toValue4(chainId))
+    current: computed15(
+      () => selectChainCapabilities(capabilities.value, toValue22(chainId))
     ),
-    atomic: computed3(
-      () => atomicSupportFor(capabilities.value, toValue4(chainId))
+    atomic: computed15(
+      () => atomicSupportFor(capabilities.value, toValue22(chainId))
     ),
     isFetching,
     error,
@@ -356,17 +1449,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 computed16, toValue as toValue23 } from "vue";
 function useSolanaRoles(connector, session) {
-  const state = computed4(
-    () => readSolanaRoles(toValue5(connector), toValue5(session))
+  const state = computed16(
+    () => readSolanaRoles(toValue23(connector), toValue23(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: computed16(() => state.value.roles),
+    absence: computed16(() => state.value.absence),
+    identity: computed16(() => state.value.roles?.identity ?? null),
+    signer: computed16(() => state.value.roles?.signer ?? null),
+    payer: computed16(() => state.value.roles?.payer ?? null)
   };
 }
 export {
@@ -398,11 +1491,32 @@ export {
   AppkitTabs,
   AppkitToggleGroup,
   AppkitTooltip,
+  useAccount,
   useAccounts,
+  useBalance,
   useCapabilities,
   useChain,
+  useCompareCosts,
+  useConnect,
+  useDelegation,
+  useDisconnect,
+  useExecuteRoute,
+  useLastTx,
+  useLookupAddress,
+  useNotification,
   usePassphraseGate,
+  useResolveName,
+  useRouteQuote,
+  useSession,
+  useSolanaAccount,
   useSolanaBalance,
-  useSolanaRoles
+  useSolanaRoles,
+  useSwitchChain,
+  useTokenBalance,
+  useTokenList,
+  useTokenSearch,
+  useTxHistory,
+  useTxMonitor,
+  useValidateDestination
 };
 //# sourceMappingURL=index.js.map