@matter/protocol 0.16.8-alpha.0-20260123-dff2cae52 → 0.16.8-alpha.0-20260127-65e1b40e2

package/src/protocol/MessageChannel.ts

@@ -6,60 +6,14 @@
 
 import { Message, MessageCodec } from "#codec/MessageCodec.js";
 import { Mark } from "#common/Mark.js";
-import {
-    Bytes,
-    Channel,
-    Diagnostic,
-    Duration,
-    IpNetworkChannel,
-    Logger,
-    MatterFlowError,
-    MaybePromise,
-    Millis,
-    Seconds,
-} from "#general";
+import { Bytes, Channel, Diagnostic, Duration, IpNetworkChannel, Logger, MaybePromise } from "#general";
 import type { ExchangeLogContext } from "#protocol/MessageExchange.js";
 import type { Session } from "#session/Session.js";
 import type { SessionParameters } from "#session/SessionParameters.js";
+import { MRP } from "./MRP.js";
 
 const logger = new Logger("MessageChannel");
 
-/**
- * Default expected processing time for a messages in milliseconds. The value is derived from kExpectedIMProcessingTime
- * from chip implementation. This is basically the default used with different names, also kExpectedLowProcessingTime or
- * kExpectedSigma1ProcessingTime.
- */
-export const DEFAULT_EXPECTED_PROCESSING_TIME = Seconds(2);
-
-/**
- * The buffer time in milliseconds to add to the peer response time to also consider network delays and other factors.
- * TODO: This is a pure guess and should be adjusted in the future.
- */
-const PEER_RESPONSE_TIME_BUFFER = Seconds(5);
-
-export namespace MRP {
-    /**
-     * The maximum number of transmission attempts for a given reliable message. The sender MAY choose this value as it
-     * sees fit.
-     */
-    export const MAX_TRANSMISSIONS = 5;
-
-    /** The base number for the exponential backoff equation. */
-    export const BACKOFF_BASE = 1.6;
-
-    /** The scaler for random jitter in the backoff equation. */
-    export const BACKOFF_JITTER = 0.25;
-
-    /** The scaler margin increase to backoff over the peer sleepy interval. */
-    export const BACKOFF_MARGIN = 1.1;
-
-    /** The number of retransmissions before transitioning from linear to exponential backoff. */
-    export const BACKOFF_THRESHOLD = 1;
-
-    /** @see {@link MatterSpecification.v12.Core}, section 4.11.8 */
-    export const STANDALONE_ACK_TIMEOUT = Millis(200);
-}
-
 export class MessageChannel implements Channel<Message> {
     public closed = false;
     #onClose?: () => MaybePromise<void>;
@@ -135,35 +89,16 @@ export class MessageChannel implements Channel<Message> {
     calculateMaximumPeerResponseTime(
         peerSessionParameters: SessionParameters,
         localSessionParameters: SessionParameters,
-        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
+        expectedProcessingTime?: Duration,
     ): Duration {
-        switch (this.channel.type) {
-            case "tcp":
-                // TCP uses 30s timeout according to chip sdk implementation, so do the same
-                return Millis(Seconds(30) + PEER_RESPONSE_TIME_BUFFER);
-
-            case "udp":
-                // UDP normally uses MRP, if not we have Group communication, which normally have no responses
-                if (!this.session.usesMrp) {
-                    throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
-                }
-                // Calculate the maximum time till the peer got our last retry and worst case for the way back
-                return Millis(
-                    this.#calculateMrpMaximumPeerResponseTime(peerSessionParameters) +
-                        this.#calculateMrpMaximumPeerResponseTime(localSessionParameters) +
-                        expectedProcessingTime +
-                        PEER_RESPONSE_TIME_BUFFER,
-                );
-
-            case "ble":
-                // chip sdk uses BTP_ACK_TIMEOUT_MS which is wrong in my eyes, so we use static 30s as like TCP here
-                return Millis(Seconds(30) + PEER_RESPONSE_TIME_BUFFER);
-
-            default:
-                throw new MatterFlowError(
-                    `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`,
-                );
-        }
+        return MRP.maxPeerResponseTimeOf({
+            peerSessionParameters,
+            localSessionParameters,
+            channelType: this.channel.type,
+            isPeerActive: this.session.isPeerActive,
+            usesMrp: this.session.usesMrp,
+            expectedProcessingTime,
+        });
     }
 
     /**
@@ -175,30 +110,10 @@ export class MessageChannel implements Channel<Message> {
      * @see {@link MatterSpecification.v10.Core}, section 4.11.2.1
      */
     getMrpResubmissionBackOffTime(retransmissionCount: number, sessionParameters?: SessionParameters) {
-        const { activeInterval, idleInterval } = sessionParameters ?? this.session.parameters;
-        // For the first message of a new exchange ... SHALL be set according to the idle state of the peer node.
-        // For all subsequent messages of the exchange, ... SHOULD be set according to the active state of the peer node
-        const peerActive = retransmissionCount > 0 && (sessionParameters !== undefined || this.session.isPeerActive);
-        const baseInterval = peerActive ? activeInterval : idleInterval;
-        return Millis.floor(
-            Millis(
-                baseInterval *
-                    MRP.BACKOFF_MARGIN *
-                    Math.pow(MRP.BACKOFF_BASE, Math.max(0, retransmissionCount - MRP.BACKOFF_THRESHOLD)) *
-                    (1 + (sessionParameters !== undefined ? 1 : Math.random()) * MRP.BACKOFF_JITTER),
-            ),
-        );
-    }
-
-    /** Calculates the maximum time the peer might take to respond when using MRP for one direction. */
-    #calculateMrpMaximumPeerResponseTime(sessionParameters: SessionParameters) {
-        let finalWaitTime = 0;
-
-        // and then add the time the other side needs for a full resubmission cycle under the assumption we are active
-        for (let i = 0; i < MRP.MAX_TRANSMISSIONS; i++) {
-            finalWaitTime = Millis(finalWaitTime + this.getMrpResubmissionBackOffTime(i, sessionParameters));
-        }
-
-        return finalWaitTime;
+        return MRP.maxRetransmissionIntervalOf({
+            transmissionNumber: retransmissionCount,
+            sessionParameters: sessionParameters ?? this.session.parameters,
+            isPeerActive: this.session.isPeerActive,
+        });
     }
 }

package/src/protocol/MessageExchange.ts

@@ -37,7 +37,8 @@ import {
     StatusResponseError,
 } from "#types";
 import { RetransmissionLimitReachedError, SessionClosedError, UnexpectedMessageError } from "./errors.js";
-import { DEFAULT_EXPECTED_PROCESSING_TIME, MessageChannel, MRP } from "./MessageChannel.js";
+import { MessageChannel } from "./MessageChannel.js";
+import { MRP } from "./MRP.js";
 
 const logger = Logger.get("MessageExchange");
 
@@ -311,7 +312,7 @@ export class MessageExchange {
                     // Ignore if this is a standalone ack, probably this was a retransmission.
                 } else {
                     throw new MatterFlowError(
-                        `Incorrect ack received. Expected ${sentMessageIdToAck}, received: ${ackedMessageId}`,
+                        `Incorrect ack received. Expected ${hex.fixed(sentMessageIdToAck, 8)}, received: ${hex.fixed(ackedMessageId, 8)}`,
                     );
                 }
             } else {
@@ -349,7 +350,7 @@ export class MessageExchange {
         const {
             expectAckOnly = false,
             disableMrpLogic,
-            expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
+            expectedProcessingTime = MRP.DEFAULT_EXPECTED_PROCESSING_TIME,
             includeAcknowledgeMessageId,
             logContext,
             protocolId = this.#protocolId,

package/src/protocol/index.ts

@@ -13,6 +13,7 @@ export * from "./MessageChannel.js";
 export * from "./MessageCounter.js";
 export * from "./MessageExchange.js";
 export * from "./MessageReceptionState.js";
+export * from "./MRP.js";
 export * from "./ProtocolHandler.js";
 export * from "./ProtocolMocks.js";
 export * from "./ProtocolStatusMessage.js";

package/src/session/NodeSession.ts

@@ -125,14 +125,14 @@ export class NodeSession extends SecureSession {
         this.#caseAuthenticatedTags = caseAuthenticatedTags ?? [];
         this.#isInitiator = isInitiator;
 
-        manager?.sessions.add(this);
-        fabric?.addSession(this);
-
         logger.debug(
             `Created secure ${this.isPase ? "PASE" : "CASE"} session for fabric index ${fabric?.fabricIndex}`,
             this.via,
             this.parameterDiagnostics,
         );
+
+        manager?.sessions.add(this);
+        fabric?.addSession(this);
     }
 
     get parameterDiagnostics() {

package/src/session/Session.ts

@@ -374,6 +374,7 @@ export abstract class Session {
 export namespace Session {
     export interface CommonConfig {
         manager?: SessionManager;
+        delayManagerRegistration?: true;
         channel?: Channel<Bytes>;
     }
 

package/src/session/case/CaseClient.ts

@@ -7,7 +7,7 @@
 import { Icac } from "#certificate/kinds/Icac.js";
 import { Noc } from "#certificate/kinds/Noc.js";
 import { Fabric } from "#fabric/Fabric.js";
-import { Bytes, Duration, EcdsaSignature, Logger, PublicKey, UnexpectedDataError } from "#general";
+import { AbortedError, Bytes, Duration, EcdsaSignature, Logger, PublicKey, UnexpectedDataError } from "#general";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { RetransmissionLimitReachedError } from "#protocol/errors.js";
 import { ChannelStatusResponseError } from "#securechannel/SecureChannelMessenger.js";
@@ -45,7 +45,13 @@ export class CaseClient {
         try {
             return await this.#doPair(messenger, exchange, fabric, peerNodeId, caseAuthenticatedTags);
         } catch (error) {
-            if (!(error instanceof ChannelStatusResponseError || error instanceof RetransmissionLimitReachedError)) {
+            if (
+                !(
+                    error instanceof ChannelStatusResponseError ||
+                    error instanceof RetransmissionLimitReachedError ||
+                    error instanceof AbortedError
+                )
+            ) {
                 await messenger.sendError(SecureChannelStatusCode.InvalidParam);
             }
             throw error;

package/src/session/case/CaseServer.ts

@@ -153,6 +153,7 @@ export class CaseServer implements ProtocolHandler {
             isResumption: true,
             peerSessionParameters: cx.peerSessionParams,
             caseAuthenticatedTags,
+            delayManagerRegistration: true, // Session establishment could still fail, so add session ourselves to the manager
         });
 
         // Generate sigma 2 resume
@@ -173,8 +174,11 @@ export class CaseServer implements ProtocolHandler {
             throw error;
         }
 
+        // Now we are sure, add the session to the manager
         NodeSession.logNew(logger, "Resumed", secureSession, cx.messenger, fabric, peerNodeId);
 
+        this.#sessions.sessions.add(secureSession);
+
         cx.resumptionRecord.resumptionId = cx.localResumptionId; /* Update the ID */
 
         // Wait for success on the peer side