@btc-vision/walletconnect 1.5.0 → 1.5.2

package/src/utils/theme.css

@@ -0,0 +1,26 @@
+.wallet-connect-light-theme {
+    --background-color: #fafafa;
+    --primaryColor: #000000;
+    --border-color: #bbbbbb;
+
+    --button-background-color: #ffffff;
+    --icon-filter: invert(1) hue-rotate(180deg) !important;
+}
+
+.wallet-connect-dark-theme {
+    --background-color: #1e1e1e;
+    --primaryColor: #ffffff;
+    --border-color: #333333;
+
+    --button-background-color: #2a2a2a;
+    --icon-filter: unset;
+}
+
+.wallet-connect-moto-theme {
+    --background-color: #171239;
+    --primaryColor: #9698e2;
+    --border-color: #201b4e;
+
+    --button-background-color: #140932;
+    --icon-filter: unset;
+}

package/src/wallets/controller.ts

@@ -0,0 +1,231 @@
+import { Network, networks } from '@btc-vision/bitcoin';
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { DefaultWalletConnectNetwork } from '../consts';
+import { WalletConnectNetwork } from '../types';
+import { _e } from '../utils/accessibility/errorDecoder';
+import { SupportedWallets } from './index';
+import type {
+    ControllerConnectAccounts,
+    ControllerErrorResponse,
+    ControllerResponse,
+    WalletConnectWallet,
+} from './types.ts';
+
+class WalletController {
+    private static wallets: Map<string, WalletConnectWallet> = new Map();
+    private static currentWallet: WalletConnectWallet | null = null;
+
+    static getWallets = () => {
+        return [...WalletController.wallets.values()];
+    };
+    static isWalletInstalled(wallet: string): boolean {
+        return this.wallets.get(wallet)?.controller?.isInstalled() || false;
+    }
+    static getWalletType(): SupportedWallets | null {
+        return WalletController.currentWallet?.name || null;
+    }
+
+    static getProvider(): Unisat | null {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        // Needs to return a Proxy to be sure useEffects are triggered
+        const provider = wallet.controller.getProvider();
+        return provider ? new Proxy(provider, {}) : null;
+    }
+
+    static async getSigner(): Promise<UnisatSigner | null> {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        return await wallet.controller.getSigner();
+    }
+
+    //TODO: check if we really want to return a default network here
+    //      instead of null.  Default is there: DefaultWalletConnectChain.network
+    static convertChainTypeToNetwork(chainType: UnisatChainType): WalletConnectNetwork {
+        const walletNetwork = (network: Network): WalletConnectNetwork => {
+            return { ...network, chainType: chainType };
+        };
+        switch (chainType) {
+            case UnisatChainType.BITCOIN_REGTEST:
+                return walletNetwork(networks.regtest);
+            case UnisatChainType.BITCOIN_TESTNET:
+                return walletNetwork(networks.testnet);
+            case UnisatChainType.BITCOIN_MAINNET:
+                return walletNetwork(networks.bitcoin);
+
+            case UnisatChainType.BITCOIN_TESTNET4:
+            case UnisatChainType.BITCOIN_SIGNET:
+            case UnisatChainType.FRACTAL_BITCOIN_TESTNET:
+            case UnisatChainType.FRACTAL_BITCOIN_MAINNET:
+            default:
+                return DefaultWalletConnectNetwork;
+        }
+    }
+
+    static async getNetwork(): Promise<WalletConnectNetwork> {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return DefaultWalletConnectNetwork;
+        }
+
+        const chainType = await wallet.controller.getNetwork();
+        return this.convertChainTypeToNetwork(chainType);
+    }
+
+    static async getPublicKey(): Promise<string | null> {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        return wallet.controller.getPublicKey();
+    }
+
+    static async canAutoConnect(walletName: string) {
+        const wallet = this.wallets.get(walletName);
+        return (wallet && (await wallet.controller.canAutoConnect())) || false;
+    }
+
+    static async connect(
+        walletName: string,
+    ): Promise<ControllerResponse<ControllerConnectAccounts | ControllerErrorResponse>> {
+        const wallet = this.wallets.get(walletName);
+        if (!wallet) {
+            return {
+                code: 404,
+                data: {
+                    message: _e('Wallet not found'),
+                },
+            };
+        }
+        try {
+            const accounts = await wallet.controller.connect();
+            await this.disconnectIfWalletChanged(wallet);
+            this.currentWallet = wallet;
+            return {
+                code: 200,
+                data: accounts,
+            };
+        } catch (error) {
+            return {
+                code: 499,
+                data: {
+                    message: _e((error as Error)?.message || (error as string)),
+                },
+            };
+        }
+    }
+
+    static async disconnectIfWalletChanged(newWallet: WalletConnectWallet) {
+        const wallet = this.currentWallet;
+        if (wallet && wallet.name != newWallet.name) {
+            await this.disconnect();
+            this.unbindHooks();
+        }
+    }
+
+    static async disconnect(): Promise<void> {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return;
+        }
+        await wallet.controller.disconnect();
+        this.currentWallet = null;
+    }
+
+    static setAccountsChangedHook(fn: (accounts: string[]) => void): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return;
+        }
+        try {
+            wallet.controller.removeAccountsChangedHook();
+            wallet.controller.setAccountsChangedHook(fn);
+        } catch (error) {
+            console.error('Error setting accounts changed hook:', error);
+        }
+    }
+
+    static setDisconnectHook(fn: () => void): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return;
+        }
+        try {
+            wallet.controller.removeDisconnectHook();
+            wallet.controller.setDisconnectHook(fn);
+        } catch (error) {
+            console.error('Error setting disconnect hook:', error);
+        }
+    }
+
+    static setChainChangedHook(fn: (network: WalletConnectNetwork) => void): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            console.log('No current wallet to set network switch hook for');
+            return;
+        }
+        try {
+            wallet.controller.removeChainChangedHook();
+            wallet.controller.setChainChangedHook((chainType: UnisatChainType) => {
+                fn(this.convertChainTypeToNetwork(chainType));
+            });
+        } catch (error) {
+            console.error('Error setting network switch hook:', error);
+        }
+    }
+
+    static removeAccountsChangedHook(): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            console.log('No current wallet to remove accounts changed hook from');
+            return;
+        }
+        try {
+            wallet.controller.removeAccountsChangedHook();
+        } catch (error) {
+            console.error('Error removing accounts changed hook:', error);
+        }
+    }
+
+    static removeDisconnectHook(): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            console.log('No current wallet to remove disconnect hook from');
+            return;
+        }
+        try {
+            wallet.controller.removeDisconnectHook();
+        } catch (error) {
+            console.error('Error removing disconnect hook:', error);
+        }
+    }
+
+    static removeChainChangedHook(): void {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            console.log('No current wallet to remove network change hook from');
+            return;
+        }
+        try {
+            wallet.controller.removeChainChangedHook();
+        } catch (error) {
+            console.error('Error removing network change hook:', error);
+        }
+    }
+
+    static registerWallet = (wallet: WalletConnectWallet): void => {
+        this.wallets.set(wallet.name, wallet);
+    };
+
+    static unbindHooks(): void {
+        this.removeDisconnectHook();
+        this.removeChainChangedHook();
+        this.removeAccountsChangedHook();
+    }
+}
+
+export { WalletController };

package/src/wallets/index.ts

@@ -0,0 +1,22 @@
+import { WalletController } from './controller';
+import OPWallet from './opwallet/controller';
+import { logo as OPWalletLogo } from './opwallet/interface';
+import UniSatWallet from './unisat/controller';
+import { logo as UnisatLogo } from './unisat/interface';
+
+type SupportedWallets = 'OP_WALLET' | 'UNISAT';
+
+WalletController.registerWallet({
+    name: 'OP_WALLET',
+    icon: OPWalletLogo,
+    controller: new OPWallet(),
+});
+
+WalletController.registerWallet({
+    name: 'UNISAT',
+    icon: UnisatLogo,
+    controller: new UniSatWallet(),
+});
+
+export { WalletController };
+export type { SupportedWallets };

package/src/wallets/opwallet/controller.ts

@@ -0,0 +1,177 @@
+import { Unisat, UnisatChainInfo, UnisatChainType } from '@btc-vision/transaction';
+import type { WalletBase } from '../types.ts';
+import type { OPWalletInterface } from './interface';
+
+interface OPWalletWindow extends Window {
+    opnet?: OPWalletInterface;
+}
+
+const notInstalledError = 'OP_WALLET is not installed';
+
+class OPWallet implements WalletBase {
+    private walletBase: OPWalletWindow['opnet'];
+    private accountsChangedHookWrapper?: (accounts: Array<string>) => void;
+    private chainChangedHookWrapper?: (network: UnisatChainInfo) => void;
+    private disconnectHookWrapper?: () => void;
+    private _isConnected: boolean = false;
+
+    isInstalled() {
+        this.walletBase = (window as unknown as OPWalletWindow).opnet;
+        return !!this.walletBase;
+    }
+    isConnected() {
+        return !!this.walletBase && this._isConnected;
+    }
+    async canAutoConnect(): Promise<boolean> {
+        // getAccounts returns empty array if not connected,
+        // without launching connection modal window.
+        const accounts = (await this.walletBase?.getAccounts()) || [];
+        return accounts.length > 0;
+    }
+
+    getChainId(): void {
+        throw new Error('Method not implemented.');
+    }
+
+    async connect(): Promise<string[]> {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.requestAccounts().then((accounts: string[]) => {
+            this._isConnected = accounts.length > 0;
+            return accounts;
+        });
+    }
+
+    async disconnect() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this._isConnected
+            ? await this.walletBase.disconnect().then(() => {
+                  this._isConnected = false;
+              })
+            : undefined;
+    }
+
+    getProvider(): Unisat | null {
+        return (this._isConnected && this.walletBase) || null;
+    }
+
+    async getSigner(): Promise<null> {
+        return Promise.resolve(null);
+    }
+
+    getPublicKey(): Promise<string> {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.getPublicKey();
+    }
+
+    async getNetwork(): Promise<UnisatChainType> {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        const chainInfo = await this.walletBase.getChain();
+        if (!chainInfo) {
+            throw new Error('Failed to retrieve chain information');
+        }
+
+        return chainInfo.enum;
+    }
+
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void {
+        console.log('Setting account changed hook for OPWallet');
+
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        this.accountsChangedHookWrapper = (accounts: string[]) => {
+            console.log('OPWallet Account Changed Hook', accounts, accounts.length);
+
+            if (accounts.length > 0) {
+                fn(accounts);
+            } else {
+                console.log(
+                    'OPWallet Account Changed Hook --> Disconnect',
+                    accounts.length,
+                    !!this.disconnectHookWrapper,
+                );
+                this._isConnected = false;
+                this.disconnectHookWrapper?.();
+            }
+        };
+
+        this.walletBase.on('accountsChanged', this.accountsChangedHookWrapper);
+    }
+
+    removeAccountsChangedHook(): void {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        if (this.accountsChangedHookWrapper) {
+            console.log('Removing account changed hook for OPWallet');
+            this.walletBase.removeListener('accountsChanged', this.accountsChangedHookWrapper);
+            this.accountsChangedHookWrapper = undefined;
+        }
+    }
+
+    setDisconnectHook(fn: () => void): void {
+        console.log('Setting disconnect hook for OPWallet');
+
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        this.disconnectHookWrapper = () => {
+            console.log('OPWallet Disconnecting Hook');
+            fn();
+        };
+
+        this.walletBase.on('disconnect', this.disconnectHookWrapper);
+    }
+
+    removeDisconnectHook(): void {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        if (this.disconnectHookWrapper) {
+            console.log('Removing disconnect hook for OPWallet');
+            this.walletBase.removeListener('disconnect', this.disconnectHookWrapper);
+            this.disconnectHookWrapper = undefined;
+        }
+    }
+
+    setChainChangedHook(fn: (chainType: UnisatChainType) => void): void {
+        console.log('Setting chain changed hook for OPWallet');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        this.chainChangedHookWrapper = (chainInfo: UnisatChainInfo) => {
+            console.log('OPWallet ChainChanged Hook', chainInfo);
+            fn(chainInfo.enum);
+        };
+
+        this.walletBase.on('chainChanged', this.chainChangedHookWrapper);
+    }
+
+    removeChainChangedHook(): void {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+
+        if (this.chainChangedHookWrapper) {
+            console.log('Removing chain changed hook for OPWallet');
+            this.walletBase.removeListener('chainChanged', this.chainChangedHookWrapper);
+            this.chainChangedHookWrapper = undefined;
+        }
+    }
+}
+
+export default OPWallet;

package/src/wallets/opwallet/interface.ts

@@ -0,0 +1,42 @@
+import type { Unisat } from '@btc-vision/transaction';
+
+export interface OPWalletInterface extends Unisat {
+    disconnect: () => Promise<void>;
+}
+
+export const logo =
+    'data:image/svg+xml;base64,' +
+    'PHN2ZyB3aWR0aD0iNDgxIiBoZWlnaHQ9IjExMiIgdmlld0JveD0iMCAwIDQ4MSAxMTIiIGZpbGw9' +
+    'Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGNsaXAtcGF0aD0i' +
+    'dXJsKCNjbGlwMF8wXzMpIj4KPHBhdGggZD0iTTIzNS40IDE4LjVMMjI4LjcgNTcuMUgyMjguMkwy' +
+    'MTkuNCAxOC41SDIwOUwyMDAuNSA1Ni45SDE5OS43TDE5My4xIDE4LjVIMTc4LjFMMTkyLjIgNzQu' +
+    'OEgxOTIuM0gyMDQuOEwyMTMuNiAzOC4ySDIxNC4yTDIyMi41IDc0LjhIMjM1LjRMMjQ5LjUgMTgu' +
+    'NUgyMzUuNFoiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGQ9Ik0yNjguOSAxOC41TDI0Ny41IDc0LjhI' +
+    'MjYxLjVMMjY0Ljc5IDY0LjZIMjg0LjcxTDI4OCA3NC44SDMwMi42TDI4MS4yIDE4LjVIMjY4Ljla' +
+    'TTI3NC43IDMyLjZIMjc1LjFMMjgxLjU5IDUzLjNIMjY4LjAzTDI3NC43IDMyLjZaIiBmaWxsPSJ3' +
+    'aGl0ZSIvPgo8cGF0aCBkPSJNMzIyLjMgMTguNUgzMDguMlY3NC44SDM0Mi4xVjYzSDMyMi4zVjE4' +
+    'LjVaIiBmaWxsPSJ3aGl0ZSIvPgo8cGF0aCBkPSJNMzY1LjQgMTguNUgzNTEuM1Y3NC44SDM4NS4y' +
+    'VjYzSDM2NS40VjE4LjVaIiBmaWxsPSJ3aGl0ZSIvPgo8cGF0aCBkPSJNNDM4LjQgMTguNVYzMC40' +
+    'SDQ1Mi41Vjc0LjhINDY2LjVWMzAuNEg0ODAuNlYxOC41SDQzOC40WiIgZmlsbD0id2hpdGUiLz4K' +
+    'PHBhdGggZD0iTTM5My41IDc0LjhINDMxLjNWNjMuNkg0MDdWNTEuOUg0MjIuNVY0MC44SDQwN1Yy' +
+    'OS44SDQzMS4zVjE4LjVIMzkzLjVWNzQuOFoiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGQ9Ik0xNjQu' +
+    'MjggNDUuMzVDMTYzLjYxIDIwLjY4IDE0Mi44NSAwLjI4IDExOC4xNyAwQzEwOS40OCAtMC4xIDEw' +
+    'MS4zNSAyLjIxIDk0LjM2IDYuMjZDOTEuNzggNy43NSA5MS4wNyAxMS4xNyA5Mi44MSAxMy41OUM5' +
+    'Ni4yNiAxOC4zOSA5OC45NiAyMy43NSAxMDAuNzkgMjkuNUMxMDEuOCAzMi43IDEwNS42MSAzMy43' +
+    'MyAxMDguNDUgMzEuOTNDMTEyIDI5LjY4IDExNi40MiAyOC42OCAxMjEuMTMgMjkuNkMxMjcuNjYg' +
+    'MzAuODcgMTMzLjA4IDM2LjA0IDEzNC41NyA0Mi41M0MxMzcuMTkgNTMuOTMgMTI4LjYgNjQuMDQg' +
+    'MTE3LjY1IDY0LjA0QzExNC4yNCA2NC4wNCAxMTEuMDcgNjMuMDUgMTA4LjQgNjEuMzRDMTA1LjU4' +
+    'IDU5LjU0IDEwMS43OCA2MC42OCAxMDAuNzcgNjMuODdDOTYuMjkgNzcuOTIgODYuNSA4OS41OSA3' +
+    'My43NSA5Ni41NEM3Mi4wOCA5Ny40NSA3MC45OSA5OS4xNCA3MC45OSAxMDEuMDRWMTA2LjYyQzcw' +
+    'Ljk5IDEwOS40MiA3My4yNiAxMTEuNjkgNzYuMDYgMTExLjY5SDk1LjE5Qzk3Ljk5IDExMS42OSAx' +
+    'MDAuMjYgMTA5LjQyIDEwMC4yNiAxMDYuNjJWOTYuODZDMTAwLjI2IDkzLjUxIDEwMy40MyA5MS4x' +
+    'OSAxMDYuNjggOTEuOTlDMTEwLjIgOTIuODUgMTEzLjg3IDkzLjMxIDExNy42NSA5My4zMUMxNDMu' +
+    'ODUgOTMuMzEgMTY1LjAxIDcxLjcxIDE2NC4yOSA0NS4zNUgxNjQuMjhaIiBmaWxsPSIjRUU3NzFC' +
+    'Ii8+CjxwYXRoIGQ9Ik00Ni42NiAwQzIwLjg5IDAgMCAyMC44OSAwIDQ2LjY2QzAgNzIuNDMgMjAu' +
+    'ODkgOTMuMzIgNDYuNjYgOTMuMzJDNzIuNDMgOTMuMzIgOTMuMzIgNzIuNDMgOTMuMzIgNDYuNjZD' +
+    'OTMuMzIgMjAuODkgNzIuNDMgMCA0Ni42NiAwWk00Ni42NiA2NC4wNUMzNy4wNiA2NC4wNSAyOS4y' +
+    'NyA1Ni4yNiAyOS4yNyA0Ni42NkMyOS4yNyAzNy4wNiAzNy4wNiAyOS4yNyA0Ni42NiAyOS4yN0M1' +
+    'Ni4yNiAyOS4yNyA2NC4wNSAzNy4wNiA2NC4wNSA0Ni42NkM2NC4wNSA1Ni4yNiA1Ni4yNiA2NC4w' +
+    'NSA0Ni42NiA2NC4wNVoiIGZpbGw9IndoaXRlIi8+CjwvZz4KPGRlZnM+CjxjbGlwUGF0aCBpZD0i' +
+    'Y2xpcDBfMF8zIj4KPHJlY3Qgd2lkdGg9IjQ4MC42IiBoZWlnaHQ9IjExMS43IiBmaWxsPSJ3aGl0' +
+    'ZSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=';

package/src/wallets/types.ts

@@ -0,0 +1,39 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { SupportedWallets } from './index';
+export type { AbstractRpcProvider } from 'opnet';
+
+export interface WalletBase {
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<UnisatSigner | null>;
+    connect(): Promise<string[] | undefined>;
+    disconnect(): Promise<void>;
+    getPublicKey(): Promise<string | null>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (network: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+    getChainId(): void;
+}
+
+export interface WalletConnectWallet {
+    name: SupportedWallets;
+    icon: string;
+    controller: WalletBase;
+}
+
+export interface ControllerResponse<T> {
+    code: number;
+    data?: T;
+}
+
+export interface ControllerErrorResponse {
+    message: string;
+}
+
+export type ControllerConnectAccounts = string[];