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

package/src/peer/PeerAddressStore.ts

@@ -4,9 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Construction, MaybePromise } from "#general";
-import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
-import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
+import { MaybePromise } from "#general";
 import { PeerAddress } from "./PeerAddress.js";
 import { PeerDescriptor } from "./PeerDescriptor.js";
 import type { PeerSet } from "./PeerSet.js";
@@ -18,20 +16,4 @@ export abstract class PeerAddressStore {
     abstract loadPeers(): MaybePromise<Iterable<PeerDescriptor>>;
     abstract updatePeer(peer: PeerDescriptor): MaybePromise<void>;
     abstract deletePeer(address: PeerAddress): MaybePromise<void>;
-    abstract createNodeStore(address: PeerAddress): MaybePromise<PeerDataStore | undefined>;
-}
-
-export abstract class PeerDataStore {
-    abstract construction: Construction<PeerDataStore>;
-
-    abstract maxEventNumber: EventNumber;
-    abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
-
-    // TODO: Find a maybe better way to achieve this without functions
-    abstract retrieveAttribute(
-        endpointId: EndpointNumber,
-        clusterId: ClusterId,
-        attributeId: AttributeId,
-    ): DecodedAttributeReportValue<any> | undefined;
-    abstract retrieveAttributes(endpointId: EndpointNumber, clusterId: ClusterId): DecodedAttributeReportValue<any>[];
 }

package/src/peer/PeerDescriptor.ts

@@ -6,7 +6,6 @@
 
 import { DiscoveryData } from "#common/Scanner.js";
 import { isDeepEqual, ServerAddressUdp } from "#general";
-import type { PeerDataStore } from "#peer/PeerAddressStore.js";
 import { PeerAddress } from "./PeerAddress.js";
 
 /**
@@ -29,27 +28,18 @@ export interface PeerDescriptor {
      * Additional information collected while locating the peer.
      */
     discoveryData?: DiscoveryData;
-
-    /**
-     * The data store for the peer.
-     *
-     * @deprecated
-     */
-    dataStore?: PeerDataStore;
 }
 
 export class ObservablePeerDescriptor implements PeerDescriptor {
     #address: PeerAddress;
     #operationalAddress?: ServerAddressUdp;
     #discoveryData?: DiscoveryData;
-    #dataStore?: PeerDataStore;
     #onChange: () => void;
 
-    constructor({ address, operationalAddress, discoveryData, dataStore }: PeerDescriptor, onChange: () => void) {
+    constructor({ address, operationalAddress, discoveryData }: PeerDescriptor, onChange: () => void) {
         this.#address = PeerAddress(address);
         this.#operationalAddress = operationalAddress;
         this.#discoveryData = discoveryData;
-        this.#dataStore = dataStore;
         this.#onChange = onChange;
     }
 
@@ -82,8 +72,4 @@ export class ObservablePeerDescriptor implements PeerDescriptor {
         this.#discoveryData = { ...this.#discoveryData, ...value };
         this.#onChange();
     }
-
-    get dataStore() {
-        return this.#dataStore;
-    }
 }

package/src/peer/PeerSet.ts

@@ -6,6 +6,7 @@
 
 import { DiscoveryData, ScannerSet } from "#common/Scanner.js";
 import {
+    AbortedError,
     anyPromise,
     AsyncObservable,
     BasicSet,
@@ -18,6 +19,7 @@ import {
     Environmental,
     ImmutableSet,
     ImplementationError,
+    isIpNetworkChannel,
     isIPv6,
     Lifetime,
     Logger,
@@ -31,9 +33,10 @@ import {
     ServerAddressUdp,
     Time,
     Timer,
+    Timestamp,
 } from "#general";
 import { MdnsClient } from "#mdns/MdnsClient.js";
-import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
+import { PeerAddress } from "#peer/PeerAddress.js";
 import { RetransmissionLimitReachedError } from "#protocol/errors.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
 import { DedicatedChannelExchangeProvider, ReconnectableExchangeProvider } from "#protocol/ExchangeProvider.js";
@@ -47,7 +50,7 @@ import { SessionParameters } from "#session/SessionParameters.js";
 import { CaseAuthenticatedTag, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
 import { Peer } from "./Peer.js";
-import { PeerAddressStore, PeerDataStore } from "./PeerAddressStore.js";
+import { PeerAddressStore } from "./PeerAddressStore.js";
 import { PeerDescriptor } from "./PeerDescriptor.js";
 
 const logger = Logger.get("PeerSet");
@@ -118,7 +121,6 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
     readonly #peers = new BasicSet<Peer>();
     readonly #construction: Construction<PeerSet>;
     readonly #store: PeerAddressStore;
-    readonly #nodeCachedData = new PeerAddressMap<PeerDataStore>(); // Temporarily until we store it in new API
     readonly #disconnected = AsyncObservable<[peer: Peer]>();
     readonly #peerContext: Peer.Context;
 
@@ -149,6 +151,8 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
             });
         });
 
+        this.#sessions.sessions.added.on(session => this.#addOrUpdatePeer(session.peerAddress, session));
+
         this.#sessions.retry.on((session, count) => {
             if (count !== 1) {
                 return;
@@ -291,8 +295,8 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
             }
         }
 
-        const { promise, resolver, rejecter } = createPromise<SecureSession>();
-        peer.activeReconnection = { promise, rejecter };
+        const { promise, resolver, rejecter } = createPromise<SecureSession | undefined>();
+        peer.activeReconnection = { promise, resolver, rejecter };
 
         this.#resume(address, options, operationalAddress)
             .then(channel => {
@@ -433,6 +437,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 ? this.#getLastOperationalAddress(address)
                 : this.#knownOperationalAddressFor(address));
 
+        const startTime = Time.nowMs;
         try {
             return await this.#connectOrDiscoverNode(address, operationalAddress, options);
         } catch (error) {
@@ -441,11 +446,17 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 this.has(address) &&
                 tryOperationalAddress === undefined
             ) {
-                logger.info(`Resume failed, remove all sessions for ${PeerAddress(address)}`);
+                logger.info(
+                    `Resume failed, remove all sessions for ${PeerAddress(address)} before ${Timestamp.dateOf(startTime)}`,
+                );
                 // We remove all sessions, this also informs the PairedNode class
-                await this.#sessions.handlePeerLoss(address);
+                await this.#sessions.handlePeerLoss(address, startTime);
+            }
+
+            // Ok, no new session
+            if (this.#sessions.maybeSessionFor(address) === undefined) {
+                throw error;
             }
-            throw error;
         }
     }
 
@@ -453,7 +464,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         address: PeerAddress,
         operationalAddress?: ServerAddressUdp,
         options?: PeerConnectionOptions,
-    ) {
+    ): Promise<SecureSession> {
         address = PeerAddress(address);
         const {
             discoveryOptions: {
@@ -493,13 +504,24 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
 
         const { type: runningDiscoveryType, promises } = existingDiscoveryDetails;
 
-        // If we have a last known address try to reach the device directly when we are not already discovering
+        // If we have a last known address, try to reach the device directly when we are not already discovering
         // In worst case parallel cases we do this step twice, but that's ok
         if (
             operationalAddress !== undefined &&
             (runningDiscoveryType === NodeDiscoveryType.None || requestedDiscoveryType === NodeDiscoveryType.None)
         ) {
+            const session = this.#sessions.maybeSessionFor(address);
             const queueSlot = await queue?.obtainSlot();
+
+            if (queueSlot !== undefined) {
+                // If we got a new session while waiting for the queue slot, we assume we are done here
+                const currentSession = this.#sessions.maybeSessionFor(address);
+                if (currentSession?.isSecure && session !== currentSession) {
+                    queueSlot.close();
+                    return currentSession;
+                }
+            }
+
             try {
                 const directReconnection = await this.#reconnectKnownAddress(
                     address,
@@ -539,7 +561,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
 
         const lastOperationalAddress = this.#getLastOperationalAddress(address);
         if (lastOperationalAddress !== undefined) {
-            // Additionally to general discovery we also try to poll the formerly known operational address
+            // Additionally to general discovery, we also try to poll the formerly known operational address
             if (requestedDiscoveryType === NodeDiscoveryType.FullDiscovery) {
                 const { promise, resolver, rejecter } = createPromise<SecureSession>();
 
@@ -601,7 +623,15 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 timeout,
                 timeout === undefined,
             );
-            const { stopTimerFunc } = peer.activeDiscovery ?? {};
+            if (peer.activeDiscovery === undefined) {
+                // It seems the discovery was canceled outside of this function, so we can return early if we have a session
+                const session = this.#sessions.maybeSessionFor(address);
+                if (session !== undefined) {
+                    return session;
+                }
+                throw new NoResponseTimeoutError("Discovery was cancelled but we have no session, retry");
+            }
+            const { stopTimerFunc } = peer.activeDiscovery;
             stopTimerFunc?.();
             peer.activeDiscovery = undefined;
 
@@ -616,17 +646,23 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                     return device !== undefined ? [device] : [];
                 },
                 async (operationalAddress, peer) => {
+                    // When we got a session, we are done
+                    const session = this.#sessions.maybeSessionFor(address);
+                    if (session !== undefined) {
+                        return session;
+                    }
+
                     const peerData = {
                         ...discoveryData,
                         ...peer,
                     };
                     const queueSlot = await queue?.obtainSlot();
                     try {
-                        const result = await this.#pair(address, operationalAddress, peerData, {
+                        const session = await this.#pair(address, operationalAddress, peerData, {
                             caseAuthenticatedTags,
                         });
-                        await this.#addOrUpdatePeer(address, operationalAddress, peerData);
-                        return result;
+                        this.#addOrUpdatePeer(address, session, peerData);
+                        return session;
                     } finally {
                         queueSlot?.close();
                     }
@@ -668,17 +704,21 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 }`,
             );
             const session = await this.#pair(address, operationalAddress, discoveryData, options);
-            await this.#addOrUpdatePeer(address, operationalAddress);
+            this.#addOrUpdatePeer(address, session, discoveryData);
             return session;
         } catch (error) {
-            if (error instanceof NoResponseTimeoutError || error instanceof ChannelStatusResponseError) {
+            if (
+                error instanceof NoResponseTimeoutError ||
+                error instanceof ChannelStatusResponseError ||
+                error instanceof AbortedError
+            ) {
                 logger.debug(
                     `Failed to resume connection to ${address} connection with ${ip}:${port}, discovering the node now:`,
                     error.message ? error.message : error,
                 );
-                // We remove all sessions, this also informs the PairedNode class
+                // We remove all sessions that were created before we started the try, this also informs the PairedNode class
                 await this.#sessions.handlePeerLoss(address, startTime);
-                return undefined;
+                return this.#sessions.maybeSessionFor(address);
             } else {
                 throw error;
             }
@@ -734,7 +774,13 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         } catch (error) {
             NoResponseTimeoutError.accept(error);
 
-            // Convert error
+            // It seems we got a new session while waiting for Case completion, so use this one
+            // TODO When case pairing can be aborted we can handle this cleanly
+            const currentSession = this.#sessions.maybeSessionFor(address);
+            if (currentSession !== undefined) {
+                return currentSession;
+            }
+
             throw new PairRetransmissionLimitReachedError(error.message);
         } finally {
             await unsecuredSession.initiateClose();
@@ -751,12 +797,8 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
         try {
             exchange = this.#exchanges.initiateExchangeForSession(paseSession, SECURE_CHANNEL_PROTOCOL_ID);
 
-            const { session, resumed } = await this.#caseClient.pair(exchange, fabric, address.nodeId, options);
+            const { session } = await this.#caseClient.pair(exchange, fabric, address.nodeId, options);
 
-            if (!resumed) {
-                // When the session was not resumed then most likely the device firmware got updated, so we clear the cache
-                this.#nodeCachedData.delete(address);
-            }
             return session;
         } catch (error) {
             await exchange?.close();
@@ -805,22 +847,21 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
             discoveredAddresses.addresses.length = 0;
         }
 
-        // Try to use first result for one last try before we need to reconnect
+        // Try to use the first result for one last try before we need to reconnect
         return discoveredAddresses?.addresses[0];
     }
 
-    async #addOrUpdatePeer(
-        address: PeerAddress,
-        operationalServerAddress?: ServerAddressUdp,
-        discoveryData?: DiscoveryData,
-    ) {
+    #addOrUpdatePeer(address: PeerAddress, session?: SecureSession, discoveryData?: DiscoveryData) {
         let peer = this.get(address);
         if (peer === undefined) {
-            peer = new Peer({ address, dataStore: await this.#store.createNodeStore(address) }, this.#peerContext);
+            peer = new Peer({ address }, this.#peerContext);
             this.#peers.add(peer);
         }
-        if (operationalServerAddress !== undefined) {
-            peer.descriptor.operationalAddress = operationalServerAddress;
+        if (session !== undefined && !session.isClosed) {
+            const channel = session.channel;
+            if (isIpNetworkChannel(channel)) {
+                peer.descriptor.operationalAddress = channel.networkAddress;
+            }
         }
         if (discoveryData !== undefined) {
             peer.descriptor.discoveryData = {
@@ -841,7 +882,13 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
     }
 
     addKnownPeer(address: PeerAddress, operationalServerAddress?: ServerAddressUdp, discoveryData?: DiscoveryData) {
-        return this.#addOrUpdatePeer(address, operationalServerAddress, discoveryData);
+        this.#addOrUpdatePeer(address, undefined, discoveryData);
+        if (operationalServerAddress !== undefined) {
+            const peer = this.get(address);
+            if (peer !== undefined) {
+                peer.descriptor.operationalAddress = operationalServerAddress;
+            }
+        }
     }
 
     #getLastOperationalAddress(address: PeerAddress) {

package/src/protocol/ExchangeManager.ts

@@ -27,7 +27,6 @@ import {
     UnexpectedDataError,
 } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
-import { DEFAULT_EXPECTED_PROCESSING_TIME } from "#protocol/MessageChannel.js";
 import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
 import { NodeSession } from "#session/NodeSession.js";
 import { Session } from "#session/Session.js";
@@ -36,6 +35,7 @@ import { UNICAST_UNSECURE_SESSION_ID } from "#session/UnsecuredSession.js";
 import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType } from "#types";
 import { MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
 import { DuplicateMessageError } from "./MessageReceptionState.js";
+import { MRP } from "./MRP.js";
 import { ProtocolHandler } from "./ProtocolHandler.js";
 
 const logger = Logger.get("ExchangeManager");
@@ -404,7 +404,10 @@ export class ExchangeManager {
         this.#workers.add(exchangeToClose.close());
     }
 
-    calculateMaximumPeerResponseTimeMsFor(session: Session, expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
+    calculateMaximumPeerResponseTimeMsFor(
+        session: Session,
+        expectedProcessingTime = MRP.DEFAULT_EXPECTED_PROCESSING_TIME,
+    ) {
         return session.channel.calculateMaximumPeerResponseTime(
             session.parameters,
             this.#sessions.sessionParameters,

package/src/protocol/ExchangeProvider.ts

@@ -6,7 +6,6 @@
 import { Diagnostic, Duration, Observable, Timestamp } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
-import { DEFAULT_EXPECTED_PROCESSING_TIME } from "#protocol/MessageChannel.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
 import { SecureSession } from "#session/SecureSession.js";
@@ -14,6 +13,7 @@ import { Session } from "#session/Session.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
 import { SessionClosedError } from "./errors.js";
+import { MRP } from "./MRP.js";
 
 /**
  * Interface for obtaining an exchange with a specific peer.
@@ -69,7 +69,7 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
         return this.#session;
     }
 
-    maximumPeerResponseTime(expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
+    maximumPeerResponseTime(expectedProcessingTime = MRP.DEFAULT_EXPECTED_PROCESSING_TIME) {
         return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#session, expectedProcessingTime);
     }
 }
@@ -130,7 +130,7 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         return this.sessions.sessionFor(this.#address);
     }
 
-    maximumPeerResponseTime(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
+    maximumPeerResponseTime(expectedProcessingTimeMs = MRP.DEFAULT_EXPECTED_PROCESSING_TIME) {
         return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(
             this.sessions.sessionFor(this.#address),
             expectedProcessingTimeMs,

package/src/protocol/MRP.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ChannelType, Duration, MatterFlowError, Millis, Seconds } from "#general";
+import { SessionParameters } from "#session/SessionParameters.js";
+
+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);
+
+    /**
+     * 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 interface ResponseTimeInputs {
+        peerSessionParameters: SessionParameters;
+        localSessionParameters: SessionParameters;
+        channelType: ChannelType;
+        isPeerActive: boolean;
+        usesMrp?: boolean;
+        expectedProcessingTime?: Duration;
+    }
+
+    export function maxPeerResponseTimeOf({
+        peerSessionParameters,
+        localSessionParameters,
+        channelType,
+        isPeerActive,
+        usesMrp = channelType === ChannelType.UDP,
+        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
+    }: ResponseTimeInputs): Duration {
+        switch (channelType) {
+            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 (!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(
+                    maxResponseTimeOf(peerSessionParameters, isPeerActive) +
+                        maxResponseTimeOf(localSessionParameters, isPeerActive) +
+                        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: ${channelType}`,
+                );
+        }
+    }
+
+    export interface RetryDelayInputs {
+        transmissionNumber: number;
+        sessionParameters: SessionParameters;
+        isPeerActive: boolean;
+    }
+
+    /**
+     * 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
+     */
+    export function maxRetransmissionIntervalOf({
+        transmissionNumber,
+        sessionParameters,
+        isPeerActive,
+    }: RetryDelayInputs) {
+        const { activeInterval, idleInterval } = sessionParameters;
+
+        // 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 = transmissionNumber > 0 && (sessionParameters !== undefined || isPeerActive);
+        const baseInterval = peerActive ? activeInterval : idleInterval;
+        return Millis.floor(
+            Millis(
+                baseInterval *
+                    MRP.BACKOFF_MARGIN *
+                    Math.pow(MRP.BACKOFF_BASE, Math.max(0, transmissionNumber - 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.
+ */
+function maxResponseTimeOf(sessionParameters: SessionParameters, isPeerActive: boolean) {
+    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 +
+                MRP.maxRetransmissionIntervalOf({
+                    transmissionNumber: i,
+                    sessionParameters,
+                    isPeerActive,
+                }),
+        );
+    }
+
+    return finalWaitTime;
+}