@tezos-x/octez.connect-dapp 5.0.4 → 5.0.5

package/dist/cjs/dapp-client/DAppClient.d.ts

@@ -88,6 +88,18 @@ export declare class DAppClient extends Client {
     private prepareRequest;
     private createStateSnapshot;
     private initUserID;
+    /**
+     * Disconnect the postMessage and P2P transports and drop all three instances.
+     *
+     * A dropped transport is not garbage. Its communication client keeps its
+     * `window` handlers (postMessage) or its matrix sync (P2P) until it is told to
+     * stop, so every path that used to just forget the instances left one more
+     * live client behind per connection. Every such path goes through here.
+     *
+     * WalletConnect is left to each call site: its session is shared across tabs
+     * and only the leader may close it, which the callers already handle.
+     */
+    private dropTransports;
     initInternalTransports(): Promise<void>;
     private initEvents;
     private onRelayerError;
@@ -302,5 +314,18 @@ export declare class DAppClient extends Client {
     private addOpenRequest;
     private sendNotificationWithAccessToken;
     private buildAccountInfosFromV4Fanout;
+    /**
+     * Is this message from the wallet behind the active account? Over P2P the
+     * senderId is already bound to the decrypting key (see handleResponse).
+     */
+    private isActiveWallet;
+    /** Is this message from a wallet we are paired with on this connection? */
+    private isPairedWallet;
+    /**
+     * A wallet-initiated disconnect. Strangers are ignored; a saved but inactive
+     * wallet only removes its own records; only the active wallet (or any paired
+     * wallet when no account is active) ends the session.
+     */
+    private onUnsolicitedDisconnect;
     private onNewAccount;
 }

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

@@ -157,11 +157,25 @@ class DAppClient extends octez_connect_core_1.Client {
             // normalized back to those same flat shapes — the wire dialect stays
             // invisible to integrators. Non-Tezos wrapped payloads keep the
             // pass-through of the generic permissionRequest/request API.
-            const isWrapped = (0, octez_connect_core_1.usesWrappedMessages)(wireMessage.version);
+            // The wrapped dialect is identified by its payload, not by the absence of
+            // a flat marker: `wrapBeaconMessage` only ever emits
+            // { id, version, senderId, message }. Routing on the version alone dropped
+            // every flat message stamped with the wrapped dialect's number -- which is
+            // how a wallet built outside this SDK (or on <= 4.8.6, echoing the peer's
+            // version) sends its `disconnect` -- so handleDisconnect never ran and the
+            // dApp kept the account connected until the user disconnected a second
+            // time (#52). Testing for `.message` positively routes that message down
+            // the flat path, and still reads a non-conformant wallet's wrapped
+            // envelope as wrapped even when it carries a redundant top-level `type`.
+            const hasWrappedPayload = Boolean(wireMessage.message);
+            const isWrapped = (0, octez_connect_core_1.usesWrappedMessages)(wireMessage.version) && hasWrappedPayload;
             // Issue #33: a V3-versioned message can arrive without its wrapped payload.
-            // Drop it safely instead of dereferencing an undefined payload, which would
-            // throw an unhandled rejection inside the transport subscription callback.
-            if (isWrapped && !wireMessage.message) {
+            // With no top-level `type` either it carries nothing to route on, so drop
+            // it instead of dereferencing an undefined payload, which would throw an
+            // unhandled rejection inside the transport subscription callback.
+            if ((0, octez_connect_core_1.usesWrappedMessages)(wireMessage.version) &&
+                !hasWrappedPayload &&
+                !('type' in wireMessage)) {
                 logger.log('handleResponse', 'Received wrapped message with undefined payload; dropping', wireMessage);
                 return;
             }
@@ -170,6 +184,13 @@ class DAppClient extends octez_connect_core_1.Client {
                 : wireMessage;
             const message = normalized !== null && normalized !== void 0 ? normalized : wireMessage;
             const typedMessage = normalized !== null && normalized !== void 0 ? normalized : wireMessage.message;
+            if ((connectionInfo.origin === octez_connect_types_1.Origin.P2P &&
+                message.senderId !== (yield (0, octez_connect_core_1.getSenderId)(connectionInfo.id))) ||
+                (connectionInfo.origin === octez_connect_types_1.Origin.EXTENSION &&
+                    !(yield this.isPairedWallet(message.senderId, connectionInfo)))) {
+                logger.warn('handleResponse', 'dropping message: senderId does not match its sender');
+                return;
+            }
             let appMetadata = normalized
                 ? typedMessage.appMetadata
                 : (_a = typedMessage.blockchainData) === null || _a === void 0 ? void 0 : _a.appMetadata;
@@ -217,7 +238,8 @@ class DAppClient extends octez_connect_core_1.Client {
             logger.log('handleResponse', 'Received message', message, connectionInfo);
             logger.log('### message ###', JSON.stringify(message));
             logger.log('### connectionInfo ###', connectionInfo);
-            const handleDisconnect = () => __awaiter(this, void 0, void 0, function* () {
+            // endSession=false: a saved but inactive wallet removes only its own records.
+            const handleDisconnect = (...args_1) => __awaiter(this, [...args_1], void 0, function* (endSession = true) {
                 var _a;
                 this.analytics.track('event', 'DAppClient', 'Disconnect received from Wallet');
                 const relevantTransport = connectionInfo.origin === octez_connect_types_1.Origin.P2P
@@ -233,11 +255,12 @@ class DAppClient extends octez_connect_core_1.Client {
                     }
                 }
                 yield this.removeAccountsForPeerIds([message.senderId]);
+                if (!endSession) {
+                    return;
+                }
                 yield this.events.emit(events_1.BeaconEvent.CHANNEL_CLOSED);
                 // Reset transport state so next requestPermissions() shows pairing modal
-                this.postMessageTransport = undefined;
-                this.p2pTransport = undefined;
-                this.walletConnectTransport = undefined;
+                yield this.dropTransports();
                 yield this.setTransport(undefined);
                 yield this.setActivePeer(undefined);
             });
@@ -284,10 +307,15 @@ class DAppClient extends octez_connect_core_1.Client {
             }
             else {
                 if (typedMessage.type === octez_connect_types_1.BeaconMessageType.Disconnect) {
-                    yield handleDisconnect();
+                    yield this.onUnsolicitedDisconnect(message.senderId, connectionInfo, handleDisconnect);
                 }
                 else if (typedMessage.type === octez_connect_types_1.BeaconMessageType.ChangeAccountRequest) {
-                    yield this.onNewAccount(typedMessage, connectionInfo);
+                    if (yield this.isActiveWallet(message.senderId, connectionInfo)) {
+                        yield this.onNewAccount(typedMessage, connectionInfo);
+                    }
+                    else {
+                        logger.warn('handleResponse', 'ignoring change account from a non-active wallet');
+                    }
                 }
             }
             if (this._transport.isResolved()) {
@@ -433,6 +461,30 @@ class DAppClient extends octez_connect_core_1.Client {
             this.storage.set(octez_connect_types_1.StorageKey.USER_ID, this.userId);
         });
     }
+    /**
+     * Disconnect the postMessage and P2P transports and drop all three instances.
+     *
+     * A dropped transport is not garbage. Its communication client keeps its
+     * `window` handlers (postMessage) or its matrix sync (P2P) until it is told to
+     * stop, so every path that used to just forget the instances left one more
+     * live client behind per connection. Every such path goes through here.
+     *
+     * WalletConnect is left to each call site: its session is shared across tabs
+     * and only the leader may close it, which the callers already handle.
+     */
+    dropTransports() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dropped = [this.postMessageTransport, this.p2pTransport].filter((transport) => transport !== undefined);
+            this.postMessageTransport = undefined;
+            this.p2pTransport = undefined;
+            this.walletConnectTransport = undefined;
+            // Best effort: a transport that fails to disconnect is still dropped, and
+            // the others are still disconnected.
+            yield Promise.all(dropped.map((transport) => transport.disconnect().catch((error) => {
+                logger.warn('dropTransports', error instanceof Error ? error.message : String(error));
+            })));
+        });
+    }
     initInternalTransports() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -546,6 +598,7 @@ class DAppClient extends octez_connect_core_1.Client {
         });
         return __awaiter(this, void 0, void 0, function* () {
             yield this.createStateSnapshot();
+            yield this.dropTransports();
             yield _super.destroy.call(this);
         });
     }
@@ -676,13 +729,19 @@ class DAppClient extends octez_connect_core_1.Client {
                         });
                         const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
                             logger.log('init', 'ABORTED');
+                            // Popup closed: replies to the QR code / request it showed no longer count.
+                            stopListening();
                             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()
+                                walletConnectTransport === null || walletConnectTransport === void 0 ? void 0 : walletConnectTransport.disconnect(),
+                                // Disconnects postMessage and P2P -- `postMessageTransport` above
+                                // is this.postMessageTransport, so dropTransports() already owns
+                                // it -- and forgets all three. It also stops the P2P client
+                                // started for the pairing QR: if its start is still pending,
+                                // P2PCommunicationClient.start() notices the stop once the login
+                                // completes and shuts it down.
+                                this.dropTransports()
                             ]);
-                            this.postMessageTransport = this.walletConnectTransport = this.p2pTransport = undefined;
                             this._activeAccount.isResolved() && this.clearActiveAccount();
                             this.events.emit(events_1.BeaconEvent.PAIR_ABORTED).catch((emitError) => console.warn(emitError));
                             if (this._initPromiseReject) {
@@ -761,17 +820,13 @@ class DAppClient extends octez_connect_core_1.Client {
     }
     resetInvalidState() {
         return __awaiter(this, arguments, void 0, function* (emit = true) {
-            var _a, _b;
             this.accountManager.removeAllAccounts();
             this._activeAccount = octez_connect_utils_1.ExposedPromise.resolve(undefined);
             this.storage.set(octez_connect_types_1.StorageKey.ACTIVE_ACCOUNT, undefined);
             emit && this.events.emit(events_1.BeaconEvent.INVALID_ACTIVE_ACCOUNT_STATE);
             !emit && this.hideUI(['alert']);
-            yield Promise.all([
-                (_a = this.postMessageTransport) === null || _a === void 0 ? void 0 : _a.disconnect(),
-                (_b = this.walletConnectTransport) === null || _b === void 0 ? void 0 : _b.disconnect()
-            ]);
-            this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+            const walletConnectTransport = this.walletConnectTransport;
+            yield Promise.all([walletConnectTransport === null || walletConnectTransport === void 0 ? void 0 : walletConnectTransport.disconnect(), this.dropTransports()]);
             yield this.setActivePeer(undefined);
             yield this.setTransport(undefined);
             this._initPromise = undefined;
@@ -805,7 +860,7 @@ class DAppClient extends octez_connect_core_1.Client {
                 if (!this.debounceSetActiveAccount && transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport) {
                     this.debounceSetActiveAccount = true;
                     this._initPromise = undefined;
-                    this.postMessageTransport = this.p2pTransport = this.walletConnectTransport = undefined;
+                    yield this.dropTransports();
                     if (this.multiTabChannel.isLeader() || (0, octez_connect_ui_1.isMobileOS)(window)) {
                         yield transport.disconnect();
                         this.openRequestsOtherTabs.clear();
@@ -1825,9 +1880,7 @@ class DAppClient extends octez_connect_core_1.Client {
                 if (request.type === octez_connect_types_1.BeaconMessageType.PermissionRequest &&
                     (yield this.getActiveAccount()) === undefined) {
                     this._initPromise = undefined;
-                    this.postMessageTransport = undefined;
-                    this.p2pTransport = undefined;
-                    this.walletConnectTransport = undefined;
+                    yield this.dropTransports();
                     yield this.setTransport();
                     yield this.setActivePeer();
                 }
@@ -2414,22 +2467,11 @@ class DAppClient extends octez_connect_core_1.Client {
             }
             yield this.clearActiveAccount();
             if (!(transport instanceof octez_connect_transport_walletconnect_1.WalletConnectTransport)) {
-                try {
-                    yield transport.disconnect();
-                }
-                catch (disconnectError) {
-                    const message = disconnectError instanceof Error ? disconnectError.message : String(disconnectError);
-                    if (typeof message === 'string' && message.includes('Syncing stopped manually')) {
-                        logger.log('disconnect', 'Matrix sync stopped manually');
-                    }
-                    else {
-                        throw disconnectError;
-                    }
-                }
+                yield transport.disconnect();
             }
-            this.postMessageTransport = undefined;
-            this.p2pTransport = undefined;
-            this.walletConnectTransport = undefined;
+            // The active transport is already disconnected above; this stops the
+            // other one (a second disconnect is a no-op) and drops the instances.
+            yield this.dropTransports();
             yield this.setTransport();
             this._initPromise = undefined;
             this._initPromiseReject = undefined;
@@ -2545,6 +2587,61 @@ class DAppClient extends octez_connect_core_1.Client {
             })));
         });
     }
+    /**
+     * Is this message from the wallet behind the active account? Over P2P the
+     * senderId is already bound to the decrypting key (see handleResponse).
+     */
+    isActiveWallet(senderId, connectionInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (connectionInfo.origin === octez_connect_types_1.Origin.WALLETCONNECT) {
+                return true;
+            }
+            yield this.activeAccountLoaded;
+            const active = yield this.getActiveAccount();
+            return Boolean(active &&
+                active.senderId === senderId &&
+                active.origin.type === connectionInfo.origin &&
+                active.origin.id === connectionInfo.id);
+        });
+    }
+    /** Is this message from a wallet we are paired with on this connection? */
+    isPairedWallet(senderId, connectionInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (connectionInfo.origin === octez_connect_types_1.Origin.P2P) {
+                const peers = (_a = (yield this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_P2P_PEERS_DAPP))) !== null && _a !== void 0 ? _a : [];
+                return peers.some((peer) => peer.publicKey === connectionInfo.id);
+            }
+            if (connectionInfo.origin === octez_connect_types_1.Origin.EXTENSION) {
+                const peers = (_b = (yield this.storage.get(octez_connect_types_1.StorageKey.TRANSPORT_POSTMESSAGE_PEERS_DAPP))) !== null && _b !== void 0 ? _b : [];
+                for (const peer of peers) {
+                    if (peer.extensionId === connectionInfo.id &&
+                        (yield (0, octez_connect_core_1.getSenderId)(peer.publicKey)) === senderId) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return true; // WalletConnect: unchanged, see isActiveWallet
+        });
+    }
+    /**
+     * A wallet-initiated disconnect. Strangers are ignored; a saved but inactive
+     * wallet only removes its own records; only the active wallet (or any paired
+     * wallet when no account is active) ends the session.
+     */
+    onUnsolicitedDisconnect(senderId, connectionInfo, handleDisconnect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.isPairedWallet(senderId, connectionInfo))) {
+                logger.warn('handleResponse', 'ignoring disconnect from an unknown wallet');
+                return;
+            }
+            yield this.activeAccountLoaded;
+            const active = yield this.getActiveAccount();
+            const endSession = !active || (yield this.isActiveWallet(senderId, connectionInfo));
+            yield handleDisconnect(endSession);
+        });
+    }
     onNewAccount(message, connectionInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -2555,6 +2652,15 @@ class DAppClient extends octez_connect_core_1.Client {
                 throw new Error('PublicKey or Address must be defined');
             }
             const address = (_a = message.address) !== null && _a !== void 0 ? _a : (yield (0, octez_connect_utils_1.getAddressFromPublicKey)(publicKey));
+            if (connectionInfo.origin !== octez_connect_types_1.Origin.WALLETCONNECT &&
+                publicKey &&
+                message.address &&
+                message.walletType !== 'abstracted_account') {
+                const derived = yield (0, octez_connect_utils_1.getAddressFromPublicKey)(publicKey).catch(() => undefined);
+                if (derived && derived !== message.address) {
+                    throw new Error(`Address "${message.address}" does not match its public key`);
+                }
+            }
             if (!(0, octez_connect_utils_1.isValidAddress)(address)) {
                 throw new Error(`Invalid address: "${address}"`);
             }