@btc-vision/walletconnect 1.4.1 → 1.5.1

package/src/WalletProvider.tsx

@@ -1,240 +0,0 @@
-import { Network } from '@btc-vision/bitcoin';
-import { Address } from '@btc-vision/transaction';
-import { AbstractRpcProvider } from 'opnet';
-import {
-    createContext,
-    ReactNode,
-    useCallback,
-    useContext,
-    useEffect,
-    useRef,
-    useState,
-} from 'react';
-import WalletConnection, { Signers, SupportedWallets, Wallets } from './WalletConnection';
-
-export interface Account {
-    isConnected: boolean;
-    signer: Signers | null;
-    address: Address;
-    addressTyped: string;
-    network: Network;
-    provider: AbstractRpcProvider;
-}
-
-interface WalletContextType {
-    connect: (wallet: SupportedWallets, signal?: AbortSignal) => Promise<void>;
-    disconnect: () => void;
-    walletType: SupportedWallets | null;
-    walletWindowInstance: Wallets | null;
-    account: Account | null;
-}
-
-const WalletContext = createContext<WalletContextType | undefined>(undefined);
-
-const MAX_RETRIES = 10;
-const RETRY_DELAY_MS = 2_000;
-
-function useDocumentComplete(fn: () => void) {
-    const fired = useRef(false);
-
-    useEffect(() => {
-        if (fired.current) return;
-        const run = () => {
-            if (fired.current) return;
-            fired.current = true;
-            fn();
-        };
-
-        if (document.readyState === 'complete') {
-            run();
-            return;
-        }
-
-        const handler = () => {
-            if (document.readyState === 'complete') {
-                document.removeEventListener('readystatechange', handler);
-                run();
-            }
-        };
-        document.addEventListener('readystatechange', handler);
-        return () => document.removeEventListener('readystatechange', handler);
-    }, [fn]);
-}
-
-export const WalletProvider = ({ children }: { children: ReactNode }) => {
-    const [walletConnection] = useState(() => new WalletConnection());
-    const [walletType, setWalletType] = useState<SupportedWallets | null>(null);
-    const [walletWindowInstance, setWalletWindowInstance] = useState<Wallets | null>(null);
-    const [account, setAccount] = useState<Account | null>(null);
-
-    /** keeps the latest listeners so they can be removed in `disconnect` */
-    const listeners = useRef<{
-        disconnect?: () => void;
-        accountsChanged?: () => void;
-    }>({});
-
-    const disconnect = useCallback(() => {
-        // detach previously attached listeners, if any
-        const inst = walletWindowInstance;
-        if (inst) {
-            if (listeners.current.disconnect) {
-                inst.removeListener?.('disconnect', listeners.current.disconnect);
-                listeners.current.disconnect = undefined;
-            }
-            if (listeners.current.accountsChanged) {
-                inst.removeListener?.('accountsChanged', listeners.current.accountsChanged);
-                listeners.current.accountsChanged = undefined;
-            }
-        }
-
-        walletConnection.disconnect();
-        setWalletType(null);
-        setWalletWindowInstance(null);
-        localStorage.removeItem('walletType');
-        setAccount(null);
-    }, [walletConnection, walletWindowInstance]);
-
-    const connect = useCallback(
-        async (type: SupportedWallets, signal?: AbortSignal) => {
-            let attempt = 0;
-
-            const throwIfAborted = () => {
-                if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');
-            };
-
-            while (attempt < MAX_RETRIES) {
-                throwIfAborted();
-                try {
-                    await walletConnection.connect(type);
-
-                    if (
-                        (walletConnection.walletType !== SupportedWallets.OP_WALLET &&
-                            !walletConnection.signer) ||
-                        !walletConnection.walletWindowInstance
-                    ) {
-                        throw new Error('Wallet not fully loaded yet');
-                    }
-                    break; // success
-                } catch (err) {
-                    attempt += 1;
-                    if (attempt >= MAX_RETRIES) {
-                        console.warn(`Failed to connect after ${MAX_RETRIES} attempts.`, err);
-                        disconnect();
-                        return;
-                    }
-                    console.warn(`Connection attempt ${attempt} failed:`, (err as Error).message);
-
-                    try {
-                        await new Promise<void>((res, rej) => {
-                            const t = setTimeout(res, RETRY_DELAY_MS);
-                            signal?.addEventListener('abort', () => {
-                                clearTimeout(t);
-                                rej(new DOMException('Aborted', 'AbortError'));
-                            });
-                        });
-                    } catch {
-                        console.debug('Connection aborted during retry delay.');
-                        return;
-                    }
-                }
-            }
-
-            throwIfAborted();
-
-            setWalletType(type);
-            setWalletWindowInstance(walletConnection.walletWindowInstance);
-            localStorage.setItem('walletType', type);
-
-            try {
-                const [signer, address, addressTyped, network, provider] = await Promise.all([
-                    walletConnection.signer,
-                    walletConnection.getAddress(),
-                    walletConnection.getAddressTyped(),
-                    walletConnection.getNetwork(),
-                    walletConnection.getProvider(),
-                ]);
-
-                setAccount({
-                    isConnected: true,
-                    signer,
-                    address,
-                    addressTyped,
-                    network,
-                    provider,
-                });
-
-                /* attach listeners exactly once per successful connect */
-                const instance = walletConnection.walletWindowInstance;
-                if (instance) {
-                    const onDisconnect = () => disconnect();
-                    const onAccountsChanged = async () => {
-                        try {
-                            const [updatedAddr, updatedAddrTyped, updatedNet, updatedProv] =
-                                await Promise.all([
-                                    walletConnection.getAddress(),
-                                    walletConnection.getAddressTyped(),
-                                    walletConnection.getNetwork(),
-                                    walletConnection.getProvider(),
-                                ]);
-
-                            setAccount((prev) =>
-                                prev
-                                    ? {
-                                          ...prev,
-                                          address: updatedAddr,
-                                          addressTyped: updatedAddrTyped,
-                                          network: updatedNet,
-                                          provider: updatedProv,
-                                      }
-                                    : prev,
-                            );
-                        } catch {
-                            disconnect();
-                        }
-                    };
-
-                    /* store for later removal */
-                    listeners.current.disconnect = onDisconnect;
-                    listeners.current.accountsChanged = onAccountsChanged;
-
-                    instance.on('disconnect', onDisconnect);
-                    instance.on('accountsChanged', onAccountsChanged);
-                }
-            } catch (err) {
-                console.warn('Unable to finalize wallet connection:', err);
-                disconnect();
-            }
-        },
-        [walletConnection, disconnect],
-    );
-
-    useDocumentComplete(() => {
-        const stored = localStorage.getItem('walletType') as SupportedWallets | null;
-        if (!stored) return;
-
-        const controller = new AbortController();
-        connect(stored, controller.signal).catch((err: unknown) => {
-            if ((err as DOMException).name !== 'AbortError') {
-                console.warn('Failed to reconnect to wallet:', err);
-            }
-        });
-
-        return () => controller.abort();
-    });
-
-    const ctx: WalletContextType = {
-        connect,
-        disconnect,
-        walletType,
-        walletWindowInstance,
-        account,
-    };
-
-    return <WalletContext.Provider value={ctx}>{children}</WalletContext.Provider>;
-};
-
-export const useWallet = (): WalletContextType => {
-    const ctx = useContext(WalletContext);
-    if (!ctx) throw new Error('useWallet must be used within a WalletProvider');
-    return ctx;
-};