@ksangkuk10/wallet-controller 1.7.14

package/controller.js

@@ -0,0 +1,697 @@
+import { AccAddress, PublicKey, SimplePublicKey, Tx, } from '@xpla/xpla.js';
+import { ConnectType, WalletApp, WalletStatus, } from '@ksangkuk10/wallet-types';
+import { WebExtensionTxStatus, } from '@ksangkuk10/web-extension-interface';
+import deepEqual from 'fast-deep-equal';
+import { BehaviorSubject, combineLatest, firstValueFrom, } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { CHROME_EXTENSION_INSTALL_URL, DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK, } from './env';
+import { mapExtensionSignBytesError, mapExtensionTxError, } from './exception/mapExtensionTxError';
+import { mapWalletConnectError, mapWalletConnectSignError, mapWalletConnectSignBytesError, } from './exception/mapWalletConnectError';
+import { selectConnection } from './modules/connect-modal';
+import { ExtensionRouter, ExtensionRouterStatus, } from './modules/extension-router';
+import { getXplaExtensions, } from './modules/extension-router/multiChannel';
+import { connect as reConnect, connectIfSessionExists as reConnectIfSessionExists, readonlyWalletModal, } from './modules/readonly-wallet';
+import { connect as wcConnect, connectIfSessionExists as wcConnectIfSessionExists, WalletConnectSessionStatus, } from './modules/walletconnect';
+import { getExtensions } from './operators/getExtensions';
+import { toConnectedWallet } from './operators/toConnectedWallet';
+import { toLcdClient } from './operators/toLcdClient';
+import { isDesktopChrome } from './utils/browser-check';
+import { checkExtensionReady } from './utils/checkExtensionReady';
+import { sortConnections } from './utils/sortConnections';
+const CONNECTIONS = {
+    [ConnectType.READONLY]: {
+        type: ConnectType.READONLY,
+        name: 'View an address',
+        icon: 'https://assets.xpla.io/icon/wallet-provider/readonly.svg',
+    },
+    [ConnectType.WALLETCONNECT]: {
+        type: ConnectType.WALLETCONNECT,
+        name: 'Wallet Connect',
+        icon: 'https://assets.xpla.io/icon/wallet-provider/walletconnect.svg',
+    },
+};
+const DEFAULT_WAITING_CHROME_EXTENSION_INSTALL_CHECK = 1000 * 3;
+const WALLETCONNECT_SUPPORT_FEATURES = new Set([
+    'post', 'sign', 'sign-bytes'
+]);
+const EMPTY_SUPPORT_FEATURES = new Set();
+//noinspection ES6MissingAwait
+export class WalletController {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.extension = null;
+        this.walletConnect = null;
+        this.readonlyWallet = null;
+        this.disableReadonlyWallet = null;
+        this.disableExtension = null;
+        this.disableWalletConnect = null;
+        /**
+         * Some mobile wallet emulates the behavior of chrome extension.
+         * It confirms that the current connection environment is such a wallet.
+         * (If you are running connect() by checking availableConnectType, you do not need to use this API.)
+         *
+         * @see Wallet#isChromeExtensionCompatibleBrowser
+         */
+        this.isChromeExtensionCompatibleBrowser = () => {
+            var _a;
+            return ((_a = this.options.dangerously__chromeExtensionCompatibleBrowserCheck) !== null && _a !== void 0 ? _a : DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK)(navigator.userAgent);
+        };
+        /**
+         * available connect types on the browser
+         *
+         * @see Wallet#availableConnectTypes
+         */
+        this.availableConnectTypes = () => {
+            return this._availableConnectTypes.asObservable();
+        };
+        /**
+         * available connections includes identifier, name, icon
+         *
+         * @see Wallet#availableConnections
+         */
+        this.availableConnections = () => {
+            return this._availableConnectTypes.pipe(map((connectTypes) => {
+                const connections = [];
+                for (const connectType of connectTypes) {
+                    if (connectType === ConnectType.EXTENSION) {
+                        const xplaExtensions = getXplaExtensions();
+                        for (const xplaExtension of xplaExtensions) {
+                            connections.push(memoConnection(ConnectType.EXTENSION, xplaExtension.name, xplaExtension.icon, xplaExtension.identifier));
+                        }
+                    }
+                    else {
+                        connections.push(CONNECTIONS[connectType]);
+                    }
+                }
+                return sortConnections(connections);
+            }));
+        };
+        /**
+         * available install types on the browser
+         *
+         * in this time, this only contains [ConnectType.EXTENSION]
+         *
+         * @see Wallet#availableInstallTypes
+         */
+        this.availableInstallTypes = () => {
+            return this._availableInstallTypes.asObservable();
+        };
+        /**
+         * available installations includes identifier, name, icon, url
+         *
+         * @see Wallet#availableInstallations
+         */
+        this.availableInstallations = () => {
+            return combineLatest([this.availableConnections(), getExtensions()]).pipe(map(([connections, extensions]) => {
+                const installedIdentifiers = new Set(connections
+                    .filter(({ type, identifier }) => {
+                    return type === ConnectType.EXTENSION && !!identifier;
+                })
+                    .map(({ identifier }) => {
+                    return identifier;
+                }));
+                return extensions
+                    .filter(({ identifier }) => {
+                    return !installedIdentifiers.has(identifier);
+                })
+                    .map(({ name, identifier, icon, url }) => {
+                    return {
+                        type: ConnectType.EXTENSION,
+                        identifier,
+                        name,
+                        icon,
+                        url,
+                    };
+                });
+            }));
+        };
+        /**
+         * @see Wallet#status
+         * @see Wallet#network
+         * @see Wallet#wallets
+         */
+        this.states = () => {
+            return this._states.asObservable();
+        };
+        /** get connectedWallet */
+        this.connectedWallet = () => {
+            return this._states.pipe(toConnectedWallet(this));
+        };
+        /** get lcdClient */
+        this.lcdClient = (lcdClientConfig) => {
+            return this._states.pipe(toLcdClient(lcdClientConfig));
+        };
+        /**
+         * reload the connected wallet states
+         *
+         * in this time, this only work on the ConnectType.EXTENSION
+         *
+         * @see Wallet#recheckStatus
+         */
+        this.refetchStates = () => {
+            var _a;
+            if (this.disableExtension) {
+                (_a = this.extension) === null || _a === void 0 ? void 0 : _a.refetchStates();
+            }
+        };
+        /**
+         * @deprecated Please use availableInstallations
+         *
+         * install for the connect type
+         *
+         * @see Wallet#install
+         */
+        this.install = (type) => {
+            if (type === ConnectType.EXTENSION) {
+                // TODO separate install links by browser types
+                window.open(CHROME_EXTENSION_INSTALL_URL, '_blank');
+            }
+            else {
+                console.warn(`[WalletController] ConnectType "${type}" does not support install() function`);
+            }
+        };
+        /**
+         * connect to wallet
+         *
+         * @see Wallet#connect
+         */
+        this.connect = async (_type, _identifier, _walletApp) => {
+            var _a, _b, _c, _d;
+            let type;
+            let identifier;
+            if (!!_type) {
+                type = _type;
+                identifier = _identifier;
+            }
+            else {
+                const connections = await firstValueFrom(this.availableConnections());
+                const selector = (_a = this.options.selectConnection) !== null && _a !== void 0 ? _a : selectConnection;
+                const selected = await selector(connections);
+                if (!selected) {
+                    return;
+                }
+                type = selected[0];
+                identifier = selected[1];
+            }
+            switch (type) {
+                case ConnectType.READONLY:
+                    const networks = Object.keys(this.options.walletConnectChainIds).map((chainId) => this.options.walletConnectChainIds[+chainId]);
+                    const createReadonlyWalletSession = (_d = (_c = (_b = this.options).createReadonlyWalletSession) === null || _c === void 0 ? void 0 : _c.call(_b, networks)) !== null && _d !== void 0 ? _d : readonlyWalletModal({ networks });
+                    const readonlyWalletSession = await createReadonlyWalletSession;
+                    if (readonlyWalletSession) {
+                        this.enableReadonlyWallet(reConnect(readonlyWalletSession));
+                    }
+                    break;
+                case ConnectType.WALLETCONNECT:
+                    this.enableWalletConnect(wcConnect(this.options, false, _walletApp));
+                    break;
+                case ConnectType.EXTENSION:
+                    if (!this.extension) {
+                        throw new Error(`extension instance is not created!`);
+                    }
+                    this.extension.connect(identifier);
+                    this.enableExtension();
+                    break;
+                default:
+                    throw new Error(`Unknown ConnectType!`);
+            }
+        };
+        /**
+         * manual connect to read only session
+         *
+         * @see Wallet#connectReadonly
+         */
+        this.connectReadonly = (xplaAddress, network) => {
+            this.enableReadonlyWallet(reConnect({
+                xplaAddress,
+                network,
+            }));
+        };
+        /** @see Wallet#disconnect */
+        this.disconnect = () => {
+            var _a, _b, _c;
+            (_a = this.disableReadonlyWallet) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.disableReadonlyWallet = null;
+            (_b = this.disableExtension) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.disableExtension = null;
+            (_c = this.disableWalletConnect) === null || _c === void 0 ? void 0 : _c.call(this);
+            this.disableWalletConnect = null;
+            this.updateStates(this._notConnected);
+        };
+        /**
+         * @see Wallet#post
+         * @param tx
+         * @param xplaAddress only available new extension
+         */
+        this.post = async (tx, xplaAddress, walletApp) => {
+            // ---------------------------------------------
+            // extension
+            // ---------------------------------------------
+            if (this.disableExtension) {
+                return new Promise((resolve, reject) => {
+                    if (!this.extension) {
+                        reject(new Error(`extension instance not created!`));
+                        return;
+                    }
+                    const subscription = this.extension.post(tx, xplaAddress).subscribe({
+                        next: (txResult) => {
+                            if (txResult.status === WebExtensionTxStatus.SUCCEED) {
+                                resolve({
+                                    ...tx,
+                                    result: txResult.payload,
+                                    success: true,
+                                });
+                                subscription.unsubscribe();
+                            }
+                        },
+                        error: (error) => {
+                            reject(mapExtensionTxError(tx, error));
+                            subscription.unsubscribe();
+                        },
+                    });
+                });
+            }
+            // ---------------------------------------------
+            // wallet connect
+            // ---------------------------------------------
+            else if (this.walletConnect) {
+                return this.walletConnect
+                    .post(tx, walletApp)
+                    .then((result) => ({
+                    ...tx,
+                    result,
+                    success: true,
+                }))
+                    .catch((error) => {
+                    throw mapWalletConnectError(tx, error);
+                });
+            }
+            else {
+                throw new Error(`There are no connections that can be posting tx!`);
+            }
+        };
+        /**
+         * @see Wallet#sign
+         * @param tx
+         * @param xplaAddress only available new extension
+         */
+        this.sign = async (tx, xplaAddress, walletApp) => {
+            if (this.disableExtension) {
+                return new Promise((resolve, reject) => {
+                    if (!this.extension) {
+                        reject(new Error(`extension instance is not created!`));
+                        return;
+                    }
+                    const subscription = this.extension.sign(tx, xplaAddress).subscribe({
+                        next: (txResult) => {
+                            if (txResult.status === WebExtensionTxStatus.SUCCEED) {
+                                resolve({
+                                    ...tx,
+                                    result: Tx.fromData(txResult.payload),
+                                    success: true,
+                                });
+                                subscription.unsubscribe();
+                            }
+                        },
+                        error: (error) => {
+                            reject(mapExtensionTxError(tx, error));
+                            subscription.unsubscribe();
+                        },
+                    });
+                });
+            }
+            // ---------------------------------------------
+            // wallet connect
+            // ---------------------------------------------
+            else if (this.walletConnect) {
+                if (walletApp && walletApp === WalletApp.XPLA_GAMES) {
+                    throw new Error(`There are no connections that can be signing!`);
+                }
+                return this.walletConnect
+                    .sign(tx, walletApp)
+                    .then((result) => {
+                    return {
+                        ...tx,
+                        result: Tx.fromData(result, false),
+                        success: true,
+                    };
+                })
+                    .catch((error) => {
+                    throw mapWalletConnectSignError(tx, error);
+                });
+            }
+            else {
+                throw new Error(`There are no connections that can be signing!`);
+            }
+        };
+        /**
+         * @see Wallet#signBytes
+         * @param bytes
+         * @param xplaAddress only available new extension
+         */
+        this.signBytes = async (bytes, xplaAddress, walletApp) => {
+            if (this.disableExtension) {
+                return new Promise((resolve, reject) => {
+                    if (!this.extension) {
+                        reject(new Error(`extension instance is not created!`));
+                        return;
+                    }
+                    const subscription = this.extension
+                        .signBytes(bytes, xplaAddress)
+                        .subscribe({
+                        next: (txResult) => {
+                            if (txResult.status === WebExtensionTxStatus.SUCCEED) {
+                                resolve({
+                                    result: {
+                                        recid: txResult.payload.recid,
+                                        signature: Uint8Array.from(Buffer.from(txResult.payload.signature, 'base64')),
+                                        public_key: txResult.payload.public_key
+                                            ? PublicKey.fromData(txResult.payload.public_key)
+                                            : undefined,
+                                    },
+                                    success: true,
+                                });
+                                subscription.unsubscribe();
+                            }
+                        },
+                        error: (error) => {
+                            reject(mapExtensionSignBytesError(bytes, error));
+                            subscription.unsubscribe();
+                        },
+                    });
+                });
+            }
+            // ---------------------------------------------
+            // wallet connect
+            // ---------------------------------------------
+            else if (this.walletConnect) {
+                if (walletApp && walletApp === WalletApp.XPLA_GAMES) {
+                    throw new Error(`There are no connections that can be signing bytes!`);
+                }
+                return this.walletConnect
+                    .signBytes(bytes, walletApp)
+                    .then((result) => {
+                    const key = new SimplePublicKey(String(result.public_key)).toData();
+                    return {
+                        result: {
+                            recid: result.recid,
+                            signature: Uint8Array.from(Buffer.from(result.signature, 'base64')),
+                            public_key: key
+                                ? PublicKey.fromData(key)
+                                : undefined,
+                        },
+                        success: true,
+                    };
+                })
+                    .catch((error) => {
+                    throw mapWalletConnectSignBytesError(bytes, error);
+                });
+            }
+            else {
+                throw new Error(`There are no connections that can be signing bytes!`);
+            }
+        };
+        /**
+         * @see Wallet#hasCW20Tokens
+         * @param chainID
+         * @param tokenAddrs Token addresses
+         */
+        this.hasCW20Tokens = async (chainID, ...tokenAddrs) => {
+            if (this.availableExtensionFeature('cw20-token')) {
+                return this.extension.hasCW20Tokens(chainID, ...tokenAddrs);
+            }
+            throw new Error(`Does not support hasCW20Tokens() on this connection`);
+        };
+        /**
+         * @see Wallet#addCW20Tokens
+         * @param chainID
+         * @param tokenAddrs Token addresses
+         */
+        this.addCW20Tokens = async (chainID, ...tokenAddrs) => {
+            if (this.availableExtensionFeature('cw20-token')) {
+                return this.extension.addCW20Tokens(chainID, ...tokenAddrs);
+            }
+            throw new Error(`Does not support addCW20Tokens() on this connection`);
+        };
+        /**
+         * @see Wallet#hasNetwork
+         * @param network
+         */
+        this.hasNetwork = (network) => {
+            if (this.availableExtensionFeature('network')) {
+                return this.extension.hasNetwork(network);
+            }
+            throw new Error(`Does not support hasNetwork() on this connection`);
+        };
+        /**
+         * @see Wallet#hasNetwork
+         * @param network
+         */
+        this.addNetwork = (network) => {
+            if (this.availableExtensionFeature('network')) {
+                return this.extension.addNetwork(network);
+            }
+            throw new Error(`Does not support addNetwork() on this connection`);
+        };
+        // ================================================================
+        // internal
+        // connect type changing
+        // ================================================================
+        this.availableExtensionFeature = (feature) => {
+            if (this.disableExtension && this.extension) {
+                const states = this.extension.getLastStates();
+                return (states.type === ExtensionRouterStatus.WALLET_CONNECTED &&
+                    states.supportFeatures.has(feature));
+            }
+        };
+        this.updateStates = (next) => {
+            const prev = this._states.getValue();
+            if (next.status === WalletStatus.WALLET_CONNECTED &&
+                next.wallets.length === 0) {
+                next = {
+                    status: WalletStatus.WALLET_NOT_CONNECTED,
+                    network: next.network,
+                };
+            }
+            if (prev.status !== next.status || !deepEqual(prev, next)) {
+                this._states.next(next);
+            }
+        };
+        this.enableReadonlyWallet = (readonlyWallet) => {
+            var _a, _b, _c;
+            (_a = this.disableWalletConnect) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.disableExtension) === null || _b === void 0 ? void 0 : _b.call(this);
+            if (this.readonlyWallet === readonlyWallet ||
+                (((_c = this.readonlyWallet) === null || _c === void 0 ? void 0 : _c.xplaAddress) === readonlyWallet.xplaAddress &&
+                    this.readonlyWallet.network === readonlyWallet.network)) {
+                return;
+            }
+            if (this.readonlyWallet) {
+                this.readonlyWallet.disconnect();
+            }
+            this.readonlyWallet = readonlyWallet;
+            this.updateStates({
+                status: WalletStatus.WALLET_CONNECTED,
+                network: readonlyWallet.network,
+                wallets: [
+                    {
+                        connectType: ConnectType.READONLY,
+                        xplaAddress: readonlyWallet.xplaAddress,
+                        design: 'readonly',
+                    },
+                ],
+                supportFeatures: EMPTY_SUPPORT_FEATURES,
+                connection: CONNECTIONS.READONLY,
+            });
+            this.disableReadonlyWallet = () => {
+                readonlyWallet.disconnect();
+                this.readonlyWallet = null;
+                this.disableReadonlyWallet = null;
+            };
+        };
+        this.enableExtension = () => {
+            var _a, _b;
+            (_a = this.disableReadonlyWallet) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.disableWalletConnect) === null || _b === void 0 ? void 0 : _b.call(this);
+            if (this.disableExtension || !this.extension) {
+                return;
+            }
+            const extensionSubscription = this.extension.states().subscribe({
+                next: (extensionStates) => {
+                    if (extensionStates.type === ExtensionRouterStatus.WALLET_CONNECTED &&
+                        AccAddress.validate(extensionStates.wallet.xplaAddress)) {
+                        this.updateStates({
+                            status: WalletStatus.WALLET_CONNECTED,
+                            network: extensionStates.network,
+                            wallets: [
+                                {
+                                    connectType: ConnectType.EXTENSION,
+                                    xplaAddress: extensionStates.wallet.xplaAddress,
+                                    design: extensionStates.wallet.design,
+                                },
+                            ],
+                            supportFeatures: extensionStates.supportFeatures,
+                            connection: memoConnection(ConnectType.EXTENSION, extensionStates.extensionInfo.name, extensionStates.extensionInfo.icon, extensionStates.extensionInfo.identifier),
+                        });
+                    }
+                    else {
+                        this.updateStates(this._notConnected);
+                    }
+                },
+            });
+            this.disableExtension = () => {
+                var _a;
+                (_a = this.extension) === null || _a === void 0 ? void 0 : _a.disconnect();
+                extensionSubscription.unsubscribe();
+                this.disableExtension = null;
+            };
+        };
+        this.enableWalletConnect = (walletConnect) => {
+            var _a, _b;
+            (_a = this.disableReadonlyWallet) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.disableExtension) === null || _b === void 0 ? void 0 : _b.call(this);
+            if (this.walletConnect === walletConnect) {
+                return;
+            }
+            if (this.walletConnect) {
+                this.walletConnect.disconnect();
+            }
+            this.walletConnect = walletConnect;
+            const subscribeWalletConnect = (wc) => {
+                return wc.session().subscribe({
+                    next: (status) => {
+                        var _a;
+                        switch (status.status) {
+                            case WalletConnectSessionStatus.CONNECTED:
+                                this.updateStates({
+                                    status: WalletStatus.WALLET_CONNECTED,
+                                    network: (_a = this.options.walletConnectChainIds[status.chainId]) !== null && _a !== void 0 ? _a : this.options.defaultNetwork,
+                                    wallets: [
+                                        {
+                                            connectType: ConnectType.WALLETCONNECT,
+                                            xplaAddress: status.xplaAddress,
+                                            design: 'walletconnect',
+                                        },
+                                    ],
+                                    supportFeatures: WALLETCONNECT_SUPPORT_FEATURES,
+                                    connection: CONNECTIONS.WALLETCONNECT,
+                                });
+                                break;
+                            default:
+                                this.updateStates(this._notConnected);
+                                break;
+                        }
+                    },
+                });
+            };
+            const walletConnectSessionSubscription = subscribeWalletConnect(walletConnect);
+            this.disableWalletConnect = () => {
+                var _a;
+                (_a = this.walletConnect) === null || _a === void 0 ? void 0 : _a.disconnect();
+                this.walletConnect = null;
+                walletConnectSessionSubscription.unsubscribe();
+                this.disableWalletConnect = null;
+            };
+        };
+        this._notConnected = {
+            status: WalletStatus.WALLET_NOT_CONNECTED,
+            network: options.defaultNetwork,
+        };
+        this._initializing = {
+            status: WalletStatus.INITIALIZING,
+            network: options.defaultNetwork,
+        };
+        this._availableConnectTypes = new BehaviorSubject([
+            ConnectType.READONLY,
+            ConnectType.WALLETCONNECT,
+        ]);
+        this._availableInstallTypes = new BehaviorSubject([]);
+        this._states = new BehaviorSubject(this._initializing);
+        let numSessionCheck = 0;
+        // wait checking the availability of the chrome extension
+        // 0. check if extension wallet session is exists
+        checkExtensionReady((_a = options.waitingChromeExtensionInstallCheck) !== null && _a !== void 0 ? _a : DEFAULT_WAITING_CHROME_EXTENSION_INSTALL_CHECK, this.isChromeExtensionCompatibleBrowser()).then((ready) => {
+            var _a;
+            if (ready) {
+                this._availableConnectTypes.next([
+                    ConnectType.EXTENSION,
+                    ConnectType.WALLETCONNECT,
+                    ConnectType.READONLY,
+                ]);
+                this.extension = new ExtensionRouter({
+                    hostWindow: window,
+                    selectExtension: options.selectExtension,
+                    dangerously__chromeExtensionCompatibleBrowserCheck: (_a = options.dangerously__chromeExtensionCompatibleBrowserCheck) !== null && _a !== void 0 ? _a : DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK,
+                    defaultNetwork: options.defaultNetwork,
+                });
+                const subscription = this.extension
+                    .states()
+                    .pipe(filter(({ type }) => type !== ExtensionRouterStatus.INITIALIZING))
+                    .subscribe((extensionStates) => {
+                    try {
+                        subscription.unsubscribe();
+                    }
+                    catch (_a) { }
+                    if (extensionStates.type === ExtensionRouterStatus.WALLET_CONNECTED &&
+                        !this.disableWalletConnect &&
+                        !this.disableReadonlyWallet) {
+                        this.enableExtension();
+                    }
+                    else if (numSessionCheck === 0) {
+                        numSessionCheck += 1;
+                    }
+                    else {
+                        this.updateStates(this._notConnected);
+                    }
+                });
+            }
+            else {
+                if (isDesktopChrome(this.isChromeExtensionCompatibleBrowser())) {
+                    this._availableInstallTypes.next([ConnectType.EXTENSION]);
+                }
+                if (numSessionCheck === 0) {
+                    numSessionCheck += 1;
+                }
+                else {
+                    this.updateStates(this._notConnected);
+                }
+            }
+        });
+        // 1. check if readonly wallet session is exists
+        const draftReadonlyWallet = reConnectIfSessionExists();
+        if (draftReadonlyWallet) {
+            this.enableReadonlyWallet(draftReadonlyWallet);
+            return;
+        }
+        // 2. check if walletconnect sesison is exists
+        const draftWalletConnect = wcConnectIfSessionExists(options);
+        if (draftWalletConnect &&
+            draftWalletConnect.getLatestSession().status ===
+                WalletConnectSessionStatus.CONNECTED) {
+            this.enableWalletConnect(draftWalletConnect);
+        }
+        else if (numSessionCheck === 0) {
+            numSessionCheck += 1;
+        }
+        else {
+            this.updateStates(this._notConnected);
+        }
+    }
+}
+const memoizedConnections = new Map();
+function memoConnection(connectType, name, icon, identifier = '') {
+    const key = [connectType, name, icon, identifier].join(';');
+    if (memoizedConnections.has(key)) {
+        return memoizedConnections.get(key);
+    }
+    const connection = {
+        type: connectType,
+        name,
+        icon,
+        identifier,
+    };
+    memoizedConnections.set(key, connection);
+    return connection;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/@ksangkuk10/wallet-controller/controller.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccAddress,\n  CreateTxOptions,\n  LCDClient,\n  PublicKey,\n  SimplePublicKey,\n  Tx,\n  SignMode,\n} from '@xpla/xpla.js';\nimport {\n  ConnectedWallet,\n  Connection,\n  ConnectType,\n  Installation,\n  NetworkInfo,\n  SignBytesResult,\n  SignResult,\n  TxResult,\n  WalletApp,\n  WalletLCDClientConfig,\n  WalletStates,\n  WalletStatus,\n} from '@ksangkuk10/wallet-types';\nimport {\n  XplaWebExtensionFeatures,\n  WebExtensionTxStatus,\n} from '@ksangkuk10/web-extension-interface';\nimport deepEqual from 'fast-deep-equal';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  firstValueFrom,\n  Observable,\n  Subscription,\n} from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\nimport {\n  CHROME_EXTENSION_INSTALL_URL,\n  DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK,\n} from './env';\nimport {\n  mapExtensionSignBytesError,\n  mapExtensionTxError,\n} from './exception/mapExtensionTxError';\nimport { \n  mapWalletConnectError,\n  mapWalletConnectSignError,\n  mapWalletConnectSignBytesError,\n} from './exception/mapWalletConnectError';\nimport { selectConnection } from './modules/connect-modal';\nimport {\n  ExtensionRouter,\n  ExtensionRouterStatus,\n} from './modules/extension-router';\nimport {\n  ExtensionInfo,\n  getXplaExtensions,\n} from './modules/extension-router/multiChannel';\nimport {\n  connect as reConnect,\n  connectIfSessionExists as reConnectIfSessionExists,\n  ReadonlyWalletController,\n  readonlyWalletModal,\n  ReadonlyWalletSession,\n} from './modules/readonly-wallet';\nimport {\n  connect as wcConnect,\n  connectIfSessionExists as wcConnectIfSessionExists,\n  WalletConnectController,\n  WalletConnectControllerOptions,\n  WalletConnectSessionStatus,\n} from './modules/walletconnect';\nimport { getExtensions } from './operators/getExtensions';\nimport { toConnectedWallet } from './operators/toConnectedWallet';\nimport { toLcdClient } from './operators/toLcdClient';\nimport { isDesktopChrome } from './utils/browser-check';\nimport { checkExtensionReady } from './utils/checkExtensionReady';\nimport { sortConnections } from './utils/sortConnections';\n\nexport interface WalletControllerOptions\n  extends WalletConnectControllerOptions {\n  /**\n   * ⚠️ Don't hardcoding this, use getChain Options()\n   *\n   * fallback network if controller is not connected\n   */\n  defaultNetwork: NetworkInfo;\n\n  /**\n   * ⚠️ Don't hardcoding this, use getChain Options()\n   *\n   * for walletconnect\n   *\n   * The network rules passed by the Xpla Mobile are 0 is testnet, 1 is mainnet.\n   *\n   * Always set testnet for 0 and mainnet for 1.\n   *\n   * @example\n   * ```\n   * const mainnet: NetworkInfo = {\n   *  name: 'mainnet',\n   *  chainID: 'dimension-1',\n   *  lcd: 'https://lcd.xpla.net',\n   * }\n   *\n   * const testnet: NetworkInfo = {\n   *  name: 'testnet',\n   *  chainID: 'cube-1',\n   *  lcd: 'https://lcd.xpla.net',\n   * }\n   *\n   * const walletConnectChainIds: Record<number, NetworkInfo> = {\n   *   0: testnet,\n   *   1: mainnet,\n   * }\n   *\n   * <WalletProvider walletConnectChainIds={walletConnectChainIds}>\n   * ```\n   */\n  walletConnectChainIds: Record<number, NetworkInfo>;\n\n  /**\n   * run at executing the `connect(ConnectType.READONLY)`\n   */\n  createReadonlyWalletSession?: (\n    networks: NetworkInfo[],\n  ) => Promise<ReadonlyWalletSession | null>;\n\n  /**\n   * run at executing the `connect()` - only used when does not input ConnectType\n   */\n  selectConnection?: (\n    connections: Connection[],\n  ) => Promise<[type: ConnectType, identifier: string | undefined] | null>;\n\n  /**\n   * run at executing the `connect(ConnectType.EXTENSION)`\n   * if user installed multiple wallets\n   */\n  selectExtension?: (\n    extensionInfos: ExtensionInfo[],\n  ) => Promise<ExtensionInfo | null>;\n\n  /**\n   * milliseconds to wait checking chrome extension is installed\n   *\n   * @default 1000 * 3 miliseconds\n   */\n  waitingChromeExtensionInstallCheck?: number;\n\n  /**\n   * ⚠️ This API is an option for wallet developers. Please don't use dApp developers.\n   *\n   * @example\n   * ```\n   * <WalletProvider dangerously__chromeExtensionCompatibleBrowserCheck={(userAgent: string) => {\n   *   return /MyWallet\\//.test(userAgent);\n   * }}>\n   * ```\n   */\n  dangerously__chromeExtensionCompatibleBrowserCheck?: (\n    userAgent: string,\n  ) => boolean;\n}\n\nconst CONNECTIONS = {\n  [ConnectType.READONLY]: {\n    type: ConnectType.READONLY,\n    name: 'View an address',\n    icon: 'https://assets.xpla.io/icon/wallet-provider/readonly.svg',\n  } as Connection,\n  [ConnectType.WALLETCONNECT]: {\n    type: ConnectType.WALLETCONNECT,\n    name: 'Wallet Connect',\n    icon: 'https://assets.xpla.io/icon/wallet-provider/walletconnect.svg',\n  } as Connection,\n} as const;\n\nconst DEFAULT_WAITING_CHROME_EXTENSION_INSTALL_CHECK = 1000 * 3;\n\nconst WALLETCONNECT_SUPPORT_FEATURES = new Set<XplaWebExtensionFeatures>([\n  'post', 'sign', 'sign-bytes'\n]);\n\nconst EMPTY_SUPPORT_FEATURES = new Set<XplaWebExtensionFeatures>();\n\n//noinspection ES6MissingAwait\nexport class WalletController {\n  private extension: ExtensionRouter | null = null;\n  private walletConnect: WalletConnectController | null = null;\n  private readonlyWallet: ReadonlyWalletController | null = null;\n\n  private _availableConnectTypes: BehaviorSubject<ConnectType[]>;\n  private _availableInstallTypes: BehaviorSubject<ConnectType[]>;\n  private _states: BehaviorSubject<WalletStates>;\n\n  private disableReadonlyWallet: (() => void) | null = null;\n  private disableExtension: (() => void) | null = null;\n  private disableWalletConnect: (() => void) | null = null;\n\n  private readonly _notConnected: WalletStates;\n  private readonly _initializing: WalletStates;\n\n  constructor(readonly options: WalletControllerOptions) {\n    this._notConnected = {\n      status: WalletStatus.WALLET_NOT_CONNECTED,\n      network: options.defaultNetwork,\n    };\n\n    this._initializing = {\n      status: WalletStatus.INITIALIZING,\n      network: options.defaultNetwork,\n    };\n\n    this._availableConnectTypes = new BehaviorSubject<ConnectType[]>([\n      ConnectType.READONLY,\n      ConnectType.WALLETCONNECT,\n    ]);\n\n    this._availableInstallTypes = new BehaviorSubject<ConnectType[]>([]);\n\n    this._states = new BehaviorSubject<WalletStates>(this._initializing);\n\n    let numSessionCheck: number = 0;\n\n    // wait checking the availability of the chrome extension\n    // 0. check if extension wallet session is exists\n    checkExtensionReady(\n      options.waitingChromeExtensionInstallCheck ??\n        DEFAULT_WAITING_CHROME_EXTENSION_INSTALL_CHECK,\n      this.isChromeExtensionCompatibleBrowser(),\n    ).then((ready: boolean) => {\n      if (ready) {\n        this._availableConnectTypes.next([\n          ConnectType.EXTENSION,\n          ConnectType.WALLETCONNECT,\n          ConnectType.READONLY,\n        ]);\n\n        this.extension = new ExtensionRouter({\n          hostWindow: window,\n          selectExtension: options.selectExtension,\n          dangerously__chromeExtensionCompatibleBrowserCheck:\n            options.dangerously__chromeExtensionCompatibleBrowserCheck ??\n            DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK,\n          defaultNetwork: options.defaultNetwork,\n        });\n\n        const subscription = this.extension\n          .states()\n          .pipe(\n            filter(({ type }) => type !== ExtensionRouterStatus.INITIALIZING),\n          )\n          .subscribe((extensionStates) => {\n            try {\n              subscription.unsubscribe();\n            } catch {}\n\n            if (\n              extensionStates.type === ExtensionRouterStatus.WALLET_CONNECTED &&\n              !this.disableWalletConnect &&\n              !this.disableReadonlyWallet\n            ) {\n              this.enableExtension();\n            } else if (numSessionCheck === 0) {\n              numSessionCheck += 1;\n            } else {\n              this.updateStates(this._notConnected);\n            }\n          });\n      } else {\n        if (isDesktopChrome(this.isChromeExtensionCompatibleBrowser())) {\n          this._availableInstallTypes.next([ConnectType.EXTENSION]);\n        }\n\n        if (numSessionCheck === 0) {\n          numSessionCheck += 1;\n        } else {\n          this.updateStates(this._notConnected);\n        }\n      }\n    });\n\n    // 1. check if readonly wallet session is exists\n    const draftReadonlyWallet = reConnectIfSessionExists();\n\n    if (draftReadonlyWallet) {\n      this.enableReadonlyWallet(draftReadonlyWallet);\n      return;\n    }\n\n    // 2. check if walletconnect sesison is exists\n    const draftWalletConnect = wcConnectIfSessionExists(options);\n\n    if (\n      draftWalletConnect &&\n      draftWalletConnect.getLatestSession().status ===\n        WalletConnectSessionStatus.CONNECTED\n    ) {\n      this.enableWalletConnect(draftWalletConnect);\n    } else if (numSessionCheck === 0) {\n      numSessionCheck += 1;\n    } else {\n      this.updateStates(this._notConnected);\n    }\n  }\n\n  /**\n   * Some mobile wallet emulates the behavior of chrome extension.\n   * It confirms that the current connection environment is such a wallet.\n   * (If you are running connect() by checking availableConnectType, you do not need to use this API.)\n   *\n   * @see Wallet#isChromeExtensionCompatibleBrowser\n   */\n  isChromeExtensionCompatibleBrowser = (): boolean => {\n    return (\n      this.options.dangerously__chromeExtensionCompatibleBrowserCheck ??\n      DEFAULT_CHROME_EXTENSION_COMPATIBLE_BROWSER_CHECK\n    )(navigator.userAgent);\n  };\n\n  /**\n   * available connect types on the browser\n   *\n   * @see Wallet#availableConnectTypes\n   */\n  availableConnectTypes = (): Observable<ConnectType[]> => {\n    return this._availableConnectTypes.asObservable();\n  };\n\n  /**\n   * available connections includes identifier, name, icon\n   *\n   * @see Wallet#availableConnections\n   */\n  availableConnections = (): Observable<Connection[]> => {\n    return this._availableConnectTypes.pipe(\n      map((connectTypes) => {\n        const connections: Connection[] = [];\n\n        for (const connectType of connectTypes) {\n          if (connectType === ConnectType.EXTENSION) {\n            const xplaExtensions = getXplaExtensions();\n\n            for (const xplaExtension of xplaExtensions) {\n              connections.push(\n                memoConnection(\n                  ConnectType.EXTENSION,\n                  xplaExtension.name,\n                  xplaExtension.icon,\n                  xplaExtension.identifier,\n                ),\n              );\n            }\n          } else {\n            connections.push(CONNECTIONS[connectType]);\n          }\n        }\n\n        return sortConnections(connections);\n      }),\n    );\n  };\n\n  /**\n   * available install types on the browser\n   *\n   * in this time, this only contains [ConnectType.EXTENSION]\n   *\n   * @see Wallet#availableInstallTypes\n   */\n  availableInstallTypes = (): Observable<ConnectType[]> => {\n    return this._availableInstallTypes.asObservable();\n  };\n\n  /**\n   * available installations includes identifier, name, icon, url\n   *\n   * @see Wallet#availableInstallations\n   */\n  availableInstallations = (): Observable<Installation[]> => {\n    return combineLatest([this.availableConnections(), getExtensions()]).pipe(\n      map(([connections, extensions]) => {\n        const installedIdentifiers = new Set<string>(\n          connections\n            .filter(({ type, identifier }) => {\n              return type === ConnectType.EXTENSION && !!identifier;\n            })\n            .map(({ identifier }) => {\n              return identifier!;\n            }),\n        );\n\n        return extensions\n          .filter(({ identifier }) => {\n            return !installedIdentifiers.has(identifier);\n          })\n          .map(({ name, identifier, icon, url }) => {\n            return {\n              type: ConnectType.EXTENSION,\n              identifier,\n              name,\n              icon,\n              url,\n            };\n          });\n      }),\n    );\n  };\n\n  /**\n   * @see Wallet#status\n   * @see Wallet#network\n   * @see Wallet#wallets\n   */\n  states = (): Observable<WalletStates> => {\n    return this._states.asObservable();\n  };\n\n  /** get connectedWallet */\n  connectedWallet = (): Observable<ConnectedWallet | undefined> => {\n    return this._states.pipe(toConnectedWallet(this));\n  };\n\n  /** get lcdClient */\n  lcdClient = (\n    lcdClientConfig?: WalletLCDClientConfig,\n  ): Observable<LCDClient> => {\n    return this._states.pipe(toLcdClient(lcdClientConfig));\n  };\n\n  /**\n   * reload the connected wallet states\n   *\n   * in this time, this only work on the ConnectType.EXTENSION\n   *\n   * @see Wallet#recheckStatus\n   */\n  refetchStates = () => {\n    if (this.disableExtension) {\n      this.extension?.refetchStates();\n    }\n  };\n\n  /**\n   * @deprecated Please use availableInstallations\n   *\n   * install for the connect type\n   *\n   * @see Wallet#install\n   */\n  install = (type: ConnectType) => {\n    if (type === ConnectType.EXTENSION) {\n      // TODO separate install links by browser types\n      window.open(CHROME_EXTENSION_INSTALL_URL, '_blank');\n    } else {\n      console.warn(\n        `[WalletController] ConnectType \"${type}\" does not support install() function`,\n      );\n    }\n  };\n\n  /**\n   * connect to wallet\n   *\n   * @see Wallet#connect\n   */\n  connect = async (_type?: ConnectType, _identifier?: string, _walletApp?: WalletApp | boolean) => {\n    let type: ConnectType;\n    let identifier: string | undefined;\n\n    if (!!_type) {\n      type = _type;\n      identifier = _identifier;\n    } else {\n      const connections = await firstValueFrom(this.availableConnections());\n      const selector = this.options.selectConnection ?? selectConnection;\n      const selected = await selector(connections);\n\n      if (!selected) {\n        return;\n      }\n\n      type = selected[0];\n      identifier = selected[1];\n    }\n\n    switch (type) {\n      case ConnectType.READONLY:\n        const networks: NetworkInfo[] = Object.keys(\n          this.options.walletConnectChainIds,\n        ).map((chainId) => this.options.walletConnectChainIds[+chainId]);\n\n        const createReadonlyWalletSession =\n          this.options.createReadonlyWalletSession?.(networks) ??\n          readonlyWalletModal({ networks });\n\n        const readonlyWalletSession = await createReadonlyWalletSession;\n\n        if (readonlyWalletSession) {\n          this.enableReadonlyWallet(reConnect(readonlyWalletSession));\n        }\n        break;\n      case ConnectType.WALLETCONNECT:\n        this.enableWalletConnect(wcConnect(this.options, false, _walletApp));\n        break;\n      case ConnectType.EXTENSION:\n        if (!this.extension) {\n          throw new Error(`extension instance is not created!`);\n        }\n\n        this.extension.connect(identifier);\n        this.enableExtension();\n        break;\n      default:\n        throw new Error(`Unknown ConnectType!`);\n    }\n  };\n\n  /**\n   * manual connect to read only session\n   *\n   * @see Wallet#connectReadonly\n   */\n  connectReadonly = (xplaAddress: string, network: NetworkInfo) => {\n    this.enableReadonlyWallet(\n      reConnect({\n        xplaAddress,\n        network,\n      }),\n    );\n  };\n\n  /** @see Wallet#disconnect */\n  disconnect = () => {\n    this.disableReadonlyWallet?.();\n    this.disableReadonlyWallet = null;\n\n    this.disableExtension?.();\n    this.disableExtension = null;\n\n    this.disableWalletConnect?.();\n    this.disableWalletConnect = null;\n\n    this.updateStates(this._notConnected);\n  };\n\n  /**\n   * @see Wallet#post\n   * @param tx\n   * @param xplaAddress only available new extension\n   */\n  post = async (\n    tx: CreateTxOptions,\n    xplaAddress?: string,\n    walletApp?: WalletApp | boolean,\n  ): Promise<TxResult> => {\n    // ---------------------------------------------\n    // extension\n    // ---------------------------------------------\n    if (this.disableExtension) {\n      return new Promise<TxResult>((resolve, reject) => {\n        if (!this.extension) {\n          reject(new Error(`extension instance not created!`));\n          return;\n        }\n\n        const subscription = this.extension.post(tx, xplaAddress).subscribe({\n          next: (txResult) => {\n            if (txResult.status === WebExtensionTxStatus.SUCCEED) {\n              resolve({\n                ...tx,\n                result: txResult.payload,\n                success: true,\n              });\n              subscription.unsubscribe();\n            }\n          },\n          error: (error) => {\n            reject(mapExtensionTxError(tx, error));\n            subscription.unsubscribe();\n          },\n        });\n      });\n    }\n    // ---------------------------------------------\n    // wallet connect\n    // ---------------------------------------------\n    else if (this.walletConnect) {\n      return this.walletConnect\n        .post(tx, walletApp)\n        .then(\n          (result) =>\n            ({\n              ...tx,\n              result,\n              success: true,\n            } as TxResult),\n        )\n        .catch((error) => {\n          throw mapWalletConnectError(tx, error);\n        });\n    } else {\n      throw new Error(`There are no connections that can be posting tx!`);\n    }\n  };\n\n  /**\n   * @see Wallet#sign\n   * @param tx\n   * @param xplaAddress only available new extension\n   */\n  sign = async (\n    tx: CreateTxOptions & {\n      sequence?: number;\n      accountNumber?: number;\n      signMode?: SignMode;\n    },\n    xplaAddress?: string,\n    walletApp?: WalletApp | boolean,\n  ): Promise<SignResult> => {\n    if (this.disableExtension) {\n      return new Promise<SignResult>((resolve, reject) => {\n        if (!this.extension) {\n          reject(new Error(`extension instance is not created!`));\n          return;\n        }\n\n        const subscription = this.extension.sign(tx, xplaAddress).subscribe({\n          next: (txResult) => {\n            if (txResult.status === WebExtensionTxStatus.SUCCEED) {\n              resolve({\n                ...tx,\n                result: Tx.fromData(txResult.payload),\n                success: true,\n              });\n              subscription.unsubscribe();\n            }\n          },\n          error: (error) => {\n            reject(mapExtensionTxError(tx, error));\n            subscription.unsubscribe();\n          },\n        });\n      });\n    }\n    // ---------------------------------------------\n    // wallet connect\n    // ---------------------------------------------\n    else if (this.walletConnect) {\n      if (walletApp && walletApp === WalletApp.XPLA_GAMES) {\n        throw new Error(`There are no connections that can be signing!`);\n      }\n\n      return this.walletConnect\n        .sign(tx, walletApp)\n        .then(\n          (result) => {\n            return {\n                ...tx,\n                result: Tx.fromData(result, false),\n                success: true,\n            }\n          }\n        )\n        .catch((error) => {\n          throw mapWalletConnectSignError(tx, error);\n        });\n    } else {\n      throw new Error(`There are no connections that can be signing!`);\n    }\n  };\n\n  /**\n   * @see Wallet#signBytes\n   * @param bytes\n   * @param xplaAddress only available new extension\n   */\n  signBytes = async (\n    bytes: Buffer,\n    xplaAddress?: string,\n    walletApp?: WalletApp | boolean,\n  ): Promise<SignBytesResult> => {\n    if (this.disableExtension) {\n      return new Promise<SignBytesResult>((resolve, reject) => {\n        if (!this.extension) {\n          reject(new Error(`extension instance is not created!`));\n          return;\n        }\n\n        const subscription = this.extension\n          .signBytes(bytes, xplaAddress)\n          .subscribe({\n            next: (txResult) => {\n              if (txResult.status === WebExtensionTxStatus.SUCCEED) {\n                resolve({\n                  result: {\n                    recid: txResult.payload.recid,\n                    signature: Uint8Array.from(\n                      Buffer.from(txResult.payload.signature, 'base64'),\n                    ),\n                    public_key: txResult.payload.public_key\n                      ? PublicKey.fromData(txResult.payload.public_key)\n                      : undefined,\n                  },\n                  success: true,\n                });\n                subscription.unsubscribe();\n              }\n            },\n            error: (error) => {\n              reject(mapExtensionSignBytesError(bytes, error));\n              subscription.unsubscribe();\n            },\n          });\n      });\n    }\n    // ---------------------------------------------\n    // wallet connect\n    // ---------------------------------------------\n    else if (this.walletConnect) {\n      if (walletApp && walletApp === WalletApp.XPLA_GAMES) {\n        throw new Error(`There are no connections that can be signing bytes!`);\n      }\n\n      return this.walletConnect\n        .signBytes(bytes, walletApp)\n        .then(\n          (result) => {\n            const key = new SimplePublicKey(String(result.public_key)).toData()\n            return {\n              result: {\n                recid: result.recid,\n                signature: Uint8Array.from(\n                  Buffer.from(result.signature, 'base64'),\n                ),\n                public_key: key\n                  ? PublicKey.fromData(key)\n                  : undefined,\n              },\n              success: true,\n            }\n          }\n        )\n        .catch((error) => {\n          throw mapWalletConnectSignBytesError(bytes, error);\n        });\n    } else {\n      throw new Error(`There are no connections that can be signing bytes!`);\n    }\n  };\n\n  /**\n   * @see Wallet#hasCW20Tokens\n   * @param chainID\n   * @param tokenAddrs Token addresses\n   */\n  hasCW20Tokens = async (\n    chainID: string,\n    ...tokenAddrs: string[]\n  ): Promise<{ [tokenAddr: string]: boolean }> => {\n    if (this.availableExtensionFeature('cw20-token')) {\n      return this.extension!.hasCW20Tokens(chainID, ...tokenAddrs);\n    }\n\n    throw new Error(`Does not support hasCW20Tokens() on this connection`);\n  };\n\n  /**\n   * @see Wallet#addCW20Tokens\n   * @param chainID\n   * @param tokenAddrs Token addresses\n   */\n  addCW20Tokens = async (\n    chainID: string,\n    ...tokenAddrs: string[]\n  ): Promise<{ [tokenAddr: string]: boolean }> => {\n    if (this.availableExtensionFeature('cw20-token')) {\n      return this.extension!.addCW20Tokens(chainID, ...tokenAddrs);\n    }\n\n    throw new Error(`Does not support addCW20Tokens() on this connection`);\n  };\n\n  /**\n   * @see Wallet#hasNetwork\n   * @param network\n   */\n  hasNetwork = (network: Omit<NetworkInfo, 'name'>): Promise<boolean> => {\n    if (this.availableExtensionFeature('network')) {\n      return this.extension!.hasNetwork(network);\n    }\n\n    throw new Error(`Does not support hasNetwork() on this connection`);\n  };\n\n  /**\n   * @see Wallet#hasNetwork\n   * @param network\n   */\n  addNetwork = (network: NetworkInfo): Promise<boolean> => {\n    if (this.availableExtensionFeature('network')) {\n      return this.extension!.addNetwork(network);\n    }\n\n    throw new Error(`Does not support addNetwork() on this connection`);\n  };\n\n  // ================================================================\n  // internal\n  // connect type changing\n  // ================================================================\n  private availableExtensionFeature = (feature: XplaWebExtensionFeatures) => {\n    if (this.disableExtension && this.extension) {\n      const states = this.extension.getLastStates();\n\n      return (\n        states.type === ExtensionRouterStatus.WALLET_CONNECTED &&\n        states.supportFeatures.has(feature)\n      );\n    }\n  };\n\n  private updateStates = (next: WalletStates) => {\n    const prev = this._states.getValue();\n\n    if (\n      next.status === WalletStatus.WALLET_CONNECTED &&\n      next.wallets.length === 0\n    ) {\n      next = {\n        status: WalletStatus.WALLET_NOT_CONNECTED,\n        network: next.network,\n      };\n    }\n\n    if (prev.status !== next.status || !deepEqual(prev, next)) {\n      this._states.next(next);\n    }\n  };\n\n  private enableReadonlyWallet = (readonlyWallet: ReadonlyWalletController) => {\n    this.disableWalletConnect?.();\n    this.disableExtension?.();\n\n    if (\n      this.readonlyWallet === readonlyWallet ||\n      (this.readonlyWallet?.xplaAddress === readonlyWallet.xplaAddress &&\n        this.readonlyWallet.network === readonlyWallet.network)\n    ) {\n      return;\n    }\n\n    if (this.readonlyWallet) {\n      this.readonlyWallet.disconnect();\n    }\n\n    this.readonlyWallet = readonlyWallet;\n\n    this.updateStates({\n      status: WalletStatus.WALLET_CONNECTED,\n      network: readonlyWallet.network,\n      wallets: [\n        {\n          connectType: ConnectType.READONLY,\n          xplaAddress: readonlyWallet.xplaAddress,\n          design: 'readonly',\n        },\n      ],\n      supportFeatures: EMPTY_SUPPORT_FEATURES,\n      connection: CONNECTIONS.READONLY,\n    });\n\n    this.disableReadonlyWallet = () => {\n      readonlyWallet.disconnect();\n      this.readonlyWallet = null;\n      this.disableReadonlyWallet = null;\n    };\n  };\n\n  private enableExtension = () => {\n    this.disableReadonlyWallet?.();\n    this.disableWalletConnect?.();\n\n    if (this.disableExtension || !this.extension) {\n      return;\n    }\n\n    const extensionSubscription = this.extension.states().subscribe({\n      next: (extensionStates) => {\n        if (\n          extensionStates.type === ExtensionRouterStatus.WALLET_CONNECTED &&\n          AccAddress.validate(extensionStates.wallet.xplaAddress)\n        ) {\n          this.updateStates({\n            status: WalletStatus.WALLET_CONNECTED,\n            network: extensionStates.network,\n            wallets: [\n              {\n                connectType: ConnectType.EXTENSION,\n                xplaAddress: extensionStates.wallet.xplaAddress,\n                design: extensionStates.wallet.design,\n              },\n            ],\n            supportFeatures: extensionStates.supportFeatures,\n            connection: memoConnection(\n              ConnectType.EXTENSION,\n              extensionStates.extensionInfo.name,\n              extensionStates.extensionInfo.icon,\n              extensionStates.extensionInfo.identifier,\n            ),\n          });\n        } else {\n          this.updateStates(this._notConnected);\n        }\n      },\n    });\n\n    this.disableExtension = () => {\n      this.extension?.disconnect();\n      extensionSubscription.unsubscribe();\n      this.disableExtension = null;\n    };\n  };\n\n  private enableWalletConnect = (walletConnect: WalletConnectController) => {\n    this.disableReadonlyWallet?.();\n    this.disableExtension?.();\n\n    if (this.walletConnect === walletConnect) {\n      return;\n    }\n\n    if (this.walletConnect) {\n      this.walletConnect.disconnect();\n    }\n\n    this.walletConnect = walletConnect;\n\n    const subscribeWalletConnect = (\n      wc: WalletConnectController,\n    ): Subscription => {\n      return wc.session().subscribe({\n        next: (status) => {\n          switch (status.status) {\n            case WalletConnectSessionStatus.CONNECTED:\n              this.updateStates({\n                status: WalletStatus.WALLET_CONNECTED,\n                network:\n                  this.options.walletConnectChainIds[status.chainId] ??\n                  this.options.defaultNetwork,\n                wallets: [\n                  {\n                    connectType: ConnectType.WALLETCONNECT,\n                    xplaAddress: status.xplaAddress,\n                    design: 'walletconnect',\n                  },\n                ],\n                supportFeatures: WALLETCONNECT_SUPPORT_FEATURES,\n                connection: CONNECTIONS.WALLETCONNECT,\n              });\n              break;\n            default:\n              this.updateStates(this._notConnected);\n              break;\n          }\n        },\n      });\n    };\n\n    const walletConnectSessionSubscription =\n      subscribeWalletConnect(walletConnect);\n\n    this.disableWalletConnect = () => {\n      this.walletConnect?.disconnect();\n      this.walletConnect = null;\n      walletConnectSessionSubscription.unsubscribe();\n      this.disableWalletConnect = null;\n    };\n  };\n}\n\nconst memoizedConnections = new Map<string, Connection>();\n\nfunction memoConnection(\n  connectType: ConnectType,\n  name: string,\n  icon: string,\n  identifier: string | undefined = '',\n): Connection {\n  const key = [connectType, name, icon, identifier].join(';');\n\n  if (memoizedConnections.has(key)) {\n    return memoizedConnections.get(key)!;\n  }\n\n  const connection: Connection = {\n    type: connectType,\n    name,\n    icon,\n    identifier,\n  };\n\n  memoizedConnections.set(key, connection);\n\n  return connection;\n}\n"]}