@naculus/connect-appkit-vue 0.2.3 → 0.2.5

package/dist/index.cjs

@@ -48,10 +48,33 @@ __export(index_exports, {
   AppkitTabs: () => AppkitTabs,
   AppkitToggleGroup: () => AppkitToggleGroup,
   AppkitTooltip: () => AppkitTooltip,
+  useAccount: () => useAccount,
   useAccounts: () => useAccounts,
+  useBalance: () => useBalance,
+  useCapabilities: () => useCapabilities,
   useChain: () => useChain,
+  useCompareCosts: () => useCompareCosts,
+  useConnect: () => useConnect,
+  useDelegation: () => useDelegation,
+  useDisconnect: () => useDisconnect,
+  useExecuteRoute: () => useExecuteRoute,
+  useLastTx: () => useLastTx,
+  useLookupAddress: () => useLookupAddress,
+  useNotification: () => useNotification,
   usePassphraseGate: () => usePassphraseGate,
-  useSolanaBalance: () => useSolanaBalance
+  useResolveName: () => useResolveName,
+  useRouteQuote: () => useRouteQuote,
+  useSession: () => useSession,
+  useSolanaAccount: () => useSolanaAccount,
+  useSolanaBalance: () => useSolanaBalance,
+  useSolanaRoles: () => useSolanaRoles,
+  useSwitchChain: () => useSwitchChain,
+  useTokenBalance: () => useTokenBalance,
+  useTokenList: () => useTokenList,
+  useTokenSearch: () => useTokenSearch,
+  useTxHistory: () => useTxHistory,
+  useTxMonitor: () => useTxMonitor,
+  useValidateDestination: () => useValidateDestination
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -266,36 +289,906 @@ function useAccounts(accounts) {
   };
 }
 
-// src/useChain.ts
+// src/useNotification.ts
 var import_connect_appkit_core = require("@naculus/connect-appkit-core");
+var import_connect_core2 = require("@naculus/connect-core");
 var import_vue2 = require("vue");
+function useNotification(options = {}) {
+  const channel = (0, import_vue2.unref)(options.channel) ?? new import_connect_core2.InAppChannel();
+  const storage = (0, import_vue2.unref)(options.storage) ?? (0, import_connect_appkit_core.createNotificationSettingsStorage)();
+  const notifications = (0, import_vue2.shallowRef)(channel.getHistory());
+  const settings = (0, import_vue2.shallowRef)(
+    import_connect_appkit_core.DEFAULT_NOTIFICATION_SETTINGS
+  );
+  const unreadCount = (0, import_vue2.computed)(
+    () => notifications.value.filter((item) => !item.read).length
+  );
+  let disposed = false;
+  void (0, import_connect_appkit_core.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();
+  });
+  (0, import_vue2.onScopeDispose)(() => {
+    disposed = true;
+    channel.onNotification = void 0;
+  });
+  const updateSettings = (update) => {
+    settings.value = (0, import_connect_appkit_core.updateNotificationSettings)(settings.value, update);
+    (0, import_connect_appkit_core.saveNotificationSettings)(storage, settings.value);
+  };
+  return {
+    notifications,
+    unreadCount,
+    settings,
+    addNotification: (item) => (0, import_connect_appkit_core.addInAppNotification)(channel, item),
+    clear: () => {
+      channel.clear();
+      notifications.value = [];
+    },
+    clearOne: (id) => {
+      void (0, import_connect_appkit_core.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((0, import_connect_appkit_core.channelsUpdate)(channels)),
+    muteChain: (chainId) => updateSettings((0, import_connect_appkit_core.mutedChainSettings)(settings.value, chainId, true)),
+    unmuteChain: (chainId) => updateSettings((0, import_connect_appkit_core.mutedChainSettings)(settings.value, chainId, false))
+  };
+}
+
+// src/useAccount.ts
+var import_vue3 = require("vue");
+function useAccount(accounts, connected) {
+  const parsed = useAccounts(accounts);
+  const isConnected = (0, import_vue3.computed)(() => (0, import_vue3.toValue)(connected));
+  const accountList = (0, import_vue3.computed)(() => (0, import_vue3.toValue)(accounts) ?? []);
+  return {
+    accounts: (0, import_vue3.computed)(
+      () => isConnected.value && accountList.value.length > 0 ? parsed.accounts.value : null
+    ),
+    evmAccount: (0, import_vue3.computed)(
+      () => isConnected.value ? parsed.evmAccount.value : null
+    ),
+    primaryAccount: (0, import_vue3.computed)(() => accountList.value[0] ?? null),
+    isConnected,
+    count: (0, import_vue3.computed)(() => accountList.value.length)
+  };
+}
+
+// src/useSession.ts
+var import_vue4 = require("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 = (0, import_vue4.shallowRef)(readSession((0, import_vue4.toValue)(manager)));
+  (0, import_vue4.watch)(
+    () => (0, import_vue4.toValue)(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: (0, import_vue4.computed)(() => snapshot.value.session),
+    chainSessions: (0, import_vue4.computed)(() => snapshot.value.chainSessions),
+    activeChainId: (0, import_vue4.computed)(() => snapshot.value.activeChainId),
+    isConnected: (0, import_vue4.computed)(() => snapshot.value.session !== null),
+    connectorId: (0, import_vue4.computed)(() => snapshot.value.connectorId)
+  };
+}
+
+// src/useConnect.ts
+var import_connect_core3 = require("@naculus/connect-core");
+var import_vue5 = require("vue");
+function useConnect(action, status) {
+  const isLoading = (0, import_vue5.shallowRef)(false);
+  const error = (0, import_vue5.shallowRef)(null);
+  let disposed = false;
+  let inFlight = null;
+  const connect = () => {
+    if (inFlight) return inFlight;
+    const invoke = (0, import_vue5.unref)(action);
+    isLoading.value = true;
+    error.value = null;
+    const pending = Promise.resolve().then(() => invoke()).catch((cause) => {
+      if (disposed) return;
+      const message = cause instanceof Error ? cause.message : "Connection failed";
+      error.value = cause instanceof import_connect_core3.WalletError ? cause : new Error(message);
+    }).finally(() => {
+      if (inFlight === pending) inFlight = null;
+      if (!disposed) isLoading.value = false;
+    });
+    inFlight = pending;
+    return pending;
+  };
+  (0, import_vue5.onScopeDispose)(() => {
+    disposed = true;
+  });
+  return {
+    connect,
+    isConnecting: (0, import_vue5.computed)(
+      () => isLoading.value || (0, import_vue5.toValue)(status) === "connecting"
+    ),
+    error
+  };
+}
+
+// src/useDisconnect.ts
+var import_vue6 = require("vue");
+function useDisconnect(action, status) {
+  const isDisconnecting = (0, import_vue6.shallowRef)(false);
+  const error = (0, import_vue6.shallowRef)(null);
+  let disposed = false;
+  let inFlight = null;
+  const disconnect = () => {
+    if (inFlight) return inFlight;
+    if ((0, import_vue6.toValue)(status) === "disconnected") return Promise.resolve();
+    const invoke = (0, import_vue6.unref)(action);
+    isDisconnecting.value = true;
+    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;
+  };
+  (0, import_vue6.onScopeDispose)(cleanup);
+  return { disconnect, isDisconnecting, error, cleanup };
+}
+
+// src/useSwitchChain.ts
+var import_connect_appkit_core2 = require("@naculus/connect-appkit-core");
+var import_vue7 = require("vue");
+function useSwitchChain(action, chainId) {
+  const isSwitching = (0, import_vue7.shallowRef)(false);
+  const error = (0, import_vue7.shallowRef)(null);
+  let generation = 0;
+  let active = 0;
+  let disposed = false;
+  const switchChain = async (targetChainId) => {
+    const invoke = (0, import_vue7.unref)(action);
+    const mine = ++generation;
+    active++;
+    isSwitching.value = true;
+    error.value = null;
+    try {
+      await invoke(targetChainId);
+    } catch (cause) {
+      const walletError = (0, import_connect_appkit_core2.toChainSwitchError)(cause);
+      if (!disposed && mine === generation) error.value = walletError;
+      throw walletError;
+    } finally {
+      active--;
+      if (!disposed) isSwitching.value = active > 0;
+    }
+  };
+  (0, import_vue7.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    switchChain,
+    isSwitching,
+    currentChainId: (0, import_vue7.computed)(() => (0, import_vue7.toValue)(chainId) ?? null),
+    error,
+    clearError: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/useBalance.ts
+var import_connect_appkit_core3 = require("@naculus/connect-appkit-core");
+var import_connect_core4 = require("@naculus/connect-core");
+var import_vue8 = require("vue");
+function useBalance(account, client, options = {}) {
+  const balance = (0, import_vue8.shallowRef)(null);
+  const isFetching = (0, import_vue8.shallowRef)(false);
+  const error = (0, import_vue8.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = (0, import_vue8.toValue)(client);
+    const address = (0, import_connect_appkit_core3.bareEvmAddress)((0, import_vue8.toValue)(account));
+    const 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;
+  };
+  (0, import_vue8.watch)(
+    [
+      () => (0, import_vue8.toValue)(account),
+      () => (0, import_vue8.toValue)(client),
+      () => (0, import_vue8.toValue)(options.refreshInterval) ?? 0
+    ],
+    ([, , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  (0, import_vue8.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    stopTimer();
+  });
+  return {
+    balance,
+    formatted: (0, import_vue8.computed)(
+      () => balance.value === null ? null : (0, import_connect_core4.formatUnits)(BigInt(balance.value), (0, import_vue8.toValue)(options.decimals) ?? 18)
+    ),
+    symbol: (0, import_vue8.computed)(() => (0, import_vue8.toValue)(options.symbol) ?? null),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/useRouteQuote.ts
+var import_connect_appkit_core4 = require("@naculus/connect-appkit-core");
+var import_vue9 = require("vue");
+function useRouteQuote(input, getQuotes, options = {}) {
+  const quotes = (0, import_vue9.shallowRef)([]);
+  const loading = (0, import_vue9.shallowRef)(false);
+  const error = (0, import_vue9.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const clearTimer = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  const fetchQuotes = async () => {
+    const current = (0, import_vue9.toValue)(input);
+    const fn = (0, import_vue9.unref)(getQuotes);
+    const own = ++generation;
+    if (!(0, import_connect_appkit_core4.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;
+    }
+  };
+  (0, import_vue9.watch)(
+    [
+      () => (0, import_vue9.toValue)(input).fromChain,
+      () => (0, import_vue9.toValue)(input).toChain,
+      () => (0, import_vue9.toValue)(input).fromToken,
+      () => (0, import_vue9.toValue)(input).toToken,
+      () => (0, import_vue9.toValue)(input).amount,
+      () => (0, import_vue9.unref)(getQuotes)
+    ],
+    ([fromChain, toChain, fromToken, , amount]) => {
+      clearTimer();
+      if (!fromChain || !toChain || !fromToken || !amount) {
+        quotes.value = [];
+        return;
+      }
+      timer = setTimeout(() => {
+        timer = null;
+        void fetchQuotes();
+      }, options.debounceMs ?? 300);
+    },
+    { immediate: true }
+  );
+  (0, import_vue9.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    clearTimer();
+  });
+  return {
+    quotes,
+    loading,
+    error,
+    refresh: fetchQuotes,
+    clear: () => {
+      clearTimer();
+      generation++;
+      quotes.value = [];
+      error.value = null;
+      loading.value = false;
+    }
+  };
+}
+
+// src/useCompareCosts.ts
+var import_connect_appkit_core5 = require("@naculus/connect-appkit-core");
+var import_vue10 = require("vue");
+function useCompareCosts(input, compareCosts) {
+  const comparisons = (0, import_vue10.shallowRef)([]);
+  const loading = (0, import_vue10.shallowRef)(false);
+  const error = (0, import_vue10.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const fetchComparisons = async () => {
+    const { operation, chains, options } = (0, import_vue10.toValue)(input);
+    const fn = (0, import_vue10.unref)(compareCosts);
+    const 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;
+    }
+  };
+  (0, import_vue10.watch)(
+    [() => (0, import_connect_appkit_core5.compareCostsKey)((0, import_vue10.toValue)(input)), () => (0, import_vue10.unref)(compareCosts)],
+    () => {
+      void fetchComparisons();
+    },
+    { immediate: true }
+  );
+  (0, import_vue10.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return { comparisons, loading, error, refresh: fetchComparisons };
+}
+
+// src/useExecuteRoute.ts
+var import_connect_appkit_core6 = require("@naculus/connect-appkit-core");
+var import_vue11 = require("vue");
+function useExecuteRoute(executeRoute) {
+  const executing = (0, import_vue11.shallowRef)(false);
+  const result = (0, import_vue11.shallowRef)(null);
+  const error = (0, import_vue11.shallowRef)(null);
+  let inFlight = false;
+  let disposed = false;
+  const execute = async (quote, recipient, options) => {
+    const fn = (0, import_vue11.unref)(executeRoute);
+    if (!fn) {
+      error.value = {
+        code: "no_executor",
+        message: "No executeRoute function provided"
+      };
+      result.value = null;
+      return null;
+    }
+    const recipientError = (0, import_connect_appkit_core6.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 = (0, import_connect_appkit_core6.toExecuteRouteError)(cause);
+      return null;
+    } finally {
+      inFlight = false;
+      if (!disposed) executing.value = false;
+    }
+  };
+  (0, import_vue11.onScopeDispose)(() => {
+    disposed = true;
+  });
+  return {
+    execute,
+    executing,
+    result,
+    error,
+    reset: () => {
+      result.value = null;
+      error.value = null;
+      executing.value = false;
+    }
+  };
+}
+
+// src/useTokenList.ts
+var import_connect_appkit_core7 = require("@naculus/connect-appkit-core");
+var import_connect_core5 = require("@naculus/connect-core");
+var import_vue12 = require("vue");
+function useTokenList(chainId, options = {}) {
+  const config = {};
+  if (options.sources) config.sources = options.sources;
+  const manager = options.manager ?? new import_connect_core5.TokenListManager(config);
+  const tokens = (0, import_vue12.shallowRef)([]);
+  const isLoading = (0, import_vue12.shallowRef)(options.autoLoad !== false);
+  const isLoaded = (0, import_vue12.shallowRef)(false);
+  const error = (0, import_vue12.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const select = () => {
+    const id = (0, import_vue12.toValue)(chainId);
+    const numeric = id ? (0, import_connect_appkit_core7.eip155ChainIdToNumber)(id) : void 0;
+    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;
+    }
+  };
+  (0, import_vue12.watch)(
+    () => (0, import_vue12.toValue)(chainId),
+    () => {
+      if (options.autoLoad !== false) void run(() => manager.load());
+    },
+    { immediate: true }
+  );
+  (0, import_vue12.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    tokens,
+    isLoading,
+    isLoaded,
+    error,
+    refetch: () => run(() => manager.refresh())
+  };
+}
+
+// src/useTokenSearch.ts
+var import_connect_appkit_core8 = require("@naculus/connect-appkit-core");
+var import_connect_core6 = require("@naculus/connect-core");
+var import_vue13 = require("vue");
+var DEBOUNCE_MS = 300;
+var EMPTY = { exact: [], fuzzy: [], hasMore: false };
+var sharedManager = null;
+function getSharedManager() {
+  if (!sharedManager) {
+    sharedManager = new import_connect_core6.TokenListManager();
+    sharedManager.load().catch(() => {
+    });
+  }
+  return sharedManager;
+}
+function useTokenSearch(query, chainId, options = {}) {
+  const results = (0, import_vue13.shallowRef)(EMPTY);
+  const isSearching = (0, import_vue13.shallowRef)(false);
+  let timer = null;
+  const clear = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  (0, import_vue13.watch)(
+    [() => ((0, import_vue13.toValue)(query) ?? "").trim(), () => (0, import_vue13.toValue)(chainId)],
+    ([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 ? (0, import_connect_appkit_core8.eip155ChainIdToNumber)(id) : void 0;
+        results.value = manager.search(q, {
+          chainId: numeric,
+          limit: options.limit ?? 20
+        });
+        isSearching.value = false;
+      }, options.debounceMs ?? DEBOUNCE_MS);
+    },
+    { immediate: true }
+  );
+  (0, import_vue13.onScopeDispose)(clear);
+  return { results, isSearching };
+}
+
+// src/useValidateDestination.ts
+var import_connect_appkit_core9 = require("@naculus/connect-appkit-core");
+var import_vue14 = require("vue");
+function useValidateDestination(address) {
+  return {
+    validation: (0, import_vue14.computed)(() => (0, import_connect_appkit_core9.validateDestination)((0, import_vue14.toValue)(address) ?? ""))
+  };
+}
+
+// src/useTokenBalance.ts
+var import_connect_appkit_core10 = require("@naculus/connect-appkit-core");
+var import_connect_core7 = require("@naculus/connect-core");
+var import_vue15 = require("vue");
+function tokensKey(tokens) {
+  return tokens.map((t) => `${t.address.toLowerCase()}|${t.decimals}|${t.symbol}`).join(",");
+}
+function useTokenBalance(account, client, tokens, options = {}) {
+  const tokenBalances = (0, import_vue15.shallowRef)([]);
+  const isFetching = (0, import_vue15.shallowRef)(false);
+  const error = (0, import_vue15.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  let timer = null;
+  const refetch = async () => {
+    const reader = (0, import_vue15.toValue)(client);
+    const address = (0, import_connect_appkit_core10.bareEvmAddress)((0, import_vue15.toValue)(account));
+    const list = (0, import_vue15.toValue)(tokens) ?? [];
+    const 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: import_connect_core7.ERC20_MIN_ABI,
+              functionName: "balanceOf",
+              args: [address]
+            });
+            const value = BigInt(raw);
+            return {
+              ...token,
+              balance: value.toString(),
+              formatted: (0, import_connect_core7.formatUnits)(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;
+  };
+  (0, import_vue15.watch)(
+    [
+      () => (0, import_vue15.toValue)(account),
+      () => (0, import_vue15.toValue)(client),
+      () => tokensKey((0, import_vue15.toValue)(tokens) ?? []),
+      () => (0, import_vue15.toValue)(options.refreshInterval) ?? 0
+    ],
+    ([, , , interval]) => {
+      stopTimer();
+      void refetch();
+      if (interval > 0) timer = setInterval(() => void refetch(), interval);
+    },
+    { immediate: true }
+  );
+  (0, import_vue15.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+    stopTimer();
+  });
+  return {
+    tokenBalances,
+    isFetching,
+    error,
+    refetch,
+    getTokenBalance: (tokenAddress) => tokenBalances.value.find(
+      (t) => t.address.toLowerCase() === tokenAddress.toLowerCase()
+    )
+  };
+}
+
+// src/useDelegation.ts
+var import_connect_appkit_core11 = require("@naculus/connect-appkit-core");
+var import_connect_core8 = require("@naculus/connect-core");
+var import_vue16 = require("vue");
+function useDelegation(account, client, chainId) {
+  const status = (0, import_vue16.shallowRef)(import_connect_core8.UNKNOWN_DELEGATION);
+  const isFetching = (0, import_vue16.shallowRef)(false);
+  const error = (0, import_vue16.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const refetch = async () => {
+    const mine = ++generation;
+    const reader = (0, import_vue16.toValue)(client);
+    const address = (0, import_connect_appkit_core11.bareEvmAddress)((0, import_vue16.toValue)(account));
+    status.value = import_connect_core8.UNKNOWN_DELEGATION;
+    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 = (0, import_connect_core8.readDelegation)(code ?? "0x");
+      }
+    } catch (cause) {
+      if (!disposed && mine === generation) {
+        status.value = import_connect_core8.UNKNOWN_DELEGATION;
+        error.value = cause instanceof Error ? cause : new Error("Code read failed");
+      }
+    } finally {
+      if (!disposed && mine === generation) isFetching.value = false;
+    }
+  };
+  (0, import_vue16.watch)(
+    () => [(0, import_vue16.toValue)(account), (0, import_vue16.toValue)(client), (0, import_vue16.toValue)(chainId)],
+    () => {
+      void refetch();
+    },
+    { immediate: true, flush: "sync" }
+  );
+  (0, import_vue16.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    delegated: (0, import_vue16.computed)(() => status.value.delegated),
+    delegate: (0, import_vue16.computed)(() => status.value.delegate),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/name-lookup.ts
+var import_connect_appkit_core12 = require("@naculus/connect-appkit-core");
+var import_vue17 = require("vue");
+function useNameLookup(options) {
+  const data = (0, import_vue17.shallowRef)(null);
+  const loading = (0, import_vue17.shallowRef)(false);
+  const error = (0, import_vue17.shallowRef)(null);
+  let generation = 0;
+  let disposed = false;
+  const run = () => {
+    const input = (0, import_vue17.toValue)(options.input).trim();
+    const skip = (0, import_vue17.toValue)(options.skip) ?? false;
+    const scope = (0, import_vue17.toValue)(options.scope);
+    const config = (0, import_vue17.toValue)(options.resolverConfig);
+    const 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((0, import_connect_appkit_core12.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;
+    });
+  };
+  (0, import_vue17.watch)(
+    () => [
+      (0, import_vue17.toValue)(options.input),
+      (0, import_vue17.toValue)(options.skip),
+      (0, import_vue17.toValue)(options.scope),
+      (0, import_vue17.toValue)(options.resolverConfig)
+    ],
+    run,
+    { immediate: true, flush: "sync", deep: true }
+  );
+  (0, import_vue17.onScopeDispose)(() => {
+    disposed = true;
+    generation++;
+  });
+  return {
+    data,
+    isLoading: (0, import_vue17.computed)(() => 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
+var import_vue18 = require("vue");
+function useSolanaAccount(accounts, connected) {
+  const isConnected = (0, import_vue18.computed)(() => (0, import_vue18.toValue)(connected));
+  const caip10 = (0, import_vue18.computed)(
+    () => isConnected.value ? ((0, import_vue18.toValue)(accounts) ?? []).find(
+      (account) => account.startsWith("solana:")
+    ) ?? null : null
+  );
+  const parts = (0, import_vue18.computed)(() => caip10.value?.split(":") ?? []);
+  return {
+    address: (0, import_vue18.computed)(
+      () => parts.value.length >= 3 ? parts.value.at(-1) ?? null : null
+    ),
+    caip10,
+    chainId: (0, import_vue18.computed)(
+      () => parts.value.length >= 3 ? parts.value.slice(0, -1).join(":") : null
+    ),
+    isConnected
+  };
+}
+
+// src/useChain.ts
+var import_connect_appkit_core13 = require("@naculus/connect-appkit-core");
+var import_vue19 = require("vue");
 function useChain(chains, chainId) {
-  const list = (0, import_vue2.computed)(() => (0, import_vue2.toValue)(chains) ?? []);
-  const id = (0, import_vue2.computed)(() => (0, import_vue2.toValue)(chainId) ?? null);
-  const currentChain = (0, import_vue2.computed)(() => (0, import_connect_appkit_core.resolveChain)(list.value, id.value));
+  const list = (0, import_vue19.computed)(() => (0, import_vue19.toValue)(chains) ?? []);
+  const id = (0, import_vue19.computed)(() => (0, import_vue19.toValue)(chainId) ?? null);
+  const currentChain = (0, import_vue19.computed)(() => (0, import_connect_appkit_core13.resolveChain)(list.value, id.value));
   return {
     currentChain,
-    chainInfo: (0, import_vue2.computed)(() => (0, import_connect_appkit_core.describeChain)(list.value, id.value)),
-    availableChains: (0, import_vue2.computed)(() => (0, import_connect_appkit_core.chainsForNamespace)(list.value, id.value)),
-    currentChainNumber: (0, import_vue2.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core.chainNumber)(currentChain.value) : null
+    chainInfo: (0, import_vue19.computed)(() => (0, import_connect_appkit_core13.describeChain)(list.value, id.value)),
+    availableChains: (0, import_vue19.computed)(() => (0, import_connect_appkit_core13.chainsForNamespace)(list.value, id.value)),
+    currentChainNumber: (0, import_vue19.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core13.chainNumber)(currentChain.value) : null
     ),
-    namespace: (0, import_vue2.computed)(
-      () => currentChain.value ? (0, import_connect_appkit_core.chainNamespace)(currentChain.value) : null
+    namespace: (0, import_vue19.computed)(
+      () => currentChain.value ? (0, import_connect_appkit_core13.chainNamespace)(currentChain.value) : null
     )
   };
 }
 
 // src/usePassphraseGate.ts
-var import_vue3 = require("vue");
+var import_vue20 = require("vue");
 function usePassphraseGate(gate) {
-  const request = (0, import_vue3.shallowRef)(gate.getSnapshot());
+  const request = (0, import_vue20.shallowRef)(gate.getSnapshot());
   const unsubscribe = gate.subscribe(() => {
     request.value = gate.getSnapshot();
   });
-  (0, import_vue3.onScopeDispose)(unsubscribe);
+  (0, import_vue20.onScopeDispose)(unsubscribe);
   return {
-    request: (0, import_vue3.readonly)(request),
+    request: (0, import_vue20.readonly)(request),
     submit: (passphrase) => gate.submit(passphrase),
     cancel: (reason) => gate.cancel(reason),
     forget: (reason) => gate.forget(reason)
@@ -303,17 +1196,17 @@ function usePassphraseGate(gate) {
 }
 
 // src/useSolanaBalance.ts
-var import_connect_core2 = require("@naculus/connect-core");
-var import_vue4 = require("vue");
+var import_connect_core9 = require("@naculus/connect-core");
+var import_vue21 = require("vue");
 function useSolanaBalance(address, rpcUrl) {
-  const balance = (0, import_vue4.shallowRef)(null);
-  const isFetching = (0, import_vue4.ref)(false);
-  const error = (0, import_vue4.shallowRef)(null);
+  const balance = (0, import_vue21.shallowRef)(null);
+  const isFetching = (0, import_vue21.ref)(false);
+  const error = (0, import_vue21.shallowRef)(null);
   let generation = 0;
   let disposed = false;
   const refetch = async () => {
-    const addr = (0, import_vue4.toValue)(address);
-    const url = (0, import_vue4.toValue)(rpcUrl);
+    const addr = (0, import_vue21.toValue)(address);
+    const url = (0, import_vue21.toValue)(rpcUrl);
     if (!addr || !url) {
       balance.value = null;
       return;
@@ -322,7 +1215,7 @@ function useSolanaBalance(address, rpcUrl) {
     isFetching.value = true;
     error.value = null;
     try {
-      const next = await (0, import_connect_core2.getSolanaBalance)(url, addr);
+      const next = await (0, import_connect_core9.getSolanaBalance)(url, addr);
       if (disposed || own !== generation) return;
       balance.value = next;
     } catch (err) {
@@ -333,16 +1226,275 @@ function useSolanaBalance(address, rpcUrl) {
       if (!disposed && own === generation) isFetching.value = false;
     }
   };
-  (0, import_vue4.watchEffect)(() => {
-    (0, import_vue4.toValue)(address);
-    (0, import_vue4.toValue)(rpcUrl);
+  (0, import_vue21.watchEffect)(() => {
+    (0, import_vue21.toValue)(address);
+    (0, import_vue21.toValue)(rpcUrl);
     void refetch();
   });
-  (0, import_vue4.onScopeDispose)(() => {
+  (0, import_vue21.onScopeDispose)(() => {
     disposed = true;
   });
   return { balance, isFetching, error, refetch };
 }
+
+// src/useLastTx.ts
+var import_vue22 = require("vue");
+function useLastTx(monitor) {
+  const lastTx = (0, import_vue22.shallowRef)(null);
+  const lastConfirmedTx = (0, import_vue22.shallowRef)(null);
+  const lastFailedTx = (0, import_vue22.shallowRef)(null);
+  (0, import_vue22.watch)(
+    () => (0, import_vue22.toValue)(monitor),
+    (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
+var import_vue23 = require("vue");
+function useTxHistory(address, chainId, monitor) {
+  const entries = (0, import_vue23.shallowRef)([]);
+  const isLoading = (0, import_vue23.shallowRef)(false);
+  const error = (0, import_vue23.shallowRef)(null);
+  let generation = 0;
+  const refresh = async () => {
+    const mine = ++generation;
+    const activeMonitor = (0, import_vue23.toValue)(monitor);
+    if (!activeMonitor) {
+      entries.value = [];
+      isLoading.value = false;
+      error.value = null;
+      return;
+    }
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const result = await activeMonitor.getTxHistory(
+        (0, import_vue23.toValue)(address) ?? void 0,
+        (0, import_vue23.toValue)(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;
+    }
+  };
+  (0, import_vue23.watch)(
+    () => [(0, import_vue23.toValue)(monitor), (0, import_vue23.toValue)(address), (0, import_vue23.toValue)(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: (0, import_vue23.computed)(() => ({
+      pending: entries.value.filter((item) => item.status === "pending").length,
+      confirmed: entries.value.filter((item) => item.status === "confirmed").length,
+      failed: entries.value.filter((item) => item.status === "failed").length
+    }))
+  };
+}
+
+// src/useTxMonitor.ts
+var import_vue24 = require("vue");
+function useTxMonitor(hash, chainId, monitor) {
+  const entry = (0, import_vue24.shallowRef)(null);
+  const isLoading = (0, import_vue24.shallowRef)(false);
+  const isWatching = (0, import_vue24.shallowRef)(false);
+  const error = (0, import_vue24.shallowRef)(null);
+  let generation = 0;
+  const refresh = async () => {
+    const activeMonitor = (0, import_vue24.toValue)(monitor);
+    const activeHash = (0, import_vue24.toValue)(hash);
+    const activeChainId = (0, import_vue24.toValue)(chainId);
+    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 = (0, import_vue24.toValue)(monitor);
+    const activeHash = (0, import_vue24.toValue)(hash);
+    const activeChainId = (0, import_vue24.toValue)(chainId);
+    if (!activeMonitor || !activeHash) return;
+    activeMonitor.stopWatching(activeHash, activeChainId ?? void 0);
+    isWatching.value = false;
+  };
+  (0, import_vue24.watch)(
+    () => [(0, import_vue24.toValue)(monitor), (0, import_vue24.toValue)(hash), (0, import_vue24.toValue)(chainId)],
+    ([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: (0, import_vue24.computed)(() => entry.value?.status ?? "idle"),
+    isLoading,
+    isWatching,
+    error,
+    refresh,
+    stopWatching
+  };
+}
+
+// src/useCapabilities.ts
+var import_connect_appkit_core14 = require("@naculus/connect-appkit-core");
+var import_vue25 = require("vue");
+function useCapabilities(client, session, chainId) {
+  const capabilities = (0, import_vue25.shallowRef)(
+    null
+  );
+  const isFetching = (0, import_vue25.shallowRef)(false);
+  const error = (0, import_vue25.shallowRef)(null);
+  let generation = 0;
+  const refetch = async () => {
+    const mine = ++generation;
+    const activeClient = (0, import_vue25.toValue)(client);
+    const activeSession = (0, import_vue25.toValue)(session);
+    if (!activeClient?.getCapabilities || !activeSession) {
+      capabilities.value = null;
+      isFetching.value = false;
+      error.value = null;
+      return;
+    }
+    isFetching.value = true;
+    error.value = null;
+    try {
+      const raw = await activeClient.getCapabilities(activeSession);
+      if (mine !== generation) return;
+      capabilities.value = (0, import_connect_appkit_core14.normalizeCapabilities)(raw);
+    } catch (err) {
+      if (mine !== generation) return;
+      capabilities.value = null;
+      error.value = err instanceof Error ? err : new Error("Capability query failed");
+    } finally {
+      if (mine === generation) isFetching.value = false;
+    }
+  };
+  (0, import_vue25.watchEffect)(() => {
+    void (0, import_vue25.toValue)(client);
+    void (0, import_vue25.toValue)(session);
+    void refetch();
+  });
+  return {
+    capabilities,
+    current: (0, import_vue25.computed)(
+      () => (0, import_connect_appkit_core14.selectChainCapabilities)(capabilities.value, (0, import_vue25.toValue)(chainId))
+    ),
+    atomic: (0, import_vue25.computed)(
+      () => (0, import_connect_appkit_core14.atomicSupportFor)(capabilities.value, (0, import_vue25.toValue)(chainId))
+    ),
+    isFetching,
+    error,
+    refetch
+  };
+}
+
+// src/useSolanaRoles.ts
+var import_connect_appkit_core15 = require("@naculus/connect-appkit-core");
+var import_vue26 = require("vue");
+function useSolanaRoles(connector, session) {
+  const state = (0, import_vue26.computed)(
+    () => (0, import_connect_appkit_core15.readSolanaRoles)((0, import_vue26.toValue)(connector), (0, import_vue26.toValue)(session))
+  );
+  return {
+    roles: (0, import_vue26.computed)(() => state.value.roles),
+    absence: (0, import_vue26.computed)(() => state.value.absence),
+    identity: (0, import_vue26.computed)(() => state.value.roles?.identity ?? null),
+    signer: (0, import_vue26.computed)(() => state.value.roles?.signer ?? null),
+    payer: (0, import_vue26.computed)(() => state.value.roles?.payer ?? null)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppkitAccordion,
@@ -373,9 +1525,32 @@ function useSolanaBalance(address, rpcUrl) {
   AppkitTabs,
   AppkitToggleGroup,
   AppkitTooltip,
+  useAccount,
   useAccounts,
+  useBalance,
+  useCapabilities,
   useChain,
+  useCompareCosts,
+  useConnect,
+  useDelegation,
+  useDisconnect,
+  useExecuteRoute,
+  useLastTx,
+  useLookupAddress,
+  useNotification,
   usePassphraseGate,
-  useSolanaBalance
+  useResolveName,
+  useRouteQuote,
+  useSession,
+  useSolanaAccount,
+  useSolanaBalance,
+  useSolanaRoles,
+  useSwitchChain,
+  useTokenBalance,
+  useTokenList,
+  useTokenSearch,
+  useTxHistory,
+  useTxMonitor,
+  useValidateDestination
 });
 //# sourceMappingURL=index.cjs.map