@matter/protocol 0.16.0-alpha.0-20251217-038f88085 → 0.16.0-alpha.0-20251221-21acf226d

package/src/bdx/flow/Flow.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "#general";
+import { InternalError, Observable } from "#general";
 import { BdxStatusCode } from "#types";
 import { BdxError } from "../BdxError.js";
 import { BdxMessenger } from "../BdxMessenger.js";
@@ -15,14 +15,35 @@ export abstract class Flow {
     readonly #transferParameters: Flow.TransferOptions;
     readonly #messenger: BdxMessenger;
     #isClosed = false;
-    #blockCounter = 0;
+    #blockCounter = -1;
     #bytesLeft?: number;
     #finalBlockCounter?: number;
+    readonly progressInfo = Observable<[bytesTransferred: number, totalBytesLength: number | undefined]>();
+    readonly progressFinished = Observable<[totalBytesTransferred: number]>();
+    #dataLength: number | undefined;
+    #transferredBytes = 0;
 
     constructor(messenger: BdxMessenger, transferParameters: Flow.TransferOptions) {
         this.#messenger = messenger;
         this.#transferParameters = transferParameters;
         this.#bytesLeft = transferParameters.dataLength;
+        this.#dataLength = transferParameters.dataLength; // Could be undefined when unknown, will be updated with blob size when outbound flow
+    }
+
+    protected set dataLength(value: number) {
+        this.#dataLength = value;
+    }
+
+    get dataLength(): number | undefined {
+        return this.#dataLength;
+    }
+
+    protected set transferredBytes(value: number) {
+        this.#transferredBytes = value;
+    }
+
+    get transferredBytes() {
+        return this.#transferredBytes;
     }
 
     protected get transferParameters(): Flow.TransferOptions {
@@ -87,16 +108,22 @@ export abstract class Flow {
     async processTransfer() {
         await this.initTransfer();
 
+        // Emit initial progress info
+        this.progressInfo.emit(0, this.dataLength);
+
         // Continue to transfer chunks until done or closed
         while (!this.isClosed) {
             if (await this.transferNextChunk()) {
                 break;
             }
+            this.progressInfo.emit(this.transferredBytes, this.dataLength);
         }
+        this.progressInfo.emit(this.transferredBytes, this.dataLength);
 
         if (!this.isClosed) {
             await this.finalizeTransfer();
         }
+        this.progressFinished.emit(this.transferredBytes);
     }
 
     protected abstract initTransfer(): Promise<void>;

package/src/bdx/flow/FollowingReceivingFlow.ts

@@ -37,16 +37,19 @@ export class FollowingReceivingFlow extends OutboundFlow {
         if (bytesToSkip > 0) {
             const skipped = await streamReader.skip(bytesToSkip);
             logger.debug(`Skipped ${skipped}bytes of data (requested ${bytesToSkip}bytes)`);
+            this.transferredBytes += bytesToSkip;
         }
         const { data, done } = await this.readDataChunk(iterator);
 
         if (done) {
             await this.messenger.sendBlockEof({ data, blockCounter });
+            this.transferredBytes += data.byteLength;
             this.finalBlockCounter = blockCounter;
             return true;
         }
 
         await this.messenger.sendBlock({ data, blockCounter });
+        this.transferredBytes += data.byteLength;
         // Ack or next BlockQuery is read on the next iteration
         return false;
     }

package/src/bdx/flow/FollowingSendingFlow.ts

@@ -22,6 +22,8 @@ export class FollowingSendingFlow extends InboundFlow {
         } = await this.messenger.readBlock();
         this.validateCounter(blockCounter);
 
+        this.transferredBytes += data.byteLength;
+
         // Write the received data chunk into the writing stream
         if (this.writeDataChunk(writeController, data, messageType)) {
             this.finalBlockCounter = blockCounter;

package/src/bdx/flow/OutboundFlow.ts

@@ -35,6 +35,7 @@ export abstract class OutboundFlow extends Flow {
 
         // Get the full or relevant part of the stream by startOffset and length
         const { startOffset = 0, dataLength = blobSize } = this.transferParameters;
+        this.dataLength = dataLength;
 
         const dataBlob =
             startOffset > 0 || dataLength !== blobSize ? blob.slice(startOffset, startOffset + dataLength) : blob;

package/src/bdx/index.ts

@@ -14,3 +14,4 @@ export * from "./FileDesignator.js";
 export * from "./flow/Flow.js";
 export * from "./PersistedFileDesignator.js";
 export * from "./schema/index.js";
+export * from "./ScopedStorage.js";

package/src/certificate/kinds/Icac.ts

@@ -60,7 +60,7 @@ export class Icac extends OperationalBase<OperationalCertificate.Icac> {
             issuer: { rcacId },
             extensions,
         } = this.cert;
-        const { fabricId, icacId } = subject;
+        const { fabricId } = subject;
         const { basicConstraints, extendedKeyUsage, subjectKeyIdentifier, authorityKeyIdentifier } = extensions;
 
         const { fabricId: rootFabricId } = root.cert.subject;
@@ -80,6 +80,8 @@ export class Icac extends OperationalBase<OperationalCertificate.Icac> {
             }
         }
 
+        // Ikea Dirigera hub provided an invalid ICAC, so disable these checks for now because also SDK seems to not check it
+        /*
         // The subject DN SHALL encode exactly one matter-icac-id attribute.
         if (icacId === undefined || Array.isArray(icacId)) {
             throw new CertificateError(`Invalid icacId in Ica certificate: ${Diagnostic.json(icacId)}`);
@@ -89,6 +91,7 @@ export class Icac extends OperationalBase<OperationalCertificate.Icac> {
         if ("rcacId" in subject) {
             throw new CertificateError(`Ica certificate must not contain an rcacId.`);
         }
+        */
 
         // The subject DN SHALL NOT encode any matter-noc-cat attribute.
         if ("caseAuthenticatedTags" in subject) {

package/src/certificate/kinds/Rcac.ts

@@ -18,6 +18,10 @@ export class Rcac extends OperationalBase<OperationalCertificate.Rcac> {
         return new Rcac(OperationalCertificate.TlvRcac.decode(tlv));
     }
 
+    static publicKeyOfTlv(tlv: Bytes): Bytes {
+        return Rcac.fromTlv(tlv).cert.ellipticCurvePublicKey;
+    }
+
     /** Construct the class from an ASN.1/DER encoded certificate */
     static fromAsn1(asn1: Bytes): Rcac {
         const cert = Certificate.parseAsn1Certificate(asn1);

package/src/certificate/kinds/definitions/operational.ts

@@ -167,7 +167,7 @@ export namespace OperationalCertificate {
 
     export const TlvIcac = BaseMatterCertificate({
         subject: {
-            icacId: TlvField(19, TlvUInt64),
+            icacId: TlvOptionalField(19, TlvUInt64),
             fabricId: TlvOptionalField(21, TlvFabricId),
         },
         issuer: AllowedSubjectAndIssuerMatterFields,

package/src/common/FailsafeContext.ts

@@ -244,9 +244,9 @@ export abstract class FailsafeContext {
         }
 
         await builder.setOperationalCert(nocValue, icacValue);
-        const fabricAlreadyExisting = this.#fabrics.find(fabric => builder.matchesToFabric(fabric));
+        const newGlobalId = await builder.globalId;
 
-        if (fabricAlreadyExisting) {
+        if (this.#fabrics.has(newGlobalId)) {
             throw new MatterFabricConflictError(
                 `Fabric with Id ${builder.fabricId} and Node Id ${builder.nodeId} already exists.`,
             );

package/src/dcl/DclClient.ts

@@ -90,12 +90,11 @@ export class DclClient {
             return await response.json();
         } catch (error) {
             MatterDclResponseError.reject(error);
-            MatterError.accept(error);
             throw new MatterDclResponseError(
                 path,
                 {
                     code: 500,
-                    message: error.message,
+                    message: (error as Error).message ?? error,
                     details: [],
                 },
                 { cause: error },