@btc-vision/walletconnect 1.5.0 → 1.5.2

package/build/WalletConnection.js

@@ -1,152 +0,0 @@
-import { networks } from '@btc-vision/bitcoin';
-import { Address, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
-import { JSONRpcProvider } from 'opnet';
-export var SupportedWallets;
-(function (SupportedWallets) {
-    SupportedWallets["OP_WALLET"] = "op_wallet";
-    SupportedWallets["UNISAT"] = "unisat";
-})(SupportedWallets || (SupportedWallets = {}));
-export class WalletConnection {
-    constructor() {
-        this.signer = null;
-        this.walletType = null;
-        this.walletWindowInstance = null;
-    }
-    async connect(walletType) {
-        if (this.walletType === walletType)
-            return;
-        if (this.walletType)
-            this.disconnect();
-        switch (walletType) {
-            case SupportedWallets.OP_WALLET: {
-                if (window.opnet) {
-                    try {
-                        await window.opnet.requestAccounts();
-                        this.walletType = walletType;
-                        this.walletWindowInstance = window.opnet;
-                        return;
-                    }
-                    catch (error) {
-                        if (!error)
-                            return;
-                        if (error instanceof Error)
-                            throw new Error(error.message);
-                        if (typeof error === 'object' &&
-                            'message' in error &&
-                            typeof error.message === 'string') {
-                            throw new Error(error.message);
-                        }
-                        console.warn(error);
-                        throw new Error(`Unknown error, check console`);
-                    }
-                }
-                else {
-                    throw new Error('OP_WALLET not found');
-                }
-            }
-            case SupportedWallets.UNISAT: {
-                if (window.unisat) {
-                    try {
-                        await window.unisat.requestAccounts();
-                        const signer = new UnisatSigner();
-                        await signer.init();
-                        this.signer = signer;
-                        this.walletType = walletType;
-                        this.walletWindowInstance = window.unisat;
-                        return;
-                    }
-                    catch (error) {
-                        if (!error)
-                            return;
-                        if (error instanceof Error)
-                            throw new Error(error.message);
-                        if (typeof error === 'object' &&
-                            'message' in error &&
-                            typeof error.message === 'string')
-                            throw new Error(error.message);
-                        console.error(error);
-                        throw new Error(`Unknown error, check console`);
-                    }
-                }
-                else {
-                    throw new Error('Unisat not found');
-                }
-            }
-            default:
-                throw new Error('Unsupported wallet');
-        }
-    }
-    disconnect() {
-        if (!this.walletWindowInstance)
-            return;
-        if (this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT)
-            this.walletWindowInstance.disconnect();
-        this.signer = null;
-        this.walletType = null;
-        this.walletWindowInstance = null;
-    }
-    async getAddress() {
-        if (!this.walletWindowInstance)
-            throw new Error('Wallet not connected');
-        if (this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT) {
-            const publicKey = await this.walletWindowInstance.getPublicKey();
-            return Address.fromString(publicKey);
-        }
-        throw new Error('Unsupported wallet');
-    }
-    async getAddressTyped() {
-        if (!this.walletWindowInstance)
-            throw new Error('Wallet not connected');
-        if (this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT) {
-            const accounts = await this.walletWindowInstance.getAccounts();
-            return accounts[0];
-        }
-        throw new Error('Unsupported wallet');
-    }
-    async getNetwork() {
-        if (!this.walletWindowInstance)
-            throw new Error('Wallet not connected');
-        if (this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT) {
-            const chain = await this.walletWindowInstance.getChain();
-            switch (chain.enum) {
-                case UnisatChainType.BITCOIN_MAINNET:
-                    return networks.bitcoin;
-                case UnisatChainType.BITCOIN_TESTNET:
-                    return networks.testnet;
-                case UnisatChainType.BITCOIN_REGTEST:
-                    return networks.regtest;
-                case UnisatChainType.FRACTAL_BITCOIN_MAINNET:
-                    return networks.bitcoin;
-                case UnisatChainType.FRACTAL_BITCOIN_TESTNET:
-                    return networks.testnet;
-                default:
-                    throw new Error('Unsupported network');
-            }
-        }
-        throw new Error('Unsupported wallet');
-    }
-    async getProvider() {
-        if (!this.walletWindowInstance)
-            throw new Error('Wallet not connected');
-        if (this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT) {
-            const chain = await this.walletWindowInstance.getChain();
-            switch (chain.enum) {
-                case UnisatChainType.BITCOIN_MAINNET:
-                    return new JSONRpcProvider('https://api.opnet.org', networks.bitcoin);
-                case UnisatChainType.BITCOIN_TESTNET:
-                    return new JSONRpcProvider('https://testnet.opnet.org', networks.testnet);
-                case UnisatChainType.BITCOIN_REGTEST:
-                    return new JSONRpcProvider('https://regtest.opnet.org', networks.regtest);
-                default:
-                    throw new Error('Unsupported network');
-            }
-        }
-        throw new Error('Unsupported wallet');
-    }
-}
-export default WalletConnection;

package/build/WalletProvider.d.ts

@@ -1,25 +0,0 @@
-import { Network } from '@btc-vision/bitcoin';
-import { Address } from '@btc-vision/transaction';
-import { AbstractRpcProvider } from 'opnet';
-import { ReactNode } from 'react';
-import { 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;
-}
-export declare const WalletProvider: ({ children }: {
-    children: ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
-export declare const useWallet: () => WalletContextType;
-export {};

package/build/WalletProvider.js

@@ -1,178 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useRef, useState, } from 'react';
-import WalletConnection, { SupportedWallets } from './WalletConnection';
-const WalletContext = createContext(undefined);
-const MAX_RETRIES = 10;
-const RETRY_DELAY_MS = 2000;
-function useDocumentComplete(fn) {
-    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 }) => {
-    const [walletConnection] = useState(() => new WalletConnection());
-    const [walletType, setWalletType] = useState(null);
-    const [walletWindowInstance, setWalletWindowInstance] = useState(null);
-    const [account, setAccount] = useState(null);
-    const listeners = useRef({});
-    const disconnect = useCallback(() => {
-        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, signal) => {
-        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;
-            }
-            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.message);
-                try {
-                    await new Promise((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,
-            });
-            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();
-                    }
-                };
-                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');
-        if (!stored)
-            return;
-        const controller = new AbortController();
-        connect(stored, controller.signal).catch((err) => {
-            if (err.name !== 'AbortError') {
-                console.warn('Failed to reconnect to wallet:', err);
-            }
-        });
-        return () => controller.abort();
-    });
-    const ctx = {
-        connect,
-        disconnect,
-        walletType,
-        walletWindowInstance,
-        account,
-    };
-    return _jsx(WalletContext.Provider, { value: ctx, children: children });
-};
-export const useWallet = () => {
-    const ctx = useContext(WalletContext);
-    if (!ctx)
-        throw new Error('useWallet must be used within a WalletProvider');
-    return ctx;
-};

package/src/WalletConnection.ts

@@ -1,210 +0,0 @@
-import { Network, networks } from '@btc-vision/bitcoin';
-import { Address, Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
-import { AbstractRpcProvider, JSONRpcProvider } from 'opnet';
-
-export enum SupportedWallets {
-    OP_WALLET = 'op_wallet',
-    UNISAT = 'unisat',
-}
-export type Signers = UnisatSigner;
-export type Wallets = Unisat;
-
-export class WalletConnection {
-    public signer: Signers | null = null; // OP_WALLET doesn't need a signer
-    public walletType: SupportedWallets | null = null;
-    public walletWindowInstance: Wallets | null = null;
-
-    /**
-     * @description Connect to the wallet
-     * @param {SupportedWallets} walletType
-     * @returns {Promise<void>}
-     */
-    public async connect(walletType: SupportedWallets): Promise<void> {
-        if (this.walletType === walletType) return;
-        if (this.walletType) this.disconnect();
-
-        switch (walletType) {
-            case SupportedWallets.OP_WALLET: {
-                if (window.opnet) {
-                    try {
-                        await window.opnet.requestAccounts(); // Trick on OP_WALLET: force the connection popup to appear
-
-                        this.walletType = walletType;
-                        this.walletWindowInstance = window.opnet;
-                        return;
-                    } catch (error: unknown) {
-                        if (!error) return;
-
-                        if (error instanceof Error) throw new Error(error.message);
-
-                        if (
-                            typeof error === 'object' &&
-                            'message' in error &&
-                            typeof error.message === 'string'
-                        ) {
-                            throw new Error(error.message);
-                        }
-
-                        console.warn(error);
-
-                        throw new Error(`Unknown error, check console`);
-                    }
-                } else {
-                    throw new Error('OP_WALLET not found');
-                }
-            }
-            case SupportedWallets.UNISAT: {
-                if (window.unisat) {
-                    try {
-                        await window.unisat.requestAccounts(); // Trick on Unisat: force the connection popup to appear
-
-                        const signer = new UnisatSigner();
-                        await signer.init();
-
-                        this.signer = signer;
-                        this.walletType = walletType;
-                        this.walletWindowInstance = window.unisat;
-                        return;
-                    } catch (error: unknown) {
-                        if (!error) return;
-
-                        if (error instanceof Error) throw new Error(error.message);
-
-                        if (
-                            typeof error === 'object' &&
-                            'message' in error &&
-                            typeof error.message === 'string'
-                        )
-                            throw new Error(error.message);
-
-                        console.error(error);
-                        throw new Error(`Unknown error, check console`);
-                    }
-                } else {
-                    throw new Error('Unisat not found');
-                }
-            }
-            default:
-                throw new Error('Unsupported wallet');
-        }
-    }
-
-    /**
-     * @description Disconnect from the wallet
-     * @returns {void}
-     */
-    public disconnect(): void {
-        if (!this.walletWindowInstance) return;
-
-        if (
-            this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT
-        )
-            this.walletWindowInstance.disconnect();
-
-        this.signer = null;
-        this.walletType = null;
-        this.walletWindowInstance = null;
-    }
-
-    /**
-     * @description Get the address of the connected wallet
-     * @returns {Promise<Address>}
-     */
-    public async getAddress(): Promise<Address> {
-        if (!this.walletWindowInstance) throw new Error('Wallet not connected');
-
-        if (
-            this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT
-        ) {
-            const publicKey = await this.walletWindowInstance.getPublicKey();
-
-            return Address.fromString(publicKey);
-        }
-
-        throw new Error('Unsupported wallet');
-    }
-
-    /**
-     * @description Get the address typed (P2TR or Native Segwit, etc.) of the connected wallet
-     * @returns {Promise<string>}
-     */
-    public async getAddressTyped(): Promise<string> {
-        if (!this.walletWindowInstance) throw new Error('Wallet not connected');
-
-        if (
-            this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT
-        ) {
-            const accounts = await this.walletWindowInstance.getAccounts();
-
-            return accounts[0];
-        }
-
-        throw new Error('Unsupported wallet');
-    }
-
-    /**
-     * @description Get the network of the connected wallet
-     * @returns {Promise<Network>}
-     */
-    public async getNetwork(): Promise<Network> {
-        if (!this.walletWindowInstance) throw new Error('Wallet not connected');
-
-        if (
-            this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT
-        ) {
-            const chain = await this.walletWindowInstance.getChain();
-
-            switch (chain.enum) {
-                case UnisatChainType.BITCOIN_MAINNET:
-                    return networks.bitcoin;
-                case UnisatChainType.BITCOIN_TESTNET:
-                    return networks.testnet;
-                case UnisatChainType.BITCOIN_REGTEST:
-                    return networks.regtest;
-                case UnisatChainType.FRACTAL_BITCOIN_MAINNET:
-                    return networks.bitcoin;
-                case UnisatChainType.FRACTAL_BITCOIN_TESTNET:
-                    return networks.testnet;
-                default:
-                    throw new Error('Unsupported network');
-            }
-        }
-
-        throw new Error('Unsupported wallet');
-    }
-
-    /**
-     * @description Get the provider of the connected wallet
-     * @returns {Promise<AbstractRpcProvider>}
-     */
-    public async getProvider(): Promise<AbstractRpcProvider> {
-        if (!this.walletWindowInstance) throw new Error('Wallet not connected');
-
-        if (
-            this.walletType === SupportedWallets.OP_WALLET ||
-            this.walletType === SupportedWallets.UNISAT
-        ) {
-            const chain = await this.walletWindowInstance.getChain();
-
-            switch (chain.enum) {
-                case UnisatChainType.BITCOIN_MAINNET:
-                    return new JSONRpcProvider('https://api.opnet.org', networks.bitcoin);
-                case UnisatChainType.BITCOIN_TESTNET:
-                    return new JSONRpcProvider('https://testnet.opnet.org', networks.testnet);
-                case UnisatChainType.BITCOIN_REGTEST:
-                    return new JSONRpcProvider('https://regtest.opnet.org', networks.regtest);
-                // TODO: Add Fractal Mainnet & Testnet when available
-                default:
-                    throw new Error('Unsupported network');
-            }
-        }
-
-        throw new Error('Unsupported wallet');
-    }
-}
-
-export default WalletConnection;