@openocean.finance/wallet-management/dist/esm/hooks/useCombinedWallets.js

Openocean Wallet Management solution.

import { useConfig as useBigmiConfig } from '@bigmi/react';
import { useMediaQuery } from '@mui/material';
import { ChainType } from '@openocean.finance/widget-sdk';
import { WalletReadyState } from '@solana/wallet-adapter-base';
import { useWallet } from '@solana/wallet-adapter-react';
import { useMemo } from 'react';
import { useAccount, useConnect } from 'wagmi';
import { defaultCoinbaseConfig } from '../config/coinbase.js';
import { defaultMetaMaskConfig } from '../config/metaMask.js';
import { defaultWalletConnectConfig } from '../config/walletConnect.js';
import { createCoinbaseConnector } from '../connectors/coinbase.js';
import { createMetaMaskConnector } from '../connectors/metaMask.js';
import { createWalletConnectConnector } from '../connectors/walletConnect.js';
import { useWalletManagementConfig } from '../providers/WalletManagementProvider/WalletManagementContext.js';
import { getConnectorIcon } from '../utils/getConnectorIcon.js';
import { getWalletPriority } from '../utils/getWalletPriority.js';
import { isWalletInstalled } from '../utils/isWalletInstalled.js';
const normalizeName = (name) => name.split(' ')[0].toLowerCase().trim();
const combineWalletLists = (utxoConnectorList, evmConnectorList, svmWalletList) => {
    const walletMap = new Map();
    utxoConnectorList.forEach((utxo) => {
        const utxoName = utxo?.displayName ||
            utxo?.name;
        const normalizedName = normalizeName(utxoName);
        const connectors = [];
        const existing = walletMap.get(normalizedName) || {
            id: utxo.id,
            name: utxoName,
            icon: getConnectorIcon(utxo),
            connectors: connectors,
        };
        existing.connectors.push({ connector: utxo, chainType: ChainType.UTXO });
        walletMap.set(normalizedName, existing);
    });
    evmConnectorList.forEach((evm) => {
        const evmName = evm?.displayName ||
            evm?.name;
        const normalizedName = normalizeName(evmName);
        const connectors = [];
        const existing = walletMap.get(normalizedName) || {
            id: evm.id,
            name: evmName,
            icon: getConnectorIcon(evm),
            connectors: connectors,
        };
        existing.connectors.push({ connector: evm, chainType: ChainType.EVM });
        walletMap.set(normalizedName, existing);
    });
    svmWalletList.forEach((svm) => {
        const normalizedName = normalizeName(svm.adapter.name);
        const connectors = [];
        const existing = walletMap.get(normalizedName) || {
            id: svm.adapter.name,
            name: svm.adapter.name,
            icon: svm.adapter.icon,
            connectors: connectors,
        };
        existing.connectors.push({
            connector: svm.adapter,
            chainType: ChainType.SVM,
        });
        walletMap.set(normalizedName, existing);
    });
    const combinedWallets = Array.from(walletMap.values());
    combinedWallets.sort(walletComparator);
    return combinedWallets;
};
export const useCombinedWallets = () => {
    const walletConfig = useWalletManagementConfig();
    const bigmiConfig = useBigmiConfig();
    const wagmiAccount = useAccount();
    const bigmiAccount = useAccount({ config: bigmiConfig });
    const { connectors: wagmiConnectors } = useConnect();
    const { connectors: bigmiConnectors } = useConnect({ config: bigmiConfig });
    const { wallets: solanaWallets } = useWallet();
    const isDesktopView = useMediaQuery((theme) => theme.breakpoints.up('sm'));
    const data = useMemo(() => {
        const evmConnectors = Array.from(wagmiConnectors);
        // Ensure standard connectors are included
        if (!evmConnectors.some((connector) => connector.id.toLowerCase().includes('walletconnect'))) {
            evmConnectors.unshift(createWalletConnectConnector(walletConfig?.walletConnect ?? defaultWalletConnectConfig));
        }
        if (!evmConnectors.some((connector) => connector.id.toLowerCase().includes('coinbase'))) {
            evmConnectors.unshift(createCoinbaseConnector(walletConfig?.coinbase ?? defaultCoinbaseConfig));
        }
        if (!evmConnectors.some((connector) => connector.id.toLowerCase().includes('metamask'))) {
            evmConnectors.unshift(createMetaMaskConnector(walletConfig?.metaMask ?? defaultMetaMaskConfig));
        }
        const includeEcosystem = (chainType) => {
            return !walletConfig.enabledChainTypes ||
                walletConfig.enabledChainTypes.includes(chainType);
        };
        const installedUTXOConnectors = includeEcosystem(ChainType.UTXO)
            ? bigmiConnectors.filter((connector) => {
                const isInstalled = isWalletInstalled(connector.id);
                const isConnected = bigmiAccount.connector?.id === connector.id;
                return isInstalled && !isConnected;
            })
            : [];
        const installedEVMConnectors = includeEcosystem(ChainType.EVM)
            ? evmConnectors.filter((connector) => {
                const isInstalled = isWalletInstalled(connector.id);
                const isConnected = wagmiAccount.connector?.id === connector.id;
                return isInstalled && !isConnected;
            })
            : [];
        const installedSVMWallets = includeEcosystem(ChainType.SVM)
            ? solanaWallets.filter((wallet) => {
                const isInstalled = wallet.adapter.readyState === WalletReadyState.Installed ||
                    wallet.adapter.readyState === WalletReadyState.Loadable;
                const isConnected = wallet.adapter.connected;
                return isInstalled && !isConnected;
            })
            : [];
        const installedCombinedWallets = combineWalletLists(installedUTXOConnectors, installedEVMConnectors, installedSVMWallets);
        // Add Near wallets (Meteor / Sender) as NVM ecosystem wallets.
        if (includeEcosystem(ChainType.NVM)) {
            const nearWallets = [
                {
                    id: 'meteor-wallet',
                    name: 'Meteor Wallet',
                    icon: 'https://assets.meteorwallet.app/logo.png',
                    connectors: [
                        {
                            // We only need an identifier here; connection logic is handled
                            // in the NVM-specific list item button in the UI layer.
                            connector: { id: 'meteor-wallet' },
                            chainType: ChainType.NVM,
                        },
                    ],
                },
                {
                    id: 'sender',
                    name: 'Sender Wallet',
                    icon: 'https://senderwallet.io/favicon.ico',
                    connectors: [
                        {
                            connector: { id: 'sender' },
                            chainType: ChainType.NVM,
                        },
                    ],
                },
            ];
            nearWallets.forEach((wallet) => {
                if (!installedCombinedWallets.some((w) => w.id === wallet.id)) {
                    installedCombinedWallets.push(wallet);
                }
            });
        }
        const notDetectedUTXOConnectors = bigmiConnectors.filter((connector) => {
            const isInstalled = isWalletInstalled(connector.id);
            return !isInstalled && isDesktopView;
        });
        const notDetectedEVMConnectors = evmConnectors.filter((connector) => {
            const isInstalled = isWalletInstalled(connector.id);
            return !isInstalled && isDesktopView;
        });
        const notDetectedSVMWallets = solanaWallets.filter((wallet) => {
            const isInstalled = wallet.adapter.readyState === WalletReadyState.Installed ||
                wallet.adapter.readyState === WalletReadyState.Loadable;
            return !isInstalled && isDesktopView;
        });
        const notDetectedCombinedWallets = combineWalletLists(notDetectedEVMConnectors, notDetectedUTXOConnectors, notDetectedSVMWallets);
        installedCombinedWallets.sort(walletComparator);
        notDetectedCombinedWallets.sort(walletComparator);
        return {
            installedWallets: installedCombinedWallets,
            notDetectedWallets: notDetectedCombinedWallets,
        };
    }, [
        bigmiAccount.connector?.id,
        bigmiConnectors,
        solanaWallets,
        wagmiAccount.connector?.id,
        wagmiConnectors,
        isDesktopView,
        walletConfig,
    ]);
    return data;
};
// Ensure the walletComparator function is updated to handle CombinedWallet
export const walletComparator = (a, b) => {
    const priorityA = getWalletPriority(a.id);
    const priorityB = getWalletPriority(b.id);
    if (priorityA !== priorityB) {
        return priorityA - priorityB;
    }
    return a.id?.localeCompare(b.id);
};
//# sourceMappingURL=useCombinedWallets.js.map