@matter/protocol 0.16.0-alpha.0-20251203-aaf94bca8 → 0.16.0-alpha.0-20251207-37e501b18

package/src/protocol/ExchangeProvider.ts

@@ -3,19 +3,17 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ChannelType, Duration, Observable } from "#general";
+import { Diagnostic, Duration, Observable } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
-import { ChannelManager } from "#protocol/ChannelManager.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
-import {
-    ChannelNotConnectedError,
-    DEFAULT_EXPECTED_PROCESSING_TIME,
-    MessageChannel,
-} from "#protocol/MessageChannel.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";
 import { Session } from "#session/Session.js";
+import { SessionManager } from "#session/SessionManager.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
+import { SessionClosedError } from "./errors.js";
 
 /**
  * Interface for obtaining an exchange with a specific peer.
@@ -41,23 +39,26 @@ export abstract class ExchangeProvider {
     abstract initiateExchange(): Promise<MessageExchange>;
     abstract reconnectChannel(): Promise<boolean>;
     abstract session: Session;
-    abstract channelType: ChannelType;
+
+    get channelType() {
+        return this.session.channel.type;
+    }
 }
 
 /**
  * Manages an exchange over an established channel.
  */
 export class DedicatedChannelExchangeProvider extends ExchangeProvider {
-    #channel: MessageChannel;
+    #session: SecureSession;
     readonly supportsReconnect = false;
 
-    constructor(exchangeManager: ExchangeManager, channel: MessageChannel) {
+    constructor(exchangeManager: ExchangeManager, session: SecureSession) {
         super(exchangeManager);
-        this.#channel = channel;
+        this.#session = session;
     }
 
     async initiateExchange(): Promise<MessageExchange> {
-        return this.exchangeManager.initiateExchangeWithChannel(this.#channel, INTERACTION_PROTOCOL_ID);
+        return this.exchangeManager.initiateExchangeForSession(this.#session, INTERACTION_PROTOCOL_ID);
     }
 
     async reconnectChannel() {
@@ -65,15 +66,11 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
     }
 
     get session() {
-        return this.#channel.session;
-    }
-
-    get channelType() {
-        return this.#channel.type;
+        return this.#session;
     }
 
     maximumPeerResponseTime(expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
-        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#channel, expectedProcessingTime);
+        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#session, expectedProcessingTime);
     }
 }
 
@@ -88,15 +85,15 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
 
     constructor(
         exchangeManager: ExchangeManager,
-        protected readonly channelManager: ChannelManager,
+        protected readonly sessions: SessionManager,
         address: PeerAddress,
         reconnectChannelFunc: () => Promise<void>,
     ) {
         super(exchangeManager);
         this.#address = address;
         this.#reconnectChannelFunc = reconnectChannelFunc;
-        channelManager.added.on(address => {
-            if (address === this.#address) {
+        sessions.sessions.added.on(session => {
+            if (session.peerAddress === this.#address) {
                 this.#channelUpdated.emit();
             }
         });
@@ -107,11 +104,16 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
     }
 
     async initiateExchange(): Promise<MessageExchange> {
-        if (!this.channelManager.hasChannel(this.#address)) {
+        if (!this.sessions.maybeSessionFor(this.#address)) {
+            using _connecting = this.sessions.construction.join(
+                "connecting to",
+                Diagnostic.strong(this.#address.toString()),
+            );
+
             await this.reconnectChannel();
         }
-        if (!this.channelManager.hasChannel(this.#address)) {
-            throw new ChannelNotConnectedError("Channel not connected");
+        if (!this.sessions.maybeSessionFor(this.#address)) {
+            throw new SessionClosedError("Channel not connected");
         }
         return this.exchangeManager.initiateExchange(this.#address, INTERACTION_PROTOCOL_ID);
     }
@@ -123,24 +125,13 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
     }
 
     get session() {
-        if (!this.channelManager.hasChannel(this.#address)) {
-            throw new ChannelNotConnectedError("Channel not connected");
-        }
-        return this.channelManager.getChannel(this.#address).session;
-    }
-
-    get channelType() {
-        if (!this.channelManager.hasChannel(this.#address)) {
-            throw new ChannelNotConnectedError("Channel not connected");
-        }
-        return this.channelManager.getChannel(this.#address).type;
+        return this.sessions.sessionFor(this.#address);
     }
 
     maximumPeerResponseTime(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
-        const channel = this.channelManager.getChannel(this.#address);
-        if (!channel) {
-            throw new ChannelNotConnectedError("Channel not connected");
-        }
-        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(channel, expectedProcessingTimeMs);
+        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(
+            this.sessions.sessionFor(this.#address),
+            expectedProcessingTimeMs,
+        );
     }
 }

package/src/protocol/MessageChannel.ts

@@ -5,14 +5,25 @@
  */
 
 import { Message, MessageCodec } from "#codec/MessageCodec.js";
-import { Bytes, Channel, Diagnostic, Duration, Logger, MatterError, MatterFlowError, Millis, Seconds } from "#general";
+import { Mark } from "#common/Mark.js";
+import {
+    Bytes,
+    Channel,
+    Diagnostic,
+    Duration,
+    IpNetworkChannel,
+    Logger,
+    MatterFlowError,
+    MaybePromise,
+    Millis,
+    Seconds,
+} from "#general";
 import type { ExchangeLogContext } from "#protocol/MessageExchange.js";
-import { Session, SessionParameters } from "#session/Session.js";
+import type { Session } from "#session/Session.js";
+import type { SessionParameters } from "#session/SessionParameters.js";
 
 const logger = new Logger("MessageChannel");
 
-export class ChannelNotConnectedError extends MatterError {}
-
 /**
  * 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
@@ -51,23 +62,19 @@ export namespace MRP {
 
 export class MessageChannel implements Channel<Message> {
     public closed = false;
-    #closeCallback?: () => Promise<void>;
+    #onClose?: () => MaybePromise<void>;
     // When the session is supporting MRP and the channel is not reliable, use MRP handling
 
     constructor(
         readonly channel: Channel<Bytes>,
         readonly session: Session,
-        closeCallback?: () => Promise<void>,
+        onClose?: () => MaybePromise<void>,
     ) {
-        this.#closeCallback = closeCallback;
-    }
-
-    set closeCallback(callback: () => Promise<void>) {
-        this.#closeCallback = callback;
+        this.#onClose = onClose;
     }
 
-    get usesMrp() {
-        return this.session.supportsMRP && !this.channel.isReliable;
+    set onClose(callback: () => MaybePromise<void>) {
+        this.#onClose = callback;
     }
 
     /** Is the underlying transport reliable? */
@@ -96,7 +103,7 @@ export class MessageChannel implements Channel<Message> {
     }
 
     async send(message: Message, logContext?: ExchangeLogContext) {
-        logger.debug("Message »", MessageCodec.messageDiagnostics(message, logContext));
+        logger.debug("Message", Mark.OUTBOUND, Message.diagnosticsOf(this.session, message, logContext));
         const packet = this.session.encode(message);
         const bytes = MessageCodec.encodePacket(packet);
         if (bytes.byteLength > this.maxPayloadSize) {
@@ -109,7 +116,11 @@ export class MessageChannel implements Channel<Message> {
     }
 
     get name() {
-        return Diagnostic.via(`${this.session.name}@${this.channel.name}`);
+        return Diagnostic.via(`${this.session.via}@${this.channel.name}`);
+    }
+
+    get networkAddress() {
+        return (this.channel as IpNetworkChannel<Bytes> | undefined)?.networkAddress;
     }
 
     async close() {
@@ -117,7 +128,7 @@ export class MessageChannel implements Channel<Message> {
         this.closed = true;
         await this.channel.close();
         if (!wasAlreadyClosed) {
-            await this.#closeCallback?.();
+            await this.#onClose?.();
         }
     }
 
@@ -133,7 +144,7 @@ export class MessageChannel implements Channel<Message> {
 
             case "udp":
                 // UDP normally uses MRP, if not we have Group communication, which normally have no responses
-                if (!this.usesMrp) {
+                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
@@ -167,7 +178,7 @@ export class MessageChannel implements Channel<Message> {
         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 peerActive = retransmissionCount > 0 && (sessionParameters !== undefined || this.session.isPeerActive);
         const baseInterval = peerActive ? activeInterval : idleInterval;
         return Millis.floor(
             Millis(

package/src/protocol/MessageCounter.ts

@@ -52,7 +52,7 @@ export class MessageCounter {
      */
     constructor(
         crypto: Crypto,
-        protected readonly aboutToRolloverCallback?: () => void,
+        protected readonly onRollover?: () => Promise<void>,
 
         // Counter is a 28 bit random number plus 1
         protected readonly rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE,
@@ -63,16 +63,16 @@ export class MessageCounter {
     async getIncrementedCounter() {
         this.messageCounter++;
         if (this.messageCounter > MAX_COUNTER_VALUE_32BIT) {
-            if (this.aboutToRolloverCallback !== undefined) {
+            if (this.onRollover !== undefined) {
                 this.messageCounter = 0;
             } else {
                 throw new InternalError("Message counter rollover not allowed.");
             }
         } else if (
-            this.aboutToRolloverCallback !== undefined &&
+            this.onRollover !== undefined &&
             this.messageCounter === MAX_COUNTER_VALUE_32BIT - this.rolloverInfoDifference
         ) {
-            this.aboutToRolloverCallback();
+            await this.onRollover();
         }
         return this.messageCounter;
     }
@@ -90,7 +90,7 @@ export class PersistedMessageCounter extends MessageCounter {
         crypto: Crypto,
         storageContext: StorageContext,
         storageKey: string,
-        aboutToRolloverCallback?: () => void,
+        aboutToRolloverCallback?: () => Promise<void>,
         rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE,
     ) {
         return asyncNew(
@@ -107,7 +107,7 @@ export class PersistedMessageCounter extends MessageCounter {
         crypto: Crypto,
         private readonly storageContext: StorageContext,
         private readonly storageKey: string,
-        aboutToRolloverCallback?: () => void,
+        aboutToRolloverCallback?: () => Promise<void>,
         rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE,
     ) {
         super(crypto, aboutToRolloverCallback, rolloverInfoDifference);
@@ -119,10 +119,10 @@ export class PersistedMessageCounter extends MessageCounter {
                 }
                 // Make sure to call the callback if we are close to a rollover also for edge cases on initialization
                 if (
-                    this.aboutToRolloverCallback !== undefined &&
+                    this.onRollover !== undefined &&
                     this.messageCounter >= MAX_COUNTER_VALUE_32BIT - this.rolloverInfoDifference
                 ) {
-                    this.aboutToRolloverCallback();
+                    await this.onRollover();
                 }
             }
         });