@tezos-x/octez.connect-dapp 0.9.0

package/dist/cjs/dapp-client/DAppClient.js

@@ -0,0 +1,2073 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAppClient = void 0;
+const axios_1 = require("axios");
+const bs58check_1 = require("bs58check");
+const events_1 = require("../events");
+const octez_connect_types_1 = require("@tezos-x/octez.connect-types");
+const octez_connect_core_1 = require("@tezos-x/octez.connect-core");
+const octez_connect_utils_1 = require("@tezos-x/octez.connect-utils");
+const beacon_message_events_1 = require("../beacon-message-events");
+const tzkt_blockexplorer_1 = require("../utils/tzkt-blockexplorer");
+const octez_connect_dapp_1 = require("@tezos-x/octez.connect-dapp");
+const DappPostMessageTransport_1 = require("../transports/DappPostMessageTransport");
+const DappP2PTransport_1 = require("../transports/DappP2PTransport");
+const DappWalletConnectTransport_1 = require("../transports/DappWalletConnectTransport");
+const octez_connect_transport_postmessage_1 = require("@tezos-x/octez.connect-transport-postmessage");
+const octez_connect_ui_1 = require("@tezos-x/octez.connect-ui");
+const octez_connect_transport_walletconnect_1 = require("@tezos-x/octez.connect-transport-walletconnect");
+const logger = new octez_connect_core_1.Logger('DAppClient');
+/**
+ * @publicapi
+ *
+ * The DAppClient has to be used in decentralized applications. It handles all the logic related to connecting to beacon-compatible
+ * wallets and sending requests.
+ *
+ * @category DApp
+ */
+class DAppClient extends octez_connect_core_1.Client {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(Object.assign({ storage: config && config.storage ? config.storage : new octez_connect_core_1.LocalStorage() }, config));
+        this.events = new octez_connect_dapp_1.BeaconEventHandler();
+        this.isGetActiveAccountHandled = false;
+        this.openRequestsOtherTabs = new Set();
+        /**
+         * A map of requests that are currently "open", meaning we have sent them to a wallet and are still awaiting a response.
+         */
+        this.openRequests = new Map();
+        /**
+         * The currently active account. For all requests that are associated to a specific request (operation request, signing request),
+         * the active account is used to determine the network and destination wallet
+         */
+        this._activeAccount = new octez_connect_utils_1.ExposedPromise();
+        /**
+         * The currently active peer. This is used to address a peer in case the active account is not set. (Eg. for permission requests)
+         */
+        this._activePeer = new octez_connect_utils_1.ExposedPromise();
+        this.isInitPending = false;
+        this.beaconIDB = new octez_connect_core_1.IndexedDBStorage('beacon', ['bug_report', 'metrics']);
+        this.debounceSetActiveAccount = false;
+        this.multiTabChannel = new octez_connect_core_1.MultiTabChannel('octez.connect-sdk-channel', this.onBCMessageHandler.bind(this), this.onElectedLeaderhandler.bind(this));
+        this.blockchains = new Map();
+        this.description = config.description;
+        this.wcProjectId = ((_a = config.walletConnectOptions) === null || _a === void 0 ? void 0 : _a.projectId) || '24469fd0a06df227b6e5f7dc7de0ff4f';
+        this.wcRelayUrl = (_b = config.walletConnectOptions) === null || _b === void 0 ? void 0 : _b.relayUrl;
+        this.featuredWallets = config.featuredWallets;
+        this.events = new octez_connect_dapp_1.BeaconEventHandler(config.eventHandlers, (_c = config.disableDefaultEvents) !== null && _c !== void 0 ? _c : false);
+        this.blockExplorer = (_d = config.blockExplorer) !== null && _d !== void 0 ? _d : new tzkt_blockexplorer_1.TzktBlockExplorer();
+        this.network = (_e = config.network) !== null && _e !== void 0 ? _e : { type: (_f = config.preferredNetwork) !== null && _f !== void 0 ? _f : octez_connect_types_1.NetworkType.MAINNET };
+        (0, octez_connect_ui_1.setColorMode)((_g = config.colorMode) !== null && _g !== void 0 ? _g : octez_connect_types_1.ColorMode.LIGHT);
+        this.disclaimerText = config.disclaimerText;
+        this.errorMessages = (_h = config.errorMessages) !== null && _h !== void 0 ? _h : {};
+        this.appMetadataManager = new octez_connect_core_1.AppMetadataManager(this.storage);
+        this.storageValidator = new octez_connect_core_1.StorageValidator(this.storage);
+        this.enableAppSwitching =
+            config.enableAppSwitching === undefined ? true : !!config.enableAppSwitching;
+        this.enableMetrics = config.enableMetrics ? true : false;
+        // Subscribe to storage changes and update the active account if it changes on other tabs
+        this.storage.subscribeToStorageChanged((event) => __awaiter(this, void 0, void 0, function* () {
+            if (event.eventType === 'storageCleared') {
+                this.setActiveAccount(undefined);
+                return;
+            }
+            if (event.eventType === 'entryModified') {
+                if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT)) {
+                    const accountIdentifier = event.newValue;
+                    if (!accountIdentifier || accountIdentifier === 'undefined') {
+                        this.setActiveAccount(undefined);
+                    }
+                    else {
+                        const account = yield this.getAccount(accountIdentifier);
+                        this.setActiveAccount(account);
+                    }
+                    return;
+                }
+                if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.ENABLE_METRICS)) {
+                    this.enableMetrics = !!(yield this.storage.get(octez_connect_types_1.StorageKey.ENABLE_METRICS));
+                    return;
+                }
+                if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.BEACON_SDK_SECRET_SEED)) {
+                    this._keyPair = new octez_connect_utils_1.ExposedPromise();
+                    this._beaconId = new octez_connect_utils_1.ExposedPromise();
+                    yield this.initSDK();
+                    return;
+                }
+            }
+        }));
+        this.activeAccountLoaded = this.storage
+            .get(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT)
+            .then((activeAccountIdentifier) => __awaiter(this, void 0, void 0, function* () {
+            if (activeAccountIdentifier) {
+                const account = yield this.accountManager.getAccount(activeAccountIdentifier);
+                yield this.setActiveAccount(account);
+                return account;
+            }
+            else {
+                yield this.setActiveAccount(undefined);
+                return undefined;
+            }
+        }))
+            .catch((storageError) => __awaiter(this, void 0, void 0, function* () {
+            logger.error(storageError);
+            yield this.resetInvalidState(false);
+            this.events.emit(events_1.BeaconEvent.INVALID_ACCOUNT_DEACTIVATED);
+            return undefined;
+        }));
+        this.handleResponse = (message, connectionInfo) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const typedMessage = message.version === '3'
+                ? message.message
+                : message;
+            let appMetadata = message.version === '3'
+                ? (_a = typedMessage.blockchainData) === null || _a === void 0 ? void 0 : _a.appMetadata
+                : typedMessage.appMetadata;
+            if (!appMetadata && message.version === '3') {
+                const storedMetadata = yield Promise.all([
+                    this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_P2P_PEERS_DAPP),
+                    this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_WALLETCONNECT_PEERS_DAPP),
+                    this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_POSTMESSAGE_PEERS_DAPP)
+                ]);
+                for (const peers of storedMetadata) {
+                    const peer = peers.find((peer) => peer.senderId === message.senderId);
+                    if (!peer) {
+                        continue;
+                    }
+                    const wallet = yield this.getWalletInfo();
+                    appMetadata = {
+                        name: peer.name,
+                        senderId: peer.senderId,
+                        icon: wallet.icon
+                    };
+                    break;
+                }
+            }
+            if (this.openRequestsOtherTabs.has(message.id)) {
+                this.multiTabChannel.postMessage({
+                    type: 'RESPONSE',
+                    data: {
+                        message,
+                        connectionInfo
+                    },
+                    id: message.id
+                });
+                if (typedMessage.type !== octez_connect_types_1.BeaconMessageType.Acknowledge) {
+                    this.openRequestsOtherTabs.delete(message.id);
+                }
+                return;
+            }
+            const openRequest = this.openRequests.get(message.id);
+            logger.log('### openRequest ###', openRequest);
+            logger.log('handleResponse', 'Received message', message, connectionInfo);
+            logger.log('### message ###', JSON.stringify(message));
+            logger.log('### connectionInfo ###', connectionInfo);
+            const handleDisconnect = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                this.analytics.track('event', 'DAppClient', 'Disconnect received from Wallet');
+                const relevantTransport = connectionInfo.origin === octez_connect_types_1.Origin.P2P
+                    ? this.p2pTransport
+                    : connectionInfo.origin === octez_connect_types_1.Origin.WALLETCONNECT
+                        ? this.walletConnectTransport
+                        : ((_a = this.postMessageTransport) !== null && _a !== void 0 ? _a : (yield this.transport));
+                if (relevantTransport) {
+                    const peers = yield relevantTransport.getPeers();
+                    const peer = peers.find((peerEl) => peerEl.senderId === message.senderId);
+                    if (peer) {
+                        yield relevantTransport.removePeer(peer);
+                    }
+                }
+                yield this.removeAccountsForPeerIds([message.senderId]);
+                yield this.events.emit(events_1.BeaconEvent.CHANNEL_CLOSED);
+            });
+            if (openRequest && typedMessage.type === octez_connect_types_1.BeaconMessageType.Acknowledge) {
+                this.analytics.track('event', 'DAppClient', 'Acknowledge received from Wallet');
+                logger.log('handleResponse', `acknowledge message received for ${message.id}`);
+                this.events
+                    .emit(events_1.BeaconEvent.ACKNOWLEDGE_RECEIVED, {
+                    message: typedMessage,
+                    extraInfo: {},
+                    walletInfo: yield this.getWalletInfo()
+                })
+                    .catch(console.error);
+            }
+            else if (openRequest) {
+                if (typedMessage.type === octez_connect_types_1.BeaconMessageType.PermissionResponse && appMetadata) {
+                    yield this.appMetadataManager.addAppMetadata(appMetadata);
+                }
+                if (typedMessage.type === octez_connect_types_1.BeaconMessageType.Error) {
+                    openRequest.reject(typedMessage);
+                }
+                else {
+                    openRequest.resolve({ message, connectionInfo });
+                }
+                this.openRequests.delete(typedMessage.id);
+            }
+            else {
+                if (typedMessage.type === octez_connect_types_1.BeaconMessageType.Disconnect) {
+                    yield handleDisconnect();
+                }
+                else if (typedMessage.type === octez_connect_types_1.BeaconMessageType.ChangeAccountRequest) {
+                    yield this.onNewAccount(typedMessage, connectionInfo);
+                }
+            }
+            if (this._transport.isResolved()) {
+                const transport = yield this.transport;
+                if (transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport &&
+                    !this.openRequests.has('session_update')) {
+                    this.openRequests.set('session_update', new octez_connect_utils_1.ExposedPromise());
+                }
+            }
+        });
+        this.storageValidator
+            .validate()
+            .then((isValid) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const account = yield this.activeAccountLoaded;
+            if (!isValid) {
+                const info = yield this.getWalletInfo(undefined, account, false);
+                info.type =
+                    info.type === 'extension' && (account === null || account === void 0 ? void 0 : account.origin.type) === octez_connect_types_1.Origin.P2P ? 'mobile' : info.type;
+                yield this.storage.set(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET, {
+                    icon: (_a = info.icon) !== null && _a !== void 0 ? _a : '',
+                    key: info.name,
+                    type: (_b = info.type) !== null && _b !== void 0 ? _b : 'web',
+                    name: info.name,
+                    url: info.deeplink
+                });
+                const nowValid = yield this.storageValidator.validate();
+                if (!nowValid) {
+                    this.resetInvalidState(false);
+                }
+            }
+            if (account && account.origin.type !== 'p2p') {
+                this.init();
+            }
+        }))
+            .catch((err) => logger.error(err.message));
+        this.sendMetrics('enable-metrics?' + this.addQueryParam('version', octez_connect_core_1.SDK_VERSION), undefined, (res) => {
+            if (!res.ok) {
+                res.status === 426
+                    ? console.error('Metrics are no longer supported for this version, please upgrade.')
+                    : console.warn('Network error encountered. Metrics sharing have been automatically disabled.');
+            }
+            this.enableMetrics = res.ok;
+            this.storage.set(octez_connect_types_1.StorageKey.ENABLE_METRICS, res.ok);
+        }, () => {
+            this.enableMetrics = false;
+            this.storage.set(octez_connect_types_1.StorageKey.ENABLE_METRICS, false);
+        });
+        this.initUserID().catch((err) => logger.error(err.message));
+    }
+    checkIfBCLeaderExists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // broadcast channel does not work on mobile
+            if ((0, octez_connect_ui_1.isMobileOS)(window)) {
+                return true;
+            }
+            const hasLeader = yield this.multiTabChannel.hasLeader();
+            if (hasLeader) {
+                return this.multiTabChannel.isLeader();
+            }
+            yield this.multiTabChannel.getLeadership();
+            return this.multiTabChannel.isLeader();
+        });
+    }
+    onElectedLeaderhandler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._transport.isResolved()) {
+                return;
+            }
+            const tranport = yield this.transport;
+            if (tranport.type !== octez_connect_types_1.TransportType.WALLETCONNECT) {
+                return;
+            }
+            if (tranport.connectionStatus === octez_connect_types_1.TransportStatus.CONNECTED) {
+                return;
+            }
+            yield tranport.connect();
+        });
+    }
+    onBCMessageHandler(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.type) {
+                case octez_connect_types_1.BeaconMessageType.PermissionRequest:
+                case octez_connect_types_1.BeaconMessageType.OperationRequest:
+                case octez_connect_types_1.BeaconMessageType.SignPayloadRequest:
+                case octez_connect_types_1.BeaconMessageType.BroadcastRequest:
+                case octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeRequest:
+                case octez_connect_types_1.BeaconMessageType.SimulatedProofOfEventChallengeRequest:
+                    this.prepareRequest(message);
+                    break;
+                case octez_connect_types_1.BeaconMessageType.BlockchainRequest:
+                    this.prepareRequest(message, true);
+                    break;
+                case 'RESPONSE':
+                    this.handleResponse(message.data.message, message.data.connectionInfo);
+                    break;
+                case 'DISCONNECT':
+                    this._transport.isResolved() && this.disconnect();
+                    break;
+                default:
+                    logger.error('onBCMessageHandler', 'message type not recognized', message);
+            }
+        });
+    }
+    prepareRequest(message_1) {
+        return __awaiter(this, arguments, void 0, function* (message, isV3 = false) {
+            if (!this.multiTabChannel.isLeader()) {
+                return;
+            }
+            // block until the transport is ready
+            const transport = (yield this._transport.promise);
+            yield transport.waitForResolution();
+            this.openRequestsOtherTabs.add(message.id);
+            isV3
+                ? this.makeRequestV3(message.data, message.id)
+                : this.makeRequest(message.data, false, message.id);
+        });
+    }
+    createStateSnapshot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!localStorage || !this.enableMetrics) {
+                return;
+            }
+            const keys = Object.values(octez_connect_types_1.StorageKey).filter((key) => !key.includes('wc@2') && !key.includes('secret') && !key.includes('account'));
+            try {
+                for (const key of keys) {
+                    yield this.beaconIDB.set(key, this.storage.getPrefixedKey(key));
+                }
+            }
+            catch (err) {
+                logger.error('createStateSnapshot', err.message);
+            }
+        });
+    }
+    initUserID() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.storage.get(octez_connect_types_1.StorageKey.USER_ID);
+            if (id) {
+                this.userId = id;
+                return;
+            }
+            this.userId = yield (0, octez_connect_utils_1.generateGUID)();
+            this.storage.set(octez_connect_types_1.StorageKey.USER_ID, this.userId);
+        });
+    }
+    initInternalTransports() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const seed = yield this.storage.get(octez_connect_types_1.StorageKey.BEACON_SDK_SECRET_SEED);
+            if (!seed) {
+                throw new Error('Secret seed not found');
+            }
+            const keyPair = yield (0, octez_connect_utils_1.getKeypairFromSeed)(seed);
+            if (this.postMessageTransport || this.p2pTransport || this.walletConnectTransport) {
+                return;
+            }
+            this.postMessageTransport = new DappPostMessageTransport_1.DappPostMessageTransport(this.name, keyPair, this.storage);
+            yield this.addListener(this.postMessageTransport);
+            this.p2pTransport = new DappP2PTransport_1.DappP2PTransport(this.name, keyPair, this.storage, this.matrixNodes, this.iconUrl, this.appUrl);
+            yield this.addListener(this.p2pTransport);
+            const wcOptions = {
+                projectId: this.wcProjectId,
+                relayUrl: this.wcRelayUrl,
+                metadata: {
+                    name: this.name,
+                    description: (_a = this.description) !== null && _a !== void 0 ? _a : '',
+                    url: (_b = this.appUrl) !== null && _b !== void 0 ? _b : '',
+                    icons: this.iconUrl ? [this.iconUrl] : []
+                }
+            };
+            this.walletConnectTransport = new DappWalletConnectTransport_1.DappWalletConnectTransport(this.name, keyPair, this.storage, {
+                network: this.network.type,
+                opts: wcOptions
+            }, this.checkIfBCLeaderExists.bind(this));
+            this.initEvents();
+            yield this.addListener(this.walletConnectTransport);
+        });
+    }
+    initEvents() {
+        if (!this.walletConnectTransport) {
+            return;
+        }
+        this.walletConnectTransport.setEventHandler("CLOSE_ALERT" /* ClientEvents.CLOSE_ALERT */, this.hideUI.bind(this, ['alert', 'toast']));
+        this.walletConnectTransport.setEventHandler("RESET_STATE" /* ClientEvents.RESET_STATE */, this.channelClosedHandler.bind(this));
+        this.walletConnectTransport.setEventHandler("WC_ACK_NOTIFICATION" /* ClientEvents.WC_ACK_NOTIFICATION */, this.wcToastHandler.bind(this));
+        this.walletConnectTransport.setEventHandler("ON_RELAYER_ERROR" /* ClientEvents.ON_RELAYER_ERROR */, this.onRelayerError.bind(this));
+    }
+    onRelayerError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.resetInvalidState(false);
+            this.events.emit(events_1.BeaconEvent.RELAYER_ERROR);
+        });
+    }
+    wcToastHandler(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletInfo = yield (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.getWalletInfo();
+                }
+                catch (_a) {
+                    return { name: 'wallet' };
+                }
+            }))();
+            yield this.events.emit(events_1.BeaconEvent.HIDE_UI, ['alert']);
+            if (status === 'pending') {
+                this.events.emit(events_1.BeaconEvent.ACKNOWLEDGE_RECEIVED, {
+                    message: {},
+                    extraInfo: {},
+                    walletInfo
+                });
+            }
+            else {
+                this.events.emit(events_1.BeaconEvent.PERMISSION_REQUEST_ERROR, {
+                    errorResponse: { errorType: octez_connect_types_1.BeaconErrorType.ABORTED_ERROR },
+                    walletInfo
+                });
+            }
+        });
+    }
+    channelClosedHandler(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = yield this.transport;
+            if (transport.type !== type) {
+                return;
+            }
+            yield this.events.emit(events_1.BeaconEvent.CHANNEL_CLOSED);
+            this.setActiveAccount(undefined);
+            yield this.disconnect();
+        });
+    }
+    /**
+     * Destroy the instance.
+     *
+     * WARNING: Call `destroy` whenever you no longer need dAppClient
+     * as it frees internal subscriptions to the transport and therefore the instance may no longer work properly.
+     * If you wish to disconnect your dApp, use `disconnect` instead.
+     */
+    destroy() {
+        const _super = Object.create(null, {
+            destroy: { get: () => super.destroy }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createStateSnapshot();
+            yield _super.destroy.call(this);
+        });
+    }
+    init(transport, substratePairing) {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._initPromise) {
+                return this._initPromise;
+            }
+            try {
+                yield this.activeAccountLoaded;
+            }
+            catch (_a) {
+                //
+            }
+            this._initPromise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                if (transport) {
+                    yield this.addListener(transport);
+                    resolve(yield _super.init.call(this, transport));
+                }
+                else if (this._transport.isSettled()) {
+                    yield (yield this.transport).connect();
+                    resolve(yield _super.init.call(this, yield this.transport));
+                }
+                else {
+                    const activeAccount = yield this.getActiveAccount();
+                    const stopListening = () => {
+                        if (this.postMessageTransport) {
+                            this.postMessageTransport.stopListeningForNewPeers().catch(console.error);
+                        }
+                        if (this.p2pTransport) {
+                            this.p2pTransport.stopListeningForNewPeers().catch(console.error);
+                        }
+                        if (this.walletConnectTransport) {
+                            this.walletConnectTransport.stopListeningForNewPeers().catch(console.error);
+                        }
+                    };
+                    yield this.initInternalTransports();
+                    if (!this.postMessageTransport || !this.p2pTransport || !this.walletConnectTransport) {
+                        return;
+                    }
+                    this.postMessageTransport.connect().then().catch(console.error);
+                    if (activeAccount && activeAccount.origin) {
+                        const origin = activeAccount.origin.type;
+                        // Select the transport that matches the active account
+                        if (origin === octez_connect_types_1.Origin.EXTENSION) {
+                            resolve(yield _super.init.call(this, this.postMessageTransport));
+                        }
+                        else if (origin === octez_connect_types_1.Origin.P2P) {
+                            resolve(yield _super.init.call(this, this.p2pTransport));
+                        }
+                        else if (origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                            resolve(yield _super.init.call(this, this.walletConnectTransport));
+                        }
+                    }
+                    else {
+                        const p2pTransport = this.p2pTransport;
+                        const postMessageTransport = this.postMessageTransport;
+                        const walletConnectTransport = this.walletConnectTransport;
+                        postMessageTransport
+                            .listenForNewPeer((peer) => {
+                            logger.log('init', 'postmessage transport peer connected', peer);
+                            this.analytics.track('event', 'DAppClient', 'Extension connected', {
+                                peerName: peer.name
+                            });
+                            this.events
+                                .emit(events_1.BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.postMessageTransport).catch(console.error);
+                            stopListening();
+                            resolve(octez_connect_types_1.TransportType.POST_MESSAGE);
+                        })
+                            .catch(console.error);
+                        p2pTransport
+                            .listenForNewPeer((peer) => {
+                            logger.log('init', 'p2p transport peer connected', peer);
+                            this.analytics.track('event', 'DAppClient', 'octez.connect Wallet connected', {
+                                peerName: peer.name
+                            });
+                            this.events
+                                .emit(events_1.BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.p2pTransport).catch(console.error);
+                            stopListening();
+                            resolve(octez_connect_types_1.TransportType.P2P);
+                        })
+                            .catch(console.error);
+                        walletConnectTransport
+                            .listenForNewPeer((peer) => {
+                            logger.log('init', 'walletconnect transport peer connected', peer);
+                            this.analytics.track('event', 'DAppClient', 'WalletConnect Wallet connected', {
+                                peerName: peer.name
+                            });
+                            this.events
+                                .emit(events_1.BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.walletConnectTransport).catch(console.error);
+                            stopListening();
+                            resolve(octez_connect_types_1.TransportType.WALLETCONNECT);
+                        })
+                            .catch(console.error);
+                        octez_connect_transport_postmessage_1.PostMessageTransport.getAvailableExtensions()
+                            .then((extensions) => __awaiter(this, void 0, void 0, function* () {
+                            this.analytics.track('event', 'DAppClient', 'Extensions detected', { extensions });
+                        }))
+                            .catch((error) => {
+                            this._initPromise = undefined;
+                            console.error(error);
+                        });
+                        const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
+                            logger.log('init', 'ABORTED');
+                            this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'abort'));
+                            yield Promise.all([
+                                postMessageTransport.disconnect(),
+                                // p2pTransport.disconnect(), do not abort connection manually
+                                walletConnectTransport.disconnect()
+                            ]);
+                            this.postMessageTransport = this.walletConnectTransport = this.p2pTransport = undefined;
+                            this._activeAccount.isResolved() && this.clearActiveAccount();
+                            this._initPromise = undefined;
+                        });
+                        const serializer = new octez_connect_core_1.Serializer();
+                        const p2pPeerInfo = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                yield p2pTransport.connect();
+                            }
+                            catch (err) {
+                                logger.error(err);
+                                yield this.hideUI(['alert']); // hide pairing alert
+                                setTimeout(() => this.events.emit(events_1.BeaconEvent.GENERIC_ERROR, err.message), 1000);
+                                abortHandler();
+                                resolve('');
+                                return;
+                            }
+                            resolve(yield serializer.serialize(yield p2pTransport.getPairingRequestInfo()));
+                        }));
+                        const walletConnectPeerInfo = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                            resolve((yield walletConnectTransport.getPairingRequestInfo()).uri);
+                        }));
+                        const postmessagePeerInfo = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                            resolve(yield serializer.serialize(yield postMessageTransport.getPairingRequestInfo()));
+                        }));
+                        this.events
+                            .emit(events_1.BeaconEvent.PAIR_INIT, {
+                            p2pPeerInfo,
+                            postmessagePeerInfo,
+                            walletConnectPeerInfo,
+                            networkType: this.network.type,
+                            abortedHandler: abortHandler.bind(this),
+                            disclaimerText: this.disclaimerText,
+                            analytics: this.analytics,
+                            featuredWallets: this.featuredWallets,
+                            substratePairing
+                        })
+                            .catch((emitError) => console.warn(emitError));
+                    }
+                }
+            }));
+            return this._initPromise;
+        });
+    }
+    /**
+     * Returns the active account
+     */
+    getActiveAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._activeAccount.promise;
+        });
+    }
+    isInvalidState(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAccount = yield this._activeAccount.promise;
+            return !activeAccount
+                ? false
+                : (activeAccount === null || activeAccount === void 0 ? void 0 : activeAccount.address) !== (account === null || account === void 0 ? void 0 : account.address) && !this.isGetActiveAccountHandled;
+        });
+    }
+    resetInvalidState() {
+        return __awaiter(this, arguments, void 0, function* (emit = true) {
+            var _a, _b;
+            this.accountManager.removeAllAccounts();
+            this._activeAccount = octez_connect_utils_1.ExposedPromise.resolve(undefined);
+            this.storage.set(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT, undefined);
+            emit && this.events.emit(events_1.BeaconEvent.INVALID_ACTIVE_ACCOUNT_STATE);
+            !emit && this.hideUI(['alert']);
+            yield Promise.all([
+                (_a = this.postMessageTransport) === null || _a === void 0 ? void 0 : _a.disconnect(),
+                (_b = this.walletConnectTransport) === null || _b === void 0 ? void 0 : _b.disconnect()
+            ]);
+            this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+            yield this.setActivePeer(undefined);
+            yield this.setTransport(undefined);
+            this._initPromise = undefined;
+        });
+    }
+    /**
+     * Sets the active account
+     *
+     * @param account The account that will be set as the active account
+     */
+    setActiveAccount(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.isGetActiveAccountHandled) {
+                console.warn(`An active account has been received, but no active subscription was found for BeaconEvent.ACTIVE_ACCOUNT_SET.`);
+            }
+            if (account && this._activeAccount.isSettled() && (yield this.isInvalidState(account))) {
+                const tranport = yield this.transport;
+                if (tranport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport && tranport.wasDisconnectedByWallet()) {
+                    yield this.resetInvalidState();
+                    return;
+                }
+            }
+            // when I'm resetting the activeAccount
+            if (!account && this._activeAccount.isResolved() && (yield this.getActiveAccount())) {
+                const transport = yield this.transport;
+                const activeAccount = yield this.getActiveAccount();
+                if (!transport || !activeAccount) {
+                    return;
+                }
+                if (!this.debounceSetActiveAccount && transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport) {
+                    this.debounceSetActiveAccount = true;
+                    this._initPromise = undefined;
+                    this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+                    if (this.multiTabChannel.isLeader() || (0, octez_connect_ui_1.isMobileOS)(window)) {
+                        yield transport.disconnect();
+                        this.openRequestsOtherTabs.clear();
+                    }
+                    else {
+                        this.multiTabChannel.postMessage({
+                            type: 'DISCONNECT'
+                        });
+                    }
+                    Array.from(this.openRequests.entries())
+                        .filter(([id, _promise]) => id !== 'session_update')
+                        .forEach(([id, promise]) => {
+                        promise.reject({
+                            type: octez_connect_types_1.BeaconMessageType.Error,
+                            errorType: octez_connect_types_1.BeaconErrorType.ABORTED_ERROR,
+                            id,
+                            senderId: '',
+                            version: '2'
+                        });
+                    });
+                    this.openRequests.clear();
+                    this.debounceSetActiveAccount = false;
+                }
+            }
+            if (this._activeAccount.isSettled()) {
+                // If the promise has already been resolved we need to create a new one.
+                this._activeAccount = octez_connect_utils_1.ExposedPromise.resolve(account);
+            }
+            else {
+                this._activeAccount.resolve(account);
+            }
+            if (!this.isGetActiveAccountHandled && this._transport.isResolved()) {
+                const transport = yield this.transport;
+                if (transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport && transport.wasDisconnectedByWallet()) {
+                    yield this.resetInvalidState();
+                    return;
+                }
+            }
+            if (account) {
+                const origin = account.origin.type;
+                yield this.initInternalTransports();
+                // Select the transport that matches the active account
+                if (origin === octez_connect_types_1.Origin.EXTENSION) {
+                    yield this.setTransport(this.postMessageTransport);
+                }
+                else if (origin === octez_connect_types_1.Origin.P2P) {
+                    yield this.setTransport(this.p2pTransport);
+                }
+                else if (origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                    yield this.setTransport(this.walletConnectTransport);
+                    (_a = this.walletConnectTransport) === null || _a === void 0 ? void 0 : _a.forceUpdate('INIT');
+                }
+                if (this._transport.isResolved()) {
+                    const transport = yield this.transport;
+                    if (transport.connectionStatus === octez_connect_types_1.TransportStatus.NOT_CONNECTED) {
+                        yield transport.connect();
+                    }
+                }
+                const peer = yield this.getPeer(account);
+                yield this.setActivePeer(peer);
+            }
+            else {
+                yield this.setActivePeer(undefined);
+                yield this.setTransport(undefined);
+            }
+            yield this.storage.set(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT, account ? account.accountIdentifier : undefined);
+            yield this.events.emit(events_1.BeaconEvent.ACTIVE_ACCOUNT_SET, account);
+            return;
+        });
+    }
+    /**
+     * Clear the active account
+     */
+    clearActiveAccount() {
+        return this.setActiveAccount();
+    }
+    setColorMode(colorMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, octez_connect_ui_1.setColorMode)(colorMode);
+        });
+    }
+    getColorMode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, octez_connect_ui_1.getColorMode)();
+        });
+    }
+    /**
+     * @deprecated
+     *
+     * Use getOwnAppMetadata instead
+     */
+    getAppMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getOwnAppMetadata();
+        });
+    }
+    showPrepare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletInfo = yield (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.getWalletInfo();
+                }
+                catch (_a) {
+                    return undefined;
+                }
+            }))();
+            yield this.events.emit(events_1.BeaconEvent.SHOW_PREPARE, { walletInfo });
+        });
+    }
+    hideUI(elements) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.events.emit(events_1.BeaconEvent.HIDE_UI, elements);
+        });
+    }
+    tryToAppSwitch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, octez_connect_ui_1.isMobileOS)(window) || !this.enableAppSwitching) {
+                return;
+            }
+            const wallet = yield this.getWalletInfo();
+            if (wallet.type !== 'mobile' || !wallet.deeplink) {
+                return;
+            }
+            const link = (0, octez_connect_ui_1.isIOS)(window) ? wallet.deeplink : `${wallet.deeplink}wc?uri=`;
+            if (!(link === null || link === void 0 ? void 0 : link.length)) {
+                return;
+            }
+            window.location = link;
+        });
+    }
+    addQueryParam(paramName, paramValue) {
+        return paramName + '=' + paramValue;
+    }
+    buildPayload(action, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const wallet = yield this.storage.get(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET);
+            const transport = this._activeAccount.isResolved()
+                ? ((_b = (_a = (yield this.getActiveAccount())) === null || _a === void 0 ? void 0 : _a.origin.type) !== null && _b !== void 0 ? _b : 'UNKNOWN')
+                : 'UNKNOWN';
+            return {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    userId: this.userId,
+                    os: (0, octez_connect_ui_1.currentOS)(),
+                    walletName: (_c = wallet === null || wallet === void 0 ? void 0 : wallet.name) !== null && _c !== void 0 ? _c : 'init',
+                    walletType: (_d = wallet === null || wallet === void 0 ? void 0 : wallet.type) !== null && _d !== void 0 ? _d : 'init',
+                    sdkVersion: octez_connect_core_1.SDK_VERSION,
+                    transport,
+                    time: new Date(),
+                    action,
+                    status
+                })
+            };
+        });
+    }
+    updateMetricsStorage(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.beaconIDB.getAllKeys('metrics');
+            if (queue.length >= 1000) {
+                const key = queue.shift();
+                this.beaconIDB.delete(key.toString(), 'metrics');
+            }
+            this.beaconIDB.set(String(Date.now()), payload, 'metrics');
+        });
+    }
+    sendMetrics(uri, options, thenHandler, catchHandler) {
+        if (!this.enableMetrics && uri === 'performance-metrics/save') {
+            options && this.updateMetricsStorage(options.body);
+        }
+        if (!this.enableMetrics) {
+            return;
+        }
+        fetch(`${octez_connect_core_1.BACKEND_URL}/${uri}`, options)
+            .then((res) => thenHandler && thenHandler(res))
+            .catch((err) => {
+            console.warn('Network error encountered. Metrics sharing have been automatically disabled.');
+            logger.error(err.message);
+            this.enableMetrics = false; // in the event of a network error, stop sending metrics
+            catchHandler && catchHandler(err);
+        });
+    }
+    checkMakeRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isResolved = this._transport.isResolved();
+            const isWCInstance = isResolved && (yield this.transport) instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport;
+            yield this.multiTabChannel.init();
+            const isLeader = this.multiTabChannel.isLeader();
+            return !isResolved || !isWCInstance || isLeader || (0, octez_connect_ui_1.isMobileOS)(window);
+        });
+    }
+    /**
+     * Will remove the account from the local storage and set a new active account if necessary.
+     *
+     * @param accountIdentifier ID of the account
+     */
+    removeAccount(accountIdentifier) {
+        const _super = Object.create(null, {
+            removeAccount: { get: () => super.removeAccount }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const removeAccountResult = _super.removeAccount.call(this, accountIdentifier);
+            const activeAccount = yield this.getActiveAccount();
+            if (activeAccount && activeAccount.accountIdentifier === accountIdentifier) {
+                yield this.setActiveAccount(undefined);
+            }
+            return removeAccountResult;
+        });
+    }
+    /**
+     * Remove all accounts and set active account to undefined
+     */
+    removeAllAccounts() {
+        const _super = Object.create(null, {
+            removeAllAccounts: { get: () => super.removeAllAccounts }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.removeAllAccounts.call(this);
+            yield this.setActiveAccount(undefined);
+        });
+    }
+    /**
+     * Removes a peer and all the accounts that have been connected through that peer
+     *
+     * @param peer Peer to be removed
+     */
+    removePeer(peer_1) {
+        return __awaiter(this, arguments, void 0, function* (peer, sendDisconnectToPeer = false) {
+            const transport = yield this.transport;
+            const removePeerResult = transport.removePeer(peer);
+            yield this.removeAccountsForPeers([peer]);
+            if (sendDisconnectToPeer) {
+                yield this.sendDisconnectToPeer(peer, transport);
+            }
+            return removePeerResult;
+        });
+    }
+    /**
+     * Remove all peers and all accounts that have been connected through those peers
+     */
+    removeAllPeers() {
+        return __awaiter(this, arguments, void 0, function* (sendDisconnectToPeers = false) {
+            const transport = yield this.transport;
+            const peers = yield transport.getPeers();
+            const removePeerResult = transport.removeAllPeers();
+            yield this.removeAccountsForPeers(peers);
+            if (sendDisconnectToPeers) {
+                const disconnectPromises = peers.map((peer) => this.sendDisconnectToPeer(peer, transport));
+                yield Promise.all(disconnectPromises);
+            }
+            return removePeerResult;
+        });
+    }
+    /**
+     * Allows the user to subscribe to specific events that are fired in the SDK
+     *
+     * @param internalEvent The event to subscribe to
+     * @param eventCallback The callback that will be called when the event occurs
+     */
+    subscribeToEvent(internalEvent, eventCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (internalEvent === events_1.BeaconEvent.ACTIVE_ACCOUNT_SET) {
+                this.isGetActiveAccountHandled = true;
+            }
+            yield this.events.on(internalEvent, eventCallback);
+        });
+    }
+    /**
+     * Check if we have permissions to send the specific message type to the active account.
+     * If no active account is set, only permission requests are allowed.
+     *
+     * @param type The type of the message
+     */
+    checkPermissions(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ([
+                octez_connect_types_1.BeaconMessageType.PermissionRequest,
+                octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeRequest,
+                octez_connect_types_1.BeaconMessageType.SimulatedProofOfEventChallengeRequest
+            ].includes(type)) {
+                return true;
+            }
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount) {
+                throw yield this.sendInternalError('No active account set!');
+            }
+            const permissions = activeAccount.scopes;
+            switch (type) {
+                case octez_connect_types_1.BeaconMessageType.OperationRequest:
+                    return permissions.includes(octez_connect_types_1.PermissionScope.OPERATION_REQUEST);
+                case octez_connect_types_1.BeaconMessageType.SignPayloadRequest:
+                    return permissions.includes(octez_connect_types_1.PermissionScope.SIGN);
+                // TODO: ENCRYPTION
+                // case BeaconMessageType.EncryptPayloadRequest:
+                //   return permissions.includes(PermissionScope.ENCRYPT)
+                case octez_connect_types_1.BeaconMessageType.BroadcastRequest:
+                    return true;
+                default:
+                    return false;
+            }
+        });
+    }
+    sendNotification(title, message, payload, protocolIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount ||
+                (activeAccount &&
+                    !activeAccount.scopes.includes(octez_connect_types_1.PermissionScope.NOTIFICATION) &&
+                    !activeAccount.notification)) {
+                throw new Error('notification permissions not given');
+            }
+            if (!((_a = activeAccount.notification) === null || _a === void 0 ? void 0 : _a.token)) {
+                throw new Error('No AccessToken');
+            }
+            const url = (_b = activeAccount.notification) === null || _b === void 0 ? void 0 : _b.apiUrl;
+            if (!url) {
+                throw new Error('No Push URL set');
+            }
+            return this.sendNotificationWithAccessToken({
+                url,
+                recipient: activeAccount.address,
+                title,
+                body: message,
+                payload,
+                protocolIdentifier,
+                accessToken: (_c = activeAccount.notification) === null || _c === void 0 ? void 0 : _c.token
+            });
+        });
+    }
+    addBlockchain(chain) {
+        this.blockchains.set(chain.identifier, chain);
+        chain.getWalletLists().then((walletLists) => {
+            (0, octez_connect_ui_1.setDesktopList)(walletLists.desktopList);
+            (0, octez_connect_ui_1.setExtensionList)(walletLists.extensionList);
+            (0, octez_connect_ui_1.setWebList)(walletLists.webList);
+            (0, octez_connect_ui_1.setiOSList)(walletLists.iOSList);
+        });
+    }
+    removeBlockchain(chainIdentifier) {
+        this.blockchains.delete(chainIdentifier);
+    }
+    permissionRequest(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.log('permissionRequest', input);
+            const blockchain = this.blockchains.get(input.blockchainIdentifier);
+            if (!blockchain) {
+                throw new Error(`Blockchain "${input.blockchainIdentifier}" not supported by dAppClient`);
+            }
+            const request = Object.assign(Object.assign({}, input), { type: octez_connect_types_1.BeaconMessageType.PermissionRequest, blockchainData: Object.assign(Object.assign({}, input.blockchainData), { appMetadata: yield this.getOwnAppMetadata() }) });
+            logger.log('REQUESTION PERMIMISSION V3', 'xxx', request);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
+            const logId = `makeRequestV3 ${Date.now()}`;
+            logger.time(true, logId);
+            const { message: response, connectionInfo } = yield this.makeRequestV3(request).catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
+            logger.log('RESPONSE V3', response, connectionInfo);
+            const partialAccountInfos = yield blockchain.getAccountInfosFromPermissionResponse(response.message);
+            const accountInfo = {
+                accountIdentifier: partialAccountInfos[0].accountId,
+                senderId: response.senderId,
+                origin: {
+                    type: connectionInfo.origin,
+                    id: connectionInfo.id
+                },
+                address: partialAccountInfos[0].address, // Store all addresses
+                publicKey: partialAccountInfos[0].publicKey,
+                scopes: response.message.blockchainData.scopes,
+                connectedAt: new Date().getTime(),
+                chainData: response.message.blockchainData
+            };
+            yield this.accountManager.addAccount(accountInfo);
+            yield this.setActiveAccount(accountInfo);
+            yield blockchain.handleResponse({
+                request,
+                account: accountInfo,
+                output: response,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            yield this.notifySuccess(request, {
+                account: accountInfo,
+                output: {
+                    address: partialAccountInfos[0].address,
+                    network: { type: 'substrate' },
+                    scopes: []
+                },
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            // return output
+            return response.message;
+        });
+    }
+    request(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.log('request', input);
+            const blockchain = this.blockchains.get(input.blockchainIdentifier);
+            if (!blockchain) {
+                throw new Error(`Blockchain "${blockchain}" not supported by dAppClient`);
+            }
+            yield blockchain.validateRequest(input);
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount) {
+                throw yield this.sendInternalError('No active account!');
+            }
+            const request = Object.assign(Object.assign({}, input), { type: octez_connect_types_1.BeaconMessageType.BlockchainRequest, accountId: activeAccount.accountIdentifier });
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'start'));
+            const logId = `makeRequestV3 ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequestV3(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message: response, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
+            yield blockchain.handleResponse({
+                request,
+                account: activeAccount,
+                output: response,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            yield this.notifySuccess(request, {
+                walletInfo: yield this.getWalletInfo()
+            });
+            return response.message;
+        });
+    }
+    /**
+     * Send a permission request to the DApp. This should be done as the first step. The wallet will respond
+     * with an publicKey and permissions that were given. The account returned will be set as the "activeAccount"
+     * and will be used for the following requests.
+     *
+     * @param input The message details we need to prepare the PermissionRequest message.
+     */
+    requestPermissions(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (input === null || input === void 0 ? void 0 : input.network) {
+                throw new Error('[BEACON] the "network" property is no longer accepted in input. Please provide it when instantiating DAppClient.');
+            }
+            const request = {
+                appMetadata: yield this.getOwnAppMetadata(),
+                type: octez_connect_types_1.BeaconMessageType.PermissionRequest,
+                network: this.network,
+                scopes: input && input.scopes
+                    ? input.scopes
+                    : [octez_connect_types_1.PermissionScope.OPERATION_REQUEST, octez_connect_types_1.PermissionScope.SIGN]
+            };
+            this.analytics.track('event', 'DAppClient', 'Permission requested');
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest()) || !(yield this.getActiveAccount())
+                ? this.makeRequest(request, undefined, undefined)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'success'));
+            logger.log('requestPermissions', '######## MESSAGE #######');
+            logger.log('requestPermissions', message);
+            const accountInfo = yield this.onNewAccount(message, connectionInfo);
+            logger.log('requestPermissions', '######## ACCOUNT INFO #######');
+            logger.log('requestPermissions', JSON.stringify(accountInfo));
+            yield this.accountManager.addAccount(accountInfo);
+            const output = Object.assign(Object.assign({}, message), { walletKey: accountInfo.walletKey, address: accountInfo.address, accountInfo });
+            yield this.notifySuccess(request, {
+                account: accountInfo,
+                output,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            this.analytics.track('event', 'DAppClient', 'Permission received', {
+                address: accountInfo.address
+            });
+            return output;
+        });
+    }
+    /**
+     * Send a proof of event request to the wallet. The wallet will either accept or decline the challenge.
+     * If it is accepted, the challenge will be stored, meaning that even if the user refresh the page, the DAppClient will keep checking if the challenge has been fulfilled.
+     * Once the challenge is stored, a challenge stored message will be sent to the wallet.
+     * It's **highly recommended** to run a proof of event challenge to check the identity of an abstracted account
+     *
+     * @param input The message details we need to prepare the ProofOfEventChallenge message.
+     */
+    requestProofOfEventChallenge(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount)
+                throw new Error('Please request permissions before doing a proof of event challenge');
+            if (activeAccount.walletType !== 'abstracted_account' &&
+                activeAccount.verificationType !== 'proof_of_event')
+                throw new Error('This wallet is not an abstracted account and thus cannot perform proof of event');
+            const request = {
+                type: octez_connect_types_1.BeaconMessageType.ProofOfEventChallengeRequest,
+                contractAddress: activeAccount.address,
+                payload: input.payload
+            };
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'start'));
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequest(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
+            this.analytics.track('event', 'DAppClient', `Proof of event challenge ${message.isAccepted ? 'accepted' : 'refused'}`, { address: activeAccount.address });
+            yield this.notifySuccess(request, {
+                account: activeAccount,
+                output: message,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            return message;
+        });
+    }
+    /**
+     * Send a simulated proof of event request to the wallet. The wallet will either accept or decline the challenge.
+     * It's the same than `requestProofOfEventChallenge` but rather than executing operations on the blockchain to prove the identity,
+     * The wallet will return a list of operations that you'll be able to run on your side to verify the identity of the abstracted account
+     * It's **highly recommended** to run a proof of event challenge to check the identity of an abstracted account
+     *
+     * @param input The message details we need to prepare the SimulatedProofOfEventChallenge message.
+     */
+    requestSimulatedProofOfEventChallenge(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount)
+                throw new Error('Please request permissions before doing a proof of event challenge');
+            if (activeAccount.walletType !== 'abstracted_account' &&
+                activeAccount.verificationType !== 'proof_of_event') {
+                throw new Error('This wallet is not an abstracted account and thus cannot perform a simulated proof of event');
+            }
+            const request = Object.assign({ type: octez_connect_types_1.BeaconMessageType.SimulatedProofOfEventChallengeRequest, contractAddress: activeAccount.address }, input);
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequest(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.analytics.track('event', 'DAppClient', `Simulated proof of event challenge ${!message.errorMessage ? 'accepted' : 'refused'}`, { address: activeAccount.address });
+            yield this.notifySuccess(request, {
+                account: activeAccount,
+                output: message,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            return message;
+        });
+    }
+    /**
+     * This method will send a "SignPayloadRequest" to the wallet. This method is meant to be used to sign
+     * arbitrary data (eg. a string). It will return the signature in the format of "edsig..."
+     *
+     * @param input The message details we need to prepare the SignPayloadRequest message.
+     */
+    requestSignPayload(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!input.payload) {
+                throw yield this.sendInternalError('Payload must be provided');
+            }
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount) {
+                throw yield this.sendInternalError('No active account!');
+            }
+            const payload = input.payload;
+            if (typeof payload !== 'string') {
+                throw new Error('Payload must be a string');
+            }
+            const signingType = (() => {
+                switch (input.signingType) {
+                    case octez_connect_types_1.SigningType.OPERATION:
+                        if (!payload.startsWith('03')) {
+                            throw new Error('When using signing type "OPERATION", the payload must start with prefix "03"');
+                        }
+                        return octez_connect_types_1.SigningType.OPERATION;
+                    case octez_connect_types_1.SigningType.MICHELINE:
+                        if (!payload.startsWith('05')) {
+                            throw new Error('When using signing type "MICHELINE", the payload must start with prefix "05"');
+                        }
+                        return octez_connect_types_1.SigningType.MICHELINE;
+                    case octez_connect_types_1.SigningType.RAW:
+                    default:
+                        return octez_connect_types_1.SigningType.RAW;
+                }
+            })();
+            this.analytics.track('event', 'DAppClient', 'Signature requested');
+            const request = {
+                type: octez_connect_types_1.BeaconMessageType.SignPayloadRequest,
+                signingType,
+                payload,
+                sourceAddress: input.sourceAddress || activeAccount.address
+            };
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'start'));
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequest(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
+            yield this.notifySuccess(request, {
+                account: activeAccount,
+                output: message,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            this.analytics.track('event', 'DAppClient', 'Signature response');
+            return message;
+        });
+    }
+    /**
+     * This method will send an "EncryptPayloadRequest" to the wallet. This method is meant to be used to encrypt or decrypt
+     * arbitrary data (eg. a string). It will return the encrypted or decrypted payload
+     *
+     * @param input The message details we need to prepare the EncryptPayloadRequest message.
+     */
+    // TODO: ENCRYPTION
+    // public async requestEncryptPayload(
+    //   input: RequestEncryptPayloadInput
+    // ): Promise<EncryptPayloadResponseOutput> {
+    //   if (!input.payload) {
+    //     throw await this.sendInternalError('Payload must be provided')
+    //   }
+    //   const activeAccount: AccountInfo | undefined = await this.getActiveAccount()
+    //   if (!activeAccount) {
+    //     throw await this.sendInternalError('No active account!')
+    //   }
+    //   const payload = input.payload
+    //   if (typeof payload !== 'string') {
+    //     throw new Error('Payload must be a string')
+    //   }
+    //   if (typeof input.encryptionCryptoOperation === 'undefined') {
+    //     throw new Error('encryptionCryptoOperation must be defined')
+    //   }
+    //   if (typeof input.encryptionType === 'undefined') {
+    //     throw new Error('encryptionType must be defined')
+    //   }
+    //   const request: EncryptPayloadRequestInput = {
+    //     type: BeaconMessageType.EncryptPayloadRequest,
+    //     cryptoOperation: input.encryptionCryptoOperation,
+    //     encryptionType: input.encryptionType,
+    //     payload,
+    //     sourceAddress: input.sourceAddress || activeAccount.address
+    //   }
+    //   const { message, connectionInfo } = await this.makeRequest<
+    //     EncryptPayloadRequest,
+    //     EncryptPayloadResponse
+    //   >(request).catch(async (requestError: ErrorResponse) => {
+    //     throw await this.handleRequestError(request, requestError)
+    //   })
+    //   await this.notifySuccess(request, {
+    //     account: activeAccount,
+    //     output: message,
+    //     connectionContext: connectionInfo,
+    //     walletInfo: await this.getWalletInfo()
+    //   })
+    //   return message
+    // }
+    /**
+     * This method sends an OperationRequest to the wallet. This method should be used for all kinds of operations,
+     * eg. transaction or delegation. Not all properties have to be provided. Data like "counter" and fees will be
+     * fetched and calculated by the wallet (but they can still be provided if required).
+     *
+     * @param input The message details we need to prepare the OperationRequest message.
+     */
+    requestOperation(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!input.operationDetails) {
+                throw yield this.sendInternalError('Operation details must be provided');
+            }
+            const activeAccount = yield this.getActiveAccount();
+            if (!activeAccount) {
+                throw yield this.sendInternalError('No active account!');
+            }
+            const request = {
+                type: octez_connect_types_1.BeaconMessageType.OperationRequest,
+                network: activeAccount.network || this.network,
+                operationDetails: input.operationDetails,
+                sourceAddress: activeAccount.address || ''
+            };
+            this.analytics.track('event', 'DAppClient', 'Operation requested');
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'start'));
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequest(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
+            yield this.notifySuccess(request, {
+                account: activeAccount,
+                output: message,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            this.analytics.track('event', 'DAppClient', 'Operation response');
+            return message;
+        });
+    }
+    /**
+     * Sends a "BroadcastRequest" to the wallet. This method can be used to inject an already signed transaction
+     * to the network.
+     *
+     * @param input The message details we need to prepare the BroadcastRequest message.
+     */
+    requestBroadcast(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!input.signedTransaction) {
+                throw yield this.sendInternalError('Signed transaction must be provided');
+            }
+            // Add error message for deprecation of network
+            // TODO: Remove when we remove deprecated preferredNetwork
+            if (input.network !== undefined && this.network.type !== ((_a = input.network) === null || _a === void 0 ? void 0 : _a.type)) {
+                console.error('[BEACON] The network specified in the DAppClient constructor does not match the network set in the broadcast request. Please set the network in the constructor. Setting it during the Broadcast Request is deprecated.');
+            }
+            const request = {
+                type: octez_connect_types_1.BeaconMessageType.BroadcastRequest,
+                network: this.network,
+                signedTransaction: input.signedTransaction
+            };
+            this.analytics.track('event', 'DAppClient', 'Broadcast requested');
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'start'));
+            const logId = `makeRequest ${Date.now()}`;
+            logger.time(true, logId);
+            const res = (yield this.checkMakeRequest())
+                ? this.makeRequest(request)
+                : this.makeRequestBC(request);
+            res.catch((requestError) => __awaiter(this, void 0, void 0, function* () {
+                requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+                    ? this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'))
+                    : this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+                logger.time(false, logId);
+                throw yield this.handleRequestError(request, requestError);
+            }));
+            const { message, connectionInfo } = (yield res);
+            logger.time(false, logId);
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
+            yield this.notifySuccess(request, {
+                network: this.network,
+                output: message,
+                blockExplorer: this.blockExplorer,
+                connectionContext: connectionInfo,
+                walletInfo: yield this.getWalletInfo()
+            });
+            this.analytics.track('event', 'DAppClient', 'Broadcast response');
+            return message;
+        });
+    }
+    setActivePeer(peer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._activePeer.isSettled()) {
+                // If the promise has already been resolved we need to create a new one.
+                this._activePeer = octez_connect_utils_1.ExposedPromise.resolve(peer);
+            }
+            else {
+                this._activePeer.resolve(peer);
+            }
+            if (!peer) {
+                return;
+            }
+            yield this.initInternalTransports();
+            if (peer.type === 'postmessage-pairing-response') {
+                yield this.setTransport(this.postMessageTransport);
+            }
+            else if (peer.type === 'p2p-pairing-response') {
+                yield this.setTransport(this.p2pTransport);
+            }
+        });
+    }
+    /**
+     * A "setter" for when the transport needs to be changed.
+     */
+    setTransport(transport) {
+        const _super = Object.create(null, {
+            setTransport: { get: () => super.setTransport }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!transport) {
+                this._initPromise = undefined;
+            }
+            const result = _super.setTransport.call(this, transport);
+            const event = transport ? Object.assign({}, transport) : undefined;
+            // remove keyPair, to prevent dApps from accidentaly leaking the privateKey
+            if (event) {
+                event.client = Object.assign(Object.assign({}, event.client), { keyPair: undefined });
+            }
+            yield this.events.emit(events_1.BeaconEvent.ACTIVE_TRANSPORT_SET, event);
+            return result;
+        });
+    }
+    /**
+     * This method will emit an internal error message.
+     *
+     * @param errorMessage The error message to send.
+     */
+    sendInternalError(errorMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.events.emit(events_1.BeaconEvent.INTERNAL_ERROR, { text: errorMessage });
+            throw new Error(errorMessage);
+        });
+    }
+    /**
+     * This method will remove all accounts associated with a specific peer.
+     *
+     * @param peersToRemove An array of peers for which accounts should be removed
+     */
+    removeAccountsForPeers(peersToRemove) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const peerIdsToRemove = peersToRemove.map((peer) => peer.senderId);
+            return this.removeAccountsForPeerIds(peerIdsToRemove);
+        });
+    }
+    removeAccountsForPeerIds(peerIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.accountManager.getAccounts();
+            // Remove all accounts with origin of the specified peer
+            const accountsToRemove = accounts.filter((account) => peerIds.includes(account.senderId));
+            const accountIdentifiersToRemove = accountsToRemove.map((accountInfo) => accountInfo.accountIdentifier);
+            yield this.accountManager.removeAccounts(accountIdentifiersToRemove);
+            // Check if one of the accounts that was removed was the active account and if yes, set it to undefined
+            const activeAccount = yield this.getActiveAccount();
+            if (activeAccount) {
+                if (accountIdentifiersToRemove.includes(activeAccount.accountIdentifier)) {
+                    yield this.setActiveAccount(undefined);
+                }
+            }
+        });
+    }
+    /**
+     * This message handles errors that we receive from the wallet.
+     *
+     * @param request The request we sent
+     * @param beaconError The error we received
+     */
+    handleRequestError(request, beaconError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.error('handleRequestError', 'error response', beaconError);
+            if (beaconError.errorType) {
+                const buttons = [];
+                if (beaconError.errorType === octez_connect_types_1.BeaconErrorType.NO_PRIVATE_KEY_FOUND_ERROR) {
+                    const actionCallback = () => __awaiter(this, void 0, void 0, function* () {
+                        const operationRequest = request;
+                        // if the account we requested is not available, we remove it locally
+                        let accountInfo;
+                        if (operationRequest.sourceAddress && operationRequest.network) {
+                            const accountIdentifier = yield (0, octez_connect_core_1.getAccountIdentifier)(operationRequest.sourceAddress, operationRequest.network);
+                            accountInfo = yield this.getAccount(accountIdentifier);
+                            if (accountInfo) {
+                                yield this.removeAccount(accountInfo.accountIdentifier);
+                            }
+                        }
+                    });
+                    buttons.push({ text: 'Remove account', actionCallback });
+                }
+                const peer = yield this.getPeer();
+                const activeAccount = yield this.getActiveAccount();
+                // If we sent a permission request, received an error and there is no active account, we need to reset the DAppClient.
+                // This most likely means that the user rejected the first permission request after pairing a wallet, so we "forget" the paired wallet to allow the user to pair again.
+                if (request.type === octez_connect_types_1.BeaconMessageType.PermissionRequest &&
+                    (yield this.getActiveAccount()) === undefined) {
+                    this._initPromise = undefined;
+                    this.postMessageTransport = undefined;
+                    this.p2pTransport = undefined;
+                    this.walletConnectTransport = undefined;
+                    yield this.setTransport();
+                    yield this.setActivePeer();
+                }
+                this.events
+                    .emit(beacon_message_events_1.messageEvents[request.type].error, {
+                    errorResponse: beaconError,
+                    walletInfo: yield this.getWalletInfo(peer, activeAccount),
+                    errorMessages: this.errorMessages
+                }, buttons)
+                    .catch((emitError) => logger.error('handleRequestError', emitError));
+                throw (0, octez_connect_core_1.getError)(beaconError.errorType, beaconError.errorData);
+            }
+            throw beaconError;
+        });
+    }
+    /**
+     * This message will send an event when we receive a successful response to one of the requests we sent.
+     *
+     * @param request The request we sent
+     * @param response The response we received
+     */
+    notifySuccess(request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.events
+                .emit(beacon_message_events_1.messageEvents[request.type].success, response)
+                .catch((emitError) => console.warn(emitError));
+        });
+    }
+    getWalletInfoFromStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.storage.get(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET);
+        });
+    }
+    updateStorageWallet(walletInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const wallet = yield this.storage.get(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET);
+            if (!wallet) {
+                return;
+            }
+            wallet.name = walletInfo.name;
+            wallet.icon = (_a = walletInfo.icon) !== null && _a !== void 0 ? _a : wallet.icon;
+            this.storage.set(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET, wallet);
+        });
+    }
+    getWalletInfo(peer_1, account_1) {
+        return __awaiter(this, arguments, void 0, function* (peer, account, readFromStorage = true) {
+            var _a, _b, _c, _d, _e, _f;
+            const selectedAccount = account ? account : yield this.getActiveAccount();
+            const selectedPeer = peer ? peer : yield this.getPeer(selectedAccount);
+            let walletInfo;
+            if (selectedAccount) {
+                walletInfo = yield this.appMetadataManager.getAppMetadata(selectedAccount.senderId);
+            }
+            let storageWallet;
+            if (readFromStorage) {
+                storageWallet = yield this.getWalletInfoFromStorage();
+            }
+            if (!walletInfo) {
+                walletInfo = {
+                    name: (_b = (_a = selectedPeer === null || selectedPeer === void 0 ? void 0 : selectedPeer.name) !== null && _a !== void 0 ? _a : storageWallet === null || storageWallet === void 0 ? void 0 : storageWallet.key) !== null && _b !== void 0 ? _b : '',
+                    icon: (_c = selectedPeer === null || selectedPeer === void 0 ? void 0 : selectedPeer.icon) !== null && _c !== void 0 ? _c : storageWallet === null || storageWallet === void 0 ? void 0 : storageWallet.icon,
+                    type: storageWallet === null || storageWallet === void 0 ? void 0 : storageWallet.type
+                };
+                this.updateStorageWallet(walletInfo);
+            }
+            const lowerCaseCompare = (str1, str2) => {
+                if (str1 && str2) {
+                    return str1.toLowerCase() === str2.toLowerCase();
+                }
+                return false;
+            };
+            const getOrgName = (name) => name.split(/[_\s]+/)[0];
+            const apps = [
+                ...(0, octez_connect_ui_1.getiOSList)(),
+                ...(0, octez_connect_ui_1.getWebList)(),
+                ...(0, octez_connect_ui_1.getDesktopList)(),
+                ...(0, octez_connect_ui_1.getExtensionList)()
+            ].filter((app) => { var _a; return lowerCaseCompare(getOrgName(app.key), getOrgName((_a = walletInfo === null || walletInfo === void 0 ? void 0 : walletInfo.name) !== null && _a !== void 0 ? _a : 'wallet')); });
+            // TODO: Remove once all wallets send the icon?
+            const mobile = apps.find((app) => app.universalLink || app.key.includes('ios') || app.key.includes('mobile'));
+            const browser = apps.find((app) => app.links);
+            const desktop = apps.find((app) => app.downloadLink);
+            const extension = apps.find((app) => app.id);
+            const appTypeMap = {
+                extension: { app: extension, type: 'extension' },
+                desktop: { app: desktop, type: 'desktop' },
+                mobile: { app: mobile, type: 'mobile' },
+                web: { app: browser, type: 'web' }
+            };
+            const defaultType = () => {
+                if ((0, octez_connect_ui_1.isBrowser)(window) && browser)
+                    return { app: browser, type: 'web' };
+                if ((0, octez_connect_ui_1.isDesktop)(window) && desktop)
+                    return { app: desktop, type: 'desktop' };
+                if ((0, octez_connect_ui_1.isBrowser)(window) && extension)
+                    return { app: extension, type: 'extension' };
+                if (mobile)
+                    return { app: mobile, type: 'mobile' };
+                return { app: undefined, type: undefined };
+            };
+            const { app, type } = storageWallet ? appTypeMap[storageWallet.type] : defaultType();
+            if (app) {
+                let deeplink;
+                if (app.hasOwnProperty('links')) {
+                    deeplink = app.links[(_d = selectedAccount === null || selectedAccount === void 0 ? void 0 : selectedAccount.network.type) !== null && _d !== void 0 ? _d : this.network.type];
+                }
+                else if (app.hasOwnProperty('deepLink')) {
+                    deeplink = app.deepLink;
+                }
+                return {
+                    name: (_e = app === null || app === void 0 ? void 0 : app.name) !== null && _e !== void 0 ? _e : walletInfo.name,
+                    icon: (_f = app === null || app === void 0 ? void 0 : app.logo) !== null && _f !== void 0 ? _f : walletInfo.icon,
+                    deeplink,
+                    type: type
+                };
+            }
+            return walletInfo;
+        });
+    }
+    getPeer(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            let peer;
+            if (account) {
+                logger.log('getPeer', 'We have an account', account);
+                const postMessagePeers = (_b = (yield ((_a = this.postMessageTransport) === null || _a === void 0 ? void 0 : _a.getPeers()))) !== null && _b !== void 0 ? _b : [];
+                const p2pPeers = (_d = (yield ((_c = this.p2pTransport) === null || _c === void 0 ? void 0 : _c.getPeers()))) !== null && _d !== void 0 ? _d : [];
+                const walletConnectPeers = (_f = (yield ((_e = this.walletConnectTransport) === null || _e === void 0 ? void 0 : _e.getPeers()))) !== null && _f !== void 0 ? _f : [];
+                const peers = [...postMessagePeers, ...p2pPeers, ...walletConnectPeers];
+                logger.log('getPeer', 'Found peers', peers, account);
+                peer = peers.find((peerEl) => peerEl.senderId === account.senderId);
+                if (!peer) {
+                    // We could not find an exact match for a sender, so we most likely received it over a relay
+                    peer = peers.find((peerEl) => peerEl.id === account.origin.id);
+                }
+            }
+            else {
+                peer = yield this._activePeer.promise;
+                logger.log('getPeer', 'Active peer', peer);
+            }
+            return peer;
+        });
+    }
+    makeRequest(requestInput, skipResponse, otherTabMessageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const messageId = otherTabMessageId !== null && otherTabMessageId !== void 0 ? otherTabMessageId : (yield (0, octez_connect_utils_1.generateGUID)());
+            if (this._initPromise && this.isInitPending) {
+                yield Promise.all([
+                    (_a = this.postMessageTransport) === null || _a === void 0 ? void 0 : _a.disconnect(),
+                    (_b = this.walletConnectTransport) === null || _b === void 0 ? void 0 : _b.disconnect()
+                ]);
+                this._initPromise = undefined;
+                this.hideUI(['toast']);
+            }
+            logger.log('makeRequest', 'starting');
+            this.isInitPending = true;
+            yield this.init();
+            this.isInitPending = false;
+            logger.log('makeRequest', 'after init');
+            if (yield this.addRequestAndCheckIfRateLimited()) {
+                this.events
+                    .emit(events_1.BeaconEvent.LOCAL_RATE_LIMIT_REACHED)
+                    .catch((emitError) => console.warn(emitError));
+                throw new Error('rate limit reached');
+            }
+            if (!(yield this.checkPermissions(requestInput.type))) {
+                this.events.emit(events_1.BeaconEvent.NO_PERMISSIONS).catch((emitError) => console.warn(emitError));
+                throw new Error('No permissions to send this request to wallet!');
+            }
+            if (!this.beaconId) {
+                throw yield this.sendInternalError('octez.connect ID not defined');
+            }
+            const request = Object.assign({ id: messageId, version: '2', senderId: yield (0, octez_connect_core_1.getSenderId)(yield this.beaconId) }, requestInput);
+            let exposed;
+            if (!skipResponse) {
+                exposed = new octez_connect_utils_1.ExposedPromise();
+                this.addOpenRequest(request.id, exposed);
+            }
+            const payload = yield new octez_connect_core_1.Serializer().serialize(request);
+            const account = yield this.getActiveAccount();
+            const peer = yield this.getPeer(account);
+            const walletInfo = yield this.getWalletInfo(peer, account);
+            logger.log('makeRequest', 'sending message', request);
+            try {
+                ;
+                (yield this.transport).send(payload, peer);
+                if (request.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
+                    (this._activeAccount.isResolved() && (yield this._activeAccount.promise))) {
+                    this.tryToAppSwitch();
+                }
+            }
+            catch (sendError) {
+                this.events.emit(events_1.BeaconEvent.INTERNAL_ERROR, {
+                    text: 'Unable to send message. If this problem persists, please reset the connection and pair your wallet again.',
+                    buttons: [
+                        {
+                            text: 'Reset Connection',
+                            actionCallback: () => __awaiter(this, void 0, void 0, function* () {
+                                (0, octez_connect_ui_1.closeToast)();
+                                this.disconnect();
+                            })
+                        }
+                    ]
+                });
+                throw sendError;
+            }
+            if (!otherTabMessageId) {
+                this.events
+                    .emit(beacon_message_events_1.messageEvents[requestInput.type].sent, {
+                    walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_c = walletInfo.name) !== null && _c !== void 0 ? _c : 'Wallet' }),
+                    extraInfo: {
+                        resetCallback: () => __awaiter(this, void 0, void 0, function* () {
+                            this.disconnect();
+                        })
+                    }
+                })
+                    .catch((emitError) => console.warn(emitError));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return exposed === null || exposed === void 0 ? void 0 : exposed.promise; // TODO: fix type
+        });
+    }
+    /**
+     * This method handles sending of requests to the DApp. It makes sure that the DAppClient is initialized and connected
+     * to the transport. After that rate limits and permissions will be checked, an ID is attached and the request is sent
+     * to the DApp over the transport.
+     *
+     * @param requestInput The BeaconMessage to be sent to the wallet
+     * @param account The account that the message will be sent to
+     */
+    makeRequestV3(requestInput, otherTabMessageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (this._initPromise && this.isInitPending) {
+                yield Promise.all([
+                    (_a = this.postMessageTransport) === null || _a === void 0 ? void 0 : _a.disconnect(),
+                    (_b = this.walletConnectTransport) === null || _b === void 0 ? void 0 : _b.disconnect()
+                ]);
+                this._initPromise = undefined;
+                this.hideUI(['toast']);
+            }
+            const messageId = otherTabMessageId !== null && otherTabMessageId !== void 0 ? otherTabMessageId : (yield (0, octez_connect_utils_1.generateGUID)());
+            logger.log('makeRequest', 'starting');
+            this.isInitPending = true;
+            yield this.init(undefined, true);
+            this.isInitPending = false;
+            logger.log('makeRequest', 'after init');
+            if (yield this.addRequestAndCheckIfRateLimited()) {
+                this.events
+                    .emit(events_1.BeaconEvent.LOCAL_RATE_LIMIT_REACHED)
+                    .catch((emitError) => console.warn(emitError));
+                throw new Error('rate limit reached');
+            }
+            if (!this.beaconId) {
+                throw yield this.sendInternalError('octez.connect ID not defined');
+            }
+            const request = {
+                id: messageId,
+                version: '3',
+                senderId: yield (0, octez_connect_core_1.getSenderId)(yield this.beaconId),
+                message: requestInput
+            };
+            const exposed = new octez_connect_utils_1.ExposedPromise();
+            this.addOpenRequest(request.id, exposed);
+            const payload = yield new octez_connect_core_1.Serializer().serialize(request);
+            const account = yield this.getActiveAccount();
+            const peer = yield this.getPeer(account);
+            const walletInfo = yield this.getWalletInfo(peer, account);
+            logger.log('makeRequest', 'sending message', request);
+            try {
+                ;
+                (yield this.transport).send(payload, peer);
+                if (request.message.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
+                    (this._activeAccount.isResolved() && (yield this._activeAccount.promise))) {
+                    this.tryToAppSwitch();
+                }
+            }
+            catch (sendError) {
+                this.events.emit(events_1.BeaconEvent.INTERNAL_ERROR, {
+                    text: 'Unable to send message. If this problem persists, please reset the connection and pair your wallet again.',
+                    buttons: [
+                        {
+                            text: 'Reset Connection',
+                            actionCallback: () => __awaiter(this, void 0, void 0, function* () {
+                                (0, octez_connect_ui_1.closeToast)();
+                                this.disconnect();
+                            })
+                        }
+                    ]
+                });
+                throw sendError;
+            }
+            const index = requestInput.type;
+            this.events
+                .emit(beacon_message_events_1.messageEvents[index].sent, {
+                walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_c = walletInfo.name) !== null && _c !== void 0 ? _c : 'Wallet' }),
+                extraInfo: {
+                    resetCallback: () => __awaiter(this, void 0, void 0, function* () {
+                        this.disconnect();
+                    })
+                }
+            })
+                .catch((emitError) => console.warn(emitError));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return exposed.promise; // TODO: fix type
+        });
+    }
+    makeRequestBC(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._transport.isResolved()) {
+                return;
+            }
+            const transport = yield this.transport;
+            if (transport.type !== octez_connect_types_1.TransportType.WALLETCONNECT) {
+                return;
+            }
+            if (yield this.addRequestAndCheckIfRateLimited()) {
+                this.events
+                    .emit(events_1.BeaconEvent.LOCAL_RATE_LIMIT_REACHED)
+                    .catch((emitError) => console.warn(emitError));
+                throw new Error('rate limit reached');
+            }
+            const id = yield (0, octez_connect_utils_1.generateGUID)();
+            this.multiTabChannel.postMessage({
+                type: request.type,
+                data: request,
+                id
+            });
+            if (request.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
+                (this._activeAccount.isResolved() && (yield this._activeAccount.promise))) {
+                this.tryToAppSwitch();
+            }
+            this.events
+                .emit(beacon_message_events_1.messageEvents[octez_connect_types_1.BeaconMessageType.PermissionRequest].sent, {
+                walletInfo: yield this.getWalletInfo(),
+                extraInfo: {
+                    resetCallback: () => this.disconnect()
+                }
+            })
+                .catch((emitError) => console.warn(emitError));
+            const exposed = new octez_connect_utils_1.ExposedPromise();
+            this.addOpenRequest(id, exposed);
+            return exposed.promise;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._transport.isResolved()) {
+                throw new Error('No transport available.');
+            }
+            const transport = yield this.transport;
+            if (transport.connectionStatus === octez_connect_types_1.TransportStatus.NOT_CONNECTED) {
+                throw new Error('Not connected.');
+            }
+            yield this.createStateSnapshot();
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('disconnect', 'start'));
+            yield this.clearActiveAccount();
+            if (!(transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport)) {
+                yield transport.disconnect();
+            }
+            this.postMessageTransport = undefined;
+            this.p2pTransport = undefined;
+            this.walletConnectTransport = undefined;
+            this.sendMetrics('performance-metrics/save', yield this.buildPayload('disconnect', 'success'));
+        });
+    }
+    /**
+     * Adds a requests to the "openRequests" set so we know what messages have already been answered/handled.
+     *
+     * @param id The ID of the message
+     * @param promise A promise that resolves once the response for that specific message is received
+     */
+    addOpenRequest(id, promise) {
+        logger.log('addOpenRequest', this.name, `adding request ${id} and waiting for answer`);
+        this.openRequests.set(id, promise);
+    }
+    sendNotificationWithAccessToken(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, recipient, title, body, payload, protocolIdentifier, accessToken } = notification;
+            const timestamp = new Date().toISOString();
+            const keypair = yield this.keyPair;
+            const rawPublicKey = keypair.publicKey;
+            const prefix = Buffer.from(new Uint8Array([13, 15, 37, 217]));
+            const publicKey = bs58check_1.default.encode(Buffer.concat([prefix, Buffer.from(rawPublicKey)]));
+            const constructedString = [
+                'Tezos Signed Message: ',
+                recipient,
+                title,
+                body,
+                timestamp,
+                payload
+            ].join(' ');
+            const bytes = (0, octez_connect_utils_1.toHex)(constructedString);
+            const payloadBytes = '05' + '01' + bytes.length.toString(16).padStart(8, '0') + bytes;
+            const signature = yield (0, octez_connect_utils_1.signMessage)(payloadBytes, {
+                secretKey: Buffer.from(keypair.secretKey)
+            });
+            const notificationResponse = yield axios_1.default.post(`${url}/send`, {
+                recipient,
+                title,
+                body,
+                timestamp,
+                payload,
+                accessToken,
+                protocolIdentifier,
+                sender: {
+                    name: this.name,
+                    publicKey,
+                    signature
+                }
+            });
+            return notificationResponse.data;
+        });
+    }
+    onNewAccount(message, connectionInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            // TODO: Migration code. Remove sometime after 1.0.0 release.
+            const tempPK = message.publicKey || message.pubkey || message.pubKey;
+            const publicKey = !!tempPK ? (0, octez_connect_utils_1.prefixPublicKey)(tempPK) : undefined;
+            if (!publicKey && !message.address) {
+                throw new Error('PublicKey or Address must be defined');
+            }
+            const address = (_a = message.address) !== null && _a !== void 0 ? _a : (yield (0, octez_connect_utils_1.getAddressFromPublicKey)(publicKey));
+            if (!(0, octez_connect_utils_1.isValidAddress)(address)) {
+                throw new Error(`Invalid address: "${address}"`);
+            }
+            if (message.walletType === 'abstracted_account' &&
+                address.substring(0, 3) !== octez_connect_utils_1.CONTRACT_PREFIX) {
+                throw new Error(`Invalid abstracted account address "${address}", it should be a ${octez_connect_utils_1.CONTRACT_PREFIX} address`);
+            }
+            logger.log('######## MESSAGE #######');
+            logger.log('onNewAccount', message);
+            const walletKey = (_b = (yield this.storage.get(octez_connect_types_1.StorageKey.LAST_SELECTED_WALLET))) === null || _b === void 0 ? void 0 : _b.key;
+            const accountInfo = Object.assign({ accountIdentifier: yield (0, octez_connect_core_1.getAccountIdentifier)(address, message.network), senderId: message.senderId, origin: {
+                    type: connectionInfo.origin,
+                    id: connectionInfo.id
+                }, walletKey,
+                address,
+                publicKey, network: message.network, scopes: message.scopes, threshold: message.threshold, notification: message.notification, connectedAt: new Date().getTime(), walletType: (_c = message.walletType) !== null && _c !== void 0 ? _c : 'implicit', verificationType: message.verificationType }, (message.verificationType === 'proof_of_event' ? { hasVerifiedChallenge: false } : {}));
+            logger.log('accountInfo', '######## ACCOUNT INFO #######');
+            logger.log('accountInfo', accountInfo);
+            yield this.accountManager.addAccount(accountInfo);
+            yield this.setActiveAccount(accountInfo);
+            return accountInfo;
+        });
+    }
+}
+exports.DAppClient = DAppClient;
+//# sourceMappingURL=DAppClient.js.map