@tezos-x/octez.connect-dapp 4.8.3 → 4.8.5

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

@@ -1,6 +1,4 @@
-import axios from 'axios';
 import bs58check from 'bs58check';
-import { BeaconEvent } from '../events';
 import { TransportType, StorageKey, BeaconMessageType, PermissionScope, NetworkType, Origin, BeaconErrorType, SigningType, ColorMode, TransportStatus
 // PermissionRequestV3
 // RequestEncryptPayloadInput,
@@ -8,11 +6,11 @@ import { TransportType, StorageKey, BeaconMessageType, PermissionScope, NetworkT
 // EncryptPayloadResponse,
 // EncryptPayloadRequest
  } from '@tezos-x/octez.connect-types';
-import { Client, AppMetadataManager, Serializer, LocalStorage, getAccountIdentifier, getSenderId, Logger, StorageValidator, SDK_VERSION, IndexedDBStorage, MultiTabChannel, BACKEND_URL, getError } from '@tezos-x/octez.connect-core';
+import { Client, AppMetadataManager, Serializer, LocalStorage, getAccountIdentifier, getSenderId, Logger, StorageValidator, SDK_VERSION, IndexedDBStorage, MultiTabChannel, getError } from '@tezos-x/octez.connect-core';
 import { getAddressFromPublicKey, ExposedPromise, generateGUID, toHex, signMessage, CONTRACT_PREFIX, prefixPublicKey, isValidAddress, getKeypairFromSeed } from '@tezos-x/octez.connect-utils';
 import { messageEvents } from '../beacon-message-events';
+import { BeaconEvent, BeaconEventHandler } from '../events';
 import { TzktBlockExplorer } from '../utils/tzkt-blockexplorer';
-import { BeaconEventHandler } from '@tezos-x/octez.connect-dapp';
 import { DappPostMessageTransport } from '../transports/DappPostMessageTransport';
 import { DappP2PTransport } from '../transports/DappP2PTransport';
 import { DappWalletConnectTransport } from '../transports/DappWalletConnectTransport';
@@ -20,6 +18,23 @@ import { PostMessageTransport } from '@tezos-x/octez.connect-transport-postmessa
 import { closeToast, getColorMode, setColorMode, setDesktopList, setExtensionList, setWebList, setiOSList, getiOSList, getDesktopList, getExtensionList, getWebList, isBrowser, isDesktop, isMobileOS, isIOS, currentOS } from '@tezos-x/octez.connect-ui';
 import { WalletConnectTransport } from '@tezos-x/octez.connect-transport-walletconnect';
 const logger = new Logger('DAppClient');
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+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 ?? undefined)
+    };
+    return lazyPromise;
+};
 /**
  * @publicapi
  *
@@ -53,12 +68,20 @@ export class DAppClient extends Client {
     walletConnectTransport;
     wcProjectId;
     wcRelayUrl;
+    /**
+     * When true, the WalletConnect transport is not built or listened to. See
+     * DAppClientOptions.disableWalletConnect.
+     */
+    disableWalletConnect;
     isGetActiveAccountHandled = false;
     openRequestsOtherTabs = new Set();
     /**
      * A map of requests that are currently "open", meaning we have sent them to a wallet and are still awaiting a response.
      */
     openRequests = new Map();
+    acknowledgedRequests = new Set();
+    openRequestTimeouts = new Map();
+    requestTimeoutMs;
     /**
      * 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
@@ -69,8 +92,22 @@ export class DAppClient extends Client {
      */
     _activePeer = new ExposedPromise();
     _initPromise;
-    isInitPending = false;
+    /**
+     * Rejector for the in-flight {@link _initPromise}. Populated while init is
+     * awaiting a peer pairing; cleared automatically when {@link _initPromise}
+     * settles. Abort paths (modal close, WC session-proposal rejection,
+     * transport-level connection failure) call this to unwedge any
+     * `await this.init()` caller, surfacing the error to handleRequestError
+     * instead of hanging.
+     */
+    _initReject;
+    _initSubstratePairing;
+    _requestPermissionsPromise;
+    _requestPermissionsKey;
+    _sdkSecretSeedPromise;
+    destroyed = false;
     activeAccountLoaded;
+    storageValidated;
     appMetadataManager;
     disclaimerText;
     errorMessages;
@@ -78,6 +115,11 @@ export class DAppClient extends Client {
     storageValidator;
     beaconIDB = new IndexedDBStorage('beacon', ['bug_report', 'metrics']);
     debounceSetActiveAccount = false;
+    // Constructor-time invalid storage recovery can race through multiple async paths.
+    // Keep this guard scoped to those startup paths.
+    hasEmittedInvalidAccountDeactivated = false;
+    _disconnectPromise;
+    _disconnectNotifyPeers = false;
     multiTabChannel = new MultiTabChannel('octez.connect-sdk-channel', this.onBCMessageHandler.bind(this), this.onElectedLeaderhandler.bind(this));
     constructor(config) {
         super({
@@ -85,8 +127,11 @@ export class DAppClient extends Client {
             ...config
         });
         this.description = config.description;
-        this.wcProjectId = config.walletConnectOptions?.projectId || '24469fd0a06df227b6e5f7dc7de0ff4f';
-        this.wcRelayUrl = config.walletConnectOptions?.relayUrl;
+        this.disableWalletConnect = config.disableWalletConnect ?? false;
+        if (!this.disableWalletConnect) {
+            this.wcProjectId = config.walletConnectOptions?.projectId || '24469fd0a06df227b6e5f7dc7de0ff4f';
+            this.wcRelayUrl = config.walletConnectOptions?.relayUrl;
+        }
         this.featuredWallets = config.featuredWallets;
         this.events = new BeaconEventHandler(config.eventHandlers, config.disableDefaultEvents ?? false);
         this.blockExplorer = config.blockExplorer ?? new TzktBlockExplorer();
@@ -99,24 +144,32 @@ export class DAppClient extends Client {
         this.enableAppSwitching =
             config.enableAppSwitching === undefined ? true : !!config.enableAppSwitching;
         this.enableMetrics = config.enableMetrics ? true : false;
+        this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
         // Subscribe to storage changes and update the active account if it changes on other tabs
         this.storage.subscribeToStorageChanged(async (event) => {
+            if (event.oldValue === event.newValue) {
+                return;
+            }
             if (event.eventType === 'storageCleared') {
-                this.setActiveAccount(undefined);
+                await this.setActiveAccount(undefined);
                 return;
             }
             if (event.eventType === 'entryModified') {
                 if (event.key === this.storage.getPrefixedKey(StorageKey.ACTIVE_ACCOUNT)) {
                     const accountIdentifier = event.newValue;
                     if (!accountIdentifier || accountIdentifier === 'undefined') {
-                        this.setActiveAccount(undefined);
+                        await this.setActiveAccount(undefined);
                     }
                     else {
                         const account = await this.getAccount(accountIdentifier);
-                        this.setActiveAccount(account);
+                        await this.setActiveAccount(account);
                     }
                     return;
                 }
+                if (event.key === this.storage.getPrefixedKey(StorageKey.ACCOUNTS)) {
+                    await this.recoverActiveAccountFromAccountsChange();
+                    return;
+                }
                 if (event.key === this.storage.getPrefixedKey(StorageKey.ENABLE_METRICS)) {
                     this.enableMetrics = !!(await this.storage.get(StorageKey.ENABLE_METRICS));
                     return;
@@ -132,30 +185,42 @@ export class DAppClient extends Client {
         this.activeAccountLoaded = this.storage
             .get(StorageKey.ACTIVE_ACCOUNT)
             .then(async (activeAccountIdentifier) => {
+            const accounts = await this.accountManager.getAccounts();
+            if (activeAccountIdentifier === 'undefined') {
+                // Non-normalizing storage backends can still surface legacy sentinel strings directly.
+                await this.deactivateInvalidAccountState('missing_active_account');
+                return undefined;
+            }
             if (activeAccountIdentifier) {
-                const account = await this.accountManager.getAccount(activeAccountIdentifier);
+                const account = accounts.find((storedAccount) => storedAccount.accountIdentifier === activeAccountIdentifier);
+                if (!account) {
+                    await this.deactivateInvalidAccountState('missing_active_account');
+                    return undefined;
+                }
                 await this.setActiveAccount(account);
                 return account;
             }
-            else {
-                await this.setActiveAccount(undefined);
+            if (accounts.length > 0 && this.hasStoredActiveAccountPointer()) {
+                await this.deactivateInvalidAccountState('missing_active_account');
                 return undefined;
             }
+            await this.setActiveAccount(undefined);
+            return undefined;
         })
             .catch(async (storageError) => {
             logger.error(storageError);
-            await this.resetInvalidState(false);
-            this.events.emit(BeaconEvent.INVALID_ACCOUNT_DEACTIVATED);
+            await this.deactivateInvalidAccountState('invalid_active_account_storage');
             return undefined;
         });
         this.handleResponse = async (message, connectionInfo) => {
-            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
                 ? typedMessage.blockchainData?.appMetadata
                 : typedMessage.appMetadata;
-            if (!appMetadata && message.version === '3') {
+            if (!appMetadata && isV3WrappedMessage) {
                 const storedMetadata = await Promise.all([
                     this.storage.get(StorageKey.TRANSPORT_P2P_PEERS_DAPP),
                     this.storage.get(StorageKey.TRANSPORT_WALLETCONNECT_PEERS_DAPP),
@@ -184,8 +249,11 @@ export class DAppClient extends Client {
                     },
                     id: message.id
                 });
-                if (typedMessage.type !== BeaconMessageType.Acknowledge) {
-                    this.openRequestsOtherTabs.delete(message.id);
+                if (typedMessage.type === BeaconMessageType.Acknowledge) {
+                    this.clearOpenRequestTimeout(message.id);
+                }
+                else {
+                    this.clearOpenRequest(message.id);
                 }
                 return;
             }
@@ -212,15 +280,19 @@ export class DAppClient extends Client {
                 await this.events.emit(BeaconEvent.CHANNEL_CLOSED);
             };
             if (openRequest && typedMessage.type === BeaconMessageType.Acknowledge) {
-                this.analytics.track('event', 'DAppClient', 'Acknowledge received from Wallet');
-                logger.log('handleResponse', `acknowledge message received for ${message.id}`);
-                this.events
-                    .emit(BeaconEvent.ACKNOWLEDGE_RECEIVED, {
-                    message: typedMessage,
-                    extraInfo: {},
-                    walletInfo: await 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(BeaconEvent.ACKNOWLEDGE_RECEIVED, {
+                        message: typedMessage,
+                        extraInfo: {},
+                        walletInfo: await this.getWalletInfo()
+                    })
+                        .catch((emitError) => logger.error('handleResponse', emitError));
+                }
             }
             else if (openRequest) {
                 if (typedMessage.type === BeaconMessageType.PermissionResponse && appMetadata) {
@@ -232,7 +304,8 @@ export class DAppClient extends Client {
                 else {
                     openRequest.resolve({ message, connectionInfo });
                 }
-                this.openRequests.delete(typedMessage.id);
+                this.clearOpenRequest(message.id);
+                this.acknowledgedRequests.delete(message.id);
             }
             else {
                 if (typedMessage.type === BeaconMessageType.Disconnect) {
@@ -241,16 +314,23 @@ export class DAppClient extends Client {
                 else if (typedMessage.type === BeaconMessageType.ChangeAccountRequest) {
                     await 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 = await this.transport;
                 if (transport instanceof WalletConnectTransport &&
-                    !this.openRequests.has('session_update')) {
-                    this.openRequests.set('session_update', new ExposedPromise());
+                    !this.openRequests.has(SESSION_UPDATE_REQUEST_ID)) {
+                    this.openRequests.set(SESSION_UPDATE_REQUEST_ID, new ExposedPromise());
                 }
             }
         };
-        this.storageValidator
+        this.storageValidated = this.storageValidator
             .validate()
             .then(async (isValid) => {
             const account = await this.activeAccountLoaded;
@@ -266,15 +346,22 @@ export class DAppClient extends Client {
                     url: info.deeplink
                 });
                 const nowValid = await this.storageValidator.validate();
-                if (!nowValid) {
-                    this.resetInvalidState(false);
+                if (!nowValid && account) {
+                    await this.deactivateInvalidAccountState('storage_validation_failed');
+                }
+                else if (!nowValid) {
+                    await 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) => logger.error('eager init failed', initError?.message ?? initError));
             }
         })
             .catch((err) => logger.error(err.message));
+        this.retainStorageValidationPromise();
         this.sendMetrics('enable-metrics?' + this.addQueryParam('version', SDK_VERSION), undefined, (res) => {
             if (!res.ok) {
                 res.status === 426
@@ -345,9 +432,43 @@ export class DAppClient extends Client {
         const transport = (await this._transport.promise);
         await 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: 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 === BeaconMessageType.Error) {
+            return {
+                ...error,
+                id
+            };
+        }
+        return {
+            id,
+            type: BeaconMessageType.Error,
+            errorType: BeaconErrorType.UNKNOWN_ERROR,
+            senderId: '',
+            version: '2'
+        };
     }
     async createStateSnapshot() {
         if (!localStorage || !this.enableMetrics) {
@@ -373,10 +494,7 @@ export class DAppClient extends Client {
         this.storage.set(StorageKey.USER_ID, this.userId);
     }
     async initInternalTransports() {
-        const seed = await this.storage.get(StorageKey.BEACON_SDK_SECRET_SEED);
-        if (!seed) {
-            throw new Error('Secret seed not found');
-        }
+        const seed = await this.getOrCreateSDKSecretSeed();
         const keyPair = await getKeypairFromSeed(seed);
         if (this.postMessageTransport || this.p2pTransport || this.walletConnectTransport) {
             return;
@@ -385,6 +503,11 @@ export class DAppClient extends Client {
         await this.addListener(this.postMessageTransport);
         this.p2pTransport = new DappP2PTransport(this.name, keyPair, this.storage, this.matrixNodes, this.iconUrl, this.appUrl);
         await 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,
@@ -402,6 +525,37 @@ export class DAppClient extends Client {
         this.initEvents();
         await this.addListener(this.walletConnectTransport);
     }
+    async getOrCreateSDKSecretSeed() {
+        if (this._sdkSecretSeedPromise) {
+            return this._sdkSecretSeedPromise;
+        }
+        this._sdkSecretSeedPromise = this.loadOrCreateSDKSecretSeed()
+            .finally(() => {
+            this._sdkSecretSeedPromise = undefined;
+        })
+            .catch((error) => {
+            throw error;
+        });
+        return this._sdkSecretSeedPromise;
+    }
+    async loadOrCreateSDKSecretSeed() {
+        const existingSeed = await this.storage.get(StorageKey.BEACON_SDK_SECRET_SEED);
+        if (this.isValidSDKSecretSeed(existingSeed)) {
+            return existingSeed;
+        }
+        await this.storage.delete(StorageKey.BEACON_SDK_SECRET_SEED);
+        this._keyPair = new ExposedPromise();
+        this._beaconId = new ExposedPromise();
+        await this.initSDK();
+        const restoredSeed = await this.storage.get(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;
@@ -433,20 +587,26 @@ export class DAppClient extends Client {
             });
         }
         else {
-            this.events.emit(BeaconEvent.PERMISSION_REQUEST_ERROR, {
-                errorResponse: { errorType: 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`.
+            this._initReject?.(this.createAbortedError());
         }
     }
     async channelClosedHandler(type) {
+        if (!this._transport.isResolved()) {
+            await this.events.emit(BeaconEvent.CHANNEL_CLOSED);
+            return;
+        }
         const transport = await this.transport;
         if (transport.type !== type) {
             return;
         }
         await this.events.emit(BeaconEvent.CHANNEL_CLOSED);
-        this.setActiveAccount(undefined);
-        await this.disconnect();
+        await this.disconnect({ notifyPeers: false });
     }
     /**
      * Destroy the instance.
@@ -456,11 +616,73 @@ export class DAppClient extends Client {
      * If you wish to disconnect your dApp, use `disconnect` instead.
      */
     async destroy() {
+        this.destroyed = true;
         await this.createStateSnapshot();
+        await this.destroyInternalTransports();
         await super.destroy();
     }
+    async destroyInternalTransports() {
+        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) {
+            await this.cleanup(transports);
+            await Promise.all(transports.map(async (transport) => {
+                await transport.disconnect();
+                if ('doClientCleanup' in transport) {
+                    await transport.doClientCleanup();
+                }
+            }));
+            this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+            await this.setTransport(undefined);
+        }
+        await this.multiTabChannel.close();
+    }
+    abortPendingInit() {
+        this._initReject?.(this.createAbortedError());
+        this._initPromise = undefined;
+        this._initReject = undefined;
+        this._initSubstratePairing = undefined;
+        this._requestPermissionsPromise = undefined;
+        this._requestPermissionsKey = undefined;
+    }
+    createAbortedError(id = '') {
+        return {
+            type: BeaconMessageType.Error,
+            id,
+            senderId: '',
+            version: '2',
+            errorType: BeaconErrorType.ABORTED_ERROR
+        };
+    }
+    /**
+     * @internal
+     */
+    isDestroyed() {
+        return this.destroyed;
+    }
+    assertNotDestroyed() {
+        if (this.destroyed) {
+            throw new Error('DAppClient has been destroyed and cannot be used again.');
+        }
+    }
     async init(transport, substratePairing) {
+        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 {
@@ -469,160 +691,265 @@ export class DAppClient extends Client {
         catch {
             //
         }
-        this._initPromise = new Promise(async (resolve) => {
-            if (transport) {
-                await this.addListener(transport);
-                resolve(await super.init(transport));
-            }
-            else if (this._transport.isSettled()) {
-                await (await this.transport).connect();
-                resolve(await super.init(await this.transport));
-            }
-            else {
-                const activeAccount = await 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);
-                    }
-                };
-                await this.initInternalTransports();
-                if (!this.postMessageTransport || !this.p2pTransport || !this.walletConnectTransport) {
-                    return;
+        this._initPromise = new Promise(async (resolve, reject) => {
+            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) {
+                    await this.addListener(transport);
+                    resolve(await super.init(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 === Origin.EXTENSION) {
-                        resolve(await super.init(this.postMessageTransport));
-                    }
-                    else if (origin === Origin.P2P) {
-                        resolve(await super.init(this.p2pTransport));
-                    }
-                    else if (origin === Origin.WALLETCONNECT) {
-                        resolve(await super.init(this.walletConnectTransport));
-                    }
+                else if (this._transport.isSettled()) {
+                    await (await this.transport).connect();
+                    resolve(await super.init(await 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
+                    const activeAccount = await 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);
+                        }
+                    };
+                    await 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: BeaconMessageType.Error,
+                            id: '',
+                            senderId: '',
+                            version: '2',
+                            errorType: 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 === Origin.EXTENSION) {
+                            resolve(await super.init(this.postMessageTransport));
+                        }
+                        else if (origin === Origin.P2P) {
+                            resolve(await super.init(this.p2pTransport));
+                        }
+                        else if (origin === Origin.WALLETCONNECT && this.walletConnectTransport) {
+                            resolve(await super.init(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(BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.postMessageTransport).catch(console.error);
+                            stopListening();
+                            resolve(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(BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.p2pTransport).catch(console.error);
+                            stopListening();
+                            resolve(TransportType.P2P);
+                        })
+                            .catch(console.error);
+                        walletConnectTransport
+                            ?.listenForNewPeer((peer) => {
+                            logger.log('init', 'walletconnect transport peer connected', peer);
+                            this.analytics.track('event', 'DAppClient', 'WalletConnect Wallet connected', {
+                                peerName: peer.name
+                            });
+                            this.events
+                                .emit(BeaconEvent.PAIR_SUCCESS, peer)
+                                .catch((emitError) => console.warn(emitError));
+                            this.setActivePeer(peer).catch(console.error);
+                            this.setTransport(this.walletConnectTransport).catch(console.error);
+                            stopListening();
+                            resolve(TransportType.WALLETCONNECT);
+                        })
+                            .catch(console.error);
+                        PostMessageTransport.getAvailableExtensions()
+                            .then(async (extensions) => {
+                            this.analytics.track('event', 'DAppClient', 'Extensions detected', { extensions });
+                        })
+                            .catch((error) => {
+                            this._initPromise = undefined;
+                            console.error(error);
                         });
-                        this.events
-                            .emit(BeaconEvent.PAIR_SUCCESS, peer)
-                            .catch((emitError) => console.warn(emitError));
-                        this.setActivePeer(peer).catch(console.error);
-                        this.setTransport(this.postMessageTransport).catch(console.error);
-                        stopListening();
-                        resolve(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 abortHandler = async () => {
+                            logger.log('init', 'ABORTED');
+                            this.sendMetrics('performance-metrics/save', await this.buildPayload('connect', 'abort'));
+                            await 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();
+                            // Reject _initPromise so any awaiter (makeRequest -> requestPermissions)
+                            // unwinds via handleRequestError instead of hanging. _initReject
+                            // also clears _initPromise as a side effect.
+                            this._initReject?.(this.createAbortedError());
+                        };
+                        const serializer = new Serializer();
+                        const p2pPeerInfo = new Promise(async (resolve) => {
+                            try {
+                                await p2pTransport.connect();
+                            }
+                            catch (err) {
+                                logger.error(err);
+                                await this.hideUI(['alert']); // hide pairing alert
+                                setTimeout(() => this.events.emit(BeaconEvent.GENERIC_ERROR, err.message), 1000);
+                                abortHandler().catch((abortErr) => logger.warn('init', 'abortHandler', abortErr));
+                                resolve('');
+                                return;
+                            }
+                            resolve(await serializer.serialize(await p2pTransport.getPairingRequestInfo()));
                         });
-                        this.events
-                            .emit(BeaconEvent.PAIR_SUCCESS, peer)
-                            .catch((emitError) => console.warn(emitError));
-                        this.setActivePeer(peer).catch(console.error);
-                        this.setTransport(this.p2pTransport).catch(console.error);
-                        stopListening();
-                        resolve(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 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(async (resolve) => {
+                            resolve(await serializer.serialize(await postMessageTransport.getPairingRequestInfo()));
                         });
                         this.events
-                            .emit(BeaconEvent.PAIR_SUCCESS, peer)
+                            .emit(BeaconEvent.PAIR_INIT, {
+                            p2pPeerInfo,
+                            postmessagePeerInfo,
+                            // Omitted entirely when WalletConnect is disabled, so the pairing UI
+                            // never tries to read a peer-info promise for a transport that isn't there.
+                            ...(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(TransportType.WALLETCONNECT);
-                    })
-                        .catch(console.error);
-                    PostMessageTransport.getAvailableExtensions()
-                        .then(async (extensions) => {
-                        this.analytics.track('event', 'DAppClient', 'Extensions detected', { extensions });
-                    })
-                        .catch((error) => {
-                        this._initPromise = undefined;
-                        console.error(error);
-                    });
-                    const abortHandler = async () => {
-                        logger.log('init', 'ABORTED');
-                        this.sendMetrics('performance-metrics/save', await this.buildPayload('connect', 'abort'));
-                        await 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 Serializer();
-                    const p2pPeerInfo = new Promise(async (resolve) => {
-                        try {
-                            await p2pTransport.connect();
-                        }
-                        catch (err) {
-                            logger.error(err);
-                            await this.hideUI(['alert']); // hide pairing alert
-                            setTimeout(() => this.events.emit(BeaconEvent.GENERIC_ERROR, err.message), 1000);
-                            abortHandler();
-                            resolve('');
-                            return;
-                        }
-                        resolve(await serializer.serialize(await p2pTransport.getPairingRequestInfo()));
-                    });
-                    const walletConnectPeerInfo = new Promise(async (resolve) => {
-                        resolve((await walletConnectTransport.getPairingRequestInfo()).uri);
-                    });
-                    const postmessagePeerInfo = new Promise(async (resolve) => {
-                        resolve(await serializer.serialize(await postMessageTransport.getPairingRequestInfo()));
-                    });
-                    this.events
-                        .emit(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
      */
     async getActiveAccount() {
+        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));
+    }
+    async deactivateInvalidAccountState(reason) {
+        if (this.hasEmittedInvalidAccountDeactivated) {
+            return;
+        }
+        this.hasEmittedInvalidAccountDeactivated = true;
+        logger.log('deactivateInvalidAccountState', reason);
+        if (reason === 'missing_active_account') {
+            await this.repairMissingActiveAccount();
+        }
+        else {
+            await this.resetInvalidState(false);
+        }
+        await this.events.emit(BeaconEvent.INVALID_ACCOUNT_DEACTIVATED, { reason });
+    }
+    async repairMissingActiveAccount() {
+        this._activeAccount = ExposedPromise.resolve(undefined);
+        await this.storage.delete(StorageKey.ACTIVE_ACCOUNT);
+        await 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(StorageKey.ACTIVE_ACCOUNT)) !== null;
+        }
+        catch {
+            return false;
+        }
+    }
     async isInvalidState(account) {
         const activeAccount = await this._activeAccount.promise;
         return !activeAccount
@@ -630,11 +957,15 @@ export class DAppClient extends Client {
             : activeAccount?.address !== account?.address && !this.isGetActiveAccountHandled;
     }
     async resetInvalidState(emit = true) {
-        this.accountManager.removeAllAccounts();
+        await this.accountManager.removeAllAccounts();
         this._activeAccount = ExposedPromise.resolve(undefined);
-        this.storage.set(StorageKey.ACTIVE_ACCOUNT, undefined);
-        emit && this.events.emit(BeaconEvent.INVALID_ACTIVE_ACCOUNT_STATE);
-        !emit && this.hideUI(['alert']);
+        await this.storage.delete(StorageKey.ACTIVE_ACCOUNT);
+        if (emit) {
+            await this.events.emit(BeaconEvent.INVALID_ACTIVE_ACCOUNT_STATE);
+        }
+        else {
+            await this.hideUI(['alert']);
+        }
         await Promise.all([
             this.postMessageTransport?.disconnect(),
             this.walletConnectTransport?.disconnect()
@@ -650,7 +981,8 @@ export class DAppClient extends Client {
      * @param account The account that will be set as the active account
      */
     async setActiveAccount(account) {
-        if (!this.isGetActiveAccountHandled) {
+        const activeAccountAlreadyCleared = !account && (await 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() && (await this.isInvalidState(account))) {
@@ -662,9 +994,9 @@ export class DAppClient extends Client {
         }
         // when I'm resetting the activeAccount
         if (!account && this._activeAccount.isResolved() && (await this.getActiveAccount())) {
-            const transport = await this.transport;
+            const transport = this._transport.isResolved() ? await this.transport : undefined;
             const activeAccount = await this.getActiveAccount();
-            if (!transport || !activeAccount) {
+            if (!activeAccount) {
                 return;
             }
             if (!this.debounceSetActiveAccount && transport instanceof WalletConnectTransport) {
@@ -680,22 +1012,15 @@ export class DAppClient extends Client {
                         type: 'DISCONNECT'
                     });
                 }
-                Array.from(this.openRequests.entries())
-                    .filter(([id, _promise]) => id !== 'session_update')
-                    .forEach(([id, promise]) => {
-                    promise.reject({
-                        type: BeaconMessageType.Error,
-                        errorType: 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 = ExposedPromise.resolve(account);
         }
@@ -736,10 +1061,37 @@ export class DAppClient extends Client {
             await this.setActivePeer(undefined);
             await this.setTransport(undefined);
         }
-        await this.storage.set(StorageKey.ACTIVE_ACCOUNT, account ? account.accountIdentifier : undefined);
-        await this.events.emit(BeaconEvent.ACTIVE_ACCOUNT_SET, account);
+        if (account) {
+            await this.storage.set(StorageKey.ACTIVE_ACCOUNT, account.accountIdentifier);
+        }
+        else if (!activeAccountAlreadyCleared) {
+            await this.storage.delete(StorageKey.ACTIVE_ACCOUNT);
+        }
+        if (!activeAccountAlreadyCleared) {
+            await this.events.emit(BeaconEvent.ACTIVE_ACCOUNT_SET, account);
+        }
         return;
     }
+    async isActiveAccountAlreadyCleared() {
+        return this._activeAccount.isResolved() && !(await this.getActiveAccount());
+    }
+    async recoverActiveAccountFromAccountsChange() {
+        const activeAccountIdentifier = await this.storage.get(StorageKey.ACTIVE_ACCOUNT);
+        if (!activeAccountIdentifier || activeAccountIdentifier === 'undefined') {
+            return;
+        }
+        if (this._activeAccount.isResolved()) {
+            const activeAccount = await this.getActiveAccount();
+            if (activeAccount?.accountIdentifier === activeAccountIdentifier) {
+                return;
+            }
+        }
+        const account = await this.getAccount(activeAccountIdentifier);
+        if (!account) {
+            return;
+        }
+        await this.setActiveAccount(account);
+    }
     /**
      * Clear the active account
      */
@@ -814,30 +1166,16 @@ export class DAppClient extends Client {
             })
         };
     }
-    async updateMetricsStorage(payload) {
-        const queue = await 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(`${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 */
     async checkMakeRequest() {
         const isResolved = this._transport.isResolved();
         const isWCInstance = isResolved && (await this.transport) instanceof WalletConnectTransport;
@@ -882,14 +1220,19 @@ export class DAppClient extends Client {
     /**
      * Remove all peers and all accounts that have been connected through those peers
      */
-    async removeAllPeers(sendDisconnectToPeers = false) {
-        const transport = await this.transport;
+    async removeAllPeers(sendDisconnectToPeers = false, options = {}) {
+        const transport = (await this.transport);
         const peers = await transport.getPeers();
-        const removePeerResult = transport.removeAllPeers();
+        const removePeerResult = await transport.removeAllPeers();
         await this.removeAccountsForPeers(peers);
         if (sendDisconnectToPeers) {
             const disconnectPromises = peers.map((peer) => this.sendDisconnectToPeer(peer, transport));
-            await Promise.all(disconnectPromises);
+            if (options.ignoreDisconnectErrors) {
+                await Promise.allSettled(disconnectPromises);
+            }
+            else {
+                await Promise.all(disconnectPromises);
+            }
         }
         return removePeerResult;
     }
@@ -994,13 +1337,15 @@ export class DAppClient extends Client {
         this.sendMetrics('performance-metrics/save', await this.buildPayload('connect', 'start'));
         const logId = `makeRequestV3 ${Date.now()}`;
         logger.time(true, logId);
-        const { message: response, connectionInfo } = await this.makeRequestV3(request).catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
+        let resolved;
+        try {
+            resolved = await this.makeRequestV3(request);
+        }
+        catch (requestError) {
+            await this.runRequestErrorSideEffects(request, requestError, logId);
+            throw requestError;
+        }
+        const { message: response, connectionInfo } = resolved;
         logger.time(false, logId);
         this.sendMetrics('performance-metrics/save', await this.buildPayload('connect', 'start'));
         logger.log('RESPONSE V3', response, connectionInfo);
@@ -1064,14 +1409,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequestV3(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message: response, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('message', 'success'));
         await blockchain.handleResponse({
@@ -1095,16 +1444,34 @@ export class DAppClient extends Client {
      * @param input The message details we need to prepare the PermissionRequest message.
      */
     async requestPermissions(input) {
-        if (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 await requestPermissionsPromise;
+        }
+        finally {
+            if (this._requestPermissionsPromise === requestPermissionsPromise) {
+                this._requestPermissionsPromise = undefined;
+                this._requestPermissionsKey = undefined;
+            }
+        }
+    }
+    async requestPermissionsInternal(scopes) {
         const request = {
             appMetadata: await this.getOwnAppMetadata(),
             type: BeaconMessageType.PermissionRequest,
             network: this.network,
-            scopes: input && input.scopes
-                ? input.scopes
-                : [PermissionScope.OPERATION_REQUEST, PermissionScope.SIGN]
+            scopes
         };
         this.analytics.track('event', 'DAppClient', 'Permission requested');
         this.sendMetrics('performance-metrics/save', await this.buildPayload('connect', 'start'));
@@ -1113,14 +1480,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest()) || !(await this.getActiveAccount())
             ? this.makeRequest(request, undefined, undefined)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('connect', 'success'));
         logger.log('requestPermissions', '######## MESSAGE #######');
@@ -1147,6 +1518,17 @@ export class DAppClient extends 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
+            : [PermissionScope.OPERATION_REQUEST, 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.
@@ -1173,14 +1555,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequest(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('message', 'success'));
         this.analytics.track('event', 'DAppClient', `Proof of event challenge ${message.isAccepted ? 'accepted' : 'refused'}`, { address: activeAccount.address });
@@ -1219,14 +1605,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequest(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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 });
         await this.notifySuccess(request, {
@@ -1286,14 +1676,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequest(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('message', 'success'));
         await this.notifySuccess(request, {
@@ -1381,14 +1775,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequest(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('message', 'success'));
         await this.notifySuccess(request, {
@@ -1428,14 +1826,18 @@ export class DAppClient extends Client {
         const res = (await this.checkMakeRequest())
             ? this.makeRequest(request)
             : this.makeRequestBC(request);
-        res.catch(async (requestError) => {
-            requestError.errorType === BeaconErrorType.ABORTED_ERROR
-                ? this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'))
-                : this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
-            logger.time(false, logId);
-            throw await this.handleRequestError(request, requestError);
-        });
-        const { message, connectionInfo } = (await res);
+        let resolved;
+        try {
+            resolved = await res;
+        }
+        catch (requestError) {
+            await 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', await this.buildPayload('message', 'success'));
         await this.notifySuccess(request, {
@@ -1501,11 +1903,14 @@ export class DAppClient extends Client {
      * @param peersToRemove An array of peers for which accounts should be removed
      */
     async removeAccountsForPeers(peersToRemove) {
+        if (peersToRemove.length === 0) {
+            return;
+        }
         const peerIdsToRemove = peersToRemove.map((peer) => peer.senderId);
         return this.removeAccountsForPeerIds(peerIdsToRemove);
     }
     async removeAccountsForPeerIds(peerIds) {
-        const accounts = await this.accountManager.getAccounts();
+        const accounts = (await this.accountManager.getAccounts()) ?? [];
         // Remove all accounts with origin of the specified peer
         const accountsToRemove = accounts.filter((account) => peerIds.includes(account.senderId));
         const accountIdentifiersToRemove = accountsToRemove.map((accountInfo) => accountInfo.accountIdentifier);
@@ -1518,6 +1923,44 @@ export class DAppClient extends 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
+     */
+    async runRequestErrorSideEffects(request, rawError, logId) {
+        // 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 === BeaconErrorType.ABORTED_ERROR) {
+            this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'abort'));
+        }
+        else {
+            this.sendMetrics('performance-metrics/save', await this.buildPayload('message', 'error'));
+        }
+        logger.time(false, logId);
+        await this.handleRequestError(typedRequest, requestError).catch(() => undefined);
+    }
     /**
      * This message handles errors that we receive from the wallet.
      *
@@ -1685,18 +2128,8 @@ export class DAppClient extends Client {
     }
     async makeRequest(requestInput, skipResponse, otherTabMessageId) {
         const messageId = otherTabMessageId ?? (await generateGUID());
-        if (this._initPromise && this.isInitPending) {
-            await Promise.all([
-                this.postMessageTransport?.disconnect(),
-                this.walletConnectTransport?.disconnect()
-            ]);
-            this._initPromise = undefined;
-            this.hideUI(['toast']);
-        }
         logger.log('makeRequest', 'starting');
-        this.isInitPending = true;
         await this.init();
-        this.isInitPending = false;
         logger.log('makeRequest', 'after init');
         if (await this.addRequestAndCheckIfRateLimited()) {
             this.events
@@ -1722,20 +2155,37 @@ export class DAppClient extends Client {
             exposed = new ExposedPromise();
             this.addOpenRequest(request.id, exposed);
         }
-        const payload = await new Serializer().serialize(request);
-        const account = await this.getActiveAccount();
-        const peer = await this.getPeer(account);
-        const walletInfo = await this.getWalletInfo(peer, account);
-        logger.log('makeRequest', 'sending message', request);
         try {
-            ;
-            (await this.transport).send(payload, peer);
+            const payload = await new Serializer().serialize(request);
+            const account = await this.getActiveAccount();
+            const peer = await this.getPeer(account);
+            const walletInfo = await this.getWalletInfo(peer, account);
+            logger.log('makeRequest', 'sending message', request);
+            await (await this.transport).send(payload, peer);
             if (request.type !== BeaconMessageType.PermissionRequest ||
                 (this._activeAccount.isResolved() && (await this._activeAccount.promise))) {
                 this.tryToAppSwitch();
             }
+            if (!otherTabMessageId) {
+                this.events
+                    .emit(messageEvents[requestInput.type].sent, {
+                    walletInfo: {
+                        ...walletInfo,
+                        name: walletInfo.name ?? 'Wallet'
+                    },
+                    extraInfo: {
+                        resetCallback: async () => {
+                            await this.disconnect();
+                        }
+                    }
+                })
+                    .catch((emitError) => logger.warn('makeRequest', emitError));
+            }
         }
         catch (sendError) {
+            if (!skipResponse) {
+                this.clearOpenRequest(request.id);
+            }
             this.events.emit(BeaconEvent.INTERNAL_ERROR, {
                 text: 'Unable to send message. If this problem persists, please reset the connection and pair your wallet again.',
                 buttons: [
@@ -1750,21 +2200,6 @@ export class DAppClient extends Client {
             });
             throw sendError;
         }
-        if (!otherTabMessageId) {
-            this.events
-                .emit(messageEvents[requestInput.type].sent, {
-                walletInfo: {
-                    ...walletInfo,
-                    name: walletInfo.name ?? 'Wallet'
-                },
-                extraInfo: {
-                    resetCallback: async () => {
-                        this.disconnect();
-                    }
-                }
-            })
-                .catch((emitError) => console.warn(emitError));
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return exposed?.promise; // TODO: fix type
     }
@@ -1777,19 +2212,9 @@ export class DAppClient extends Client {
      * @param account The account that the message will be sent to
      */
     async makeRequestV3(requestInput, otherTabMessageId) {
-        if (this._initPromise && this.isInitPending) {
-            await Promise.all([
-                this.postMessageTransport?.disconnect(),
-                this.walletConnectTransport?.disconnect()
-            ]);
-            this._initPromise = undefined;
-            this.hideUI(['toast']);
-        }
         const messageId = otherTabMessageId ?? (await generateGUID());
         logger.log('makeRequest', 'starting');
-        this.isInitPending = true;
         await this.init(undefined, true);
-        this.isInitPending = false;
         logger.log('makeRequest', 'after init');
         if (await this.addRequestAndCheckIfRateLimited()) {
             this.events
@@ -1808,20 +2233,34 @@ export class DAppClient extends Client {
         };
         const exposed = new ExposedPromise();
         this.addOpenRequest(request.id, exposed);
-        const payload = await new Serializer().serialize(request);
-        const account = await this.getActiveAccount();
-        const peer = await this.getPeer(account);
-        const walletInfo = await this.getWalletInfo(peer, account);
-        logger.log('makeRequest', 'sending message', request);
         try {
-            ;
-            (await this.transport).send(payload, peer);
+            const payload = await new Serializer().serialize(request);
+            const account = await this.getActiveAccount();
+            const peer = await this.getPeer(account);
+            const walletInfo = await this.getWalletInfo(peer, account);
+            logger.log('makeRequest', 'sending message', request);
+            await (await this.transport).send(payload, peer);
             if (request.message.type !== BeaconMessageType.PermissionRequest ||
                 (this._activeAccount.isResolved() && (await this._activeAccount.promise))) {
                 this.tryToAppSwitch();
             }
+            const index = requestInput.type;
+            this.events
+                .emit(messageEvents[index].sent, {
+                walletInfo: {
+                    ...walletInfo,
+                    name: walletInfo.name ?? 'Wallet'
+                },
+                extraInfo: {
+                    resetCallback: async () => {
+                        await this.disconnect();
+                    }
+                }
+            })
+                .catch((emitError) => logger.warn('makeRequestV3', emitError));
         }
         catch (sendError) {
+            this.clearOpenRequest(request.id);
             this.events.emit(BeaconEvent.INTERNAL_ERROR, {
                 text: 'Unable to send message. If this problem persists, please reset the connection and pair your wallet again.',
                 buttons: [
@@ -1836,20 +2275,6 @@ export class DAppClient extends Client {
             });
             throw sendError;
         }
-        const index = requestInput.type;
-        this.events
-            .emit(messageEvents[index].sent, {
-            walletInfo: {
-                ...walletInfo,
-                name: walletInfo.name ?? 'Wallet'
-            },
-            extraInfo: {
-                resetCallback: async () => {
-                    this.disconnect();
-                }
-            }
-        })
-            .catch((emitError) => console.warn(emitError));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return exposed.promise; // TODO: fix type
     }
@@ -1889,24 +2314,140 @@ export class DAppClient extends Client {
         this.addOpenRequest(id, exposed);
         return exposed.promise;
     }
-    async disconnect() {
+    /**
+     * 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().
+     */
+    async disconnect(options = {}) {
+        const { notifyPeers = true } = options;
+        if (!this._disconnectPromise) {
+            this._disconnectNotifyPeers = false;
+        }
+        this._disconnectNotifyPeers = this._disconnectNotifyPeers || notifyPeers;
+        if (this._disconnectPromise) {
+            return this._disconnectPromise;
+        }
+        this._disconnectPromise = (async () => this.disconnectInternal())().finally(() => {
+            this._disconnectPromise = undefined;
+            this._disconnectNotifyPeers = false;
+        });
+        return this._disconnectPromise;
+    }
+    async disconnectInternal() {
+        this.abortPendingInit();
         if (!this._transport.isResolved()) {
-            throw new Error('No transport available.');
+            const initializedTransports = this.getInitializedTransports();
+            this.abortOpenRequests();
+            await this.removeAllPeersFromTransports(initializedTransports);
+            await this.clearActiveAccount();
+            await this.disconnectResolvedTransports(initializedTransports);
+            this.clearInternalTransportReferences();
+            return;
         }
-        const transport = await this.transport;
+        const transport = (await this.transport);
         if (transport.connectionStatus === TransportStatus.NOT_CONNECTED) {
-            throw new Error('Not connected.');
+            await this.clearActiveAccount();
+            this.abortOpenRequests();
+            return;
         }
         await this.createStateSnapshot();
         this.sendMetrics('performance-metrics/save', await this.buildPayload('disconnect', 'start'));
+        this.abortOpenRequests();
+        const transports = this.getResolvedTransports(transport);
+        await this.removeAllPeersFromTransports(transports);
         await this.clearActiveAccount();
-        if (!(transport instanceof WalletConnectTransport)) {
-            await transport.disconnect();
-        }
+        await this.disconnectResolvedTransports(transports);
+        this.clearInternalTransportReferences();
+        this.sendMetrics('performance-metrics/save', await 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;
-        this.sendMetrics('performance-metrics/save', await this.buildPayload('disconnect', 'success'));
+    }
+    async removeAllPeersFromTransports(transports) {
+        const peersByTransport = await Promise.all(transports.map(async (transport) => {
+            const transportPeers = await transport.getPeers();
+            return {
+                transport,
+                peers: transportPeers
+            };
+        }));
+        await Promise.all(peersByTransport.map(({ transport }) => transport.removeAllPeers()));
+        const peersToRemove = peersByTransport.flatMap(({ peers: transportPeers }) => transportPeers);
+        await this.removeAccountsForPeers(peersToRemove);
+        // If cleanup already removed peers, a late notify upgrade has nothing left to notify.
+        const sendDisconnectToPeers = this._disconnectNotifyPeers;
+        if (!sendDisconnectToPeers) {
+            return;
+        }
+        await 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(':');
+    }
+    async disconnectResolvedTransports(transports) {
+        const results = await Promise.allSettled(transports.map(async (transport) => {
+            if (this.isTransportConnected(transport)) {
+                await transport.disconnect();
+            }
+            if (this.hasClientCleanup(transport)) {
+                await 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 !== TransportStatus.NOT_CONNECTED;
     }
     /**
      * Adds a requests to the "openRequests" set so we know what messages have already been answered/handled.
@@ -1916,7 +2457,64 @@ export class DAppClient extends 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: BeaconMessageType.Error,
+                errorType: BeaconErrorType.PEER_UNREACHABLE,
+                senderId: '',
+                version: '2'
+            };
+            promise.reject(errorResponse);
+            this.clearOpenRequest(id);
+            this.events.emit(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();
     }
     async sendNotificationWithAccessToken(notification) {
         const { url, recipient, title, body, payload, protocolIdentifier, accessToken } = notification;
@@ -1938,26 +2536,33 @@ export class DAppClient extends Client {
         const signature = await signMessage(payloadBytes, {
             secretKey: Buffer.from(keypair.secretKey)
         });
-        const notificationResponse = await axios.post(`${url}/send`, {
-            recipient,
-            title,
-            body,
-            timestamp,
-            payload,
-            accessToken,
-            protocolIdentifier,
-            sender: {
-                name: this.name,
-                publicKey,
-                signature
-            }
+        const notificationResponse = await fetch(`${url}/send`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                recipient,
+                title,
+                body,
+                timestamp,
+                payload,
+                accessToken,
+                protocolIdentifier,
+                sender: {
+                    name: this.name,
+                    publicKey,
+                    signature
+                }
+            })
         });
-        return notificationResponse.data;
+        if (!notificationResponse.ok) {
+            throw new Error(`sendNotification failed: ${notificationResponse.status} ${notificationResponse.statusText}`);
+        }
+        return notificationResponse.json();
     }
     async onNewAccount(message, connectionInfo) {
         // TODO: Migration code. Remove sometime after 1.0.0 release.
         const tempPK = message.publicKey || message.pubkey || message.pubKey;
-        const publicKey = !!tempPK ? prefixPublicKey(tempPK) : undefined;
+        const publicKey = tempPK ? prefixPublicKey(tempPK) : undefined;
         if (!publicKey && !message.address) {
             throw new Error('PublicKey or Address must be defined');
         }