@matter/protocol 0.15.0-alpha.0-20250625-4a4b1be1b → 0.15.0-alpha.0-20250626-fc3a84ce9

package/src/peer/ControllerCommissioningFlow.ts

@@ -178,7 +178,7 @@ export class OperativeConnectionFailedError extends CommissioningError {}
 /** Error that throws when Commissioning fails but a process can be continued. */
 class RecoverableCommissioningError extends CommissioningError {}
 
-const DEFAULT_FAILSAFE_TIME_MS = 60_000; // 60 seconds
+const DEFAULT_FAILSAFE_TIME_S = 60;
 
 /**
  * Class to abstract the Device commission flow in a step wise way as defined in Specs. The specs are not 100%
@@ -197,10 +197,10 @@ export class ControllerCommissioningFlow {
     readonly #clusterClients = new Map<ClusterId, ClusterClientObj>();
     #commissioningStartedTime: number | undefined;
     #commissioningExpiryTime: number | undefined;
-    #lastFailSafeTime: number | undefined;
+    #currentFailSafeEndTime: number | undefined;
     protected lastBreadcrumb = 1;
     protected collectedCommissioningData: CollectedCommissioningData = {};
-    #failSafeTimeMs = DEFAULT_FAILSAFE_TIME_MS;
+    #defaultFailSafeTimeS = DEFAULT_FAILSAFE_TIME_S;
 
     constructor(
         /** InteractionClient for the initiated PASE session */
@@ -251,8 +251,7 @@ export class ControllerCommissioningFlow {
                 const result = await step.stepLogic();
                 this.#setCommissioningStepResult(step, result);
 
-                if (this.#lastFailSafeTime !== undefined) {
-                    const timeSinceLastArmFailsafe = Time.nowMs() - this.#lastFailSafeTime;
+                if (this.#currentFailSafeEndTime !== undefined) {
                     if (this.#commissioningExpiryTime !== undefined && Time.nowMs() > this.#commissioningExpiryTime) {
                         logger.error(
                             `Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name} succeeded, but commissioning took too long in general!`,
@@ -268,13 +267,12 @@ export class ControllerCommissioningFlow {
                      * timeout within 60 seconds of the completion of PASE session establishment, using the ArmFailSafe
                      * command (see Section 11.9.6.2, “ArmFailSafe Command”)
                      */
-                    if (timeSinceLastArmFailsafe > this.#failSafeTimeMs / 2) {
+                    const timeLeft = Math.floor((this.#currentFailSafeEndTime - Time.nowMs()) / 1000);
+                    if (timeLeft < this.#defaultFailSafeTimeS / 2) {
                         logger.info(
                             `After Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${
                                 step.name
-                            } succeeded, ${Math.floor(
-                                timeSinceLastArmFailsafe / 1000,
-                            )}s elapsed since last arm failsafe, re-arming failsafe`,
+                            } succeeded, ${timeLeft}s left for failsafe timer, re-arming failsafe`,
                         );
                         await this.#armFailsafe();
                         failSafeTimerReArmedAfterPreviousStep = true;
@@ -597,40 +595,59 @@ export class ControllerCommissioningFlow {
      * reading BasicCommissioningInfo attribute (see Section 11.10.5.2, “BasicCommissioningInfo
      * Attribute”) prior to invoking the ArmFailSafe command.
      */
-    async #armFailsafe() {
+    async #armFailsafe(timeS?: number) {
         const client = this.#getClusterClient(GeneralCommissioning.Cluster);
         if (this.collectedCommissioningData.basicCommissioningInfo === undefined) {
             const basicCommissioningInfo = await client.getBasicCommissioningInfoAttribute();
             this.collectedCommissioningData.basicCommissioningInfo = basicCommissioningInfo;
-            this.#failSafeTimeMs = basicCommissioningInfo.failSafeExpiryLengthSeconds * 1000;
+            this.#defaultFailSafeTimeS = basicCommissioningInfo.failSafeExpiryLengthSeconds;
             this.#commissioningStartedTime = Time.nowMs();
             this.#commissioningExpiryTime =
                 this.#commissioningStartedTime + basicCommissioningInfo.maxCumulativeFailsafeSeconds * 1000;
         }
+        const expiryLengthSeconds = timeS ?? this.#defaultFailSafeTimeS;
         this.#ensureGeneralCommissioningSuccess(
             "armFailSafe",
             await client.armFailSafe({
                 breadcrumb: this.lastBreadcrumb,
-                expiryLengthSeconds:
-                    this.collectedCommissioningData.basicCommissioningInfo?.failSafeExpiryLengthSeconds,
+                expiryLengthSeconds,
             }),
         );
-        this.#lastFailSafeTime = Time.nowMs();
+        this.#currentFailSafeEndTime = Time.nowMs() + expiryLengthSeconds * 1000;
         return {
             code: CommissioningStepResultCode.Success,
             breadcrumb: this.lastBreadcrumb,
         };
     }
 
+    get #failSafeTimeLeftS() {
+        if (this.#currentFailSafeEndTime === undefined) {
+            return 0;
+        }
+        return Math.max(0, Math.ceil((this.#currentFailSafeEndTime - Time.nowMs()) / 1000));
+    }
+
+    async #ensureFailsafeTimerForS(maxProcessingTime: number) {
+        const minFailsafeTimeS = this.interactionClient.maximumPeerResponseTimeMs(maxProcessingTime);
+
+        const timeLeft = this.#failSafeTimeLeftS;
+        if (timeLeft < minFailsafeTimeS) {
+            logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTimeS}s`);
+            await this.#armFailsafe(Math.max(minFailsafeTimeS, this.#defaultFailSafeTimeS));
+        } else {
+            logger.debug(`Failsafe timer is already set for at least ${timeLeft}s`);
+        }
+    }
+
     async #resetFailsafeTimer() {
-        if (this.#lastFailSafeTime === undefined) return;
+        if (this.#currentFailSafeEndTime === undefined) return;
         try {
             const client = this.#getClusterClient(GeneralCommissioning.Cluster);
             await client.armFailSafe({
                 breadcrumb: this.lastBreadcrumb,
                 expiryLengthSeconds: 0,
             });
-            this.#lastFailSafeTime = undefined; // No failsafe active anymore
+            this.#currentFailSafeEndTime = undefined; // No failsafe active anymore
         } catch (error) {
             logger.error(`Error while resetting failsafe timer`, error);
         }
@@ -1000,20 +1017,27 @@ export class ControllerCommissioningFlow {
         const ssid = Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiSsid);
         const credentials = Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiCredentials);
 
-        const { networkingStatus, wiFiScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
-            {
-                ssid,
-                breadcrumb: this.lastBreadcrumb++,
-            },
-            { useExtendedFailSafeMessageResponseTimeout: true },
-        );
-        if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
-            throw new WifiNetworkSetupFailedError(`Commissionee failed to scan for WiFi networks: ${debugText}`);
-        }
-        if (wiFiScanResults === undefined || wiFiScanResults.length === 0) {
-            throw new WifiNetworkSetupFailedError(
-                `Commissionee did not return any WiFi networks for the requested SSID ${this.commissioningOptions.wifiNetwork.wifiSsid}`,
-            );
+        // Only Scan when the device supports concurrent connections
+        if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
+            const scanMaxTimeSeconds = await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute();
+            await this.#ensureFailsafeTimerForS(scanMaxTimeSeconds);
+
+            const { networkingStatus, wiFiScanResults, debugText } =
+                await networkCommissioningClusterClient.scanNetworks(
+                    {
+                        ssid,
+                        breadcrumb: this.lastBreadcrumb++,
+                    },
+                    { expectedProcessingTimeMs: scanMaxTimeSeconds * 1000 },
+                );
+            if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
+                throw new WifiNetworkSetupFailedError(`Commissionee failed to scan for WiFi networks: ${debugText}`);
+            }
+            if (wiFiScanResults === undefined || wiFiScanResults.length === 0) {
+                throw new WifiNetworkSetupFailedError(
+                    `Commissionee did not return any WiFi networks for the requested SSID ${this.commissioningOptions.wifiNetwork.wifiSsid}`,
+                );
+            }
         }
 
         const {
@@ -1056,12 +1080,15 @@ export class ControllerCommissioningFlow {
             };
         }
 
+        const connectMaxTimeSeconds = await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute();
+        await this.#ensureFailsafeTimerForS(connectMaxTimeSeconds);
+
         const connectResult = await networkCommissioningClusterClient.connectNetwork(
             {
                 networkId: networkId,
                 breadcrumb: this.lastBreadcrumb++,
             },
-            { useExtendedFailSafeMessageResponseTimeout: true },
+            { expectedProcessingTimeMs: connectMaxTimeSeconds * 1000 },
         );
 
         if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
@@ -1135,33 +1162,42 @@ export class ControllerCommissioningFlow {
             true,
         );
 
-        const { networkingStatus, threadScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
-            { breadcrumb: this.lastBreadcrumb++ },
-            { useExtendedFailSafeMessageResponseTimeout: true },
-        );
-        if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
-            throw new ThreadNetworkSetupFailedError(`Commissionee failed to scan for Thread networks: ${debugText}`);
-        }
-        if (threadScanResults === undefined || threadScanResults.length === 0) {
-            throw new ThreadNetworkSetupFailedError(
-                `Commissionee did not return any Thread networks for the requested Network ${this.commissioningOptions.threadNetwork.networkName}`,
+        // Only Scan when the device supports concurrent connections
+        if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
+            const scanMaxTimeSeconds = await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute();
+            await this.#ensureFailsafeTimerForS(scanMaxTimeSeconds);
+
+            const { networkingStatus, threadScanResults, debugText } =
+                await networkCommissioningClusterClient.scanNetworks(
+                    { breadcrumb: this.lastBreadcrumb++ },
+                    { expectedProcessingTimeMs: scanMaxTimeSeconds * 1000 },
+                );
+            if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
+                throw new ThreadNetworkSetupFailedError(
+                    `Commissionee failed to scan for Thread networks: ${debugText}`,
+                );
+            }
+            if (threadScanResults === undefined || threadScanResults.length === 0) {
+                throw new ThreadNetworkSetupFailedError(
+                    `Commissionee did not return any Thread networks for the requested Network ${this.commissioningOptions.threadNetwork.networkName}`,
+                );
+            }
+            const wantedNetworkFound = threadScanResults.find(
+                ({ networkName }) => networkName === this.commissioningOptions.threadNetwork?.networkName,
             );
-        }
-        const wantedNetworkFound = threadScanResults.find(
-            ({ networkName }) => networkName === this.commissioningOptions.threadNetwork?.networkName,
-        );
-        if (wantedNetworkFound === undefined) {
-            throw new ThreadNetworkSetupFailedError(
-                `Commissionee did not return the requested Network ${
+            if (wantedNetworkFound === undefined) {
+                throw new ThreadNetworkSetupFailedError(
+                    `Commissionee did not return the requested Network ${
+                        this.commissioningOptions.threadNetwork.networkName
+                    }: ${Diagnostic.json(threadScanResults)}`,
+                );
+            }
+            logger.debug(
+                `Commissionee found wanted Thread network ${
                     this.commissioningOptions.threadNetwork.networkName
-                }: ${Diagnostic.json(threadScanResults)}`,
+                }: ${Diagnostic.json(wantedNetworkFound)}`,
             );
         }
-        logger.debug(
-            `Commissionee found wanted Thread network ${
-                this.commissioningOptions.threadNetwork.networkName
-            }: ${Diagnostic.json(wantedNetworkFound)}`,
-        );
 
         const {
             networkingStatus: addNetworkingStatus,
@@ -1201,12 +1237,15 @@ export class ControllerCommissioningFlow {
             };
         }
 
+        const connectMaxTimeSeconds = await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute();
+        await this.#ensureFailsafeTimerForS(connectMaxTimeSeconds);
+
         const connectResult = await networkCommissioningClusterClient.connectNetwork(
             {
                 networkId: networkId,
                 breadcrumb: this.lastBreadcrumb++,
             },
-            { useExtendedFailSafeMessageResponseTimeout: true },
+            { expectedProcessingTimeMs: connectMaxTimeSeconds * 1000 },
         );
 
         if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
@@ -1245,7 +1284,7 @@ export class ControllerCommissioningFlow {
         // TODO: Check whats needed for non-concurrent commissioning flows (maybe arm initially longer?)
         const reArmFailsafeInterval = Time.getPeriodicTimer(
             "Re-Arm Failsafe during reconnect",
-            this.#failSafeTimeMs / 2,
+            (this.#defaultFailSafeTimeS / 2) * 1000,
             () => {
                 const now = Time.nowMs();
                 if (this.#commissioningExpiryTime !== undefined && now < this.#commissioningExpiryTime) {
@@ -1313,7 +1352,7 @@ export class ControllerCommissioningFlow {
                 useExtendedFailSafeMessageResponseTimeout: true,
             }),
         );
-        this.#lastFailSafeTime = undefined; // gets deactivated when successful
+        this.#currentFailSafeEndTime = undefined; // gets deactivated when successful
 
         return {
             code: CommissioningStepResultCode.Success,

package/src/peer/PeerSet.ts

@@ -32,14 +32,15 @@ import {
 import { SubscriptionClient } from "#interaction/SubscriptionClient.js";
 import { MdnsScanner } from "#mdns/MdnsScanner.js";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
+import { ChannelManager } from "#protocol/ChannelManager.js";
+import { ChannelNotConnectedError, ExchangeManager } from "#protocol/ExchangeManager.js";
+import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "#protocol/ExchangeProvider.js";
+import { MessageChannel } from "#protocol/MessageChannel.js";
+import { MessageExchange, RetransmissionLimitReachedError } from "#protocol/MessageExchange.js";
 import { ChannelStatusResponseError } from "#securechannel/index.js";
 import { CaseClient, SecureSession, Session } from "#session/index.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { GroupId, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
-import { ChannelManager } from "../protocol/ChannelManager.js";
-import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
-import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
-import { MessageExchange, RetransmissionLimitReachedError } from "../protocol/MessageExchange.js";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
 import { InteractionQueue } from "./InteractionQueue.js";
 import { OperationalPeer } from "./OperationalPeer.js";

package/src/protocol/ChannelManager.ts

@@ -6,9 +6,9 @@
 
 import { AsyncObservable, Channel, Environment, Environmental, Logger, MatterError } from "#general";
 import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
-import { NodeSession } from "../session/NodeSession.js";
-import { Session } from "../session/Session.js";
-import { MessageChannel } from "./ExchangeManager.js";
+import { MessageChannel } from "#protocol/MessageChannel.js";
+import { NodeSession } from "#session/NodeSession.js";
+import { Session } from "#session/Session.js";
 
 const logger = Logger.get("ChannelManager");
 

package/src/protocol/ExchangeManager.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { DecodedMessage, MessageCodec, SessionType } from "#codec/MessageCodec.js";
 import {
     Channel,
     Crypto,
@@ -22,15 +23,15 @@ import {
     UnexpectedDataError,
 } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
+import { MessageChannel } from "#protocol/MessageChannel.js";
+import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
+import { SecureChannelProtocol } from "#securechannel/SecureChannelProtocol.js";
+import { NodeSession } from "#session/NodeSession.js";
+import { Session } from "#session/Session.js";
+import { SessionManager, UNICAST_UNSECURE_SESSION_ID } from "#session/SessionManager.js";
 import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType } from "#types";
-import { DecodedMessage, Message, MessageCodec, SessionType } from "../codec/MessageCodec.js";
-import { SecureChannelMessenger } from "../securechannel/SecureChannelMessenger.js";
-import { SecureChannelProtocol } from "../securechannel/SecureChannelProtocol.js";
-import { NodeSession } from "../session/NodeSession.js";
-import { Session } from "../session/Session.js";
-import { SessionManager, UNICAST_UNSECURE_SESSION_ID } from "../session/SessionManager.js";
 import { ChannelManager } from "./ChannelManager.js";
-import { ExchangeLogContext, MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
+import { DEFAULT_EXPECTED_PROCESSING_TIME_MS, MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
 import { DuplicateMessageError } from "./MessageReceptionState.js";
 import { ProtocolHandler } from "./ProtocolHandler.js";
 
@@ -40,66 +41,6 @@ const MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION = 5;
 
 export class ChannelNotConnectedError extends MatterError {}
 
-export class MessageChannel implements Channel<Message> {
-    public closed = false;
-    #closeCallback?: () => Promise<void>;
-
-    constructor(
-        readonly channel: Channel<Uint8Array>,
-        readonly session: Session,
-        closeCallback?: () => Promise<void>,
-    ) {
-        this.#closeCallback = closeCallback;
-    }
-
-    set closeCallback(callback: () => Promise<void>) {
-        this.#closeCallback = callback;
-    }
-
-    /** Is the underlying transport reliable? */
-    get isReliable() {
-        return this.channel.isReliable;
-    }
-
-    get type() {
-        return this.channel.type;
-    }
-
-    /**
-     * Max Payload size of the exchange which bases on the maximum payload size of the channel. The full encoded matter
-     * message payload sent here can be as huge as allowed by the channel.
-     */
-    get maxPayloadSize() {
-        return this.channel.maxPayloadSize;
-    }
-
-    async send(message: Message, logContext?: ExchangeLogContext) {
-        logger.debug("Message »", MessageCodec.messageDiagnostics(message, logContext));
-        const packet = this.session.encode(message);
-        const bytes = MessageCodec.encodePacket(packet);
-        if (bytes.length > this.maxPayloadSize) {
-            logger.warn(
-                `Matter message to send to ${this.name} is ${bytes.length}bytes long, which is larger than the maximum allowed size of ${this.maxPayloadSize}. This only works if both nodes support it.`,
-            );
-        }
-
-        return await this.channel.send(bytes);
-    }
-
-    get name() {
-        return `${this.channel.name} on session ${this.session.name}`;
-    }
-
-    async close() {
-        const wasAlreadyClosed = this.closed;
-        this.closed = true;
-        await this.channel.close();
-        if (!wasAlreadyClosed) {
-            await this.#closeCallback?.();
-        }
-    }
-}
-
 /**
  * Interfaces {@link ExchangeManager} with other components.
  */
@@ -465,6 +406,16 @@ export class ExchangeManager {
         exchangeToClose.close().catch(error => logger.error("Error closing exchange", error)); // TODO Promise??
     }
 
+    calculateMaximumPeerResponseTimeMsFor(
+        channel: MessageChannel,
+        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    ) {
+        return channel.calculateMaximumPeerResponseTimeMs(
+            this.#sessionManager.sessionParameters,
+            expectedProcessingTimeMs,
+        );
+    }
+
     #messageExchangeContextFor(channel: MessageChannel): MessageExchangeContext {
         return {
             channel,

package/src/protocol/ExchangeProvider.ts

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ChannelType, Observable } from "#general";
+import { PeerAddress } from "#peer/PeerAddress.js";
+import { ChannelManager } from "#protocol/ChannelManager.js";
+import { ChannelNotConnectedError, ExchangeManager } from "#protocol/ExchangeManager.js";
+import { MessageChannel } from "#protocol/MessageChannel.js";
+import { DEFAULT_EXPECTED_PROCESSING_TIME_MS, MessageExchange } from "#protocol/MessageExchange.js";
+import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
+import { Session } from "#session/Session.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
-import { PeerAddress } from "../peer/PeerAddress.js";
-import { ChannelManager } from "../protocol/ChannelManager.js";
-import { ChannelNotConnectedError, ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
-import { MessageExchange } from "../protocol/MessageExchange.js";
-import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
-import { Session } from "../session/Session.js";
 
 /**
  * Interface for obtaining an exchange with a specific peer.
@@ -32,6 +33,7 @@ export abstract class ExchangeProvider {
         this.exchangeManager.addProtocolHandler(handler);
     }
 
+    abstract maximumPeerResponseTimeMs(expectedProcessingTimeMs?: number): number;
     abstract initiateExchange(): Promise<MessageExchange>;
     abstract reconnectChannel(): Promise<boolean>;
     abstract session: Session;
@@ -65,6 +67,10 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
     get channelType() {
         return this.#channel.type;
     }
+
+    maximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
+        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#channel, expectedProcessingTimeMs);
+    }
 }
 
 /**
@@ -125,4 +131,12 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         }
         return this.channelManager.getChannel(this.#address).type;
     }
+
+    maximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
+        const channel = this.channelManager.getChannel(this.#address);
+        if (!channel) {
+            throw new ChannelNotConnectedError("Channel not connected");
+        }
+        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(channel, expectedProcessingTimeMs);
+    }
 }

package/src/protocol/MessageChannel.ts

@@ -0,0 +1,163 @@
+import { Message, MessageCodec } from "#codec/index.js";
+import { Channel, Logger, MatterFlowError } from "#general";
+import { DEFAULT_EXPECTED_PROCESSING_TIME_MS, ExchangeLogContext } from "#protocol/MessageExchange.js";
+import { Session, SessionParameters } from "#session/index.js";
+
+const logger = new Logger("MessageChannel");
+
+/**
+ * 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_MS = 5_000;
+
+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_MS = 200;
+}
+
+export class MessageChannel implements Channel<Message> {
+    public closed = false;
+    #closeCallback?: () => Promise<void>;
+    // When the session is supporting MRP and the channel is not reliable, use MRP handling
+
+    constructor(
+        readonly channel: Channel<Uint8Array>,
+        readonly session: Session,
+        closeCallback?: () => Promise<void>,
+    ) {
+        this.#closeCallback = closeCallback;
+    }
+
+    set closeCallback(callback: () => Promise<void>) {
+        this.#closeCallback = callback;
+    }
+
+    get usesMrp() {
+        return this.session.supportsMRP && !this.channel.isReliable;
+    }
+
+    /** Is the underlying transport reliable? */
+    get isReliable() {
+        return this.channel.isReliable;
+    }
+
+    get type() {
+        return this.channel.type;
+    }
+
+    /**
+     * Max Payload size of the exchange which bases on the maximum payload size of the channel. The full encoded matter
+     * message payload sent here can be as huge as allowed by the channel.
+     */
+    get maxPayloadSize() {
+        return this.channel.maxPayloadSize;
+    }
+
+    async send(message: Message, logContext?: ExchangeLogContext) {
+        logger.debug("Message »", MessageCodec.messageDiagnostics(message, logContext));
+        const packet = this.session.encode(message);
+        const bytes = MessageCodec.encodePacket(packet);
+        if (bytes.length > this.maxPayloadSize) {
+            logger.warn(
+                `Matter message to send to ${this.name} is ${bytes.length}bytes long, which is larger than the maximum allowed size of ${this.maxPayloadSize}. This only works if both nodes support it.`,
+            );
+        }
+
+        return await this.channel.send(bytes);
+    }
+
+    get name() {
+        return `${this.channel.name} on session ${this.session.name}`;
+    }
+
+    async close() {
+        const wasAlreadyClosed = this.closed;
+        this.closed = true;
+        await this.channel.close();
+        if (!wasAlreadyClosed) {
+            await this.#closeCallback?.();
+        }
+    }
+
+    calculateMaximumPeerResponseTimeMs(
+        sessionParameters: SessionParameters,
+        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    ) {
+        switch (this.channel.type) {
+            case "tcp":
+                // TCP uses 30s timeout according to chip sdk implementation, so do the same
+                return 30_000 + PEER_RESPONSE_TIME_BUFFER_MS;
+            case "udp":
+                // UDP normally uses MRP, if not we have Group communication, which normally have no responses
+                if (!this.usesMrp) {
+                    throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
+                }
+                return (
+                    this.#calculateMrpMaximumPeerResponseTime(sessionParameters, expectedProcessingTimeMs) +
+                    PEER_RESPONSE_TIME_BUFFER_MS
+                );
+            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 30_000 + PEER_RESPONSE_TIME_BUFFER_MS;
+            default:
+                throw new MatterFlowError(
+                    `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`,
+                );
+        }
+    }
+
+    /**
+     * Calculates the backoff time for a resubmission based on the current retransmission count.
+     * If no session parameters are provided, the parameters of the current session are used.
+     * If session parameters are provided, the method can be used to calculate the maximum backoff time for the other
+     * side of the exchange.
+     *
+     * @see {@link MatterSpecification.v10.Core}, section 4.11.2.1
+     */
+    getMrpResubmissionBackOffTime(retransmissionCount: number, sessionParameters?: SessionParameters) {
+        const { activeIntervalMs, idleIntervalMs } = sessionParameters ?? this.session.parameters;
+        const baseInterval =
+            sessionParameters !== undefined || this.session.isPeerActive() ? activeIntervalMs : idleIntervalMs;
+        return Math.floor(
+            MRP.BACKOFF_MARGIN *
+                baseInterval *
+                Math.pow(MRP.BACKOFF_BASE, Math.max(0, retransmissionCount - MRP.BACKOFF_THRESHOLD)) *
+                (1 + (sessionParameters !== undefined ? 1 : Math.random()) * MRP.BACKOFF_JITTER),
+        );
+    }
+
+    #calculateMrpMaximumPeerResponseTime(
+        sessionParameters: SessionParameters,
+        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    ) {
+        // We use the expected processing time and deduct the time we already waited since last resubmission
+        let finalWaitTime = expectedProcessingTimeMs;
+
+        // 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 += this.getMrpResubmissionBackOffTime(i, sessionParameters);
+        }
+
+        // TODO: Also add any network latency buffer, for now lets consider it's included in the processing time already
+        return finalWaitTime;
+    }
+}