@matter/protocol 0.15.4 → 0.15.5

package/src/interaction/SubscriptionClient.ts

@@ -5,10 +5,11 @@
  */
 
 import { Environment, Environmental, Logger, MaybePromise, Time, Timer } from "#general";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
-import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+import { IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
 
 const logger = Logger.get("SubscriptionClient");
 
@@ -16,7 +17,7 @@ export interface RegisteredSubscription {
     id: number;
     maximumPeerResponseTimeMs: number;
     maxIntervalS: number;
-    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onData: (dataReport: DecodedDataReport) => MaybePromise<void>;
     onTimeout?: () => void;
 }
 
@@ -28,7 +29,7 @@ export interface RegisteredSubscription {
 export class SubscriptionClient implements ProtocolHandler {
     readonly id = INTERACTION_PROTOCOL_ID;
     readonly requiresSecureSession = true;
-    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #listeners = new Map<number, (dataReport: DecodedDataReport) => MaybePromise<void>>();
     readonly #timeouts = new Map<number, Timer>();
 
     constructor() {}
@@ -80,10 +81,10 @@ export class SubscriptionClient implements ProtocolHandler {
     async onNewExchange(exchange: MessageExchange) {
         const messenger = new IncomingInteractionClientMessenger(exchange);
 
-        let dataReport: DataReport;
+        let dataReport: DecodedDataReport;
         try {
             // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
-            dataReport = await messenger.readAggregateDataReport([...this.#listeners.keys()]);
+            dataReport = await messenger.readAggregateDataReport(undefined, [...this.#listeners.keys()]);
         } finally {
             messenger.close().catch(error => logger.info("Error closing client messenger", error));
         }

package/src/mdns/MdnsScanner.ts

@@ -1042,8 +1042,7 @@ export class MdnsScanner implements Scanner {
         if (this.#closing) return;
         const message = DnsCodec.decode(messageBytes);
         if (message === undefined) return; // The message cannot be parsed
-        if (message.messageType !== DnsMessageType.Response && message.messageType !== DnsMessageType.TruncatedResponse)
-            return;
+        if (!DnsMessageType.isResponse(message.messageType)) return;
 
         const answers = this.#structureAnswers([...message.answers, ...message.additionalRecords]);
 

package/src/mdns/MdnsServer.ts

@@ -100,8 +100,8 @@ export class MdnsServer {
         const message = DnsCodec.decode(messageBytes);
         if (message === undefined) return; // The message cannot be parsed
         const { transactionId, messageType, queries, answers: knownAnswers } = message;
-        if (messageType !== DnsMessageType.Query && messageType !== DnsMessageType.TruncatedQuery) return;
-        if (queries.length === 0) return; // No queries to answer, can happen in a TruncatedQuery, let's ignore for now
+        if (!DnsMessageType.isQuery(messageType)) return;
+        if (queries.length === 0) return; // TODO correctly handle TruncatedQueries by waiting and combining multiple queries
         for (const portRecords of records.values()) {
             let answers = queries.flatMap(query => this.#queryRecords(query, portRecords));
             if (answers.length === 0) continue;

package/src/peer/PeerAddressStore.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ReadScope } from "#action/client/ReadScope.js";
 import { Construction, MaybePromise } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
@@ -27,7 +28,7 @@ export abstract class PeerDataStore {
     abstract maxEventNumber: EventNumber;
     abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
 
-    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[]): MaybePromise<void>;
+    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[], scope: ReadScope): MaybePromise<void>;
 
     // TODO: Find a maybe better way to achieve this without functions
     abstract retrieveAttribute(
@@ -41,4 +42,5 @@ export abstract class PeerDataStore {
         filterEndpointId?: EndpointNumber,
         filterClusterId?: ClusterId,
     ): { endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[];
+    abstract cleanupAttributeData(endpointId: EndpointNumber, clusterIds?: ClusterId[]): MaybePromise<void>;
 }

package/src/session/SessionManager.ts

@@ -21,6 +21,7 @@ import {
     ObserverGroup,
     StorageContext,
     StorageManager,
+    toHex,
 } from "#general";
 import { Subscription } from "#interaction/Subscription.js";
 import { Specification } from "#model";
@@ -76,6 +77,7 @@ type ResumptionStorageRecord = {
     sharedSecret: Uint8Array;
     resumptionId: Uint8Array;
     fabricId: FabricId;
+    fabricIndex: FabricIndex;
     peerNodeId: NodeId;
     sessionParameters: {
         idleIntervalMs: number;
@@ -545,21 +547,21 @@ export class SessionManager {
                 ([
                     address,
                     { sharedSecret, resumptionId, peerNodeId, fabric, sessionParameters, caseAuthenticatedTags },
-                ]) =>
-                    ({
-                        nodeId: address.nodeId,
-                        sharedSecret,
-                        resumptionId,
-                        fabricId: fabric.fabricId,
-                        peerNodeId: peerNodeId,
-                        sessionParameters: {
-                            ...sessionParameters,
-                            supportedTransports: sessionParameters.supportedTransports
-                                ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
-                                : undefined,
-                        },
-                        caseAuthenticatedTags,
-                    }) as ResumptionStorageRecord,
+                ]): ResumptionStorageRecord => ({
+                    nodeId: address.nodeId,
+                    sharedSecret,
+                    resumptionId,
+                    fabricId: fabric.fabricId,
+                    fabricIndex: fabric.fabricIndex,
+                    peerNodeId: peerNodeId,
+                    sessionParameters: {
+                        ...sessionParameters,
+                        supportedTransports: sessionParameters.supportedTransports
+                            ? SupportedTransportsSchema.encode(sessionParameters.supportedTransports)
+                            : undefined,
+                    },
+                    caseAuthenticatedTags,
+                }),
             ),
         );
     }
@@ -578,6 +580,7 @@ export class SessionManager {
                 sharedSecret,
                 resumptionId,
                 fabricId,
+                fabricIndex,
                 peerNodeId,
                 sessionParameters: {
                     idleIntervalMs,
@@ -592,19 +595,27 @@ export class SessionManager {
                 } = {},
                 caseAuthenticatedTags,
             }) => {
-                const fabric = this.#context.fabrics.find(fabric => fabric.fabricId === fabricId);
-                logger.info(
-                    "restoring resumption record for node",
-                    nodeId,
-                    "and peer node",
-                    peerNodeId,
-                    "for fabric index",
-                    fabric?.fabricIndex,
+                const fabric = this.#context.fabrics.find(
+                    fabric =>
+                        fabric.fabricId === fabricId &&
+                        // Backward compatibility logic: fabricIndex was added later (0.15.5), so it might be undefined in older records
+                        (fabricIndex === undefined || fabric.fabricIndex === fabricIndex),
                 );
                 if (!fabric) {
-                    logger.error("fabric not found for resumption record", fabricId);
+                    logger.warn(
+                        `Ignoring resumption record for fabric 0x${toHex(fabricId)} and index ${fabricIndex} because we cannot find a matching fabric`,
+                    );
                     return;
                 }
+                logger.info(
+                    "restoring resumption record for node",
+                    fabric.addressOf(nodeId).toString(),
+                    "and peer node",
+                    fabric.addressOf(peerNodeId).toString(),
+                    "for fabric id",
+                    `0x${toHex(fabric.fabricId)}`,
+                    `(0x${toHex(fabric.rootVendorId)}, "${fabric?.label}")`,
+                );
                 this.#resumptionRecords.set(fabric.addressOf(nodeId), {
                     sharedSecret,
                     resumptionId,

package/src/session/pase/PaseServer.ts

@@ -68,7 +68,8 @@ export class PaseServer implements ProtocolHandler {
             // successfully established a session, the Commissionee SHALL NOT accept any more requests for new PASE
             // sessions until session establishment fails or the successfully established PASE session is terminated on
             // the commissioning channel.
-            if (this.sessions.getPaseSession()) {
+            const paseSession = this.sessions.getPaseSession();
+            if (paseSession !== undefined && !paseSession.isClosing) {
                 logger.info("Pase server: Pairing already in progress (PASE session exists), ignoring new exchange.");
             } else if (this.#pairingTimer?.isRunning) {
                 logger.info(