@matter/protocol 0.16.0-alpha.0-20251001-7eb06da95 → 0.16.0-alpha.0-20251004-92135c7df

package/src/peer/PeerSet.ts

@@ -10,6 +10,7 @@ import {
     AsyncObservable,
     BasicSet,
     ChannelType,
+    ConnectionlessTransportSet,
     Construction,
     createPromise,
     Duration,
@@ -22,12 +23,11 @@ import {
     Logger,
     MatterError,
     Minutes,
-    NetInterfaceSet,
     NoResponseTimeoutError,
     ObservableSet,
     Seconds,
     ServerAddress,
-    ServerAddressIp,
+    ServerAddressUdp,
     STANDARD_MATTER_PORT,
     Time,
     Timer,
@@ -109,7 +109,7 @@ export interface PeerSetContext {
     exchanges: ExchangeManager;
     subscriptionClient: SubscriptionClient;
     scanners: ScannerSet;
-    netInterfaces: NetInterfaceSet;
+    transports: ConnectionlessTransportSet;
     store: PeerAddressStore;
 }
 
@@ -122,7 +122,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #exchanges: ExchangeManager;
     readonly #subscriptionClient: SubscriptionClient;
     readonly #scanners: ScannerSet;
-    readonly #netInterfaces: NetInterfaceSet;
+    readonly #transports: ConnectionlessTransportSet;
     readonly #caseClient: CaseClient;
     readonly #peers = new BasicSet<OperationalPeer>();
     readonly #peersByAddress = new PeerAddressMap<OperationalPeer>();
@@ -138,14 +138,22 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #disconnected = AsyncObservable<[address: PeerAddress]>();
 
     constructor(context: PeerSetContext) {
-        const { sessions, channels, exchanges, subscriptionClient, scanners, netInterfaces, store } = context;
+        const {
+            sessions,
+            channels,
+            exchanges,
+            subscriptionClient,
+            scanners,
+            transports: netInterfaces,
+            store,
+        } = context;
 
         this.#sessions = sessions;
         this.#channels = channels;
         this.#exchanges = exchanges;
         this.#subscriptionClient = subscriptionClient;
         this.#scanners = scanners;
-        this.#netInterfaces = netInterfaces;
+        this.#transports = netInterfaces;
         this.#store = store;
         this.#caseClient = new CaseClient(this.#sessions);
 
@@ -231,7 +239,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             exchanges: env.get(ExchangeManager),
             subscriptionClient: env.get(SubscriptionClient),
             scanners: env.get(ScannerSet),
-            netInterfaces: env.get(NetInterfaceSet),
+            transports: env.get(ConnectionlessTransportSet),
             store: env.get(PeerAddressStore),
         });
         env.set(PeerSet, instance);
@@ -257,7 +265,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address: PeerAddress,
         options: PeerConnectionOptions & {
             allowUnknownPeer?: boolean;
-            operationalAddress?: ServerAddressIp;
+            operationalAddress?: ServerAddressUdp;
         },
     ) {
         address = PeerAddress(address);
@@ -422,7 +430,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
      * device is discovered again using its operational instance details.
      * It returns the operational MessageChannel on success.
      */
-    async #resume(address: PeerAddress, options: PeerConnectionOptions, tryOperationalAddress?: ServerAddressIp) {
+    async #resume(address: PeerAddress, options: PeerConnectionOptions, tryOperationalAddress?: ServerAddressUdp) {
         const { discoveryOptions: { discoveryType } = {} } = options;
 
         const operationalAddress =
@@ -449,7 +457,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #connectOrDiscoverNode(
         address: PeerAddress,
-        operationalAddress?: ServerAddressIp,
+        operationalAddress?: ServerAddressUdp,
         options?: PeerConnectionOptions,
     ) {
         address = PeerAddress(address);
@@ -630,7 +638,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #reconnectKnownAddress(
         address: PeerAddress,
-        operationalAddress: ServerAddressIp,
+        operationalAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
         options?: CaseClient.PairOptions,
     ): Promise<MessageChannel | undefined> {
@@ -670,7 +678,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         GroupId.assertGroupId(groupId);
         const multicastAddress = this.#sessions.fabricFor(address).groups.multicastAddressFor(groupId);
 
-        const operationalInterface = this.#netInterfaces.interfaceFor(ChannelType.UDP, multicastAddress);
+        const operationalInterface = this.#transports.interfaceFor(ChannelType.UDP, multicastAddress);
         if (operationalInterface === undefined) {
             throw new PairRetransmissionLimitReachedError(`IPv6 interface not initialized`);
         }
@@ -689,7 +697,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /** Pair with an operational device (already commissioned) and establish a CASE session. */
     async #pair(
         address: PeerAddress,
-        operationalServerAddress: ServerAddressIp,
+        operationalServerAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
         options?: CaseClient.PairOptions,
     ) {
@@ -697,10 +705,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         const { ip, port } = operationalServerAddress;
         // Do CASE pairing
         const isIpv6Address = isIPv6(ip);
-        const operationalInterface = this.#netInterfaces.interfaceFor(
-            ChannelType.UDP,
-            isIpv6Address ? "::" : "0.0.0.0",
-        );
+        const operationalInterface = this.#transports.interfaceFor(ChannelType.UDP, isIpv6Address ? "::" : "0.0.0.0");
 
         if (operationalInterface === undefined) {
             throw new PairRetransmissionLimitReachedError(
@@ -812,7 +817,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #addOrUpdatePeer(
         address: PeerAddress,
-        operationalServerAddress: ServerAddressIp,
+        operationalServerAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
     ) {
         let peer = this.#peersByAddress.get(address);

package/src/protocol/ExchangeManager.ts

@@ -8,6 +8,8 @@ import { DecodedMessage, MessageCodec, SessionType } from "#codec/MessageCodec.j
 import {
     Bytes,
     Channel,
+    ConnectionlessTransport,
+    ConnectionlessTransportSet,
     Crypto,
     Diagnostic,
     Environment,
@@ -18,8 +20,6 @@ import {
     MatterError,
     MatterFlowError,
     ObserverGroup,
-    TransportInterface,
-    TransportInterfaceSet,
     UdpInterface,
     UnexpectedDataError,
 } from "#general";
@@ -49,35 +49,35 @@ const MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION = 5;
  */
 export interface ExchangeManagerContext {
     crypto: Crypto;
-    transportInterfaces: TransportInterfaceSet;
+    netInterface: ConnectionlessTransportSet;
     sessionManager: SessionManager;
     channelManager: ChannelManager;
 }
 
 export class ExchangeManager {
-    readonly #transportInterfaces: TransportInterfaceSet;
+    readonly #transports: ConnectionlessTransportSet;
     readonly #sessionManager: SessionManager;
     readonly #channelManager: ChannelManager;
     readonly #exchangeCounter: ExchangeCounter;
     readonly #exchanges = new Map<number, MessageExchange>();
     readonly #protocols = new Map<number, ProtocolHandler>();
-    readonly #listeners = new Map<TransportInterface, TransportInterface.Listener>();
+    readonly #listeners = new Map<ConnectionlessTransport, ConnectionlessTransport.Listener>();
     readonly #closers = new Set<Promise<void>>();
     readonly #observers = new ObserverGroup(this);
     #closing = false;
 
     constructor(context: ExchangeManagerContext) {
-        this.#transportInterfaces = context.transportInterfaces;
+        this.#transports = context.netInterface;
         this.#sessionManager = context.sessionManager;
         this.#channelManager = context.channelManager;
         this.#exchangeCounter = new ExchangeCounter(context.crypto);
 
-        for (const transportInterface of this.#transportInterfaces) {
-            this.#addListener(transportInterface);
+        for (const netInterface of this.#transports) {
+            this.#addListener(netInterface);
         }
 
-        this.#observers.on(this.#transportInterfaces.added, this.#addListener);
-        this.#observers.on(this.#transportInterfaces.deleted, this.#deleteListener);
+        this.#observers.on(this.#transports.added, this.#addListener);
+        this.#observers.on(this.#transports.deleted, this.#deleteListener);
 
         this.#observers.on(this.#sessionManager.sessions.deleted, session => {
             if (!session.closingAfterExchangeFinished) {
@@ -90,7 +90,7 @@ export class ExchangeManager {
     static [Environmental.create](env: Environment) {
         const instance = new ExchangeManager({
             crypto: env.get(Crypto),
-            transportInterfaces: env.get(TransportInterfaceSet),
+            netInterface: env.get(ConnectionlessTransportSet),
             sessionManager: env.get(SessionManager),
             channelManager: env.get(ChannelManager),
         });
@@ -261,7 +261,11 @@ export class ExchangeManager {
 
             // Having a "Secure Session" means it is encrypted in our internal working
             // TODO When adding Group sessions, we need to check how to adjust that handling
-            if (protocolHandler !== undefined && protocolHandler.requiresSecureSession !== session.isSecure) {
+            if (
+                protocolHandler !== undefined &&
+                protocolHandler.requiresSecureSession !== session.isSecure &&
+                !isStandaloneAck
+            ) {
                 logger.debug(
                     `Ignoring message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId} on channel ${channel.name} because not matching the security requirements.`,
                 );
@@ -313,7 +317,7 @@ export class ExchangeManager {
                         );
                     }
                     return;
-                } else {
+                } else if (!isStandaloneAck) {
                     logger.info(
                         `Discarding unexpected message ${messageId} for protocol ${
                             message.payloadHeader.protocolId
@@ -416,7 +420,11 @@ export class ExchangeManager {
         channel: MessageChannel,
         expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ) {
-        return channel.calculateMaximumPeerResponseTime(this.#sessionManager.sessionParameters, expectedProcessingTime);
+        return channel.calculateMaximumPeerResponseTime(
+            channel.session.parameters,
+            this.#sessionManager.sessionParameters,
+            expectedProcessingTime,
+        );
     }
 
     #messageExchangeContextFor(channel: MessageChannel): MessageExchangeContext {
@@ -427,11 +435,11 @@ export class ExchangeManager {
         };
     }
 
-    #addListener(transportInterface: TransportInterface) {
-        const udpInterface = transportInterface instanceof UdpInterface;
+    #addListener(netInterface: ConnectionlessTransport) {
+        const udpInterface = netInterface instanceof UdpInterface;
         this.#listeners.set(
-            transportInterface,
-            transportInterface.onData((socket, data) => {
+            netInterface,
+            netInterface.onData((socket, data) => {
                 if (udpInterface && data.byteLength > socket.maxPayloadSize) {
                     logger.warn(
                         `Ignoring UDP message on channel ${socket.name} with size ${data.byteLength} from ${socket.name}, which is larger than the maximum allowed size of ${socket.maxPayloadSize}.`,
@@ -456,12 +464,12 @@ export class ExchangeManager {
         );
     }
 
-    #deleteListener(transportInterface: TransportInterface) {
-        const listener = this.#listeners.get(transportInterface);
+    #deleteListener(netInterface: ConnectionlessTransport) {
+        const listener = this.#listeners.get(netInterface);
         if (listener === undefined) {
             return;
         }
-        this.#listeners.delete(transportInterface);
+        this.#listeners.delete(netInterface);
 
         const closer = listener
             .close()

package/src/protocol/MessageChannel.ts

@@ -114,7 +114,8 @@ export class MessageChannel implements Channel<Message> {
     }
 
     calculateMaximumPeerResponseTime(
-        sessionParameters: SessionParameters,
+        peerSessionParameters: SessionParameters,
+        localSessionParameters: SessionParameters,
         expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ): Duration {
         switch (this.channel.type) {
@@ -127,8 +128,11 @@ export class MessageChannel implements Channel<Message> {
                 if (!this.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(sessionParameters, expectedProcessingTime) +
+                    this.#calculateMrpMaximumPeerResponseTime(peerSessionParameters) +
+                        this.#calculateMrpMaximumPeerResponseTime(localSessionParameters) +
+                        expectedProcessingTime +
                         PEER_RESPONSE_TIME_BUFFER,
                 );
 
@@ -153,8 +157,10 @@ export class MessageChannel implements Channel<Message> {
      */
     getMrpResubmissionBackOffTime(retransmissionCount: number, sessionParameters?: SessionParameters) {
         const { activeInterval, idleInterval } = sessionParameters ?? this.session.parameters;
-        const baseInterval =
-            sessionParameters !== undefined || this.session.isPeerActive() ? activeInterval : idleInterval;
+        // 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 *
@@ -165,19 +171,15 @@ export class MessageChannel implements Channel<Message> {
         );
     }
 
-    #calculateMrpMaximumPeerResponseTime(
-        sessionParameters: SessionParameters,
-        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
-    ) {
-        // We use the expected processing time and deduct the time we already waited since last resubmission
-        let finalWaitTime = expectedProcessingTime;
+    /** 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));
         }
 
-        // TODO: Also add any network latency buffer, for now lets consider it's included in the processing time already
         return finalWaitTime;
     }
 }

package/src/protocol/MessageExchange.ts

@@ -31,7 +31,6 @@ import {
 } from "#protocol/MessageChannel.js";
 import { GroupSession } from "#session/GroupSession.js";
 import { SessionParameters } from "#session/Session.js";
-import { SessionIntervals } from "#session/SessionIntervals.js";
 import {
     GroupId,
     NodeId,
@@ -145,9 +144,6 @@ export class MessageExchange {
         );
     }
 
-    readonly #activeInterval: Duration;
-    readonly #idleInterval: Duration;
-    readonly #activeThreshold: Duration;
     readonly #messagesQueue = new DataReadQueue<Message>();
     #receivedMessageToAck: Message | undefined;
     #receivedMessageAckTimer = Time.getTimer("Ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
@@ -196,10 +192,7 @@ export class MessageExchange {
         this.#exchangeId = exchangeId;
         this.#protocolId = protocolId;
 
-        const { activeInterval, idleInterval, activeThreshold } = SessionIntervals(session.parameters);
-        this.#activeInterval = activeInterval;
-        this.#idleInterval = idleInterval;
-        this.#activeThreshold = activeThreshold;
+        const { activeThreshold, activeInterval, idleInterval } = this.session.parameters;
 
         this.#used = !isInitiator; // If we are the initiator then exchange was not used yet, so track it
 
@@ -211,9 +204,9 @@ export class MessageExchange {
                 exId: this.#exchangeId,
                 sess: session.name,
                 peerSess: this.#peerSessionId,
-                SAT: this.#activeThreshold,
-                SAI: this.#activeInterval,
-                SII: this.#idleInterval,
+                SAT: Duration.format(activeThreshold),
+                SAI: Duration.format(activeInterval),
+                SII: Duration.format(idleInterval),
                 maxTrans: MRP.MAX_TRANSMISSIONS,
                 exchangeFlags: Diagnostic.asFlags({
                     MRP: this.channel.usesMrp,
@@ -489,6 +482,7 @@ export class MessageExchange {
             timeout = Instant; // If we have messages in the queue, we can return them immediately
         } else {
             timeout = this.channel.calculateMaximumPeerResponseTime(
+                this.session.parameters,
                 this.context.localSessionParameters,
                 options?.expectedProcessingTime,
             );
@@ -496,13 +490,6 @@ export class MessageExchange {
         return this.#messagesQueue.read(timeout);
     }
 
-    calculateMaximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
-        return this.channel.calculateMaximumPeerResponseTime(
-            this.context.localSessionParameters,
-            expectedProcessingTimeMs,
-        );
-    }
-
     #retransmitMessage(message: Message, expectedProcessingTime?: Duration) {
         this.#retransmissionCounter++;
         if (this.#retransmissionCounter >= MRP.MAX_TRANSMISSIONS) {
@@ -512,6 +499,7 @@ export class MessageExchange {
                 // We already have waited after the last message was sent, so deduct this time from the final wait time
                 const finalWaitTime = Millis(
                     this.channel.calculateMaximumPeerResponseTime(
+                        this.session.parameters,
                         this.context.localSessionParameters,
                         expectedProcessingTime,
                     ) - (this.#retransmissionTimer?.interval ?? Instant),

package/src/session/NodeSession.ts

@@ -13,6 +13,7 @@ import {
     CRYPTO_SYMMETRIC_KEY_LENGTH,
     Crypto,
     Diagnostic,
+    Duration,
     Logger,
     MatterError,
     MatterFlowError,
@@ -176,9 +177,9 @@ export class NodeSession extends SecureSession {
     get parameterDiagnostics() {
         return Diagnostic.dict(
             {
-                SII: this.idleInterval,
-                SAI: this.activeInterval,
-                SAT: this.activeThreshold,
+                SII: Duration.format(this.idleInterval),
+                SAI: Duration.format(this.activeInterval),
+                SAT: Duration.format(this.activeThreshold),
                 DMRev: this.dataModelRevision,
                 IMRev: this.interactionModelRevision,
                 spec: Diagnostic.hex(this.specificationVersion),

package/src/session/SessionIntervals.ts

@@ -49,7 +49,7 @@ export function SessionIntervals(intervals?: Partial<SessionIntervals>): Session
 }
 
 export namespace SessionIntervals {
-    export const defaults = {
+    export const defaults: SessionIntervals = {
         idleInterval: Millis(500),
         activeInterval: Millis(300),
         activeThreshold: Seconds(4),

package/src/session/case/CaseMessages.ts

@@ -10,8 +10,8 @@ import {
     CRYPTO_HASH_LEN_BYTES,
     CRYPTO_PUBLIC_KEY_SIZE_BYTES,
 } from "#general";
-import { TlvByteString, TlvField, TlvObject, TlvOptionalField, TlvUInt16 } from "#types";
-import { TlvSessionParameters } from "../pase/PaseMessages.js";
+import { TlvByteString, TlvField, TlvObject, TlvOptionalField, TlvUInt16, TypeFromSchema } from "#types";
+import { TlvSessionParameters, WithDurationSessionParameters } from "../pase/PaseMessages.js";
 
 const CASE_SIGNATURE_LENGTH = CRYPTO_GROUP_SIZE_BYTES * 2;
 
@@ -34,6 +34,7 @@ export const TlvCaseSigma1 = TlvObject({
     resumptionId: TlvOptionalField(6, TlvByteString.bound({ length: 16 })),
     initiatorResumeMic: TlvOptionalField(7, TlvByteString.bound({ length: CRYPTO_AEAD_MIC_LENGTH_BYTES })),
 });
+export type CaseSigma1 = WithDurationSessionParameters<TypeFromSchema<typeof TlvCaseSigma1>, "initiatorSessionParams">;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
 export const TlvCaseSigma2 = TlvObject({
@@ -43,6 +44,7 @@ export const TlvCaseSigma2 = TlvObject({
     encrypted: TlvField(4, TlvByteString),
     responderSessionParams: TlvOptionalField(5, TlvSessionParameters),
 });
+export type CaseSigma2 = WithDurationSessionParameters<TypeFromSchema<typeof TlvCaseSigma2>, "responderSessionParams">;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
 export const TlvCaseSigma2Resume = TlvObject({
@@ -51,11 +53,16 @@ export const TlvCaseSigma2Resume = TlvObject({
     responderSessionId: TlvField(3, TlvUInt16),
     responderSessionParams: TlvOptionalField(4, TlvSessionParameters),
 });
+export type CaseSigma2Resume = WithDurationSessionParameters<
+    TypeFromSchema<typeof TlvCaseSigma2Resume>,
+    "responderSessionParams"
+>;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
 export const TlvCaseSigma3 = TlvObject({
     encrypted: TlvField(1, TlvByteString),
 });
+export type CaseSigma3 = TypeFromSchema<typeof TlvCaseSigma3>;
 
 /** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
 export const TlvSignedData = TlvObject({
@@ -64,6 +71,7 @@ export const TlvSignedData = TlvObject({
     responderPublicKey: TlvField(3, TlvByteString.bound({ length: CRYPTO_PUBLIC_KEY_SIZE_BYTES })),
     initiatorPublicKey: TlvField(4, TlvByteString.bound({ length: CRYPTO_PUBLIC_KEY_SIZE_BYTES })),
 });
+export type SignedData = TypeFromSchema<typeof TlvSignedData>;
 
 /** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
 export const TlvEncryptedDataSigma2 = TlvObject({
@@ -72,6 +80,7 @@ export const TlvEncryptedDataSigma2 = TlvObject({
     signature: TlvField(3, TlvByteString.bound({ length: CASE_SIGNATURE_LENGTH })),
     resumptionId: TlvField(4, TlvByteString.bound({ length: 16 })),
 });
+export type EncryptedDataSigma2 = TypeFromSchema<typeof TlvEncryptedDataSigma2>;
 
 /** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
 export const TlvEncryptedDataSigma3 = TlvObject({
@@ -79,3 +88,4 @@ export const TlvEncryptedDataSigma3 = TlvObject({
     responderIcac: TlvOptionalField(2, TlvByteString),
     signature: TlvField(3, TlvByteString.bound({ length: CASE_SIGNATURE_LENGTH })),
 });
+export type EncryptedDataSigma3 = TypeFromSchema<typeof TlvEncryptedDataSigma3>;

package/src/session/case/CaseMessenger.ts

@@ -7,12 +7,20 @@
 import { MatterFlowError } from "#general";
 import { SecureMessageType, TypeFromSchema } from "#types";
 import { SecureChannelMessenger } from "../../securechannel/SecureChannelMessenger.js";
-import { TlvCaseSigma1, TlvCaseSigma2, TlvCaseSigma2Resume, TlvCaseSigma3 } from "./CaseMessages.js";
+import {
+    CaseSigma1,
+    CaseSigma2,
+    CaseSigma2Resume,
+    TlvCaseSigma1,
+    TlvCaseSigma2,
+    TlvCaseSigma2Resume,
+    TlvCaseSigma3,
+} from "./CaseMessages.js";
 
 export class CaseServerMessenger extends SecureChannelMessenger {
     async readSigma1() {
         const { payload } = await this.nextMessage(SecureMessageType.Sigma1);
-        return { sigma1Bytes: payload, sigma1: TlvCaseSigma1.decode(payload) };
+        return { sigma1Bytes: payload, sigma1: TlvCaseSigma1.decode(payload) as CaseSigma1 };
     }
 
     sendSigma2(sigma2: TypeFromSchema<typeof TlvCaseSigma2>) {
@@ -41,9 +49,9 @@ export class CaseClientMessenger extends SecureChannelMessenger {
         } = await this.anyNextMessage("Sigma2(Resume)");
         switch (messageType) {
             case SecureMessageType.Sigma2:
-                return { sigma2Bytes: payload, sigma2: TlvCaseSigma2.decode(payload) };
+                return { sigma2Bytes: payload, sigma2: TlvCaseSigma2.decode(payload) as CaseSigma2 };
             case SecureMessageType.Sigma2Resume:
-                return { sigma2Resume: TlvCaseSigma2Resume.decode(payload) };
+                return { sigma2Resume: TlvCaseSigma2Resume.decode(payload) as CaseSigma2Resume };
             default:
                 throw new MatterFlowError(
                     `Received unexpected message type while expecting CASE Sigma2(Resume): ${messageType}, expected: ${SecureMessageType.Sigma2} or ${SecureMessageType.Sigma2Resume}`,

package/src/session/case/CaseServer.ts

@@ -6,14 +6,15 @@
 
 import { Noc } from "#certificate/kinds/Noc.js";
 import { Bytes, Crypto, CryptoDecryptError, Logger, PublicKey, UnexpectedDataError } from "#general";
-import { TlvSessionParameters } from "#session/pase/PaseMessages.js";
+import { SessionParametersWithDurations } from "#session/pase/PaseMessages.js";
 import { ResumptionRecord, SessionManager } from "#session/SessionManager.js";
-import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode, TypeFromSchema } from "#types";
+import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { FabricManager, FabricNotFoundError } from "../../fabric/FabricManager.js";
 import { MessageExchange } from "../../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
 import { ChannelStatusResponseError } from "../../securechannel/SecureChannelMessenger.js";
 import {
+    CaseSigma1,
     KDFSR1_KEY_INFO,
     KDFSR2_INFO,
     KDFSR2_KEY_INFO,
@@ -22,7 +23,6 @@ import {
     RESUME2_MIC_NONCE,
     TBE_DATA2_NONCE,
     TBE_DATA3_NONCE,
-    TlvCaseSigma1,
     TlvEncryptedDataSigma2,
     TlvEncryptedDataSigma3,
     TlvSignedData,
@@ -313,7 +313,7 @@ class Sigma1Context {
     destinationId: Bytes;
     peerRandom: Bytes;
     peerEcdhPublicKey: Bytes;
-    peerSessionParams?: TypeFromSchema<typeof TlvSessionParameters>;
+    peerSessionParams?: SessionParametersWithDurations;
     resumptionRecord?: ResumptionRecord;
 
     #localResumptionId?: Bytes;
@@ -322,7 +322,7 @@ class Sigma1Context {
         crypto: Crypto,
         messenger: CaseServerMessenger,
         bytes: Bytes,
-        sigma1: TypeFromSchema<typeof TlvCaseSigma1>,
+        sigma1: CaseSigma1,
         resumptionRecord?: ResumptionRecord,
     ) {
         this.crypto = crypto;