@project-chip/matter.js 0.13.0-alpha.0-20250311-3eb0af5f2 → 0.13.0-alpha.0-20250322-f085fa576

package/src/MatterController.ts

@@ -22,6 +22,7 @@ import {
     CRYPTO_SYMMETRIC_KEY_LENGTH,
     ImplementationError,
     Logger,
+    MatterError,
     NetInterfaceSet,
     ServerAddressIp,
     serverAddressToString,
@@ -59,7 +60,6 @@ import {
     SecureChannelProtocol,
     SessionManager,
     SubscriptionClient,
-    UnknownNodeError,
 } from "#protocol";
 import {
     CaseAuthenticatedTag,
@@ -72,7 +72,9 @@ import {
     TypeFromPartialBitSchema,
     VendorId,
 } from "#types";
+import { ClassExtends } from "@matter/general";
 import { ControllerStoreInterface } from "@matter/node";
+import { ControllerCommissioningFlow, MessageChannel } from "@matter/protocol";
 
 export type CommissionedNodeDetails = {
     operationalServerAddress?: ServerAddressIp;
@@ -104,6 +106,9 @@ export class MatterController {
         adminFabricIndex?: FabricIndex;
         caseAuthenticatedTags?: CaseAuthenticatedTag[];
         adminFabricLabel: string;
+        rootNodeId?: NodeId;
+        rootCertificateAuthority?: CertificateAuthority;
+        rootFabric?: Fabric;
     }): Promise<MatterController> {
         const {
             controllerStore,
@@ -115,17 +120,20 @@ export class MatterController {
             adminFabricIndex = FabricIndex(DEFAULT_FABRIC_INDEX),
             caseAuthenticatedTags,
             adminFabricLabel,
+            rootNodeId,
+            rootCertificateAuthority,
+            rootFabric,
         } = options;
 
-        const ca = await CertificateAuthority.create(controllerStore.caStorage);
+        const ca = rootCertificateAuthority ?? (await CertificateAuthority.create(controllerStore.caStorage));
         const fabricStorage = controllerStore.fabricStorage;
 
         let controller: MatterController | undefined = undefined;
         // Check if we have a fabric stored in the storage, if yes initialize this one, else build a new one
-        if (await fabricStorage.has("fabric")) {
-            const fabric = new Fabric(await fabricStorage.get<Fabric.Config>("fabric"));
+        if (rootFabric !== undefined || (await fabricStorage.has("fabric"))) {
+            const fabric = rootFabric ?? new Fabric(await fabricStorage.get<Fabric.Config>("fabric"));
             if (Bytes.areEqual(fabric.rootCert, ca.rootCert)) {
-                logger.info("Loaded existing fabric from storage");
+                logger.info("Used existing fabric");
                 controller = new MatterController({
                     controllerStore,
                     scanners,
@@ -136,9 +144,12 @@ export class MatterController {
                     sessionClosedCallback,
                 });
             } else {
+                if (rootFabric !== undefined) {
+                    throw new MatterError("Fabric CA certificate is not in sync with CA.");
+                }
                 logger.info("Fabric CA certificate changed ...");
                 if (await controllerStore.nodesStorage.has("commissionedNodes")) {
-                    throw new Error(
+                    throw new MatterError(
                         "Fabric certificate changed, but commissioned nodes are still present. Please clear the storage.",
                     );
                 }
@@ -146,16 +157,16 @@ export class MatterController {
         }
         if (controller === undefined) {
             logger.info("Creating new fabric");
-            const rootNodeId = NodeId.randomOperationalNodeId();
+            const controllerNodeId = rootNodeId ?? NodeId.randomOperationalNodeId();
             const ipkValue = Crypto.getRandomData(CRYPTO_SYMMETRIC_KEY_LENGTH);
             const fabricBuilder = new FabricBuilder()
                 .setRootCert(ca.rootCert)
-                .setRootNodeId(rootNodeId)
+                .setRootNodeId(controllerNodeId)
                 .setIdentityProtectionKey(ipkValue)
                 .setRootVendorId(adminVendorId ?? DEFAULT_ADMIN_VENDOR_ID)
                 .setLabel(adminFabricLabel);
             fabricBuilder.setOperationalCert(
-                ca.generateNoc(fabricBuilder.publicKey, adminFabricId, rootNodeId, caseAuthenticatedTags),
+                ca.generateNoc(fabricBuilder.publicKey, adminFabricId, controllerNodeId, caseAuthenticatedTags),
             );
             const fabric = await fabricBuilder.build(adminFabricIndex);
 
@@ -174,7 +185,8 @@ export class MatterController {
     }
 
     public static async createAsPaseCommissioner(options: {
-        certificateAuthorityConfig: CertificateAuthority.Configuration;
+        certificateAuthorityConfig?: CertificateAuthority.Configuration;
+        rootCertificateAuthority?: CertificateAuthority;
         fabricConfig: Fabric.Config;
         scanners: ScannerSet;
         netInterfaces: NetInterfaceSet;
@@ -183,6 +195,7 @@ export class MatterController {
     }): Promise<MatterController> {
         const {
             certificateAuthorityConfig,
+            rootCertificateAuthority,
             fabricConfig,
             adminFabricLabel,
             scanners,
@@ -200,7 +213,12 @@ export class MatterController {
             logger.info("BLE is not enabled. Using only IP network for commissioning.");
         }
 
-        const certificateManager = await CertificateAuthority.create(certificateAuthorityConfig);
+        if (rootCertificateAuthority === undefined && certificateAuthorityConfig === undefined) {
+            throw new ImplementationError("Either rootCertificateAuthority or certificateAuthorityConfig must be set.");
+        }
+
+        const certificateManager =
+            rootCertificateAuthority ?? (await CertificateAuthority.create(certificateAuthorityConfig!));
 
         // Stored data are temporary anyway and no node will be connected, so just use an in-memory storage
         const storageManager = new StorageManager(new StorageBackendMemory());
@@ -388,7 +406,10 @@ export class MatterController {
      */
     async commission(
         options: NodeCommissioningOptions,
-        completeCommissioningCallback?: (peerNodeId: NodeId, discoveryData?: DiscoveryData) => Promise<boolean>,
+        customizations?: {
+            completeCommissioningCallback?: (peerNodeId: NodeId, discoveryData?: DiscoveryData) => Promise<boolean>;
+            commissioningFlowImpl?: ClassExtends<ControllerCommissioningFlow>;
+        },
     ): Promise<NodeId> {
         const commissioningOptions: DiscoveryAndCommissioningOptions = {
             ...options.commissioning,
@@ -397,6 +418,8 @@ export class MatterController {
             passcode: options.passcode,
         };
 
+        const { completeCommissioningCallback, commissioningFlowImpl } = customizations ?? {};
+
         if (completeCommissioningCallback) {
             commissioningOptions.finalizeCommissioning = async (peerAddress, discoveryData) => {
                 const result = await completeCommissioningCallback(peerAddress.nodeId, discoveryData);
@@ -405,6 +428,7 @@ export class MatterController {
                 }
             };
         }
+        commissioningOptions.commissioningFlowImpl = commissioningFlowImpl;
 
         const address = await this.commissioner.commissionWithDiscovery(commissioningOptions);
 
@@ -417,6 +441,17 @@ export class MatterController {
         return this.peers.disconnect(this.fabric.addressOf(nodeId));
     }
 
+    async connectPaseChannel(options: NodeCommissioningOptions) {
+        const { paseSecureChannel } = await this.commissioner.discoverAndEstablishPase({
+            ...options.commissioning,
+            fabric: this.fabric,
+            discovery: options.discovery,
+            passcode: options.passcode,
+        });
+        logger.warn("PASE channel established", paseSecureChannel.session.name, paseSecureChannel.session.isSecure);
+        return paseSecureChannel;
+    }
+
     async removeNode(nodeId: NodeId) {
         return this.peers.delete(this.fabric.addressOf(nodeId));
     }
@@ -504,8 +539,11 @@ export class MatterController {
         return this.clients.connect(this.fabric.addressOf(peerNodeId), { discoveryOptions, allowUnknownPeer });
     }
 
-    createInteractionClient(peerNodeId: NodeId, discoveryOptions: DiscoveryOptions) {
-        return this.clients.getInteractionClient(this.fabric.addressOf(peerNodeId), discoveryOptions);
+    createInteractionClient(peerNodeIdOrChannel: NodeId | MessageChannel, discoveryOptions: DiscoveryOptions) {
+        if (peerNodeIdOrChannel instanceof MessageChannel) {
+            return this.clients.getInteractionClientForChannel(peerNodeIdOrChannel);
+        }
+        return this.clients.getInteractionClient(this.fabric.addressOf(peerNodeIdOrChannel), discoveryOptions);
     }
 
     async getNextAvailableSessionId() {
@@ -548,11 +586,8 @@ export class MatterController {
         filterClusterId?: ClusterId,
     ): Promise<{ endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[]> {
         const peer = this.peers.get(this.fabric.addressOf(nodeId));
-        if (peer === undefined) {
-            throw new UnknownNodeError(`Node ${nodeId} is not commissioned.`);
-        }
-        if (peer.dataStore === undefined) {
-            return []; // We have no store, also also no data
+        if (peer === undefined || peer.dataStore === undefined) {
+            return []; // We have no store, also no data
         }
         await peer.dataStore.construction;
         return peer.dataStore.getClusterDataVersions(filterEndpointId, filterClusterId);
@@ -564,11 +599,8 @@ export class MatterController {
         clusterId: ClusterId,
     ): Promise<DecodedAttributeReportValue<any>[]> {
         const peer = this.peers.get(this.fabric.addressOf(nodeId));
-        if (peer === undefined) {
-            throw new UnknownNodeError(`Node ${nodeId} is not commissioned.`);
-        }
-        if (peer.dataStore === undefined) {
-            return []; // We have no store, also also no data
+        if (peer === undefined || peer.dataStore === undefined) {
+            return []; // We have no store, also no data
         }
         await peer.dataStore.construction;
         return peer.dataStore.retrieveAttributes(endpointId, clusterId);

package/src/PaseCommissioner.ts

@@ -119,7 +119,7 @@ export class PaseCommissioner {
     ) {
         const controller = this.assertControllerIsStarted();
 
-        return await controller.commission(nodeOptions, completeCommissioningCallback);
+        return await controller.commission(nodeOptions, { completeCommissioningCallback });
     }
 
     /** Disconnects all connected nodes and Closes the network connections and other resources of the controller. */

package/src/device/PairedNode.ts

@@ -346,20 +346,26 @@ export class PairedNode {
         this.#reconnectFunc = reconnectFunc;
 
         this.#interactionClient = interactionClient;
-        this.#interactionClient.channelUpdated.on(() => {
-            // When we had planned a reconnect because of a disconnect we can stop the timer now
-            if (
-                this.#reconnectDelayTimer?.isRunning &&
-                !this.#clientReconnectInProgress &&
-                !this.#reconnectionInProgress &&
-                this.#connectionState === NodeStates.Reconnecting
-            ) {
-                logger.info(`Node ${this.nodeId}: Got a reconnect, so reconnection not needed anymore ...`);
-                this.#reconnectDelayTimer?.stop();
-                this.#reconnectDelayTimer = undefined;
-                this.#setConnectionState(NodeStates.Connected);
-            }
-        });
+        if (this.#interactionClient.isReconnectable) {
+            this.#interactionClient.channelUpdated.on(() => {
+                // When we had planned a reconnect because of a disconnect we can stop the timer now
+                if (
+                    this.#reconnectDelayTimer?.isRunning &&
+                    !this.#clientReconnectInProgress &&
+                    !this.#reconnectionInProgress &&
+                    this.#connectionState === NodeStates.Reconnecting
+                ) {
+                    logger.info(`Node ${this.nodeId}: Got a reconnect, so reconnection not needed anymore ...`);
+                    this.#reconnectDelayTimer?.stop();
+                    this.#reconnectDelayTimer = undefined;
+                    this.#setConnectionState(NodeStates.Connected);
+                }
+            });
+        } else {
+            logger.warn(
+                `Node ${this.nodeId}: InteractionClient is not reconnectable, no automatic reconnection will happen in case of errors.`,
+            );
+        }
         this.#nodeDetails = new DeviceInformation(nodeId, knownNodeDetails);
         logger.info(`Node ${this.nodeId}: Created paired node with device data`, this.#nodeDetails.meta);