@coin-voyage/crypto 2.2.2 → 2.2.3-beta.1

package/dist/evm/create-default-evm-config.js

@@ -35,7 +35,7 @@ export function createDefaultEVMConfig(props) {
         }
     }
     if (isWalletInstalled("app.phantom.ethereum")) {
-        connectors.push(extendConnector(injected({ target: "phantom" }), "phantom", "Phantom"));
+        connectors.push(extendConnector(injected({ target: "phantom" }), "app.phantom", "Phantom"));
     }
     if (!isWalletInstalled("coinbase")) {
         const coinbase = createCoinbaseConnector(props?.coinbase ?? {

package/dist/evm/utils.d.ts

@@ -1,4 +1,4 @@
-import { ChainId } from "@coin-voyage/shared/common";
+import { ChainId } from "@coin-voyage/shared/types";
 import type { Connector, CreateConnectorFn } from "wagmi";
 import { BaseConnector } from "../types/base-connector";
 import type { CreateConnectorFnExtended } from "./types";

package/dist/evm/utils.js

@@ -1,4 +1,4 @@
-import { ChainId } from "@coin-voyage/shared/common";
+import { ChainId } from "@coin-voyage/shared/types";
 import { getWalletIcon } from "../assets/icons";
 export const ALCHEMY_KEY = "kikl1LthkvlPnpk8Y2eY3vqGSKVoRGFj";
 export const extendConnector = (connector, id, name) => {

package/dist/hooks/use-account-disconnect.js

@@ -1,6 +1,6 @@
 import { disconnect as utxoDisconnect } from "@bigmi/client";
 import { useConfig as useBigmiConfig } from "@bigmi/react";
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import { useDisconnectWallet } from "@mysten/dapp-kit";
 import { useWallet } from "@solana/wallet-adapter-react";
 import { useDisconnect } from "wagmi";
@@ -26,13 +26,14 @@ export const useAccountDisconnect = () => {
         }
     };
     return async (account) => {
-        if (account) {
+        if (account?.isConnected) {
             return disconnect(account.chainType);
         }
         // Disconnect all accounts if no specific account is provided
         for (const acc of accounts) {
+            if (!acc.isConnected)
+                continue;
             await disconnect(acc.chainType);
-            console.log(`Disconnected account on ${acc.chainType}`);
         }
     };
 };

package/dist/hooks/use-account.d.ts

@@ -1,6 +1,6 @@
 import { Connector as UTXOConnector } from "@bigmi/client";
 import { Account as BTCAccount } from "@bigmi/core";
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import type { Connector } from "wagmi";
 import type { WalletAdapterExtended } from "../solana/types";
 import type { WalletProps } from "../types/wallet";

package/dist/hooks/use-account.js

@@ -1,10 +1,13 @@
-import { useConfig as useBigmiConfig, useAccount as useBtcAccount } from "@bigmi/react";
-import { ChainId, ChainType } from "@coin-voyage/shared/common";
+import { getAccount as getBtcAccount, watchAccount as watchBtcAccount, } from "@bigmi/client";
+import { useConfig as useBigmiConfig } from "@bigmi/react";
+import { ChainId, ChainType } from "@coin-voyage/shared/types";
 import { useCurrentAccount, useCurrentWallet } from "@mysten/dapp-kit";
 import { useWallet } from "@solana/wallet-adapter-react";
+import { useCallback, useRef, useSyncExternalStore } from "react";
 import { useAccount as useAccountInternal } from "wagmi";
 import { getConnector } from "../lib/utils/connector";
 import { extendsWalletAdapter } from "../solana/utils";
+import { useLastConnector } from "./use-last-connector";
 const defaultAccount = {
     chainType: ChainType.EVM,
     isConnected: false,
@@ -108,35 +111,44 @@ const buildUtxoAccount = (btcAccount) => {
  * @bigmi/react for Bitcoin, and @mysten/dapp-kit for Sui) and normalizes their responses into a unified Account type.
  */
 export const useAccount = (args) => {
-    const btcConfig = useBigmiConfig();
-    const btcAccount = useBtcAccount({ config: btcConfig });
+    const { lastConnector } = useLastConnector();
     const wagmiAccount = useAccountInternal();
     const { wallet } = useWallet();
     const suiWallet = useCurrentWallet();
     const suiAccount = useCurrentAccount();
+    const btcConfig = useBigmiConfig();
+    const btcSnapshotCache = useRef(getBtcAccount(btcConfig));
+    const btcSubscribe = useCallback((onChange) => watchBtcAccount(btcConfig, {
+        onChange: () => {
+            btcSnapshotCache.current = getBtcAccount(btcConfig);
+            onChange();
+        },
+    }), [btcConfig]);
+    const btcGetSnapshot = useCallback(() => btcSnapshotCache.current, []);
+    const btcAccount = useSyncExternalStore(btcSubscribe, btcGetSnapshot, btcGetSnapshot);
     const lastConnectedAccount = args?.selectedWallet
-        ? getConnector(args?.selectedWallet.connectors, args?.chainType)
+        ? getConnector(args?.selectedWallet.connectors, args.chainType ?? lastConnector?.chainType)
         : undefined;
-    const solana = buildSolanaAccount(wallet);
-    const sui = buildSuiAccount(suiWallet, suiAccount);
-    const evm = buildEvmAccount(wagmiAccount);
-    const utxo = buildUtxoAccount(btcAccount);
-    const accounts = [evm, solana, sui, utxo];
+    const accounts = [
+        buildEvmAccount(wagmiAccount),
+        buildSolanaAccount(wallet),
+        buildSuiAccount(suiWallet, suiAccount),
+        buildUtxoAccount(btcAccount),
+    ];
     const connectedAccounts = accounts.filter((account) => account.isConnected);
     const selectedChainTypeAccount = args?.chainType
-        ? connectedAccounts.find((account) => account.chainType === args?.chainType) || defaultAccount
+        ? connectedAccounts.find((account) => account.chainType === args.chainType)
         : undefined;
     // If lastConnectedAccount exists, attempt to find a connected account with a matching connector ID or name.
     // If no matching account is found, fallback to the first connected account.
     // If lastConnectedAccount is not present, simply select the first connected account.
     const selectedAccount = lastConnectedAccount
         ? connectedAccounts.find((account) => {
-            const connectorIdMatch = lastConnectedAccount?.id === account.connector?.id;
-            const connectorNameMatch = !lastConnectedAccount?.id &&
-                lastConnectedAccount?.name === account.connector?.name;
-            return connectorIdMatch || connectorNameMatch;
-        }) || connectedAccounts[0]
-        : connectedAccounts[0];
+            return (account.chainType === args?.chainType &&
+                (account.connector?.id === lastConnectedAccount?.id ||
+                    account.connector?.name === lastConnectedAccount?.name));
+        }) || connectedAccounts.find((account) => account.chainType === args?.chainType)
+        : connectedAccounts.find((account) => account.chainType === args?.chainType) || connectedAccounts[0];
     return {
         account: selectedChainTypeAccount || selectedAccount || defaultAccount,
         accounts: connectedAccounts,

package/dist/hooks/use-connect-callback.d.ts

@@ -1,9 +1,9 @@
-import { ChainId, ChainType } from "@coin-voyage/shared/common";
+import { ChainId, ChainType } from "@coin-voyage/shared/types";
 import React from "react";
 export type useConnectCallbackProps = {
     onConnect?: ({ address, chainId, connectorId, type, }: {
         address: string;
-        chainId?: number;
+        chainId?: ChainId;
         connectorId?: string;
         type: ChainType;
     }) => void;

package/dist/hooks/use-installed-wallets.d.ts

@@ -1,4 +1,4 @@
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import type { ChainTypeWalletConnector } from "../types/wallet";
 export type Wallet = {
     id: string;

package/dist/hooks/use-installed-wallets.js

@@ -1,5 +1,5 @@
 import { useConfig as useBigmiConfig } from "@bigmi/react";
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import { useWallets } from "@mysten/dapp-kit";
 import { WalletReadyState } from "@solana/wallet-adapter-base";
 import { useWallet } from "@solana/wallet-adapter-react";
@@ -9,7 +9,18 @@ import { getConnectorIcon } from "../lib/utils/get-connector-icon";
 import { getWalletPriority } from "../lib/utils/get-wallet-priority";
 import { isWalletInstalled } from "../lib/utils/is-wallet-installed";
 import { extendsWalletAdapter } from "../solana/utils";
-const normalizeName = (name) => name.split(" ")[0].toLowerCase().trim();
+// canonical wallet ID for multi-chain wallets 
+const getCanonicalWalletId = (idOrName) => {
+    const lower = idOrName.toLowerCase();
+    // Explicit multi-chain wallet mapping
+    if (lower.includes("phantom"))
+        return "app.phantom";
+    if (lower.includes("rainbow"))
+        return "me.rainbow";
+    if (lower.includes("metamask"))
+        return "io.metamask";
+    return lower.split(" ")[0];
+};
 export const useInstalledWallets = (filterChainType) => {
     const bigmiConfig = useBigmiConfig?.() ?? null;
     const wagmiConfig = useContext(WagmiContext) ?? null;
@@ -18,7 +29,7 @@ export const useInstalledWallets = (filterChainType) => {
     return useMemo(() => {
         const shouldInclude = (chainType) => !filterChainType || filterChainType === chainType;
         const installedUTXO = shouldInclude(ChainType.UTXO)
-            ? (bigmiConfig?.connectors.filter((c) => isWalletInstalled(c.id)) ?? [])
+            ? bigmiConfig?.connectors.filter((c) => isWalletInstalled(c.id)) ?? []
             : [];
         const installedEVM = shouldInclude(ChainType.EVM)
             ? Array.from(wagmiConfig?.connectors ?? []).filter((c) => isWalletInstalled(c.id))
@@ -27,62 +38,38 @@ export const useInstalledWallets = (filterChainType) => {
             ? solanaWallets.filter((w) => [WalletReadyState.Installed, WalletReadyState.Loadable].includes(w.adapter.readyState))
             : [];
         const installedSui = shouldInclude(ChainType.SUI) && suiWallets ? suiWallets : [];
-        return combineWalletLists(installedUTXO, installedEVM, installedSol, installedSui);
+        return combineWalletLists(installedUTXO, installedEVM, installedSol, installedSui, filterChainType);
     }, [bigmiConfig?.connectors, wagmiConfig?.connectors, solanaWallets, suiWallets, filterChainType]);
 };
-const combineWalletLists = (utxoConnectorList, evmConnectorList, solanaWalletList, suiWalletList) => {
+const combineWalletLists = (utxoConnectorList, evmConnectorList, solanaWalletList, suiWalletList, filterChainType) => {
     const walletMap = new Map();
+    const addConnector = (rawId, displayName, icon, connector) => {
+        const walletId = getCanonicalWalletId(rawId);
+        if (filterChainType && connector.chainType !== filterChainType)
+            return;
+        const existing = walletMap.get(walletId);
+        if (existing) {
+            existing.connectors.push(connector);
+        }
+        else {
+            walletMap.set(walletId, { id: walletId, name: displayName, icon, connectors: [connector] });
+        }
+    };
     utxoConnectorList.forEach((utxo) => {
-        const utxoName = utxo.name;
-        const normalizedName = normalizeName(utxoName);
-        const existing = walletMap.get(normalizedName) || {
-            id: utxo.id,
-            name: utxoName,
-            icon: getConnectorIcon(utxo),
-            connectors: [],
-        };
-        existing.connectors.push({ connector: utxo, chainType: ChainType.UTXO });
-        walletMap.set(normalizedName, existing);
+        addConnector(utxo.id, utxo.name, getConnectorIcon(utxo), { connector: utxo, chainType: ChainType.UTXO });
     });
     evmConnectorList.forEach((evm) => {
-        const evmName = evm?.displayName || evm?.name;
-        const normalizedName = normalizeName(evmName);
-        const existing = walletMap.get(normalizedName) || {
-            id: evm.id,
-            name: evmName,
-            icon: getConnectorIcon(evm),
-            connectors: [],
-        };
-        existing.connectors.push({ connector: evm, chainType: ChainType.EVM });
-        walletMap.set(normalizedName, existing);
+        const name = evm?.displayName || evm?.name;
+        addConnector(evm.id, name, getConnectorIcon(evm), { connector: evm, chainType: ChainType.EVM });
     });
     solanaWalletList.forEach((svm) => {
-        const normalizedName = normalizeName(svm.adapter.name);
-        const existing = walletMap.get(normalizedName) || {
-            id: svm.adapter.name,
-            name: svm.adapter.name,
-            icon: svm.adapter.icon,
-            connectors: [],
-        };
-        existing.connectors.push({
+        addConnector(svm.adapter.name, svm.adapter.name, svm.adapter.icon, {
             connector: extendsWalletAdapter(svm.adapter, svm.adapter.name),
             chainType: ChainType.SOL,
         });
-        walletMap.set(normalizedName, existing);
     });
     suiWalletList.forEach((moveVM) => {
-        const normalizedName = normalizeName(moveVM.name);
-        const existing = walletMap.get(normalizedName) || {
-            id: moveVM.name,
-            name: moveVM.name,
-            icon: moveVM.icon,
-            connectors: [],
-        };
-        existing.connectors.push({
-            connector: moveVM,
-            chainType: ChainType.SUI,
-        });
-        walletMap.set(normalizedName, existing);
+        addConnector(moveVM.name, moveVM.name, moveVM.icon, { connector: moveVM, chainType: ChainType.SUI });
     });
     const combinedWallets = Array.from(walletMap.values());
     combinedWallets.sort(walletComparator);
@@ -91,8 +78,7 @@ const combineWalletLists = (utxoConnectorList, evmConnectorList, solanaWalletLis
 const walletComparator = (a, b) => {
     const priorityA = getWalletPriority(a.id);
     const priorityB = getWalletPriority(b.id);
-    if (priorityA !== priorityB) {
+    if (priorityA !== priorityB)
         return priorityA - priorityB;
-    }
-    return a.id?.localeCompare(b.id);
+    return a.id.localeCompare(b.id);
 };

package/dist/hooks/use-last-connector.d.ts

@@ -1,4 +1,10 @@
+import type { ChainType } from "@coin-voyage/shared/types";
+import type { WalletConnector } from "../types/wallet-connector";
 export declare const useLastConnector: () => {
-    lastConnectorId: string | null;
-    updateLastConnectorId: (id: string) => void;
+    lastConnectorId: string | undefined;
+    lastConnector: {
+        id: string;
+        chainType: ChainType;
+    } | null;
+    updateLastConnectorId: (connector: WalletConnector, chainType: ChainType) => void;
 };

package/dist/hooks/use-last-connector.js

@@ -1,13 +1,24 @@
 import { getValue, setValue } from "@coin-voyage/shared/common";
-import { useState } from "react";
+import { useCallback, useState } from "react";
+import { getConnectorId } from "../lib/utils/connector";
 export const useLastConnector = () => {
-    const [lastConnectorId] = useState(() => {
-        // Initialize from localStorage on mount
-        const id = getValue("@coin-voyage/recentConnectorId");
-        return id ?? "";
+    const [lastConnectorIdWithChain, setLastConnectorIdWithChain] = useState(() => {
+        const stored = getValue("@coin-voyage/recentConnectorId");
+        return stored ?? null;
     });
-    const updateLastConnectorId = (id) => {
-        setValue("@coin-voyage/recentConnectorId", id);
-    };
-    return { lastConnectorId, updateLastConnectorId };
+    const updateLastConnectorId = useCallback((connector, chainType) => {
+        const idWithChain = `${getConnectorId(connector)}-${chainType}`;
+        setValue("@coin-voyage/recentConnectorId", idWithChain);
+        setLastConnectorIdWithChain(idWithChain);
+    }, []);
+    // Parse into ID + chainType for easy access
+    const lastConnector = lastConnectorIdWithChain
+        ? (() => {
+            const split = lastConnectorIdWithChain.split("-");
+            const id = split[0];
+            const chainType = split[1];
+            return { id, chainType };
+        })()
+        : null;
+    return { lastConnectorId: lastConnector?.id, lastConnector, updateLastConnectorId };
 };

package/dist/hooks/use-prepare-transaction.d.ts

@@ -1,4 +1,4 @@
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import { ExecuteTransaction } from "../types/transaction";
 export declare function usePrepareTransaction(chainType?: ChainType): {
     execute: (params: ExecuteTransaction) => Promise<string | undefined>;

package/dist/hooks/use-prepare-transaction.js

@@ -1,4 +1,4 @@
-import { ChainType } from "@coin-voyage/shared/common";
+import { ChainType } from "@coin-voyage/shared/types";
 import { useEVMTransaction } from "../evm/use-evm-transaction";
 import { useSolanaTransaction } from "../solana/use-solana-transaction";
 import { useSUITransaction } from "../sui/use-sui-transaction";

package/dist/hooks/use-universal-connect.js

@@ -1,30 +1,30 @@
 import { useConfig as useBigmiConfig, useConnect as useUTXOConnect } from "@bigmi/react";
-import { ChainId, ChainType } from "@coin-voyage/shared/common";
+import { ChainId, ChainType } from "@coin-voyage/shared/types";
 import { useConnectWallet } from "@mysten/dapp-kit";
 import { useWallet } from "@solana/wallet-adapter-react";
+import { useCallback } from "react";
 import { useConfig as useWagmiConfig, useConnect as useWagmiConnect } from "wagmi";
-import { getConnectorId } from "../lib/utils/connector";
 import { useLastConnector } from "./use-last-connector";
-import { useCallback } from "react";
 export const useUniversalConnect = (props) => {
     const utxoConfig = useBigmiConfig();
     const evmConfig = useWagmiConfig();
     const { updateLastConnectorId } = useLastConnector();
     const { select, disconnect, connected } = useWallet();
     const { mutateAsync: suiConnectAsync } = useConnectWallet();
+    const { onError, onSuccess, onSettled, onMutate } = props || {};
     const { connectAsync } = useWagmiConnect({
         config: evmConfig,
         mutation: {
             ...props,
             onSuccess(data, variables) {
                 const connector = variables.connector || variables.connector;
-                updateLastConnectorId(getConnectorId(connector));
-                props?.onSuccess?.(data, {
+                updateLastConnectorId(connector, ChainType.EVM);
+                onSuccess?.(data, {
                     chainId: variables?.chainId,
                     connector,
                 });
             },
-            onError: props?.onError,
+            onError,
         },
     });
     const { connectAsync: utxoConnectAsync } = useUTXOConnect({
@@ -33,18 +33,18 @@ export const useUniversalConnect = (props) => {
             ...props,
             onSuccess(data, variables) {
                 const connector = variables.connector;
-                updateLastConnectorId(getConnectorId(connector));
-                props?.onSuccess?.(data, {
+                updateLastConnectorId(connector, ChainType.UTXO);
+                onSuccess?.(data, {
                     chainId: ChainId.BTC,
                     connector,
                 });
             },
-            onError: props?.onError,
+            onError,
         },
     });
     const connect = useCallback(async ({ walletConnector }) => {
         const { connector, chainType } = walletConnector;
-        props?.onMutate?.({ connector });
+        onMutate?.({ connector });
         try {
             switch (chainType) {
                 case ChainType.EVM:
@@ -82,20 +82,20 @@ export const useUniversalConnect = (props) => {
                             walletAdapter.connect().catch(handleError);
                         });
                     }
-                    updateLastConnectorId(getConnectorId(connector));
-                    props?.onSuccess?.(undefined, { connector: walletAdapter });
+                    updateLastConnectorId(connector, ChainType.SOL);
+                    onSuccess?.(undefined, { connector: walletAdapter });
                     break;
                 }
                 case ChainType.SUI:
                     await suiConnectAsync({
                         wallet: connector,
                     }, {
-                        onError: props?.onError,
+                        onError,
                         onSuccess: async (data) => {
-                            updateLastConnectorId(getConnectorId(connector));
-                            props?.onSuccess?.(data, { connector });
+                            updateLastConnectorId(connector, ChainType.SUI);
+                            onSuccess?.(data, { connector });
                         },
-                        onSettled: props?.onSettled,
+                        onSettled: onSettled,
                     });
                     break;
                 default:
@@ -103,7 +103,7 @@ export const useUniversalConnect = (props) => {
             }
         }
         catch (err) {
-            props?.onError?.(err);
+            onError?.(err);
         }
     }, [
         connectAsync,
@@ -113,10 +113,10 @@ export const useUniversalConnect = (props) => {
         disconnect,
         select,
         updateLastConnectorId,
-        props?.onError,
-        props?.onSuccess,
-        props?.onSettled,
-        props?.onMutate,
+        onError,
+        onSuccess,
+        onSettled,
+        onMutate,
     ]);
     return { connect };
 };

package/dist/lib/utils/connector.d.ts

@@ -1,4 +1,4 @@
-import type { ChainType } from "@coin-voyage/shared/common";
+import type { ChainType } from "@coin-voyage/shared/types";
 import type { ChainTypeWalletConnector } from "../../types/wallet";
 import type { WalletConnector } from "../../types/wallet-connector";
 export declare const getConnectorId: (connector: WalletConnector) => string;

package/dist/lib/utils/get-wallet-priority.js

@@ -3,9 +3,9 @@ const walletPriority = {
     metamask: 1,
     "io.metamask": 1,
     "io.metamask.mobile": 1,
+    slush: 1,
     phantom: 1,
     "app.phantom": 1,
-    slush: 1,
     coinbasewalletsdk: 2,
     "com.coinbase.wallet": 2,
     walletconnect: 1001,

package/dist/types/wallet.d.ts

@@ -1,4 +1,4 @@
-import type { ChainId, ChainType } from "@coin-voyage/shared/common";
+import type { ChainId, ChainType } from "@coin-voyage/shared/types";
 import type { WalletProviderProps as SuiWalletProviderProps } from "@mysten/dapp-kit";
 import type { WalletProviderProps } from "@solana/wallet-adapter-react";
 import type { EVMConfiguration } from "../evm/create-default-evm-config";

package/dist/utxo/send-btc.js

@@ -1,5 +1,5 @@
 import { sendUTXOTransaction } from "@bigmi/core";
-import { ChainId } from "@coin-voyage/shared/common";
+import { ChainId } from "@coin-voyage/shared/types";
 import { Psbt } from "bitcoinjs-lib";
 import { createUnsecuredToken } from "jsontokens";
 import { withTimeout } from "viem";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coin-voyage/crypto",
   "description": "Crypto utilities for Coin Voyage",
-  "version": "2.2.2",
+  "version": "2.2.3-beta.1",
   "private": false,
   "sideEffects": false,
   "author": "Lars <lars@coinvoyage.io>",
@@ -50,7 +50,7 @@
     "@solana/wallet-adapter-walletconnect": "0.1.21",
     "@solana/wallet-adapter-base": "0.9.27",
     "@solana/wallet-adapter-coinbase": "0.1.23",
-    "@coin-voyage/shared": "2.2.0"
+    "@coin-voyage/shared": "2.2.5-beta.8"
   },
   "devDependencies": {
     "@types/elliptic": "6.4.18"