@coin-voyage/swapkit 0.2.0 → 0.3.0

package/dist/components/connected-wallets.d.ts

@@ -1 +1 @@
-export declare function ConnectedWallets(): import("react/jsx-runtime").JSX.Element | null;
+export declare function ConnectedWallets(): import("react/jsx-runtime").JSX.Element;

package/dist/components/connected-wallets.js

@@ -1,10 +1,12 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useAccount, useAccountDisconnect, useInstalledWallets } from "@coin-voyage/crypto/hooks";
 import { getChainTypeName } from "@coin-voyage/shared/chain";
+import { ChainType } from "@coin-voyage/shared/types";
 import { useEffect, useRef, useState } from "react";
 import { CloseIcon, UnplugIcon } from "./icons";
-import { ConnectedWalletPanel, ConnectedWalletRow, DisconnectAllButton, IconButton, TriggerWalletIcons, ToolbarGroup, WalletDetails, WalletDisconnectButton, WalletIdentity, WalletLabel, WalletPanelHeader, } from "./styles";
+import { ConnectedWalletPanel, ConnectedWalletRow, DisconnectAllButton, IconButton, TriggerWalletIcons, ToolbarGroup, WalletActions, WalletDetails, WalletDisconnectButton, WalletIdentity, WalletLabel, WalletPanelHeader, WalletSwitchButton, } from "./styles";
 import { WalletIconDisplay } from "./wallet-icon";
+import { WalletConnector } from "./wallet-connector";
 function truncateAddress(address) {
     return address.length <= 14 ? address : `${address.slice(0, 6)}…${address.slice(-5)}`;
 }
@@ -17,6 +19,15 @@ function connectorId(connector) {
         return connector.name;
     return undefined;
 }
+function connectorName(connector) {
+    if (!connector || typeof connector !== "object")
+        return undefined;
+    if ("displayName" in connector && typeof connector.displayName === "string")
+        return connector.displayName;
+    if ("name" in connector && typeof connector.name === "string")
+        return connector.name;
+    return undefined;
+}
 function accountAddress(account) {
     return account.address ?? account.addresses?.[0];
 }
@@ -25,11 +36,20 @@ export function ConnectedWallets() {
     const wallets = useInstalledWallets();
     const disconnectAccount = useAccountDisconnect();
     const [open, setOpen] = useState(false);
+    const [switchAccount, setSwitchAccount] = useState(null);
     const groupRef = useRef(null);
     const connectedAccounts = accounts.filter((account) => account.isConnected);
     const walletForAccount = (account) => {
         const accountConnectorId = connectorId(account.connector);
-        return wallets.find((wallet) => wallet.connectors.some((candidate) => candidate.chainType === account.chainType && connectorId(candidate.connector) === accountConnectorId));
+        const accountConnectorName = connectorName(account.connector)?.toLowerCase();
+        return wallets.find((wallet) => wallet.connectors.some((candidate) => {
+            if (candidate.chainType !== account.chainType)
+                return false;
+            const candidateConnectorId = connectorId(candidate.connector);
+            const candidateConnectorName = connectorName(candidate.connector)?.toLowerCase();
+            return ((accountConnectorId !== undefined && candidateConnectorId === accountConnectorId) ||
+                (accountConnectorName !== undefined && candidateConnectorName === accountConnectorName));
+        }));
     };
     useEffect(() => {
         if (!open)
@@ -49,18 +69,21 @@ export function ConnectedWallets() {
             document.removeEventListener("keydown", dismissFromKeyboard);
         };
     }, [open]);
-    if (connectedAccounts.length === 0)
-        return null;
     const triggerLabel = connectedAccounts.length === 1
         ? truncateAddress(accountAddress(connectedAccounts[0]) ?? "Wallet")
         : `${connectedAccounts.length} connections`;
-    return (_jsxs(ToolbarGroup, { ref: groupRef, children: [_jsxs(IconButton, { type: "button", "aria-label": "Connected wallets", "aria-expanded": open, onClick: () => setOpen((current) => !current), children: [_jsx(TriggerWalletIcons, { children: connectedAccounts.slice(0, 3).map((account, index) => {
-                            const wallet = walletForAccount(account);
-                            return (_jsx(WalletIconDisplay, { icon: wallet?.icon, name: wallet?.name ?? getChainTypeName(account.chainType), size: 20 }, `${account.chainType}:${accountAddress(account) ?? index}`));
-                        }) }), _jsx(WalletLabel, { children: triggerLabel })] }), open && (_jsxs(ConnectedWalletPanel, { role: "menu", "aria-label": "Connected wallets menu", children: [_jsx(WalletPanelHeader, { children: "Connected wallets" }), connectedAccounts.map((account, index) => {
-                        const wallet = walletForAccount(account);
-                        const chainName = getChainTypeName(account.chainType);
-                        const address = accountAddress(account);
-                        return (_jsxs(ConnectedWalletRow, { children: [_jsxs(WalletIdentity, { children: [_jsx(WalletIconDisplay, { icon: wallet?.icon, name: wallet?.name ?? chainName, size: 20 }), _jsxs(WalletDetails, { children: [_jsx("strong", { children: chainName }), _jsx("small", { children: address ? truncateAddress(address) : "Connected" })] })] }), _jsx(WalletDisconnectButton, { type: "button", "aria-label": `Disconnect ${chainName} wallet`, onClick: () => void disconnectAccount(account), children: _jsx(CloseIcon, { size: 16 }) })] }, `${account.chainType}:${address ?? index}`));
-                    }), _jsxs(DisconnectAllButton, { type: "button", onClick: () => void disconnectAccount(), children: [_jsx(UnplugIcon, {}), "Disconnect all"] })] }))] }));
+    return (_jsxs(_Fragment, { children: [connectedAccounts.length > 0 && (_jsxs(ToolbarGroup, { ref: groupRef, children: [_jsxs(IconButton, { type: "button", "aria-label": "Connected wallets", "aria-expanded": open, onClick: () => setOpen((current) => !current), children: [_jsx(TriggerWalletIcons, { children: connectedAccounts.slice(0, 3).map((account, index) => {
+                                    const wallet = walletForAccount(account);
+                                    return (_jsx(WalletIconDisplay, { icon: wallet?.icon, name: wallet?.name ?? getChainTypeName(account.chainType), size: 20 }, `${account.chainType}:${accountAddress(account) ?? index}`));
+                                }) }), _jsx(WalletLabel, { children: triggerLabel })] }), open && (_jsxs(ConnectedWalletPanel, { role: "group", "aria-label": "Connected wallets", children: [_jsx(WalletPanelHeader, { children: "Connected wallets" }), connectedAccounts.map((account, index) => {
+                                const wallet = walletForAccount(account);
+                                const chainName = getChainTypeName(account.chainType);
+                                const address = accountAddress(account);
+                                return (_jsxs(ConnectedWalletRow, { children: [_jsxs(WalletIdentity, { children: [_jsx(WalletIconDisplay, { icon: wallet?.icon, name: wallet?.name ?? chainName, size: 20 }), _jsxs(WalletDetails, { children: [_jsx("strong", { children: chainName }), _jsx("small", { children: address ? truncateAddress(address) : "Connected" })] })] }), _jsxs(WalletActions, { children: [_jsx(WalletSwitchButton, { type: "button", "aria-label": `Switch ${chainName} wallet`, onClick: () => {
+                                                        setOpen(false);
+                                                        setSwitchAccount(account);
+                                                    }, children: "Switch" }), _jsx(WalletDisconnectButton, { type: "button", "aria-label": `Disconnect ${chainName} wallet`, onClick: () => void disconnectAccount(account), children: _jsx(CloseIcon, { size: 16 }) })] })] }, `${account.chainType}:${address ?? index}`));
+                            }), _jsxs(DisconnectAllButton, { type: "button", onClick: () => void disconnectAccount(), children: [_jsx(UnplugIcon, {}), "Disconnect all"] })] }))] })), _jsx(WalletConnector, { open: switchAccount !== null, chainType: switchAccount?.chainType, intent: "switch", beforeConnect: switchAccount && switchAccount.chainType !== ChainType.SOL
+                    ? () => disconnectAccount(switchAccount)
+                    : undefined, onClose: () => setSwitchAccount(null) })] }));
 }

package/dist/components/connected-wallets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/connected-wallets.test.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { ChainId, ChainType } from "@coin-voyage/shared/types";
+import { cleanup, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ConnectedWallets } from "./connected-wallets";
+const disconnectAccount = vi.fn();
+let accountsConnected = true;
+let accountChainType = ChainType.SOL;
+let accountAddress = "current-address";
+let accountConnector = { id: "Test wallet", name: "Test wallet" };
+let installedWalletOverride;
+vi.mock("@coin-voyage/crypto/hooks", () => ({
+    useAccount: () => ({
+        accounts: accountsConnected
+            ? [
+                {
+                    address: accountAddress,
+                    chainId: ChainId.SOL,
+                    chainType: accountChainType,
+                    connector: accountConnector,
+                    isConnected: true,
+                    isConnecting: false,
+                    isDisconnected: false,
+                    isReconnecting: false,
+                    status: "connected",
+                },
+            ]
+            : [],
+    }),
+    useAccountDisconnect: () => disconnectAccount,
+    useInstalledWallets: () => [
+        installedWalletOverride ?? {
+            id: "test-wallet",
+            name: "Test wallet",
+            connectors: [{ chainType: accountChainType, connector: { id: "Test wallet", name: "Test wallet" } }],
+        },
+    ],
+}));
+vi.mock("./wallet-connector", () => ({
+    WalletConnector: ({ open, chainType, intent }) => open ? _jsx("div", { "data-testid": "wallet-connector", children: `${intent}:${chainType}` }) : null,
+}));
+afterEach(() => {
+    cleanup();
+    disconnectAccount.mockClear();
+    accountsConnected = true;
+    accountChainType = ChainType.SOL;
+    accountAddress = "current-address";
+    accountConnector = { id: "Test wallet", name: "Test wallet" };
+    installedWalletOverride = undefined;
+});
+describe("ConnectedWallets", () => {
+    it("opens the wallet switcher for the selected account chain", async () => {
+        const user = userEvent.setup();
+        render(_jsx(ConnectedWallets, {}));
+        await user.click(screen.getByRole("button", { name: "Connected wallets" }));
+        await user.click(screen.getByRole("button", { name: "Switch Solana wallet" }));
+        expect(screen.queryByRole("group", { name: "Connected wallets" })).toBeNull();
+        expect(screen.getByTestId("wallet-connector").textContent).toBe(`switch:${ChainType.SOL}`);
+        expect(disconnectAccount).not.toHaveBeenCalled();
+    });
+    it("keeps the switcher open while the previous account disconnects", async () => {
+        const user = userEvent.setup();
+        const { rerender } = render(_jsx(ConnectedWallets, {}));
+        await user.click(screen.getByRole("button", { name: "Connected wallets" }));
+        await user.click(screen.getByRole("button", { name: "Switch Solana wallet" }));
+        accountsConnected = false;
+        rerender(_jsx(ConnectedWallets, {}));
+        expect(screen.getByTestId("wallet-connector").textContent).toBe(`switch:${ChainType.SOL}`);
+    });
+    it("updates the connected-wallet label when Phantom changes address", () => {
+        accountAddress = "old-address-123456789";
+        const { rerender } = render(_jsx(ConnectedWallets, {}));
+        expect(screen.getByRole("button", { name: "Connected wallets" }).textContent).toContain("old-ad…56789");
+        accountAddress = "new-address-987654321";
+        rerender(_jsx(ConnectedWallets, {}));
+        expect(screen.getByRole("button", { name: "Connected wallets" }).textContent).toContain("new-ad…54321");
+    });
+    it("uses the Phantom icon for its Ethereum connection in a multichain wallet", () => {
+        accountChainType = ChainType.EVM;
+        accountConnector = { id: "injected", name: "Phantom" };
+        installedWalletOverride = {
+            id: "app.phantom",
+            name: "Phantom",
+            icon: "phantom.svg",
+            connectors: [
+                { chainType: ChainType.EVM, connector: { id: "app.phantom", name: "Phantom" } },
+                { chainType: ChainType.SOL, connector: { id: "Phantom", name: "Phantom" } },
+            ],
+        };
+        render(_jsx(ConnectedWallets, {}));
+        expect(screen.getByAltText("Phantom wallet")).not.toBeNull();
+    });
+    it("only disconnects an account from the explicit disconnect action", async () => {
+        accountChainType = ChainType.EVM;
+        const user = userEvent.setup();
+        render(_jsx(ConnectedWallets, {}));
+        await user.click(screen.getByRole("button", { name: "Connected wallets" }));
+        await user.click(screen.getByRole("button", { name: "Disconnect Ethereum wallet" }));
+        expect(disconnectAccount).toHaveBeenCalledTimes(1);
+        expect(disconnectAccount.mock.calls[0]?.[0]?.chainType).toBe(ChainType.EVM);
+    });
+});

package/dist/components/styles.d.ts

@@ -95,6 +95,8 @@ export declare const WalletPanelHeader: import("styled-components").StyledCompon
 export declare const ConnectedWalletRow: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const WalletIdentity: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const WalletDetails: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const WalletActions: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const WalletSwitchButton: import("styled-components").StyledComponent<"button", any, {}, never>;
 export declare const WalletDisconnectButton: import("styled-components").StyledComponent<"button", any, {}, never>;
 export declare const DisconnectAllButton: import("styled-components").StyledComponent<"button", any, {}, never>;
 export declare const TriggerWalletIcons: import("styled-components").StyledComponent<"span", any, {}, never>;

package/dist/components/styles.js

@@ -955,6 +955,11 @@ export const WalletOption = styled.button `
   &:hover {
     background: var(--sk-surface);
   }
+
+  &:disabled {
+    cursor: wait;
+    opacity: 0.6;
+  }
 `;
 export const WalletIconFrame = styled.span `
   display: inline-flex;
@@ -1068,6 +1073,28 @@ export const WalletDetails = styled.div `
     font-size: 12px;
   }
 `;
+export const WalletActions = styled.div `
+  display: flex;
+  flex: 0 0 auto;
+  align-items: center;
+  gap: 4px;
+`;
+export const WalletSwitchButton = styled.button `
+  height: 28px;
+  padding: 0 8px;
+  border: 0;
+  border-radius: 6px;
+  color: var(--sk-text-muted);
+  background: transparent;
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 500;
+
+  &:hover {
+    color: var(--sk-accent);
+    background: color-mix(in srgb, var(--sk-accent) 12%, transparent);
+  }
+`;
 export const WalletDisconnectButton = styled.button `
   display: inline-flex;
   width: 28px;

package/dist/components/swap.js

@@ -306,7 +306,7 @@ export function Swap({ defaultSourceCurrency, defaultDestinationCurrency, defaul
                         }, onPaste: () => {
                             setOutputWalletMenuOpen(false);
                             setManualWalletOpen(true);
-                        } })) : undefined }), quoteState.error && _jsx(ErrorBox, { children: quoteState.error }), tokenError && _jsx(ErrorBox, { children: tokenError }), insufficientBalance && _jsxs(ErrorBox, { children: ["Insufficient ", sourceToken?.currency.symbol, " balance"] }), sameSwap && _jsx(ErrorBox, { children: "Select a different token or destination wallet" }), (quoteState.loading || quoteState.quote) && (_jsxs(BreakdownCard, { children: [_jsxs(BreakdownToggle, { type: "button", "aria-expanded": breakdownOpen, onClick: () => setBreakdownOpen((open) => !open), children: [_jsx("span", { children: quoteState.loading ? "Finding the best route…" : quoteSummary }), _jsxs(BreakdownMeta, { children: [quoteState.quote && (_jsxs(NetworkCost, { children: [_jsx(FuelIcon, {}), _jsx("span", { children: formatUsd(quoteState.quote.input.breakdown?.gas?.value_usd) })] })), _jsx(ChevronDownIcon, { size: 16, up: breakdownOpen })] })] }), breakdownOpen && (_jsxs(BreakdownBody, { children: [quoteState.quote?.output.amount_out_minimum && (_jsxs(DetailRow, { children: [_jsx("span", { children: "Receive at least" }), _jsxs("strong", { children: [quoteState.quote.output.amount_out_minimum.ui, " ", quoteState.quote.output.currency.symbol] })] })), _jsxs(DetailRow, { children: [_jsx("span", { children: "Price impact" }), _jsx("strong", { children: quoteState.quote ? formatPriceImpact(quoteState.quote.price_impact) : "—" })] }), _jsxs(DetailRow, { children: [_jsx("span", { children: "Network cost" }), _jsx("strong", { children: formatUsd(quoteState.quote?.input.breakdown?.gas?.value_usd) })] }), _jsxs(DetailRow, { children: [_jsx("span", { children: "Total fees" }), quoteState.quote?.input.breakdown?.fees?.total_fee.value_usd === 0 ? (_jsx(FreeFeeBadge, { children: "Free" })) : (_jsx("strong", { children: formatUsd(quoteState.quote?.input.breakdown?.fees?.total_fee.value_usd) }))] })] }))] })), walletRequirement.target !== "none" ? (_jsx(WalletRequirementButton, { type: "button", onClick: () => setConnectTarget({ open: true, chainType: walletRequirement.chainType }), children: walletRequirement.label })) : (_jsxs(PrimaryButton, { type: "button", disabled: !canExecute || quoteState.loading, onClick: () => void executeSwap(), children: [quoteState.loading ? _jsx(Spinner, {}) : null, isLoading ? "Loading tokens…" : quoteState.loading ? "Fetching quote…" : "Swap"] })), _jsx(TokenPicker, { open: sourcePickerOpen, title: "Select Token", tokens: tokens, selectedId: resolvedSourceId, onClose: () => setSourcePickerOpen(false), onSelect: (token) => selectToken("input", token) }), _jsx(TokenPicker, { open: destinationPickerOpen, title: "Select Token", tokens: tokens, selectedId: resolvedDestinationId, onClose: () => setDestinationPickerOpen(false), onSelect: (token) => selectToken("output", token) }), _jsx(WalletConnector, { open: connectTarget.open, chainType: connectTarget.chainType, onClose: () => setConnectTarget({ open: false }) }), manualWalletOpen && (_jsx(ManualWalletModal, { open: true, chainId: destinationToken?.currency.chain_id, initialValue: manualAddress, onClose: () => setManualWalletOpen(false), onSave: (address) => {
+                        } })) : undefined }), quoteState.error && _jsx(ErrorBox, { children: quoteState.error }), tokenError && _jsx(ErrorBox, { children: tokenError }), insufficientBalance && _jsxs(ErrorBox, { children: ["Insufficient ", sourceToken?.currency.symbol, " balance"] }), sameSwap && _jsx(ErrorBox, { children: "Select a different token or destination wallet" }), (quoteState.loading || quoteState.quote) && (_jsxs(BreakdownCard, { children: [_jsxs(BreakdownToggle, { type: "button", "aria-expanded": breakdownOpen, onClick: () => setBreakdownOpen((open) => !open), children: [_jsx("span", { children: quoteState.loading ? "Finding the best route…" : quoteSummary }), _jsxs(BreakdownMeta, { children: [quoteState.quote && (_jsxs(NetworkCost, { children: [_jsx(FuelIcon, {}), _jsx("span", { children: formatUsd(quoteState.quote.input.breakdown?.gas?.value_usd) })] })), _jsx(ChevronDownIcon, { size: 16, up: breakdownOpen })] })] }), breakdownOpen && (_jsxs(BreakdownBody, { children: [quoteState.quote?.output.amount_out_minimum && (_jsxs(DetailRow, { children: [_jsx("span", { children: "Receive at least" }), _jsxs("strong", { children: [quoteState.quote.output.amount_out_minimum.ui, " ", quoteState.quote.output.currency.symbol] })] })), _jsxs(DetailRow, { children: [_jsx("span", { children: "Price impact" }), _jsx("strong", { children: quoteState.quote ? formatPriceImpact(quoteState.quote.price_impact) : "—" })] }), _jsxs(DetailRow, { children: [_jsx("span", { children: "Network cost" }), _jsx("strong", { children: formatUsd(quoteState.quote?.input.breakdown?.gas?.value_usd) })] }), _jsxs(DetailRow, { children: [_jsx("span", { children: "Total fees" }), quoteState.quote?.input.breakdown?.fees?.total_fee.value_usd === 0 ? (_jsx(FreeFeeBadge, { children: "Free" })) : (_jsx("strong", { children: formatUsd(quoteState.quote?.input.breakdown?.fees?.total_fee.value_usd) }))] })] }))] })), walletRequirement.target !== "none" ? (_jsx(WalletRequirementButton, { type: "button", onClick: () => setConnectTarget({ open: true, chainType: walletRequirement.chainType }), children: walletRequirement.label })) : (_jsxs(PrimaryButton, { type: "button", disabled: !canExecute || quoteState.loading, onClick: () => void executeSwap(), children: [quoteState.loading ? _jsx(Spinner, {}) : null, isLoading ? "Loading tokens…" : quoteState.loading ? "Fetching quote…" : "Swap"] })), _jsx(TokenPicker, { open: sourcePickerOpen, title: "Select Token", tokens: tokens, selectedId: resolvedSourceId, onClose: () => setSourcePickerOpen(false), onSelect: (token) => selectToken("input", token) }), _jsx(TokenPicker, { open: destinationPickerOpen, title: "Select Token", tokens: tokens, selectedId: resolvedDestinationId, preferredChainId: sourceToken?.currency.chain_id, onClose: () => setDestinationPickerOpen(false), onSelect: (token) => selectToken("output", token) }), _jsx(WalletConnector, { open: connectTarget.open, chainType: connectTarget.chainType, onClose: () => setConnectTarget({ open: false }) }), manualWalletOpen && (_jsx(ManualWalletModal, { open: true, chainId: destinationToken?.currency.chain_id, initialValue: manualAddress, onClose: () => setManualWalletOpen(false), onSave: (address) => {
                         if (destinationToken)
                             swapState.setManualOutputWallet({ chainId: destinationToken.currency.chain_id, address });
                     } })), _jsx(ExecutionModal, { stage: execution.stage, onClose: () => {

package/dist/components/token-picker.d.ts

@@ -1,11 +1,13 @@
+import { ChainId } from "@coin-voyage/shared/types";
 import type { SwapToken } from "../hooks/use-token-data";
 interface TokenPickerProps {
     open: boolean;
     title: string;
     tokens: SwapToken[];
     selectedId?: string;
+    preferredChainId?: ChainId;
     onClose: () => void;
     onSelect: (token: SwapToken) => void;
 }
-export declare function TokenPicker({ open, title, tokens, selectedId, onClose, onSelect }: TokenPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function TokenPicker({ open, title, tokens, selectedId, preferredChainId, onClose, onSelect, }: TokenPickerProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/token-picker.js

@@ -21,16 +21,18 @@ function tokenDescription(token) {
 function AllNetworksMark() {
     return (_jsxs(AllNetworksLogo, { role: "img", "aria-label": "All networks", children: [_jsx("span", { children: getChainLogo(ChainId.BTC) }), _jsx("span", { children: getChainLogo(ChainId.SUI) }), _jsx("span", { children: getChainLogo(ChainId.ROBINHOOD) })] }));
 }
-export function TokenPicker({ open, title, tokens, selectedId, onClose, onSelect }) {
+export function TokenPicker({ open, title, tokens, selectedId, preferredChainId, onClose, onSelect, }) {
     const [query, setQuery] = useState("");
     const [selectedChainId, setSelectedChainId] = useState();
+    const [showAllNetworks, setShowAllNetworks] = useState(false);
     const [networkMenuOpen, setNetworkMenuOpen] = useState(false);
     const networkButtonRef = useRef(null);
     const networkMenuRef = useRef(null);
     const networks = useMemo(() => [...new Set(tokens.map(({ currency }) => currency.chain_id))].sort((left, right) => (getChainName(left) ?? "").localeCompare(getChainName(right) ?? "")), [tokens]);
+    const activeChainId = selectedChainId ?? (showAllNetworks ? undefined : preferredChainId);
     const filtered = useMemo(() => {
-        const onSelectedNetwork = selectedChainId
-            ? tokens.filter(({ currency }) => currency.chain_id === selectedChainId)
+        const onSelectedNetwork = activeChainId
+            ? tokens.filter(({ currency }) => currency.chain_id === activeChainId)
             : tokens;
         const normalized = query.trim().toLowerCase();
         if (!normalized)
@@ -38,8 +40,15 @@ export function TokenPicker({ open, title, tokens, selectedId, onClose, onSelect
         return onSelectedNetwork.filter(({ currency }) => [currency.symbol, currency.name, getChainName(currency.chain_id), currency.address]
             .filter(Boolean)
             .some((value) => value.toLowerCase().includes(normalized)));
-    }, [query, selectedChainId, tokens]);
-    const selectedNetworkName = selectedChainId ? (getChainName(selectedChainId) ?? "Unknown Network") : "All Networks";
+    }, [activeChainId, query, tokens]);
+    const selectedNetworkName = activeChainId ? (getChainName(activeChainId) ?? "Unknown Network") : "All Networks";
+    const closePicker = () => {
+        setQuery("");
+        setSelectedChainId(undefined);
+        setShowAllNetworks(false);
+        setNetworkMenuOpen(false);
+        onClose();
+    };
     useEffect(() => {
         if (!networkMenuOpen)
             return;
@@ -52,18 +61,19 @@ export function TokenPicker({ open, title, tokens, selectedId, onClose, onSelect
         document.addEventListener("mousedown", closeOnOutsideClick);
         return () => document.removeEventListener("mousedown", closeOnOutsideClick);
     }, [networkMenuOpen]);
-    return (_jsx(Modal, { open: open, title: title, onClose: onClose, children: _jsxs(PickerBody, { children: [_jsxs(PickerControls, { children: [_jsxs(SearchField, { children: [_jsx(SearchIcon, {}), _jsx(SearchInput, { type: "search", value: query, placeholder: "Search", "aria-label": "Search tokens", onChange: (event) => setQuery(event.target.value) })] }), _jsxs(NetworkButton, { ref: networkButtonRef, type: "button", "aria-label": selectedNetworkName, "aria-expanded": networkMenuOpen, onClick: () => setNetworkMenuOpen((current) => !current), children: [selectedChainId ? (_jsx(NetworkLogo, { "aria-hidden": true, children: getChainLogo(selectedChainId) })) : (_jsx(AllNetworksMark, {})), _jsx(ChevronDownIcon, { size: 16, up: networkMenuOpen })] })] }), networkMenuOpen && (_jsxs(NetworkMenu, { ref: networkMenuRef, role: "listbox", "aria-label": "Networks", children: [_jsxs(NetworkOption, { type: "button", role: "option", "aria-selected": selectedChainId === undefined, onClick: () => {
+    return (_jsx(Modal, { open: open, title: title, onClose: closePicker, children: _jsxs(PickerBody, { children: [_jsxs(PickerControls, { children: [_jsxs(SearchField, { children: [_jsx(SearchIcon, {}), _jsx(SearchInput, { type: "search", value: query, placeholder: "Search", "aria-label": "Search tokens", onChange: (event) => setQuery(event.target.value) })] }), _jsxs(NetworkButton, { ref: networkButtonRef, type: "button", "aria-label": selectedNetworkName, "aria-expanded": networkMenuOpen, onClick: () => setNetworkMenuOpen((current) => !current), children: [activeChainId ? _jsx(NetworkLogo, { "aria-hidden": true, children: getChainLogo(activeChainId) }) : _jsx(AllNetworksMark, {}), _jsx(ChevronDownIcon, { size: 16, up: networkMenuOpen })] })] }), networkMenuOpen && (_jsxs(NetworkMenu, { ref: networkMenuRef, role: "listbox", "aria-label": "Networks", children: [_jsxs(NetworkOption, { type: "button", role: "option", "aria-selected": activeChainId === undefined, onClick: () => {
                                 setSelectedChainId(undefined);
+                                setShowAllNetworks(true);
                                 setNetworkMenuOpen(false);
-                            }, children: [_jsx(AllNetworksMark, {}), "All Networks"] }), networks.map((chainId) => (_jsxs(NetworkOption, { type: "button", role: "option", "aria-selected": chainId === selectedChainId, onClick: () => {
+                            }, children: [_jsx(AllNetworksMark, {}), "All Networks"] }), networks.map((chainId) => (_jsxs(NetworkOption, { type: "button", role: "option", "aria-selected": chainId === activeChainId, onClick: () => {
                                 setSelectedChainId(chainId);
+                                setShowAllNetworks(false);
                                 setNetworkMenuOpen(false);
                             }, children: [_jsx(NetworkLogo, { "aria-hidden": true, children: getChainLogo(chainId) }), getChainName(chainId)] }, chainId)))] })), _jsxs(TokenList, { role: "listbox", "aria-label": title, children: [filtered.map((token) => {
                             const id = currencyID(token.currency);
                             return (_jsxs(TokenOption, { type: "button", role: "option", "aria-label": `${token.currency.symbol} ${token.currency.name}`, "aria-selected": id === selectedId, onClick: () => {
                                     onSelect(token);
-                                    setQuery("");
-                                    onClose();
+                                    closePicker();
                                 }, children: [_jsx(TokenIcon, { currency: token.currency, size: 40 }), _jsxs(TokenMeta, { children: [_jsx("strong", { children: token.currency.name }), _jsx("small", { children: tokenDescription(token) })] }), _jsxs(TokenBalance, { children: [_jsx("strong", { children: formatUsd(token.balanceUsd) }), _jsx("small", { children: token.balance === undefined ? "" : token.balance.toLocaleString() })] })] }, id));
                         }), filtered.length === 0 && _jsx(EmptyState, { children: "No matching tokens" })] })] }) }));
 }

package/dist/components/token-picker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/token-picker.test.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { ChainId } from "@coin-voyage/shared/types";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { TokenPicker } from "./token-picker";
+vi.mock("./modal", () => ({
+    Modal: ({ open, title, children }) => open ? (_jsx("div", { role: "dialog", "aria-label": title, children: children })) : null,
+}));
+afterEach(cleanup);
+function token(currency) {
+    return { currency };
+}
+const tokens = [
+    token({ id: "sol", chain_id: ChainId.SOL, name: "Solana", symbol: "SOL", decimals: 9 }),
+    token({
+        id: "usdc-sol",
+        chain_id: ChainId.SOL,
+        address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        name: "USD Coin",
+        symbol: "USDC",
+        decimals: 6,
+    }),
+    token({ id: "eth", chain_id: ChainId.ETH, name: "Ether", symbol: "ETH", decimals: 18 }),
+    token({ id: "usdc-base", chain_id: ChainId.BASE, name: "Base USD Coin", symbol: "USDC", decimals: 6 }),
+];
+describe("TokenPicker", () => {
+    it("prefilters BUY tokens to the selected SELL chain", () => {
+        render(_jsx(TokenPicker, { open: true, title: "Select BUY token", tokens: tokens, preferredChainId: ChainId.SOL, onClose: vi.fn(), onSelect: vi.fn() }));
+        expect(screen.getByRole("option", { name: "SOL Solana" })).toBeTruthy();
+        expect(screen.getByRole("option", { name: "USDC USD Coin" })).toBeTruthy();
+        expect(screen.queryByRole("option", { name: "ETH Ether" })).toBeNull();
+        fireEvent.click(screen.getByRole("button", { name: "Solana" }));
+        fireEvent.click(screen.getByRole("option", { name: /All Networks/i }));
+        expect(screen.getByRole("option", { name: "ETH Ether" })).toBeTruthy();
+    });
+    it("does not include other networks with the same chain type", () => {
+        render(_jsx(TokenPicker, { open: true, title: "Select BUY token", tokens: tokens, preferredChainId: ChainId.ETH, onClose: vi.fn(), onSelect: vi.fn() }));
+        expect(screen.getByRole("option", { name: "ETH Ether" })).toBeTruthy();
+        expect(screen.queryByRole("option", { name: "USDC Base USD Coin" })).toBeNull();
+        expect(screen.queryByRole("option", { name: "SOL Solana" })).toBeNull();
+    });
+});

package/dist/components/wallet-connector.d.ts

@@ -2,7 +2,9 @@ import type { ChainType } from "@coin-voyage/shared/types";
 interface WalletConnectorProps {
     open: boolean;
     chainType?: ChainType;
+    intent?: "connect" | "switch";
+    beforeConnect?: () => Promise<unknown>;
     onClose: () => void;
 }
-export declare function WalletConnector({ open, chainType, onClose }: WalletConnectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function WalletConnector(props: WalletConnectorProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/components/wallet-connector.js

@@ -1,33 +1,82 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useInstalledWallets, useUniversalConnect } from "@coin-voyage/crypto/hooks";
+import { getErrorMessage, isWalletConnectionCancelledError } from "@coin-voyage/crypto/utils";
 import { getChainTypeName } from "@coin-voyage/shared/chain";
-import { useMemo, useState } from "react";
-import { EmptyState, Hint, MultichainBadge, WalletList, WalletOption, WalletOptionMeta } from "./styles";
+import { useMemo, useRef, useState } from "react";
+import { EmptyState, Hint, MultichainBadge, WalletList, WalletOption, WalletOptionMeta, WalletSwitchButton, } from "./styles";
 import { Modal } from "./modal";
 import { WalletIconDisplay } from "./wallet-icon";
-export function WalletConnector({ open, chainType, onClose }) {
+export function WalletConnector(props) {
+    if (!props.open)
+        return null;
+    return _jsx(OpenWalletConnector, { ...props });
+}
+function OpenWalletConnector({ chainType, intent = "connect", beforeConnect, onClose }) {
     const installedWallets = useInstalledWallets();
     const wallets = useMemo(() => chainType
         ? installedWallets.filter((wallet) => wallet.connectors.some((connector) => connector.chainType === chainType))
         : installedWallets, [chainType, installedWallets]);
     const [error, setError] = useState(null);
+    const [pending, setPending] = useState(false);
+    const [selectedWallet, setSelectedWallet] = useState(null);
+    const pendingRef = useRef(false);
+    const selectedConnectors = selectedWallet
+        ? selectedWallet.connectors.filter((connector, index, connectors) => connectors.findIndex((candidate) => candidate.chainType === connector.chainType) === index)
+        : [];
+    const close = () => {
+        pendingRef.current = false;
+        onClose();
+    };
+    const showError = (error) => {
+        if (isWalletConnectionCancelledError(error))
+            return;
+        setError(getErrorMessage(error) || "Unable to connect wallet");
+    };
     const { connect } = useUniversalConnect({
-        onSuccess: onClose,
-        onError: (connectError) => {
-            const message = connectError instanceof Error ? connectError.message : "Unable to connect wallet";
-            if (!message.toLowerCase().includes("rejected"))
-                setError(message);
-        },
+        onSuccess: close,
+        onError: showError,
     });
-    return (_jsxs(Modal, { open: open, title: "Connect wallet", onClose: onClose, children: [_jsx(WalletList, { children: wallets.map((wallet) => {
-                    const connector = wallet.connectors.find((candidate) => !chainType || candidate.chainType === chainType);
-                    if (!connector)
-                        return null;
-                    const chainTypes = [...new Set(wallet.connectors.map((candidate) => candidate.chainType))];
-                    const capabilityLabel = chainTypes.map((candidate) => getChainTypeName(candidate)).join(" · ");
-                    return (_jsxs(WalletOption, { type: "button", "aria-label": `Connect ${wallet.name} wallet`, onClick: () => {
-                            setError(null);
-                            void connect({ walletConnector: connector });
-                        }, children: [_jsx(WalletIconDisplay, { icon: wallet.icon, name: wallet.name }), _jsxs(WalletOptionMeta, { children: [_jsxs("span", { children: [_jsx("strong", { children: wallet.name }), chainTypes.length > 1 && _jsx(MultichainBadge, { children: "Multichain" })] }), _jsx("small", { children: chainTypes.length > 1 ? capabilityLabel : `${capabilityLabel} wallet` })] })] }, wallet.id));
-                }) }), wallets.length === 0 && _jsx(EmptyState, { children: "No compatible installed wallets found" }), error && _jsx(Hint, { "$tone": "danger", children: error })] }));
+    const handleConnect = async (connector) => {
+        if (pendingRef.current)
+            return;
+        pendingRef.current = true;
+        setPending(true);
+        setError(null);
+        try {
+            await beforeConnect?.();
+            await connect({ walletConnector: connector });
+        }
+        catch (error) {
+            showError(error);
+        }
+        finally {
+            const shouldUpdatePending = pendingRef.current;
+            pendingRef.current = false;
+            if (shouldUpdatePending)
+                setPending(false);
+        }
+    };
+    const chooseWallet = (wallet) => {
+        const connectors = wallet.connectors.filter(({ chainType: connectorChainType }) => !chainType || connectorChainType === chainType);
+        if (!chainType && new Set(connectors.map((connector) => connector.chainType)).size > 1) {
+            setSelectedWallet(wallet);
+            return;
+        }
+        if (connectors[0])
+            void handleConnect(connectors[0]);
+    };
+    const modalTitle = selectedWallet ? "Choose network" : intent === "switch" ? "Switch wallet" : "Connect wallet";
+    return (_jsxs(Modal, { open: true, title: modalTitle, onClose: close, closeDisabled: pending, children: [selectedWallet && (_jsx(WalletSwitchButton, { type: "button", disabled: pending, onClick: () => setSelectedWallet(null), children: "Back" })), _jsx(WalletList, { "aria-busy": pending, children: selectedWallet
+                    ? selectedConnectors.map((connector) => {
+                        const chainName = getChainTypeName(connector.chainType);
+                        return (_jsxs(WalletOption, { type: "button", disabled: pending, "aria-label": `Connect ${selectedWallet.name} on ${chainName}`, onClick: () => void handleConnect(connector), children: [_jsx(WalletIconDisplay, { icon: selectedWallet.icon, name: chainName }), _jsxs(WalletOptionMeta, { children: [_jsx("span", { children: _jsx("strong", { children: chainName }) }), _jsxs("small", { children: [chainName, " network"] })] })] }, connector.chainType));
+                    })
+                    : wallets.map((wallet) => {
+                        const connector = wallet.connectors.find((candidate) => !chainType || candidate.chainType === chainType);
+                        if (!connector)
+                            return null;
+                        const chainTypes = [...new Set(wallet.connectors.map(({ chainType }) => chainType))];
+                        const capabilityLabel = chainTypes.map(getChainTypeName).join(" · ");
+                        return (_jsxs(WalletOption, { type: "button", disabled: pending, "aria-label": `${intent === "switch" ? "Switch to" : "Connect"} ${wallet.name} wallet`, onClick: () => chooseWallet(wallet), children: [_jsx(WalletIconDisplay, { icon: wallet.icon, name: wallet.name }), _jsxs(WalletOptionMeta, { children: [_jsxs("span", { children: [_jsx("strong", { children: wallet.name }), chainTypes.length > 1 && _jsx(MultichainBadge, { children: "Multichain" })] }), _jsx("small", { children: chainTypes.length > 1 ? capabilityLabel : `${capabilityLabel} wallet` })] })] }, wallet.id));
+                    }) }), !selectedWallet && wallets.length === 0 && _jsx(EmptyState, { children: "No compatible installed wallets found" }), error && (_jsx(Hint, { "$tone": "danger", role: "alert", children: error }))] }));
 }

package/dist/components/wallet-connector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/wallet-connector.test.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { ChainType } from "@coin-voyage/shared/types";
+import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { WalletConnector } from "./wallet-connector";
+const connectWallet = vi.fn();
+let connectErrorHandler;
+let installedWallets = [
+    {
+        id: "phantom",
+        name: "Phantom",
+        connectors: [{ chainType: ChainType.SOL, connector: { id: "Phantom", name: "Phantom" } }],
+    },
+];
+vi.mock("@coin-voyage/crypto/hooks", () => ({
+    useInstalledWallets: () => installedWallets,
+    useUniversalConnect: ({ onError }) => {
+        connectErrorHandler = onError;
+        return { connect: connectWallet };
+    },
+}));
+vi.mock("./modal", () => ({
+    Modal: ({ open, title, closeDisabled, children, }) => open ? (_jsx("div", { role: "dialog", "aria-label": title, "data-close-disabled": closeDisabled || undefined, children: children })) : null,
+}));
+afterEach(() => {
+    cleanup();
+    connectWallet.mockClear();
+    connectErrorHandler = undefined;
+    installedWallets = [
+        {
+            id: "phantom",
+            name: "Phantom",
+            connectors: [{ chainType: ChainType.SOL, connector: { id: "Phantom", name: "Phantom" } }],
+        },
+    ];
+});
+describe("WalletConnector", () => {
+    it("uses switch language when replacing a connected wallet", () => {
+        render(_jsx(WalletConnector, { open: true, chainType: ChainType.SOL, intent: "switch", onClose: vi.fn() }));
+        expect(screen.getByRole("dialog", { name: "Switch wallet" })).not.toBeNull();
+        expect(screen.getByRole("button", { name: "Switch to Phantom wallet" })).not.toBeNull();
+    });
+    it("ignores repeated selections while a switch is pending", async () => {
+        const user = userEvent.setup();
+        let finishConnect;
+        connectWallet.mockImplementation(() => new Promise((resolve) => {
+            finishConnect = resolve;
+        }));
+        render(_jsx(WalletConnector, { open: true, chainType: ChainType.SOL, intent: "switch", onClose: vi.fn() }));
+        const option = screen.getByRole("button", { name: "Switch to Phantom wallet" });
+        await user.dblClick(option);
+        expect(connectWallet).toHaveBeenCalledTimes(1);
+        expect(option.hasAttribute("disabled")).toBe(true);
+        expect(screen.getByRole("dialog").getAttribute("data-close-disabled")).toBe("true");
+        finishConnect?.();
+        await waitFor(() => expect(option.hasAttribute("disabled")).toBe(false));
+    });
+    it("asks which chain to connect for a multichain wallet", async () => {
+        const user = userEvent.setup();
+        const solanaConnector = { chainType: ChainType.SOL, connector: { id: "Phantom", name: "Phantom" } };
+        installedWallets = [
+            {
+                id: "phantom",
+                name: "Phantom",
+                connectors: [{ chainType: ChainType.EVM, connector: { id: "app.phantom", name: "Phantom" } }, solanaConnector],
+            },
+        ];
+        render(_jsx(WalletConnector, { open: true, onClose: vi.fn() }));
+        await user.click(screen.getByRole("button", { name: "Connect Phantom wallet" }));
+        expect(connectWallet).not.toHaveBeenCalled();
+        expect(screen.getByRole("dialog", { name: "Choose network" })).not.toBeNull();
+        await user.click(screen.getByRole("button", { name: "Connect Phantom on Solana" }));
+        expect(connectWallet).toHaveBeenCalledWith({ walletConnector: solanaConnector });
+    });
+    it("does not show viem's resource-unavailable error when the wallet prompt is closed", () => {
+        render(_jsx(WalletConnector, { open: true, onClose: vi.fn() }));
+        act(() => {
+            connectErrorHandler?.(new Error("Requested resource not available. Details: Requested resource not available. Version: viem@2.55.10"));
+        });
+        expect(screen.queryByRole("alert")).toBeNull();
+    });
+    it("still shows actionable connection errors", () => {
+        render(_jsx(WalletConnector, { open: true, onClose: vi.fn() }));
+        act(() => connectErrorHandler?.(new Error("Wallet provider unavailable")));
+        expect(screen.getByRole("alert").textContent).toBe("Wallet provider unavailable");
+    });
+});

package/dist/providers/swapkit-provider.d.ts

@@ -1,2 +1,2 @@
 import type { SwapKitProviderProps } from "../types";
-export declare function SwapKitProvider({ apiKey, environment, mode, theme, children, }: SwapKitProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SwapKitProvider({ apiKey, environment, mode, theme, onConnect, onDisconnect, children, }: SwapKitProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/swapkit-provider.js

@@ -1,16 +1,18 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useInWagmiContext } from "@coin-voyage/crypto/evm";
+import { useConnectCallback } from "@coin-voyage/crypto/hooks";
 import { ApiClient } from "@coin-voyage/shared/api";
 import { generateSessionId } from "@coin-voyage/shared/utils";
 import { useMemo, useState } from "react";
 import { SwapKitContext } from "./swapkit-context";
 import { swapkitVersion } from "../lib/version";
-export function SwapKitProvider({ apiKey, environment = "production", mode = "auto", theme = {}, children, }) {
+export function SwapKitProvider({ apiKey, environment = "production", mode = "auto", theme = {}, onConnect, onDisconnect, children, }) {
     const inWalletContext = useInWagmiContext();
     if (!inWalletContext)
         throw new Error("SwapKitProvider must be used within a WalletProvider");
     if (!apiKey.trim())
         throw new Error("SwapKitProvider requires a public API key");
+    useConnectCallback({ onConnect, onDisconnect });
     const [sessionId] = useState(generateSessionId);
     const api = useMemo(() => new ApiClient({ apiKey, environment, sessionId, version: `swapkit/${swapkitVersion}` }), [apiKey, environment, sessionId]);
     const context = useMemo(() => ({ api, environment, mode, theme }), [api, environment, mode, theme]);

package/dist/providers/swapkit-provider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/swapkit-provider.test.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { SwapKitProvider } from "./swapkit-provider";
+const useConnectCallback = vi.fn();
+vi.mock("@coin-voyage/crypto/evm", () => ({
+    useInWagmiContext: () => true,
+}));
+vi.mock("@coin-voyage/crypto/hooks", () => ({
+    useConnectCallback: (props) => useConnectCallback(props),
+}));
+describe("SwapKitProvider", () => {
+    it("listens for connected-provider address changes", () => {
+        const onConnect = vi.fn();
+        const onDisconnect = vi.fn();
+        render(_jsx(SwapKitProvider, { apiKey: "public-api-key", onConnect: onConnect, onDisconnect: onDisconnect, children: _jsx("div", {}) }));
+        expect(useConnectCallback).toHaveBeenCalledWith({ onConnect, onDisconnect });
+    });
+});

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { APIEnvironment } from "@coin-voyage/shared/api";
+import type { useConnectCallbackProps } from "@coin-voyage/crypto/hooks";
 import type { CurrencyBase } from "@coin-voyage/shared/types";
 import type { ReactNode } from "react";
 export type SwapKitMode = "light" | "dark" | "auto";
@@ -20,7 +21,7 @@ export interface SwapKitTheme {
     shadow: string;
     radius: string;
 }
-export interface SwapKitProviderProps {
+export interface SwapKitProviderProps extends Pick<useConnectCallbackProps, "onConnect" | "onDisconnect"> {
     apiKey: string;
     environment?: APIEnvironment;
     mode?: SwapKitMode;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coin-voyage/swapkit",
   "description": "A reusable cross-chain swap component for CoinVoyage.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "sideEffects": false,
   "author": "Lars <lars@coinvoyage.io>",
@@ -22,8 +22,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@coin-voyage/crypto": "3.4.0",
-    "@coin-voyage/shared": "3.4.1-beta.1"
+    "@coin-voyage/crypto": "3.5.0",
+    "@coin-voyage/shared": "3.5.0"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.0",
@@ -36,7 +36,7 @@
     "typescript-plugin-styled-components": "^3.0.0"
   },
   "peerDependencies": {
-    "@bigmi/react": "^0.8.0",
+    "@bigmi/react": "^0.9.1",
     "@mysten/dapp-kit-react": "^2.1.4",
     "@solana/wallet-adapter-react": "^0.15.39",
     "@tanstack/react-query": "^5.90.6",