@matter/protocol 0.16.0-alpha.0-20250930-05e6cc3f8 → 0.16.0-alpha.0-20251003-dc6d5523d

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;

package/src/session/pase/PaseMessages.ts

@@ -6,6 +6,7 @@
 
 import { SupportedTransportsBitmap } from "#common/SupportedTransportsBitmap.js";
 import { CRYPTO_HASH_LEN_BYTES, CRYPTO_PUBLIC_KEY_SIZE_BYTES } from "#general";
+import { SessionIntervals } from "#session/SessionIntervals.js";
 import {
     TlvBitmap,
     TlvBoolean,
@@ -15,18 +16,19 @@ import {
     TlvOptionalField,
     TlvUInt16,
     TlvUInt32,
+    TypeFromSchema,
 } from "#types";
 
 /** @see {@link MatterSpecification.v13.Core} § 4.12.8 */
 export const TlvSessionParameters = TlvObject({
     /** Maximum sleep interval of node when in idle mode. */
-    idleIntervalMs: TlvOptionalField(1, TlvUInt32) /* default: SESSION_IDLE_INTERVAL */,
+    idleInterval: TlvOptionalField(1, TlvUInt32) /* default: SESSION_IDLE_INTERVAL */,
 
     /** Maximum sleep interval of node when in active mode. */
-    activeIntervalMs: TlvOptionalField(2, TlvUInt32) /* default: SESSION_ACTIVE_INTERVAL */,
+    activeInterval: TlvOptionalField(2, TlvUInt32) /* default: SESSION_ACTIVE_INTERVAL */,
 
     /** Minimum amount of time the node SHOULD stay active after network activity. */
-    activeThresholdMs: TlvOptionalField(3, TlvUInt16) /* default: SESSION_ACTIVE_THRESHOLD */,
+    activeThreshold: TlvOptionalField(3, TlvUInt16) /* default: SESSION_ACTIVE_THRESHOLD */,
 
     /** Data model revision. */
     dataModelRevision: TlvOptionalField(4, TlvUInt16) /* default: 16 OR 17, we choose 17 aka Matter 1.2 */,
@@ -47,6 +49,17 @@ export const TlvSessionParameters = TlvObject({
     maxTcpMessageSize: TlvOptionalField(9, TlvUInt32) /* default: 64000 */,
 });
 
+// Replace the interval fields with Duration-typed fields in the exported type
+export type SessionParametersWithDurations = Omit<
+    TypeFromSchema<typeof TlvSessionParameters>,
+    "activeThreshold" | "activeInterval" | "idleInterval"
+> &
+    Partial<SessionIntervals>;
+
+export type WithDurationSessionParameters<T, K extends keyof T> = Omit<T, K> & {
+    [P in K]?: SessionParametersWithDurations;
+};
+
 /** @see {@link MatterSpecification.v13.Core} § 4.14.1.2 */
 export const TlvPbkdfParamRequest = TlvObject({
     initiatorRandom: TlvField(1, TlvByteString.bound({ length: 32 })),
@@ -55,6 +68,10 @@ export const TlvPbkdfParamRequest = TlvObject({
     hasPbkdfParameters: TlvField(4, TlvBoolean),
     initiatorSessionParams: TlvOptionalField(5, TlvSessionParameters),
 });
+export type PbkdfParamRequest = WithDurationSessionParameters<
+    TypeFromSchema<typeof TlvPbkdfParamRequest>,
+    "initiatorSessionParams"
+>;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.1.2 */
 export const TlvPbkdfParamResponse = TlvObject({
@@ -70,19 +87,26 @@ export const TlvPbkdfParamResponse = TlvObject({
     ),
     responderSessionParams: TlvOptionalField(5, TlvSessionParameters),
 });
+export type PbkdfParamResponse = WithDurationSessionParameters<
+    TypeFromSchema<typeof TlvPbkdfParamResponse>,
+    "responderSessionParams"
+>;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.1.2 */
 export const TlvPasePake1 = TlvObject({
     x: TlvField(1, TlvByteString.bound({ length: CRYPTO_PUBLIC_KEY_SIZE_BYTES })), // pA
 });
+export type PasePake1 = TypeFromSchema<typeof TlvPasePake1>;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.1.2 */
 export const TlvPasePake2 = TlvObject({
     y: TlvField(1, TlvByteString.bound({ length: CRYPTO_PUBLIC_KEY_SIZE_BYTES })), // pB
     verifier: TlvField(2, TlvByteString.bound({ length: CRYPTO_HASH_LEN_BYTES })), // cB
 });
+export type PasePake2 = TypeFromSchema<typeof TlvPasePake2>;
 
 /** @see {@link MatterSpecification.v13.Core} § 4.14.1.2 */
 export const TlvPasePake3 = TlvObject({
     verifier: TlvField(1, TlvByteString.bound({ length: CRYPTO_HASH_LEN_BYTES })), // cA
 });
+export type PasePake3 = TypeFromSchema<typeof TlvPasePake3>;

package/src/session/pase/PaseMessenger.ts

@@ -5,9 +5,14 @@
  */
 
 import { Bytes } from "#general";
-import { SecureMessageType, TypeFromSchema } from "#types";
+import { SecureMessageType } from "#types";
 import { DEFAULT_NORMAL_PROCESSING_TIME, SecureChannelMessenger } from "../../securechannel/SecureChannelMessenger.js";
 import {
+    PasePake1,
+    PasePake2,
+    PasePake3,
+    PbkdfParamRequest,
+    PbkdfParamResponse,
     TlvPasePake1,
     TlvPasePake2,
     TlvPasePake3,
@@ -18,16 +23,10 @@ import {
 export const DEFAULT_PASSCODE_ID = 0;
 export const SPAKE_CONTEXT = Bytes.fromString("CHIP PAKE V1 Commissioning");
 
-type PbkdfParamRequest = TypeFromSchema<typeof TlvPbkdfParamRequest>;
-type PbkdfParamResponse = TypeFromSchema<typeof TlvPbkdfParamResponse>;
-type PasePake1 = TypeFromSchema<typeof TlvPasePake1>;
-type PasePake2 = TypeFromSchema<typeof TlvPasePake2>;
-type PasePake3 = TypeFromSchema<typeof TlvPasePake3>;
-
 export class PaseServerMessenger extends SecureChannelMessenger {
     async readPbkdfParamRequest() {
         const { payload } = await this.nextMessage(SecureMessageType.PbkdfParamRequest, DEFAULT_NORMAL_PROCESSING_TIME);
-        return { requestPayload: payload, request: TlvPbkdfParamRequest.decode(payload) };
+        return { requestPayload: payload, request: TlvPbkdfParamRequest.decode(payload) as PbkdfParamRequest };
     }
 
     async sendPbkdfParamResponse(response: PbkdfParamResponse) {
@@ -61,7 +60,7 @@ export class PaseClientMessenger extends SecureChannelMessenger {
             SecureMessageType.PbkdfParamResponse,
             DEFAULT_NORMAL_PROCESSING_TIME,
         );
-        return { responsePayload: payload, response: TlvPbkdfParamResponse.decode(payload) };
+        return { responsePayload: payload, response: TlvPbkdfParamResponse.decode(payload) as PbkdfParamResponse };
     }
 
     sendPasePake1(pasePake1: PasePake1) {