@matter/protocol 0.16.8-alpha.0-20260125-38e62bc3e → 0.16.8-alpha.0-20260127-de48449ad

package/src/protocol/MessageChannel.ts

@@ -12,64 +12,38 @@ import {
     Diagnostic,
     Duration,
     IpNetworkChannel,
+    isIpNetworkChannel,
     Logger,
-    MatterFlowError,
     MaybePromise,
-    Millis,
-    Seconds,
+    ObservableValue,
+    sameIpNetworkChannel,
+    ServerAddressUdp,
 } 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> {
+    #channel: Channel<Bytes>;
+    #networkAddress = ObservableValue<[ServerAddressUdp]>();
+    #isIpNetworkChannel = false;
     public closed = false;
     #onClose?: () => MaybePromise<void>;
     // When the session is supporting MRP and the channel is not reliable, use MRP handling
 
     constructor(
-        readonly channel: Channel<Bytes>,
+        channel: Channel<Bytes>,
         readonly session: Session,
         onClose?: () => MaybePromise<void>,
     ) {
+        this.#channel = channel;
+        if (isIpNetworkChannel(channel)) {
+            this.#isIpNetworkChannel = true;
+            this.#networkAddress.emit(channel.networkAddress);
+        }
         this.#onClose = onClose;
     }
 
@@ -79,7 +53,7 @@ export class MessageChannel implements Channel<Message> {
 
     /** Is the underlying transport reliable? */
     get isReliable() {
-        return this.channel.isReliable;
+        return this.#channel.isReliable;
     }
 
     /**
@@ -91,7 +65,7 @@ export class MessageChannel implements Channel<Message> {
     }
 
     get type() {
-        return this.channel.type;
+        return this.#channel.type;
     }
 
     /**
@@ -99,7 +73,7 @@ export class MessageChannel implements Channel<Message> {
      * message payload sent here can be as huge as allowed by the channel.
      */
     get maxPayloadSize() {
-        return this.channel.maxPayloadSize;
+        return this.#channel.maxPayloadSize;
     }
 
     async send(message: Message, logContext?: ExchangeLogContext) {
@@ -112,21 +86,52 @@ export class MessageChannel implements Channel<Message> {
             );
         }
 
-        return await this.channel.send(bytes);
+        return await this.#channel.send(bytes);
     }
 
     get name() {
-        return Diagnostic.via(`${this.session.via}@${this.channel.name}`);
+        return Diagnostic.via(`${this.session.via}@${this.#channel.name}`);
     }
 
     get networkAddress() {
-        return (this.channel as IpNetworkChannel<Bytes> | undefined)?.networkAddress;
+        return this.#networkAddress.value;
+    }
+
+    get networkAddressChanged() {
+        return this.#networkAddress;
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    /**
+     * Sync the addresses for IP network channels and replace channel if the IPs change
+     * If the channel is on a non ip network then the call is basically ignored
+     * We already use a new naming here which will be more used in future, so yes inconsistency in naming is ok for now
+     * TODO refactor this out again and remove the address from the channel
+     */
+    set socket(channel: Channel<Bytes>) {
+        if (
+            this.closed ||
+            !this.#isIpNetworkChannel ||
+            !isIpNetworkChannel(channel) ||
+            channel.type !== "udp" ||
+            this.#channel.type !== "udp"
+        ) {
+            return;
+        }
+        if (!sameIpNetworkChannel(channel, this.#channel as IpNetworkChannel<Bytes>)) {
+            logger.debug(`Updated address to`, this.name);
+            this.#channel = channel;
+            this.#networkAddress.emit(channel.networkAddress);
+        }
     }
 
     async close() {
         const wasAlreadyClosed = this.closed;
         this.closed = true;
-        await this.channel.close();
+        await this.#channel.close();
         if (!wasAlreadyClosed) {
             await this.#onClose?.();
         }
@@ -135,35 +140,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 +161,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/ProtocolMocks.ts

@@ -162,6 +162,7 @@ export namespace ProtocolMocks {
         name = "mock-byte-channel";
         type = ChannelType.UDP;
         networkAddress: ServerAddressUdp;
+        networkAddressChanged = new Observable<[ServerAddressUdp]>();
 
         constructor(config: MockNetworkConfig) {
             const index = config.index ?? 1;

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

@@ -338,9 +338,6 @@ export abstract class Session {
         return this.#manager;
     }
 
-    /**
-     * This is primarily intended for testing.
-     */
     protected set channel(channel: MessageChannel) {
         if (this.#channel !== undefined) {
             throw new ImplementationError("Cannot replace active channel");
@@ -353,7 +350,7 @@ export abstract class Session {
     }
 
     /**
-     * Invoked by manager when the session is "live".
+     * Invoked by the manager when the session is "live".
      *
      * This is separate from construction because we sometimes discard sessions without installing in a manager or
      * closing.
@@ -374,6 +371,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