@tezos-x/octez.connect-dapp 4.8.4 → 4.8.6

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

@@ -24,6 +24,23 @@ const octez_connect_transport_postmessage_1 = require("@tezos-x/octez.connect-tr
 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');
+const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
+const SESSION_UPDATE_REQUEST_ID = 'session_update';
+const createLazyPromise = (factory) => {
+    let promise;
+    const getPromise = () => {
+        if (!promise) {
+            promise = factory();
+        }
+        return promise;
+    };
+    const lazyPromise = {
+        then: (onfulfilled, onrejected) => getPromise().then(onfulfilled, onrejected),
+        catch: (onrejected) => getPromise().catch(onrejected),
+        finally: (onfinally) => getPromise().finally(onfinally !== null && onfinally !== void 0 ? onfinally : undefined)
+    };
+    return lazyPromise;
+};
 /**
  * @publicapi
  *
@@ -34,7 +51,7 @@ const logger = new octez_connect_core_1.Logger('DAppClient');
  */
 class DAppClient extends octez_connect_core_1.Client {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         super(Object.assign({ storage: config && config.storage ? config.storage : new octez_connect_core_1.LocalStorage() }, config));
         this.events = new events_1.BeaconEventHandler();
         this.isGetActiveAccountHandled = false;
@@ -43,6 +60,8 @@ class DAppClient extends octez_connect_core_1.Client {
          * 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();
+        this.acknowledgedRequests = new Set();
+        this.openRequestTimeouts = 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
@@ -52,44 +71,59 @@ class DAppClient extends octez_connect_core_1.Client {
          * 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.destroyed = false;
         this.beaconIDB = new octez_connect_core_1.IndexedDBStorage('beacon', ['bug_report', 'metrics']);
         this.debounceSetActiveAccount = false;
+        // Constructor-time invalid storage recovery can race through multiple async paths.
+        // Keep this guard scoped to those startup paths.
+        this.hasEmittedInvalidAccountDeactivated = false;
+        this._disconnectNotifyPeers = 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.disableWalletConnect = (_a = config.disableWalletConnect) !== null && _a !== void 0 ? _a : false;
+        if (!this.disableWalletConnect) {
+            this.wcProjectId = ((_b = config.walletConnectOptions) === null || _b === void 0 ? void 0 : _b.projectId) || '24469fd0a06df227b6e5f7dc7de0ff4f';
+            this.wcRelayUrl = (_c = config.walletConnectOptions) === null || _c === void 0 ? void 0 : _c.relayUrl;
+        }
         this.featuredWallets = config.featuredWallets;
-        this.events = new events_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.events = new events_1.BeaconEventHandler(config.eventHandlers, (_d = config.disableDefaultEvents) !== null && _d !== void 0 ? _d : false);
+        this.blockExplorer = (_e = config.blockExplorer) !== null && _e !== void 0 ? _e : new tzkt_blockexplorer_1.TzktBlockExplorer();
+        this.network = (_f = config.network) !== null && _f !== void 0 ? _f : { type: (_g = config.preferredNetwork) !== null && _g !== void 0 ? _g : octez_connect_types_1.NetworkType.MAINNET };
+        (0, octez_connect_ui_1.setColorMode)((_h = config.colorMode) !== null && _h !== void 0 ? _h : octez_connect_types_1.ColorMode.LIGHT);
         this.disclaimerText = config.disclaimerText;
-        this.errorMessages = (_h = config.errorMessages) !== null && _h !== void 0 ? _h : {};
+        this.errorMessages = (_j = config.errorMessages) !== null && _j !== void 0 ? _j : {};
         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;
+        this.requestTimeoutMs = (_k = config.requestTimeoutMs) !== null && _k !== void 0 ? _k : DEFAULT_REQUEST_TIMEOUT_MS;
         // 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.oldValue === event.newValue) {
+                return;
+            }
             if (event.eventType === 'storageCleared') {
-                this.setActiveAccount(undefined);
+                yield 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);
+                        yield this.setActiveAccount(undefined);
                     }
                     else {
                         const account = yield this.getAccount(accountIdentifier);
-                        this.setActiveAccount(account);
+                        yield this.setActiveAccount(account);
                     }
                     return;
                 }
+                if (event.key === this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.ACCOUNTS)) {
+                    yield this.recoverActiveAccountFromAccountsChange();
+                    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;
@@ -105,31 +139,43 @@ class DAppClient extends octez_connect_core_1.Client {
         this.activeAccountLoaded = this.storage
             .get(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT)
             .then((activeAccountIdentifier) => __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.accountManager.getAccounts();
+            if (activeAccountIdentifier === 'undefined') {
+                // Non-normalizing storage backends can still surface legacy sentinel strings directly.
+                yield this.deactivateInvalidAccountState('missing_active_account');
+                return undefined;
+            }
             if (activeAccountIdentifier) {
-                const account = yield this.accountManager.getAccount(activeAccountIdentifier);
+                const account = accounts.find((storedAccount) => storedAccount.accountIdentifier === activeAccountIdentifier);
+                if (!account) {
+                    yield this.deactivateInvalidAccountState('missing_active_account');
+                    return undefined;
+                }
                 yield this.setActiveAccount(account);
                 return account;
             }
-            else {
-                yield this.setActiveAccount(undefined);
+            if (accounts.length > 0 && this.hasStoredActiveAccountPointer()) {
+                yield this.deactivateInvalidAccountState('missing_active_account');
                 return undefined;
             }
+            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);
+            yield this.deactivateInvalidAccountState('invalid_active_account_storage');
             return undefined;
         }));
         this.handleResponse = (message, connectionInfo) => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const typedMessage = message.version === '3'
+            const isV3WrappedMessage = message.version === '3' && 'message' in message;
+            const typedMessage = isV3WrappedMessage
                 ? message.message
                 : message;
-            let appMetadata = message.version === '3'
+            let appMetadata = isV3WrappedMessage
                 ? (_a = typedMessage.blockchainData) === null || _a === void 0 ? void 0 : _a.appMetadata
                 : typedMessage.appMetadata;
-            if (!appMetadata && message.version === '3') {
+            if (!appMetadata && isV3WrappedMessage) {
                 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),
@@ -158,8 +204,11 @@ class DAppClient extends octez_connect_core_1.Client {
                     },
                     id: message.id
                 });
-                if (typedMessage.type !== octez_connect_types_1.BeaconMessageType.Acknowledge) {
-                    this.openRequestsOtherTabs.delete(message.id);
+                if (typedMessage.type === octez_connect_types_1.BeaconMessageType.Acknowledge) {
+                    this.clearOpenRequestTimeout(message.id);
+                }
+                else {
+                    this.clearOpenRequest(message.id);
                 }
                 return;
             }
@@ -187,15 +236,19 @@ class DAppClient extends octez_connect_core_1.Client {
                 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);
+                if (!this.acknowledgedRequests.has(message.id)) {
+                    this.acknowledgedRequests.add(message.id);
+                    this.clearOpenRequestTimeout(message.id);
+                    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((emitError) => logger.error('handleResponse', emitError));
+                }
             }
             else if (openRequest) {
                 if (typedMessage.type === octez_connect_types_1.BeaconMessageType.PermissionResponse && appMetadata) {
@@ -207,7 +260,8 @@ class DAppClient extends octez_connect_core_1.Client {
                 else {
                     openRequest.resolve({ message, connectionInfo });
                 }
-                this.openRequests.delete(typedMessage.id);
+                this.clearOpenRequest(message.id);
+                this.acknowledgedRequests.delete(message.id);
             }
             else {
                 if (typedMessage.type === octez_connect_types_1.BeaconMessageType.Disconnect) {
@@ -216,16 +270,23 @@ class DAppClient extends octez_connect_core_1.Client {
                 else if (typedMessage.type === octez_connect_types_1.BeaconMessageType.ChangeAccountRequest) {
                     yield this.onNewAccount(typedMessage, connectionInfo);
                 }
+                else {
+                    logger.warn('handleResponse', 'received response for unknown or closed request', {
+                        id: message.id,
+                        type: typedMessage.type,
+                        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.openRequests.has(SESSION_UPDATE_REQUEST_ID)) {
+                    this.openRequests.set(SESSION_UPDATE_REQUEST_ID, new octez_connect_utils_1.ExposedPromise());
                 }
             }
         });
-        this.storageValidator
+        this.storageValidated = this.storageValidator
             .validate()
             .then((isValid) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -242,15 +303,22 @@ class DAppClient extends octez_connect_core_1.Client {
                     url: info.deeplink
                 });
                 const nowValid = yield this.storageValidator.validate();
-                if (!nowValid) {
-                    this.resetInvalidState(false);
+                if (!nowValid && account) {
+                    yield this.deactivateInvalidAccountState('storage_validation_failed');
+                }
+                else if (!nowValid) {
+                    yield this.resetInvalidState(false);
                 }
             }
             if (account && account.origin.type !== 'p2p') {
-                this.init();
+                // Fire-and-forget eager init for stored sessions. init() can now
+                // reject (e.g. when an abort path settles _initPromise), so swallow
+                // here; downstream callers of init() handle rejection on their own.
+                this.init().catch((initError) => { var _a; return logger.error('eager init failed', (_a = initError === null || initError === void 0 ? void 0 : initError.message) !== null && _a !== void 0 ? _a : initError); });
             }
         }))
             .catch((err) => logger.error(err.message));
+        this.retainStorageValidationPromise();
         this.sendMetrics('enable-metrics?' + this.addQueryParam('version', octez_connect_core_1.SDK_VERSION), undefined, (res) => {
             if (!res.ok) {
                 res.status === 426
@@ -328,11 +396,42 @@ class DAppClient extends octez_connect_core_1.Client {
             const transport = (yield this._transport.promise);
             yield transport.waitForResolution();
             this.openRequestsOtherTabs.add(message.id);
-            isV3
+            const requestPromise = isV3
                 ? this.makeRequestV3(message.data, message.id)
                 : this.makeRequest(message.data, false, message.id);
+            requestPromise.catch((requestError) => {
+                const errorResponse = this.buildDelegatedRequestError(message.id, requestError);
+                this.multiTabChannel.postMessage({
+                    type: 'RESPONSE',
+                    data: {
+                        message: errorResponse,
+                        connectionInfo: {
+                            origin: octez_connect_types_1.Origin.WALLETCONNECT,
+                            id: ''
+                        }
+                    },
+                    id: message.id
+                });
+                this.clearOpenRequest(message.id);
+            });
         });
     }
+    buildDelegatedRequestError(id, error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'type' in error &&
+            'errorType' in error &&
+            error.type === octez_connect_types_1.BeaconMessageType.Error) {
+            return Object.assign(Object.assign({}, error), { id });
+        }
+        return {
+            id,
+            type: octez_connect_types_1.BeaconMessageType.Error,
+            errorType: octez_connect_types_1.BeaconErrorType.UNKNOWN_ERROR,
+            senderId: '',
+            version: '2'
+        };
+    }
     createStateSnapshot() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!localStorage || !this.enableMetrics) {
@@ -363,10 +462,7 @@ class DAppClient extends octez_connect_core_1.Client {
     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 seed = yield this.getOrCreateSDKSecretSeed();
             const keyPair = yield (0, octez_connect_utils_1.getKeypairFromSeed)(seed);
             if (this.postMessageTransport || this.p2pTransport || this.walletConnectTransport) {
                 return;
@@ -375,6 +471,11 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            // Skip WalletConnect entirely when disabled (e.g. inside a Firefox MV3 content-script
+            // compartment where the WC provider cannot run). postMessage + P2P are unaffected.
+            if (this.disableWalletConnect) {
+                return;
+            }
             const wcOptions = {
                 projectId: this.wcProjectId,
                 relayUrl: this.wcRelayUrl,
@@ -393,6 +494,41 @@ class DAppClient extends octez_connect_core_1.Client {
             yield this.addListener(this.walletConnectTransport);
         });
     }
+    getOrCreateSDKSecretSeed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sdkSecretSeedPromise) {
+                return this._sdkSecretSeedPromise;
+            }
+            this._sdkSecretSeedPromise = this.loadOrCreateSDKSecretSeed()
+                .finally(() => {
+                this._sdkSecretSeedPromise = undefined;
+            })
+                .catch((error) => {
+                throw error;
+            });
+            return this._sdkSecretSeedPromise;
+        });
+    }
+    loadOrCreateSDKSecretSeed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingSeed = yield this.storage.get(octez_connect_types_1.StorageKey.BEACON_SDK_SECRET_SEED);
+            if (this.isValidSDKSecretSeed(existingSeed)) {
+                return existingSeed;
+            }
+            yield this.storage.delete(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();
+            const restoredSeed = yield this.storage.get(octez_connect_types_1.StorageKey.BEACON_SDK_SECRET_SEED);
+            if (this.isValidSDKSecretSeed(restoredSeed)) {
+                return restoredSeed;
+            }
+            throw new Error('Secret seed not found');
+        });
+    }
+    isValidSDKSecretSeed(seed) {
+        return typeof seed === 'string' && seed !== '' && seed !== 'undefined' && seed !== 'null';
+    }
     initEvents() {
         if (!this.walletConnectTransport) {
             return;
@@ -410,6 +546,7 @@ class DAppClient extends octez_connect_core_1.Client {
     }
     wcToastHandler(status) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const walletInfo = yield (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     return yield this.getWalletInfo();
@@ -427,22 +564,28 @@ class DAppClient extends octez_connect_core_1.Client {
                 });
             }
             else {
-                this.events.emit(events_1.BeaconEvent.PERMISSION_REQUEST_ERROR, {
-                    errorResponse: { errorType: octez_connect_types_1.BeaconErrorType.ABORTED_ERROR },
-                    walletInfo
-                });
+                // The WC transport reports session-proposal rejection through this event
+                // when there are no active listeners yet (no peer paired). Reject the
+                // in-flight init promise so `await dapp.requestPermissions()` unwinds
+                // through requestPermissions' catch -> handleRequestError, which both
+                // emits PERMISSION_REQUEST_ERROR and resets transport state. Without
+                // this, the dapp wedges with a pending `_initPromise`.
+                (_a = this._initReject) === null || _a === void 0 ? void 0 : _a.call(this, this.createAbortedError());
             }
         });
     }
     channelClosedHandler(type) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this._transport.isResolved()) {
+                yield this.events.emit(events_1.BeaconEvent.CHANNEL_CLOSED);
+                return;
+            }
             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();
+            yield this.disconnect({ notifyPeers: false });
         });
     }
     /**
@@ -457,16 +600,81 @@ class DAppClient extends octez_connect_core_1.Client {
             destroy: { get: () => super.destroy }
         });
         return __awaiter(this, void 0, void 0, function* () {
+            this.destroyed = true;
             yield this.createStateSnapshot();
+            yield this.destroyInternalTransports();
             yield _super.destroy.call(this);
         });
     }
+    destroyInternalTransports() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.abortPendingInit();
+            const transports = [];
+            if (this.postMessageTransport) {
+                transports.push(this.postMessageTransport);
+            }
+            if (this.p2pTransport) {
+                transports.push(this.p2pTransport);
+            }
+            if (this.walletConnectTransport) {
+                transports.push(this.walletConnectTransport);
+            }
+            if (transports.length > 0) {
+                yield this.cleanup(transports);
+                yield Promise.all(transports.map((transport) => __awaiter(this, void 0, void 0, function* () {
+                    yield transport.disconnect();
+                    if ('doClientCleanup' in transport) {
+                        yield transport.doClientCleanup();
+                    }
+                })));
+                this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+                yield this.setTransport(undefined);
+            }
+            yield this.multiTabChannel.close();
+        });
+    }
+    abortPendingInit() {
+        var _a;
+        (_a = this._initReject) === null || _a === void 0 ? void 0 : _a.call(this, this.createAbortedError());
+        this._initPromise = undefined;
+        this._initReject = undefined;
+        this._initSubstratePairing = undefined;
+        this._requestPermissionsPromise = undefined;
+        this._requestPermissionsKey = undefined;
+    }
+    createAbortedError(id = '') {
+        return {
+            type: octez_connect_types_1.BeaconMessageType.Error,
+            id,
+            senderId: '',
+            version: '2',
+            errorType: octez_connect_types_1.BeaconErrorType.ABORTED_ERROR
+        };
+    }
+    /**
+     * @internal
+     */
+    isDestroyed() {
+        return this.destroyed;
+    }
+    assertNotDestroyed() {
+        if (this.destroyed) {
+            throw new Error('DAppClient has been destroyed and cannot be used again.');
+        }
+    }
     init(transport, substratePairing) {
         const _super = Object.create(null, {
             init: { get: () => super.init }
         });
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestroyed();
+            const requestedSubstratePairing = substratePairing === true;
             if (this._initPromise) {
+                if (!transport &&
+                    this._initReject &&
+                    this._initSubstratePairing !== requestedSubstratePairing) {
+                    throw new Error('Cannot start a permission request with different pairing options while another pairing is pending');
+                }
                 return this._initPromise;
             }
             try {
@@ -475,163 +683,260 @@ class DAppClient extends octez_connect_core_1.Client {
             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._initPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this._initSubstratePairing = requestedSubstratePairing;
+                // Capture reject so abort paths (modal close, transport-level rejection)
+                // can unwedge a pending `await this.init()`. _initReject is cleared by
+                // the .finally below whether the promise resolves or rejects, so the
+                // field accurately means "currently rejectable" rather than "most recent
+                // rejector".
+                this._initReject = (reason) => {
+                    this._initPromise = undefined;
+                    reject(reason);
+                };
+                // The body uses `new Promise(async ...)` (an anti-pattern: unhandled
+                // throws are swallowed). Wrap it so any unexpected throw rejects the
+                // promise instead of stranding `await this.init()` callers forever.
+                // A proper structural fix would replace the async-executor entirely
+                // with chained promises; left as follow-up to keep this PR focused.
+                try {
+                    if (transport) {
+                        yield this.addListener(transport);
+                        resolve(yield _super.init.call(this, transport));
                     }
-                    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 if (this._transport.isSettled()) {
+                        yield (yield this.transport).connect();
+                        resolve(yield _super.init.call(this, yield this.transport));
                     }
                     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
+                        const activeAccount = yield this.getActiveAccount();
+                        const stopListening = () => {
+                            const onError = (err) => logger.error('stopListeningForNewPeers', err);
+                            if (this.postMessageTransport) {
+                                this.postMessageTransport.stopListeningForNewPeers().catch(onError);
+                            }
+                            if (this.p2pTransport) {
+                                this.p2pTransport.stopListeningForNewPeers().catch(onError);
+                            }
+                            if (this.walletConnectTransport) {
+                                this.walletConnectTransport.stopListeningForNewPeers().catch(onError);
+                            }
+                        };
+                        yield this.initInternalTransports();
+                        if (!this.postMessageTransport ||
+                            !this.p2pTransport ||
+                            (!this.disableWalletConnect && !this.walletConnectTransport)) {
+                            // Bare return here used to strand the promise forever -- no UI is
+                            // emitted, no peer ever pairs, no abort path fires. Reject explicitly
+                            // so callers see a deterministic error. (WalletConnect is exempt when
+                            // disableWalletConnect is set -- its transport is intentionally absent.)
+                            const noTransportError = {
+                                type: octez_connect_types_1.BeaconMessageType.Error,
+                                id: '',
+                                senderId: '',
+                                version: '2',
+                                errorType: octez_connect_types_1.BeaconErrorType.UNKNOWN_ERROR
+                            };
+                            reject(noTransportError);
+                            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 && this.walletConnectTransport) {
+                                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 === null || walletConnectTransport === void 0 ? void 0 : 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);
                             });
-                            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
+                            const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
+                                var _a;
+                                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 === null || walletConnectTransport === void 0 ? void 0 : walletConnectTransport.disconnect()
+                                ]);
+                                this.postMessageTransport = this.walletConnectTransport = this.p2pTransport = undefined;
+                                this._activeAccount.isResolved() && this.clearActiveAccount();
+                                // Reject _initPromise so any awaiter (makeRequest -> requestPermissions)
+                                // unwinds via handleRequestError instead of hanging. _initReject
+                                // also clears _initPromise as a side effect.
+                                (_a = this._initReject) === null || _a === void 0 ? void 0 : _a.call(this, this.createAbortedError());
                             });
+                            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().catch((abortErr) => logger.warn('init', 'abortHandler', abortErr));
+                                    resolve('');
+                                    return;
+                                }
+                                resolve(yield serializer.serialize(yield p2pTransport.getPairingRequestInfo()));
+                            }));
+                            const walletConnectPeerInfo = walletConnectTransport
+                                ? createLazyPromise(() => walletConnectTransport
+                                    .getPairingRequestInfo()
+                                    .then((pairingRequestInfo) => pairingRequestInfo.uri)
+                                    .catch((error) => {
+                                    logger.warn('init', 'walletconnect pairing request failed', error);
+                                    return '';
+                                }))
+                                : undefined;
+                            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_SUCCESS, peer)
+                                .emit(events_1.BeaconEvent.PAIR_INIT, Object.assign(Object.assign({ p2pPeerInfo,
+                                postmessagePeerInfo }, (walletConnectPeerInfo ? { walletConnectPeerInfo } : {})), { networkType: this.network.type, abortedHandler: abortHandler.bind(this), disclaimerText: this.disclaimerText, analytics: this.analytics, featuredWallets: this.featuredWallets, substratePairing }))
                                 .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));
+                        }
                     }
                 }
+                catch (err) {
+                    // An async-executor throw would otherwise be silently swallowed,
+                    // leaving _initPromise pending and every awaiter stranded.
+                    reject(err);
+                }
             }));
+            // Drop the _initReject reference whether init resolved or rejected, so the
+            // field is never stale. Using an explicit helper keeps the dangling
+            // observer chain out of statement position (which the lint rules forbid).
+            this.clearInitRejectOnSettle(this._initPromise);
             return this._initPromise;
         });
     }
+    /**
+     * Attach a settle observer to {@link _initPromise} that drops
+     * {@link _initReject} once the promise settles (resolved or rejected).
+     * Errors on the observer chain are swallowed; only the original
+     * {@link _initPromise} surfaces them to its awaiters.
+     */
+    clearInitRejectOnSettle(initPromise) {
+        initPromise
+            .finally(() => {
+            this._initReject = undefined;
+            this._initSubstratePairing = undefined;
+        })
+            .catch(() => {
+            // observer-only; original promise's rejection is delivered to awaiters
+        });
+    }
     /**
      * Returns the active account
      */
     getActiveAccount() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestroyed();
             return this._activeAccount.promise;
         });
     }
+    retainStorageValidationPromise() {
+        // Constructor validation is intentionally fire-and-forget, but retaining
+        // the promise gives tests a deterministic hook without changing public API.
+        this.storageValidated.catch((err) => logger.error(err.message));
+    }
+    deactivateInvalidAccountState(reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasEmittedInvalidAccountDeactivated) {
+                return;
+            }
+            this.hasEmittedInvalidAccountDeactivated = true;
+            logger.log('deactivateInvalidAccountState', reason);
+            if (reason === 'missing_active_account') {
+                yield this.repairMissingActiveAccount();
+            }
+            else {
+                yield this.resetInvalidState(false);
+            }
+            yield this.events.emit(events_1.BeaconEvent.INVALID_ACCOUNT_DEACTIVATED, { reason });
+        });
+    }
+    repairMissingActiveAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._activeAccount = octez_connect_utils_1.ExposedPromise.resolve(undefined);
+            yield this.storage.delete(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT);
+            yield this.setActivePeer(undefined);
+        });
+    }
+    hasStoredActiveAccountPointer() {
+        // LocalStorage-specific repair: that backend is where literal sentinel strings were produced.
+        if (typeof localStorage === 'undefined') {
+            return false;
+        }
+        try {
+            return localStorage.getItem(this.storage.getPrefixedKey(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT)) !== null;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
     isInvalidState(account) {
         return __awaiter(this, void 0, void 0, function* () {
             const activeAccount = yield this._activeAccount.promise;
@@ -643,11 +948,15 @@ class DAppClient extends octez_connect_core_1.Client {
     resetInvalidState() {
         return __awaiter(this, arguments, void 0, function* (emit = true) {
             var _a, _b;
-            this.accountManager.removeAllAccounts();
+            yield 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 this.storage.delete(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT);
+            if (emit) {
+                yield this.events.emit(events_1.BeaconEvent.INVALID_ACTIVE_ACCOUNT_STATE);
+            }
+            else {
+                yield 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()
@@ -666,7 +975,8 @@ class DAppClient extends octez_connect_core_1.Client {
     setActiveAccount(account) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!this.isGetActiveAccountHandled) {
+            const activeAccountAlreadyCleared = !account && (yield this.isActiveAccountAlreadyCleared());
+            if (!activeAccountAlreadyCleared && !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))) {
@@ -678,9 +988,9 @@ class DAppClient extends octez_connect_core_1.Client {
             }
             // when I'm resetting the activeAccount
             if (!account && this._activeAccount.isResolved() && (yield this.getActiveAccount())) {
-                const transport = yield this.transport;
+                const transport = this._transport.isResolved() ? yield this.transport : undefined;
                 const activeAccount = yield this.getActiveAccount();
-                if (!transport || !activeAccount) {
+                if (!activeAccount) {
                     return;
                 }
                 if (!this.debounceSetActiveAccount && transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport) {
@@ -696,22 +1006,15 @@ class DAppClient extends octez_connect_core_1.Client {
                             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.abortOpenRequests();
                     this.debounceSetActiveAccount = false;
                 }
             }
-            if (this._activeAccount.isSettled()) {
+            if (activeAccountAlreadyCleared) {
+                // Keep peer and transport cleanup below idempotent, but do not write storage or emit
+                // another ACTIVE_ACCOUNT_SET(undefined) for an already-empty account.
+            }
+            else 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);
             }
@@ -752,11 +1055,42 @@ class DAppClient extends octez_connect_core_1.Client {
                 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);
+            if (account) {
+                yield this.storage.set(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT, account.accountIdentifier);
+            }
+            else if (!activeAccountAlreadyCleared) {
+                yield this.storage.delete(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT);
+            }
+            if (!activeAccountAlreadyCleared) {
+                yield this.events.emit(events_1.BeaconEvent.ACTIVE_ACCOUNT_SET, account);
+            }
             return;
         });
     }
+    isActiveAccountAlreadyCleared() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._activeAccount.isResolved() && !(yield this.getActiveAccount());
+        });
+    }
+    recoverActiveAccountFromAccountsChange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAccountIdentifier = yield this.storage.get(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT);
+            if (!activeAccountIdentifier || activeAccountIdentifier === 'undefined') {
+                return;
+            }
+            if (this._activeAccount.isResolved()) {
+                const activeAccount = yield this.getActiveAccount();
+                if ((activeAccount === null || activeAccount === void 0 ? void 0 : activeAccount.accountIdentifier) === activeAccountIdentifier) {
+                    return;
+                }
+            }
+            const account = yield this.getAccount(activeAccountIdentifier);
+            if (!account) {
+                return;
+            }
+            yield this.setActiveAccount(account);
+        });
+    }
     /**
      * Clear the active account
      */
@@ -846,32 +1180,16 @@ class DAppClient extends octez_connect_core_1.Client {
             };
         });
     }
-    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);
-        });
+    // Metrics phone home to a Papers-controlled endpoint that the ECAD fork
+    // does not control or ingest. The disabled path also queued payloads into
+    // IndexedDB before the DB was ready, surfacing as unhandledRejection.
+    // Hard-disabled here; full removal (option, storage key, IDB store,
+    // BACKEND_URL constant, all call sites) tracked as a follow-up.
+    /* eslint-disable @typescript-eslint/no-unused-vars -- hard-disabled stub keeps its signature for call-site type-safety; params are intentionally unused pending full removal. */
+    sendMetrics(_uri, _options, _thenHandler, _catchHandler) {
+        return;
     }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
     checkMakeRequest() {
         return __awaiter(this, void 0, void 0, function* () {
             const isResolved = this._transport.isResolved();
@@ -931,14 +1249,19 @@ class DAppClient extends octez_connect_core_1.Client {
      * 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;
+        return __awaiter(this, arguments, void 0, function* (sendDisconnectToPeers = false, options = {}) {
+            const transport = (yield this.transport);
             const peers = yield transport.getPeers();
-            const removePeerResult = transport.removeAllPeers();
+            const removePeerResult = yield transport.removeAllPeers();
             yield this.removeAccountsForPeers(peers);
             if (sendDisconnectToPeers) {
                 const disconnectPromises = peers.map((peer) => this.sendDisconnectToPeer(peer, transport));
-                yield Promise.all(disconnectPromises);
+                if (options.ignoreDisconnectErrors) {
+                    yield Promise.allSettled(disconnectPromises);
+                }
+                else {
+                    yield Promise.all(disconnectPromises);
+                }
             }
             return removePeerResult;
         });
@@ -1044,13 +1367,15 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
-            }));
+            let resolved;
+            try {
+                resolved = yield this.makeRequestV3(request);
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            const { message: response, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
             logger.log('RESPONSE V3', response, connectionInfo);
@@ -1112,14 +1437,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message: response, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
             yield blockchain.handleResponse({
@@ -1145,16 +1474,36 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     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.');
+            this.assertNotDestroyed();
+            const scopes = this.getPermissionRequestScopes(input);
+            const requestPermissionsKey = this.getPermissionRequestKey(scopes);
+            if (this._requestPermissionsPromise) {
+                if (this._requestPermissionsKey !== requestPermissionsKey) {
+                    throw new Error('Cannot start a permission request with different scopes while another permission request is pending');
+                }
+                return this._requestPermissionsPromise;
+            }
+            const requestPermissionsPromise = this.requestPermissionsInternal(scopes);
+            this._requestPermissionsPromise = requestPermissionsPromise;
+            this._requestPermissionsKey = requestPermissionsKey;
+            try {
+                return yield requestPermissionsPromise;
             }
+            finally {
+                if (this._requestPermissionsPromise === requestPermissionsPromise) {
+                    this._requestPermissionsPromise = undefined;
+                    this._requestPermissionsKey = undefined;
+                }
+            }
+        });
+    }
+    requestPermissionsInternal(scopes) {
+        return __awaiter(this, void 0, void 0, function* () {
             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]
+                scopes
             };
             this.analytics.track('event', 'DAppClient', 'Permission requested');
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'start'));
@@ -1163,14 +1512,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('connect', 'success'));
             logger.log('requestPermissions', '######## MESSAGE #######');
@@ -1193,6 +1546,17 @@ class DAppClient extends octez_connect_core_1.Client {
             return output;
         });
     }
+    getPermissionRequestScopes(input) {
+        if (input && 'network' in input) {
+            throw new Error('[BEACON] the "network" property is no longer accepted in input. Please provide it when instantiating DAppClient.');
+        }
+        return input && input.scopes
+            ? input.scopes
+            : [octez_connect_types_1.PermissionScope.OPERATION_REQUEST, octez_connect_types_1.PermissionScope.SIGN];
+    }
+    getPermissionRequestKey(scopes) {
+        return [...scopes].sort().join('|');
+    }
     /**
      * 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.
@@ -1220,14 +1584,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             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 });
@@ -1264,14 +1632,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             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, {
@@ -1333,14 +1705,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
             yield this.notifySuccess(request, {
@@ -1430,14 +1806,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
             yield this.notifySuccess(request, {
@@ -1480,14 +1860,18 @@ class DAppClient extends octez_connect_core_1.Client {
             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);
+            let resolved;
+            try {
+                resolved = yield res;
+            }
+            catch (requestError) {
+                yield this.runRequestErrorSideEffects(request, requestError, logId);
+                throw requestError;
+            }
+            if (!resolved) {
+                throw new Error('Internal error: makeRequest returned no result');
+            }
+            const { message, connectionInfo } = resolved;
             logger.time(false, logId);
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'success'));
             yield this.notifySuccess(request, {
@@ -1561,13 +1945,17 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     removeAccountsForPeers(peersToRemove) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (peersToRemove.length === 0) {
+                return;
+            }
             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();
+            var _a;
+            const accounts = (_a = (yield this.accountManager.getAccounts())) !== null && _a !== void 0 ? _a : [];
             // 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);
@@ -1581,6 +1969,46 @@ class DAppClient extends octez_connect_core_1.Client {
             }
         });
     }
+    /**
+     * Run the standard request-error side effects (abort/error metric,
+     * timer stop, {@link handleRequestError}) on a single awaited control
+     * flow so callers can re-throw the original {@link ErrorResponse} without
+     * leaking an UnhandledPromiseRejection.
+     *
+     * Why this exists: every request method historically used a fire-and-
+     * forget `res.catch(handler)` whose handler did `throw await
+     * this.handleRequestError(...)`. The catch returned a detached promise
+     * nobody awaited; `handleRequestError`'s thrown wrapped error became an
+     * unhandled rejection. The bug rarely surfaced before the dapp-init
+     * promise was made rejectable, because pre-pairing rejection paths used
+     * to hang instead of routing through these handlers. Once init started
+     * rejecting reliably, the unhandled rejection started firing on every
+     * WC session-proposal rejection. We swallow the wrapped throw here so
+     * callers can re-throw the original `ErrorResponse`, matching the
+     * post-pairing rejection contract at the openRequest path.
+     *
+     * @param request The request we sent
+     * @param requestError The error we received
+     * @param logId The {@link logger.time} label opened for this request
+     */
+    runRequestErrorSideEffects(request, rawError, logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // V3 request shapes (PermissionRequestV3, BlockchainRequestV3) flow through
+            // here too. They aren't part of BeaconRequestInputMessage, but
+            // handleRequestError only inspects `.type` plus optional fields it already
+            // guards on. Catch params are `unknown` under strict TS, same story.
+            const typedRequest = request;
+            const requestError = rawError;
+            if (requestError.errorType === octez_connect_types_1.BeaconErrorType.ABORTED_ERROR) {
+                this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'abort'));
+            }
+            else {
+                this.sendMetrics('performance-metrics/save', yield this.buildPayload('message', 'error'));
+            }
+            logger.time(false, logId);
+            yield this.handleRequestError(typedRequest, requestError).catch(() => undefined);
+        });
+    }
     /**
      * This message handles errors that we receive from the wallet.
      *
@@ -1763,20 +2191,10 @@ class DAppClient extends octez_connect_core_1.Client {
     }
     makeRequest(requestInput, skipResponse, otherTabMessageId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a;
             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
@@ -1797,20 +2215,34 @@ class DAppClient extends octez_connect_core_1.Client {
                 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);
+                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);
+                yield (yield this.transport).send(payload, peer);
                 if (request.type !== octez_connect_types_1.BeaconMessageType.PermissionRequest ||
                     (this._activeAccount.isResolved() && (yield this._activeAccount.promise))) {
                     this.tryToAppSwitch();
                 }
+                if (!otherTabMessageId) {
+                    this.events
+                        .emit(beacon_message_events_1.messageEvents[requestInput.type].sent, {
+                        walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_a = walletInfo.name) !== null && _a !== void 0 ? _a : 'Wallet' }),
+                        extraInfo: {
+                            resetCallback: () => __awaiter(this, void 0, void 0, function* () {
+                                yield this.disconnect();
+                            })
+                        }
+                    })
+                        .catch((emitError) => logger.warn('makeRequest', emitError));
+                }
             }
             catch (sendError) {
+                if (!skipResponse) {
+                    this.clearOpenRequest(request.id);
+                }
                 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: [
@@ -1825,18 +2257,6 @@ class DAppClient extends octez_connect_core_1.Client {
                 });
                 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
         });
@@ -1851,20 +2271,10 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     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']);
-            }
+            var _a;
             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
@@ -1883,20 +2293,31 @@ class DAppClient extends octez_connect_core_1.Client {
             };
             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);
+                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);
+                yield (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();
                 }
+                const index = requestInput.type;
+                this.events
+                    .emit(beacon_message_events_1.messageEvents[index].sent, {
+                    walletInfo: Object.assign(Object.assign({}, walletInfo), { name: (_a = walletInfo.name) !== null && _a !== void 0 ? _a : 'Wallet' }),
+                    extraInfo: {
+                        resetCallback: () => __awaiter(this, void 0, void 0, function* () {
+                            yield this.disconnect();
+                        })
+                    }
+                })
+                    .catch((emitError) => logger.warn('makeRequestV3', emitError));
             }
             catch (sendError) {
+                this.clearOpenRequest(request.id);
                 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: [
@@ -1911,17 +2332,6 @@ class DAppClient extends octez_connect_core_1.Client {
                 });
                 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
         });
@@ -1964,27 +2374,149 @@ class DAppClient extends octez_connect_core_1.Client {
             return exposed.promise;
         });
     }
+    /**
+     * Disconnects all resolved transports (postMessage, P2P, WalletConnect), removes their peers,
+     * and clears active account state. After calling, the DAppClient remains usable for a new
+     * requestPermissions().
+     */
     disconnect() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const { notifyPeers = true } = options;
+            if (!this._disconnectPromise) {
+                this._disconnectNotifyPeers = false;
+            }
+            this._disconnectNotifyPeers = this._disconnectNotifyPeers || notifyPeers;
+            if (this._disconnectPromise) {
+                return this._disconnectPromise;
+            }
+            this._disconnectPromise = (() => __awaiter(this, void 0, void 0, function* () { return this.disconnectInternal(); }))().finally(() => {
+                this._disconnectPromise = undefined;
+                this._disconnectNotifyPeers = false;
+            });
+            return this._disconnectPromise;
+        });
+    }
+    disconnectInternal() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.abortPendingInit();
             if (!this._transport.isResolved()) {
-                throw new Error('No transport available.');
+                const initializedTransports = this.getInitializedTransports();
+                this.abortOpenRequests();
+                yield this.removeAllPeersFromTransports(initializedTransports);
+                yield this.clearActiveAccount();
+                yield this.disconnectResolvedTransports(initializedTransports);
+                this.clearInternalTransportReferences();
+                return;
             }
-            const transport = yield this.transport;
+            const transport = (yield this.transport);
             if (transport.connectionStatus === octez_connect_types_1.TransportStatus.NOT_CONNECTED) {
-                throw new Error('Not connected.');
+                yield this.clearActiveAccount();
+                this.abortOpenRequests();
+                return;
             }
             yield this.createStateSnapshot();
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('disconnect', 'start'));
+            this.abortOpenRequests();
+            const transports = this.getResolvedTransports(transport);
+            yield this.removeAllPeersFromTransports(transports);
             yield this.clearActiveAccount();
-            if (!(transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport)) {
-                yield transport.disconnect();
-            }
-            this.postMessageTransport = undefined;
-            this.p2pTransport = undefined;
-            this.walletConnectTransport = undefined;
+            yield this.disconnectResolvedTransports(transports);
+            this.clearInternalTransportReferences();
             this.sendMetrics('performance-metrics/save', yield this.buildPayload('disconnect', 'success'));
         });
     }
+    getInitializedTransports() {
+        const transports = [];
+        const addTransport = (transport) => {
+            if (transport && !transports.includes(transport)) {
+                transports.push(transport);
+            }
+        };
+        addTransport(this.postMessageTransport);
+        addTransport(this.p2pTransport);
+        addTransport(this.walletConnectTransport);
+        return transports;
+    }
+    getResolvedTransports(selectedTransport) {
+        const transports = this.getInitializedTransports();
+        const addTransport = (transport) => {
+            if (transport && !transports.includes(transport)) {
+                transports.push(transport);
+            }
+        };
+        addTransport(this.postMessageTransport);
+        addTransport(this.p2pTransport);
+        addTransport(this.walletConnectTransport);
+        addTransport(selectedTransport);
+        return transports;
+    }
+    clearInternalTransportReferences() {
+        this.postMessageTransport = undefined;
+        this.p2pTransport = undefined;
+        this.walletConnectTransport = undefined;
+    }
+    removeAllPeersFromTransports(transports) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const peersByTransport = yield Promise.all(transports.map((transport) => __awaiter(this, void 0, void 0, function* () {
+                const transportPeers = yield transport.getPeers();
+                return {
+                    transport,
+                    peers: transportPeers
+                };
+            })));
+            yield Promise.all(peersByTransport.map(({ transport }) => transport.removeAllPeers()));
+            const peersToRemove = peersByTransport.flatMap(({ peers: transportPeers }) => transportPeers);
+            yield this.removeAccountsForPeers(peersToRemove);
+            // If cleanup already removed peers, a late notify upgrade has nothing left to notify.
+            const sendDisconnectToPeers = this._disconnectNotifyPeers;
+            if (!sendDisconnectToPeers) {
+                return;
+            }
+            yield Promise.allSettled(this.getUniquePeerNotifications(peersByTransport).map(({ transport, peer }) => this.sendDisconnectToPeer(peer, transport)));
+        });
+    }
+    getUniquePeerNotifications(peersByTransport) {
+        const notifications = [];
+        const seen = new Set();
+        peersByTransport.forEach(({ transport, peers: transportPeers }) => {
+            transportPeers.forEach((peer) => {
+                const key = this.getPeerNotificationKey(transport, peer);
+                if (seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                notifications.push({ transport, peer });
+            });
+        });
+        return notifications;
+    }
+    getPeerNotificationKey(transport, peer) {
+        return [transport.type, peer.publicKey, peer.senderId, peer.id].filter(Boolean).join(':');
+    }
+    disconnectResolvedTransports(transports) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield Promise.allSettled(transports.map((transport) => __awaiter(this, void 0, void 0, function* () {
+                if (this.isTransportConnected(transport)) {
+                    yield transport.disconnect();
+                }
+                if (this.hasClientCleanup(transport)) {
+                    yield transport.doClientCleanup();
+                }
+            })));
+            results.forEach((result) => {
+                if (result.status === 'rejected') {
+                    logger.warn('disconnectResolvedTransports', result.reason);
+                }
+            });
+        });
+    }
+    hasClientCleanup(transport) {
+        const transportWithClientCleanup = transport;
+        return typeof transportWithClientCleanup.doClientCleanup === 'function';
+    }
+    isTransportConnected(transport) {
+        return transport.connectionStatus !== octez_connect_types_1.TransportStatus.NOT_CONNECTED;
+    }
     /**
      * Adds a requests to the "openRequests" set so we know what messages have already been answered/handled.
      *
@@ -1993,7 +2525,64 @@ class DAppClient extends octez_connect_core_1.Client {
      */
     addOpenRequest(id, promise) {
         logger.log('addOpenRequest', this.name, `adding request ${id} and waiting for answer`);
+        this.clearOpenRequestTimeout(id);
+        this.openRequests.delete(id);
         this.openRequests.set(id, promise);
+        this.addOpenRequestTimeout(id, promise);
+    }
+    addOpenRequestTimeout(id, promise) {
+        if (id === SESSION_UPDATE_REQUEST_ID) {
+            return;
+        }
+        if (!Number.isFinite(this.requestTimeoutMs) || this.requestTimeoutMs <= 0) {
+            return;
+        }
+        const timeout = setTimeout(() => {
+            if (this.openRequests.get(id) !== promise) {
+                return;
+            }
+            const errorResponse = {
+                id,
+                type: octez_connect_types_1.BeaconMessageType.Error,
+                errorType: octez_connect_types_1.BeaconErrorType.PEER_UNREACHABLE,
+                senderId: '',
+                version: '2'
+            };
+            promise.reject(errorResponse);
+            this.clearOpenRequest(id);
+            this.events.emit(events_1.BeaconEvent.CHANNEL_CLOSED).catch((emitError) => {
+                logger.error('addOpenRequestTimeout', emitError);
+            });
+        }, this.requestTimeoutMs);
+        this.openRequestTimeouts.set(id, timeout);
+    }
+    clearOpenRequest(id) {
+        this.clearOpenRequestTimeout(id);
+        this.openRequests.delete(id);
+        this.openRequestsOtherTabs.delete(id);
+    }
+    clearOpenRequestTimeout(id) {
+        const timeout = this.openRequestTimeouts.get(id);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.openRequestTimeouts.delete(id);
+        }
+    }
+    clearAllOpenRequestTimeouts() {
+        this.openRequestTimeouts.forEach((timeout) => clearTimeout(timeout));
+        this.openRequestTimeouts.clear();
+    }
+    abortOpenRequests() {
+        Array.from(this.openRequests.entries())
+            .filter(([id]) => id !== SESSION_UPDATE_REQUEST_ID)
+            .forEach(([id, promise]) => {
+            promise.reject(this.createAbortedError(id));
+            this.clearOpenRequest(id);
+        });
+        this.openRequests.clear();
+        this.openRequestsOtherTabs.clear();
+        this.acknowledgedRequests.clear();
+        this.clearAllOpenRequestTimeouts();
     }
     sendNotificationWithAccessToken(notification) {
         return __awaiter(this, void 0, void 0, function* () {