@btc-vision/walletconnect 1.4.1 → 1.5.1

package/build/wallets/controller.d.ts

@@ -0,0 +1,29 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { WalletConnectNetwork } from '../types';
+import { SupportedWallets } from './index';
+import type { ControllerConnectAccounts, ControllerErrorResponse, ControllerResponse, WalletConnectWallet } from './types.ts';
+declare class WalletController {
+    private static wallets;
+    private static currentWallet;
+    static getWallets: () => WalletConnectWallet[];
+    static isWalletInstalled(wallet: string): boolean;
+    static getWalletType(): SupportedWallets | null;
+    static getProvider(): Unisat | null;
+    static getSigner(): Promise<UnisatSigner | null>;
+    static convertChainTypeToNetwork(chainType: UnisatChainType): WalletConnectNetwork;
+    static getNetwork(): Promise<WalletConnectNetwork>;
+    static getPublicKey(): Promise<string | null>;
+    static canAutoConnect(walletName: string): Promise<boolean>;
+    static connect(walletName: string): Promise<ControllerResponse<ControllerConnectAccounts | ControllerErrorResponse>>;
+    static disconnectIfWalletChanged(newWallet: WalletConnectWallet): Promise<void>;
+    static disconnect(): Promise<void>;
+    static setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    static setDisconnectHook(fn: () => void): void;
+    static setChainChangedHook(fn: (network: WalletConnectNetwork) => void): void;
+    static removeAccountsChangedHook(): void;
+    static removeDisconnectHook(): void;
+    static removeChainChangedHook(): void;
+    static registerWallet: (wallet: WalletConnectWallet) => void;
+    static unbindHooks(): void;
+}
+export { WalletController };

package/build/wallets/controller.js

@@ -0,0 +1,205 @@
+var _a;
+import { networks } from '@btc-vision/bitcoin';
+import { UnisatChainType } from '@btc-vision/transaction';
+import { DefaultWalletConnectNetwork } from '../consts';
+import { _e } from '../utils/accessibility/errorDecoder';
+class WalletController {
+    static isWalletInstalled(wallet) {
+        return this.wallets.get(wallet)?.controller?.isInstalled() || false;
+    }
+    static getWalletType() {
+        return _a.currentWallet?.name || null;
+    }
+    static getProvider() {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        const provider = wallet.controller.getProvider();
+        return provider ? new Proxy(provider, {}) : null;
+    }
+    static async getSigner() {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        return await wallet.controller.getSigner();
+    }
+    static convertChainTypeToNetwork(chainType) {
+        const walletNetwork = (network) => {
+            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() {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return DefaultWalletConnectNetwork;
+        }
+        const chainType = await wallet.controller.getNetwork();
+        return this.convertChainTypeToNetwork(chainType);
+    }
+    static async getPublicKey() {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return null;
+        }
+        return wallet.controller.getPublicKey();
+    }
+    static async canAutoConnect(walletName) {
+        const wallet = this.wallets.get(walletName);
+        return (wallet && (await wallet.controller.canAutoConnect())) || false;
+    }
+    static async connect(walletName) {
+        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?.message || error),
+                },
+            };
+        }
+    }
+    static async disconnectIfWalletChanged(newWallet) {
+        const wallet = this.currentWallet;
+        if (wallet && wallet.name != newWallet.name) {
+            await this.disconnect();
+            this.unbindHooks();
+        }
+    }
+    static async disconnect() {
+        const wallet = this.currentWallet;
+        if (!wallet) {
+            return;
+        }
+        await wallet.controller.disconnect();
+        this.currentWallet = null;
+    }
+    static setAccountsChangedHook(fn) {
+        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) {
+        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) {
+        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) => {
+                fn(this.convertChainTypeToNetwork(chainType));
+            });
+        }
+        catch (error) {
+            console.error('Error setting network switch hook:', error);
+        }
+    }
+    static removeAccountsChangedHook() {
+        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() {
+        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() {
+        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 unbindHooks() {
+        this.removeDisconnectHook();
+        this.removeChainChangedHook();
+        this.removeAccountsChangedHook();
+    }
+}
+_a = WalletController;
+WalletController.wallets = new Map();
+WalletController.currentWallet = null;
+WalletController.getWallets = () => {
+    return [..._a.wallets.values()];
+};
+WalletController.registerWallet = (wallet) => {
+    _a.wallets.set(wallet.name, wallet);
+};
+export { WalletController };

package/build/wallets/index.d.ts

@@ -0,0 +1,4 @@
+import { WalletController } from './controller';
+type SupportedWallets = 'OP_WALLET' | 'UNISAT';
+export { WalletController };
+export type { SupportedWallets };

package/build/wallets/index.js

@@ -0,0 +1,16 @@
+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';
+WalletController.registerWallet({
+    name: 'OP_WALLET',
+    icon: OPWalletLogo,
+    controller: new OPWallet(),
+});
+WalletController.registerWallet({
+    name: 'UNISAT',
+    icon: UnisatLogo,
+    controller: new UniSatWallet(),
+});
+export { WalletController };

package/build/wallets/opwallet/controller.d.ts

@@ -0,0 +1,26 @@
+import { Unisat, UnisatChainType } from '@btc-vision/transaction';
+import type { WalletBase } from '../types.ts';
+declare class OPWallet implements WalletBase {
+    private walletBase;
+    private accountsChangedHookWrapper?;
+    private chainChangedHookWrapper?;
+    private disconnectHookWrapper?;
+    private _isConnected;
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getChainId(): void;
+    connect(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<null>;
+    getPublicKey(): Promise<string>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (chainType: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+}
+export default OPWallet;

package/build/wallets/opwallet/controller.js

@@ -0,0 +1,132 @@
+const notInstalledError = 'OP_WALLET is not installed';
+class OPWallet {
+    constructor() {
+        this._isConnected = false;
+    }
+    isInstalled() {
+        this.walletBase = window.opnet;
+        return !!this.walletBase;
+    }
+    isConnected() {
+        return !!this.walletBase && this._isConnected;
+    }
+    async canAutoConnect() {
+        const accounts = (await this.walletBase?.getAccounts()) || [];
+        return accounts.length > 0;
+    }
+    getChainId() {
+        throw new Error('Method not implemented.');
+    }
+    async connect() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.requestAccounts().then((accounts) => {
+            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() {
+        return (this._isConnected && this.walletBase) || null;
+    }
+    async getSigner() {
+        return Promise.resolve(null);
+    }
+    getPublicKey() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.getPublicKey();
+    }
+    async getNetwork() {
+        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) {
+        console.log('Setting account changed hook for OPWallet');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        this.accountsChangedHookWrapper = (accounts) => {
+            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() {
+        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) {
+        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() {
+        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) {
+        console.log('Setting chain changed hook for OPWallet');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        this.chainChangedHookWrapper = (chainInfo) => {
+            console.log('OPWallet ChainChanged Hook', chainInfo);
+            fn(chainInfo.enum);
+        };
+        this.walletBase.on('chainChanged', this.chainChangedHookWrapper);
+    }
+    removeChainChangedHook() {
+        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/build/wallets/opwallet/interface.d.ts

@@ -0,0 +1,5 @@
+import type { Unisat } from '@btc-vision/transaction';
+export interface OPWalletInterface extends Unisat {
+    disconnect: () => Promise<void>;
+}
+export declare const logo: string;

package/build/wallets/opwallet/interface.js

@@ -0,0 +1,35 @@
+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/build/wallets/types.d.ts

@@ -0,0 +1,34 @@
+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[];

package/build/wallets/types.js

@@ -0,0 +1 @@
+export {};

package/build/wallets/unisat/controller.d.ts

@@ -0,0 +1,26 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import type { WalletBase } from '../types.ts';
+declare class UnisatWallet implements WalletBase {
+    private walletBase;
+    private accountsChangedHookWrapper?;
+    private chainChangedHookWrapper?;
+    private disconnectHookWrapper?;
+    private _isConnected;
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<UnisatSigner>;
+    getChainId(): void;
+    connect(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getPublicKey(): Promise<string>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (chainType: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+}
+export default UnisatWallet;

package/build/wallets/unisat/controller.js

@@ -0,0 +1,135 @@
+import { UnisatSigner } from '@btc-vision/transaction';
+const notInstalledError = 'UNISAT is not installed';
+class UnisatWallet {
+    constructor() {
+        this._isConnected = false;
+    }
+    isInstalled() {
+        this.walletBase = window.unisat;
+        return !!this.walletBase;
+    }
+    isConnected() {
+        return !!this.walletBase && this._isConnected;
+    }
+    async canAutoConnect() {
+        const accounts = (await this.walletBase?.getAccounts()) || [];
+        return accounts.length > 0;
+    }
+    getProvider() {
+        return (this._isConnected && this.walletBase) || null;
+    }
+    async getSigner() {
+        const signer = new UnisatSigner();
+        await signer.init();
+        return signer;
+    }
+    getChainId() {
+        throw new Error('Method not implemented.');
+    }
+    async connect() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.requestAccounts().then((accounts) => {
+            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;
+    }
+    getPublicKey() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        return this.walletBase.getPublicKey();
+    }
+    async getNetwork() {
+        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) {
+        console.log('Setting account changed hook for Unisat');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        this.accountsChangedHookWrapper = (accounts) => {
+            console.log('Unisat Account Changed Hook', accounts, accounts.length);
+            if (accounts.length > 0) {
+                fn(accounts);
+            }
+            else {
+                console.log('Unisat Account Changed Hook --> Disconnect', accounts.length, !!this.disconnectHookWrapper);
+                this._isConnected = false;
+                this.disconnectHookWrapper?.();
+            }
+        };
+        this.walletBase.on('accountsChanged', this.accountsChangedHookWrapper);
+    }
+    removeAccountsChangedHook() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        if (this.accountsChangedHookWrapper) {
+            console.log('Removing account changed hook for Unisat');
+            this.walletBase.removeListener('accountsChanged', this.accountsChangedHookWrapper);
+            this.accountsChangedHookWrapper = undefined;
+        }
+    }
+    setDisconnectHook(fn) {
+        console.log('Setting disconnect hook for Unisat');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        this.disconnectHookWrapper = () => {
+            console.log('Unisat Disconnecting Hook');
+            fn();
+        };
+        this.walletBase.on('disconnect', this.disconnectHookWrapper);
+    }
+    removeDisconnectHook() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        if (this.disconnectHookWrapper) {
+            console.log('Removing disconnect hook for Unisat');
+            this.walletBase.removeListener('disconnect', this.disconnectHookWrapper);
+            this.disconnectHookWrapper = undefined;
+        }
+    }
+    setChainChangedHook(fn) {
+        console.log('Setting chain changed hook for Unisat');
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        this.chainChangedHookWrapper = (chainInfo) => {
+            console.log('Unisat ChainChanged Hook', chainInfo);
+            fn(chainInfo.enum);
+        };
+        this.walletBase.on('chainChanged', this.chainChangedHookWrapper);
+    }
+    removeChainChangedHook() {
+        if (!this.isInstalled() || !this.walletBase) {
+            throw new Error(notInstalledError);
+        }
+        if (this.chainChangedHookWrapper) {
+            console.log('Removing chain changed hook for Unisat');
+            this.walletBase.removeListener('chainChanged', this.chainChangedHookWrapper);
+            this.chainChangedHookWrapper = undefined;
+        }
+    }
+}
+export default UnisatWallet;

package/build/wallets/unisat/interface.d.ts

@@ -0,0 +1,5 @@
+import type { Unisat } from '@btc-vision/transaction';
+export interface UnisatWalletInterface extends Unisat {
+    disconnect: () => Promise<void>;
+}
+export declare const logo: string;