@project-chip/matter.js 0.2.0 → 0.3.0

package/README.md

@@ -1,27 +1,73 @@
 # matter.js
 
-![experimental](https://img.shields.io/badge/status-Experimental-red) [![license](https://img.shields.io/badge/license-Apache2-green.svg)](https://raw.githubusercontent.com/project-chip/matter.js/master/LICENSE)
-
 Implementation of Matter protocol in typescript with no native dependencies (and very limited dependencies).
 
-## Current status
+This is the JavaScript only Core of the Matter protocol. It is used by other projects to implement Matter Nodes and Clients and add the relevant specific implementations for Network and other elements.
+
+The following features are abstracted away to allow to be implemented environment specific:
+* Network (UDP/MDNS)
+* Crypto (to be split out)
+* Storage
+* Date/Timer
+* Logger (Default uses "console")
+
+## Exported functionality
+This library exports the Matter protocol functionality as well as some helper functions as named exports:
+
+| Export                                  | Description                                                                                                                              |
+|-----------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| `@project-chip/matter.js`               | Exports the current (legacy!) low level API to implement a Device or a Controller. This will be replaced soon by the new High Level API! |
+| `@project-chip/matter.js/certificate`   | Exports Certificate (Root-/PAA/PAI/IAC/DA-Certificates) related functionality                                                            |
+| `@project-chip/matter.js/cluster`       | Exports Matter Cluster definitions and Default Cluster-Handlers                                                                          |
+| `@project-chip/matter.js/codec`         | Exports Codecs for e.g. Matter-Messages                                                                                                  |
+| `@project-chip/matter.js/common`        | Exports certain common functionalities                                                                                                   |
+| `@project-chip/matter.js/crypto`        | Exports Crypto related abstract functionality that needs to be implemented platform specific!                                            |
+| `@project-chip/matter.js/datatype`      | Exports Matter Data types                                                                                                                |
+| `@project-chip/matter.js/fabric`        | Exports Matter-Fabric functionality                                                                                                      |
+| `@project-chip/matter.js/interaction`   | Exports Matter Interaction protocol functionality                                                                                        |
+| `@project-chip/matter.js/log`           | Exports Logging functionality (based on "console")                                                                                       |
+| `@project-chip/matter.js/math`          | Exports Math functionality used by Matter                                                                                                |
+| `@project-chip/matter.js/mdns`          | Exports Basic MDNS functionality (uses Network implementation)                                                                           |
+| `@project-chip/matter.js/net`           | Exports Basic Network abstract functionality that needs to be implemented platform specific!                                             |
+| `@project-chip/matter.js/protocol`      | Exports Basic Matter protocol functionality                                                                                              |
+| `@project-chip/matter.js/schema`        | Exports Schema definitions and functionality                                                                                             |
+| `@project-chip/matter.js/securechannel` | Exports Secure Channel functionality                                                                                                     |
+| `@project-chip/matter.js/session`       | Exports Session and Secure-Session functionality                                                                                         |
+| `@project-chip/matter.js/spec`          | Exports Matter Specification References                                                                                                  |
+| `@project-chip/matter.js/storage`       | Exports Basic Storage abstract functionality that needs to be implemented platform specific!                                             |
+| `@project-chip/matter.js/time`          | Exports Basic Time/Timer abstract functionality that needs to be implemented platform specific!                                          |
+| `@project-chip/matter.js/tlv`           | Exports Matter TLV type definitions                                                                                                      |
+| `@project-chip/matter.js/util`          | Exports Basic Utility functionality                                                                                                      |
 
-This is work in progress.
+Both exports and the typings are exported as CommonJS and ES6 modules.
 
-Completed implementations:
-- [X] TLV codec (coder/decoder) and schema mapping and validation engine
-- [X] 12 cluster definitions (including TLV structures for all messages)
+### Typescript note
+To have Typescript and your IDE know all the relevant exported functionality you need to use the following in your tsconfig.json:
+
+```json5
+{
+    "compilerOptions": {
+        "moduleResolution": "node16", // Required to support package.json exports
+        "module": "node16" // Required to make sure all imports are js
+    }
+}
+```
 
 ## matter.js usage
 
 matter.js is used at the core of those two projects:
 * [matternode](https://github.com/project-chip/matternode): a light-weight node.js implementation of a Matter Node
-* [node-matter](https://github.com/mfucci/node-matter): a Matter client / server running on node.js compatible with HA (Android / iOs support in progress)
+* [matter-node.js](../matter-node.js/README.md): a Matter client / server running on node.js compatible with HA (Android / iOs support in progress)
 
-## Tests
+## Building
 
-Run tests in node.js: npm run test
+* `npm run build`: Build all code and create CommonJS and ES6 variants in dist directory. This will built incrementally and only build the changed files.
+* `npm run build-clean`: Clean the dist directory and build all code from scratch
+
+## Tests
 
-Run tests in the browser: npm run test-web
+* `npm run test-node`: Run tests in node.js
+* `npm run test-web`: Run tests in the browser
+* `npm run test`: Run all tests
 
-test-web will create a /coverage directory conatining the test code coverage
+test-web will create a /coverage directory containing the test code coverage

package/dist/cjs/MatterController.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ResumptionRecord } from "./session/SessionManager.js";
+import { NetInterface } from "./net/NetInterface.js";
+import { InteractionClient } from "./protocol/interaction/InteractionClient.js";
+import { NodeId } from "./datatype/NodeId.js";
+import { RootCertificateManager } from "./certificate/RootCertificateManager.js";
+import { Scanner } from "./common/Scanner.js";
+import { Fabric } from "./fabric/Fabric.js";
+import { MessageChannel } from "./protocol/ExchangeManager.js";
+import { ByteArray } from "./util/ByteArray.js";
+import { StorageManager } from "./storage/StorageManager.js";
+export declare class MatterController {
+    private readonly scanner;
+    private readonly netInterfaceIpv4;
+    private readonly netInterfaceIpv6;
+    private readonly certificateManager;
+    private readonly fabric;
+    private readonly storageManager;
+    static create(scanner: Scanner, netInterfaceIpv4: NetInterface, netInterfaceIpv6: NetInterface, storageManager: StorageManager): Promise<MatterController>;
+    private readonly sessionManager;
+    private readonly channelManager;
+    private readonly exchangeManager;
+    private readonly paseClient;
+    private readonly caseClient;
+    private readonly controllerStorage;
+    constructor(scanner: Scanner, netInterfaceIpv4: NetInterface, netInterfaceIpv6: NetInterface, certificateManager: RootCertificateManager, fabric: Fabric, storageManager: StorageManager);
+    commission(commissionAddress: string, commissionPort: number, _discriminator: number, setupPin: number): Promise<NodeId>;
+    resume(peerNodeId: NodeId, timeoutSeconds?: number): Promise<MessageChannel<unknown>>;
+    pair(peerNodeId: NodeId, operationalIp: string, operationalPort: number): Promise<MessageChannel<unknown>>;
+    isCommissioned(): false;
+    connect(nodeId: NodeId, timeoutSeconds?: number): Promise<InteractionClient>;
+    private ensureSuccess;
+    getNextAvailableSessionId(): any;
+    getFabric(): Fabric;
+    createSecureSession(sessionId: number, fabric: Fabric | undefined, peerNodeId: NodeId, peerSessionId: number, sharedSecret: ByteArray, salt: ByteArray, isInitiator: boolean, isResumption: boolean, idleRetransTimeoutMs?: number, activeRetransTimeoutMs?: number): any;
+    getResumptionRecord(resumptionId: ByteArray): any;
+    findResumptionRecordByNodeId(nodeId: NodeId): any;
+    saveResumptionRecord(resumptionRecord: ResumptionRecord): any;
+    announce(): void;
+    close(): void;
+}
+//# sourceMappingURL=MatterController.d.ts.map

package/dist/cjs/MatterController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatterController.d.ts","sourceRoot":"","sources":["../../src/MatterController.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,gBAAgB,EAAkB,MAAM,6BAA6B,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAE/F,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAI9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAE,MAAM,EAAmC,MAAM,oBAAoB,CAAC;AAG7E,OAAO,EAAqC,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAKlG,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAS7D,qBAAa,gBAAgB;IA8BrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc;WAlCf,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IAqB3I,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAiB;gBAG9B,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,YAAY,EAC9B,gBAAgB,EAAE,YAAY,EAC9B,kBAAkB,EAAE,sBAAsB,EAC1C,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,cAAc;IAY7C,UAAU,CAAC,iBAAiB,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IA+DtG,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,SAAK;IAQ9C,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;IAW7E,cAAc;IAIR,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM;IAkBrD,OAAO,CAAC,aAAa;IAKrB,yBAAyB;IAIzB,SAAS;IAIT,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,oBAAoB,CAAC,EAAE,MAAM,EAAE,sBAAsB,CAAC,EAAE,MAAM;IAInQ,mBAAmB,CAAC,YAAY,EAAE,SAAS;IAI3C,4BAA4B,CAAC,MAAM,EAAE,MAAM;IAI3C,oBAAoB,CAAC,gBAAgB,EAAE,gBAAgB;IAIvD,QAAQ;IAIR,KAAK;CAIR"}

package/dist/cjs/MatterController.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatterController = void 0;
+const SecureChannelMessages_js_1 = require("./protocol/securechannel/SecureChannelMessages.js");
+const SessionManager_js_1 = require("./session/SessionManager.js");
+const PaseClient_js_1 = require("./session/pase/PaseClient.js");
+const CaseClient_js_1 = require("./session/case/CaseClient.js");
+const InteractionClient_js_1 = require("./protocol/interaction/InteractionClient.js");
+const FabricIndex_js_1 = require("./datatype/FabricIndex.js");
+const NodeId_js_1 = require("./datatype/NodeId.js");
+const VendorId_js_1 = require("./datatype/VendorId.js");
+const Crypto_js_1 = require("./crypto/Crypto.js");
+const CertificateManager_js_1 = require("./certificate/CertificateManager.js");
+const RootCertificateManager_js_1 = require("./certificate/RootCertificateManager.js");
+const Logger_js_1 = require("./log/Logger.js");
+const Fabric_js_1 = require("./fabric/Fabric.js");
+const ChannelManager_js_1 = require("./protocol/ChannelManager.js");
+const ExchangeManager_js_1 = require("./protocol/ExchangeManager.js");
+const Ip_js_1 = require("./util/Ip.js");
+const BasicInformationCluster_js_1 = require("./cluster/BasicInformationCluster.js");
+const GeneralCommissioningCluster_js_1 = require("./cluster/GeneralCommissioningCluster.js");
+const OperationalCredentialsCluster_js_1 = require("./cluster/OperationalCredentialsCluster.js");
+const ByteArray_js_1 = require("./util/ByteArray.js");
+const FABRIC_INDEX = new FabricIndex_js_1.FabricIndex(1);
+const FABRIC_ID = BigInt(1);
+const CONTROLLER_NODE_ID = new NodeId_js_1.NodeId(BigInt(1));
+const ADMIN_VENDOR_ID = new VendorId_js_1.VendorId(752);
+const logger = Logger_js_1.Logger.get("MatterController");
+class MatterController {
+    static create(scanner, netInterfaceIpv4, netInterfaceIpv6, storageManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const certificateManager = new RootCertificateManager_js_1.RootCertificateManager(storageManager);
+            const ipkValue = Crypto_js_1.Crypto.getRandomData(16);
+            const fabricBuilder = new Fabric_js_1.FabricBuilder(FABRIC_INDEX)
+                .setRootCert(certificateManager.getRootCert())
+                .setRootNodeId(CONTROLLER_NODE_ID)
+                .setIdentityProtectionKey(ipkValue)
+                .setRootVendorId(ADMIN_VENDOR_ID);
+            fabricBuilder.setOperationalCert(certificateManager.generateNoc(fabricBuilder.getPublicKey(), FABRIC_ID, CONTROLLER_NODE_ID));
+            // Check if we have a fabric stored in the storage, if yes initialize this one, else build a new one
+            const controllerStorage = storageManager.createContext("MatterController");
+            if (controllerStorage.has("fabric")) {
+                const storedFabric = Fabric_js_1.Fabric.createFromStorageObject(controllerStorage.get("fabric"));
+                return new MatterController(scanner, netInterfaceIpv4, netInterfaceIpv6, certificateManager, storedFabric, storageManager);
+            }
+            else {
+                return new MatterController(scanner, netInterfaceIpv4, netInterfaceIpv6, certificateManager, yield fabricBuilder.build(), storageManager);
+            }
+        });
+    }
+    constructor(scanner, netInterfaceIpv4, netInterfaceIpv6, certificateManager, fabric, storageManager) {
+        this.scanner = scanner;
+        this.netInterfaceIpv4 = netInterfaceIpv4;
+        this.netInterfaceIpv6 = netInterfaceIpv6;
+        this.certificateManager = certificateManager;
+        this.fabric = fabric;
+        this.storageManager = storageManager;
+        this.channelManager = new ChannelManager_js_1.ChannelManager();
+        this.paseClient = new PaseClient_js_1.PaseClient();
+        this.caseClient = new CaseClient_js_1.CaseClient();
+        this.controllerStorage = this.storageManager.createContext("MatterController");
+        this.sessionManager = new SessionManager_js_1.SessionManager(this, this.storageManager);
+        this.sessionManager.initFromStorage([this.fabric]);
+        this.exchangeManager = new ExchangeManager_js_1.ExchangeManager(this.sessionManager, this.channelManager);
+        this.exchangeManager.addNetInterface(netInterfaceIpv4);
+        this.exchangeManager.addNetInterface(netInterfaceIpv6);
+    }
+    commission(commissionAddress, commissionPort, _discriminator, setupPin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const paseInterface = (0, Ip_js_1.isIPv6)(commissionAddress) ? this.netInterfaceIpv6 : this.netInterfaceIpv4;
+            const paseChannel = yield paseInterface.openChannel(commissionAddress, commissionPort);
+            // Do PASE paring
+            const paseUnsecureMessageChannel = new ExchangeManager_js_1.MessageChannel(paseChannel, this.sessionManager.getUnsecureSession());
+            const paseSecureSession = yield this.paseClient.pair(this, this.exchangeManager.initiateExchangeWithChannel(paseUnsecureMessageChannel, SecureChannelMessages_js_1.SECURE_CHANNEL_PROTOCOL_ID), setupPin);
+            // Use the created secure session to do the commissioning
+            const paseSecureMessageChannel = new ExchangeManager_js_1.MessageChannel(paseChannel, paseSecureSession);
+            let interactionClient = new InteractionClient_js_1.InteractionClient(new ExchangeManager_js_1.ExchangeProvider(this.exchangeManager, paseSecureMessageChannel));
+            // Get and display the product name (just for debugging)
+            const basicClusterClient = (0, InteractionClient_js_1.ClusterClient)(interactionClient, 0, BasicInformationCluster_js_1.BasicInformationCluster);
+            const productName = yield basicClusterClient.getProductName();
+            logger.info("Paired with device:", productName);
+            // Do the commissioning
+            let generalCommissioningClusterClient = (0, InteractionClient_js_1.ClusterClient)(interactionClient, 0, GeneralCommissioningCluster_js_1.GeneralCommissioningCluster);
+            this.ensureSuccess(yield generalCommissioningClusterClient.armFailSafe({ breadcrumb: BigInt(1), expiryLengthSeconds: 60 }));
+            this.ensureSuccess(yield generalCommissioningClusterClient.setRegulatoryConfig({ breadcrumb: BigInt(2), newRegulatoryConfig: 2 /* RegulatoryLocationType.IndoorOutdoor */, countryCode: "US" }));
+            const operationalCredentialsClusterClient = (0, InteractionClient_js_1.ClusterClient)(interactionClient, 0, OperationalCredentialsCluster_js_1.OperationalCredentialsCluster);
+            const { certificate: deviceAttestation } = yield operationalCredentialsClusterClient.requestCertChain({ type: 1 /* CertificateChainType.DeviceAttestation */ });
+            // TODO: extract device public key from deviceAttestation
+            const { certificate: productAttestation } = yield operationalCredentialsClusterClient.requestCertChain({ type: 2 /* CertificateChainType.ProductAttestationIntermediate */ });
+            // TODO: validate deviceAttestation and productAttestation
+            const { elements: attestationElements, signature: attestationSignature } = yield operationalCredentialsClusterClient.requestAttestation({ attestationNonce: Crypto_js_1.Crypto.getRandomData(32) });
+            // TODO: validate attestationSignature using device public key
+            const { elements: csrElements, signature: csrSignature } = yield operationalCredentialsClusterClient.requestCertSigning({ certSigningRequestNonce: Crypto_js_1.Crypto.getRandomData(32) });
+            if (deviceAttestation.length === 0 || productAttestation.length === 0 || attestationElements.length === 0 || attestationSignature.length === 0 || csrElements.length === 0 || csrSignature.length === 0) {
+                // TODO: validate the data really
+                throw new Error("Invalid response from device");
+            }
+            // TOTO: validate csrSignature using device public key
+            const { certSigningRequest } = OperationalCredentialsCluster_js_1.TlvCertSigningRequest.decode(csrElements);
+            const operationalPublicKey = CertificateManager_js_1.CertificateManager.getPublicKeyFromCsr(certSigningRequest);
+            yield operationalCredentialsClusterClient.addRootCert({ certificate: this.certificateManager.getRootCert() });
+            const peerNodeId = new NodeId_js_1.NodeId(BigInt(1));
+            const peerOperationalCert = this.certificateManager.generateNoc(operationalPublicKey, FABRIC_ID, peerNodeId);
+            yield operationalCredentialsClusterClient.addOperationalCert({
+                operationalCert: peerOperationalCert,
+                intermediateCaCert: new ByteArray_js_1.ByteArray(0),
+                identityProtectionKey: this.fabric.identityProtectionKey,
+                adminVendorId: ADMIN_VENDOR_ID,
+                caseAdminNode: CONTROLLER_NODE_ID,
+            });
+            // Look for the device broadcast over MDNS and do CASE pairing
+            interactionClient = yield this.connect(peerNodeId, 5);
+            // Complete the commission
+            generalCommissioningClusterClient = (0, InteractionClient_js_1.ClusterClient)(interactionClient, 0, GeneralCommissioningCluster_js_1.GeneralCommissioningCluster);
+            this.ensureSuccess(yield generalCommissioningClusterClient.commissioningComplete());
+            this.controllerStorage.set("fabric", this.fabric.toStorageObject());
+            this.controllerStorage.set("fabricCommissioned", true);
+            return peerNodeId;
+        });
+    }
+    resume(peerNodeId, timeoutSeconds = 60) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const scanResult = yield this.scanner.findDevice(this.fabric, peerNodeId, timeoutSeconds);
+            if (scanResult === undefined)
+                throw new Error("The device being commissioned cannot be found on the network");
+            const { ip: operationalIp, port: operationalPort } = scanResult;
+            return this.pair(peerNodeId, operationalIp, operationalPort);
+        });
+    }
+    pair(peerNodeId, operationalIp, operationalPort) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Do CASE pairing
+            const operationalInterface = (0, Ip_js_1.isIPv6)(operationalIp) ? this.netInterfaceIpv6 : this.netInterfaceIpv4;
+            const operationalChannel = yield operationalInterface.openChannel(operationalIp, operationalPort);
+            const operationalUnsecureMessageExchange = new ExchangeManager_js_1.MessageChannel(operationalChannel, this.sessionManager.getUnsecureSession());
+            const operationalSecureSession = yield this.caseClient.pair(this, this.exchangeManager.initiateExchangeWithChannel(operationalUnsecureMessageExchange, SecureChannelMessages_js_1.SECURE_CHANNEL_PROTOCOL_ID), this.fabric, peerNodeId);
+            const channel = new ExchangeManager_js_1.MessageChannel(operationalChannel, operationalSecureSession);
+            this.channelManager.setChannel(this.fabric, peerNodeId, channel);
+            return channel;
+        });
+    }
+    isCommissioned() {
+        return this.controllerStorage.get("fabricCommissioned", false);
+    }
+    connect(nodeId, timeoutSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let channel;
+            try {
+                channel = this.channelManager.getChannel(this.fabric, nodeId);
+            }
+            catch (error) {
+                if (error instanceof ChannelManager_js_1.NoChannelError) {
+                    channel = yield this.resume(nodeId, timeoutSeconds);
+                }
+                else {
+                    throw error;
+                }
+            }
+            return new InteractionClient_js_1.InteractionClient(new ExchangeManager_js_1.ExchangeProvider(this.exchangeManager, channel, () => __awaiter(this, void 0, void 0, function* () {
+                this.channelManager.removeChannel(this.fabric, nodeId);
+                yield this.resume(nodeId);
+                return this.channelManager.getChannel(this.fabric, nodeId);
+            })));
+        });
+    }
+    ensureSuccess({ errorCode, debugText }) {
+        if (errorCode === 0 /* CommissioningError.Ok */)
+            return;
+        throw new Error(`Commission error: ${errorCode}, ${debugText}`);
+    }
+    getNextAvailableSessionId() {
+        return this.sessionManager.getNextAvailableSessionId();
+    }
+    getFabric() {
+        return this.fabric;
+    }
+    createSecureSession(sessionId, fabric, peerNodeId, peerSessionId, sharedSecret, salt, isInitiator, isResumption, idleRetransTimeoutMs, activeRetransTimeoutMs) {
+        return this.sessionManager.createSecureSession(sessionId, fabric, peerNodeId, peerSessionId, sharedSecret, salt, isInitiator, isResumption, idleRetransTimeoutMs, activeRetransTimeoutMs);
+    }
+    getResumptionRecord(resumptionId) {
+        return this.sessionManager.findResumptionRecordById(resumptionId);
+    }
+    findResumptionRecordByNodeId(nodeId) {
+        return this.sessionManager.findResumptionRecordByNodeId(nodeId);
+    }
+    saveResumptionRecord(resumptionRecord) {
+        return this.sessionManager.saveResumptionRecord(resumptionRecord);
+    }
+    announce() {
+        // nothing TODO
+    }
+    close() {
+        this.scanner.close();
+        this.exchangeManager.close();
+    }
+}
+exports.MatterController = MatterController;

package/dist/cjs/MatterDevice.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Session } from "./session/Session.js";
+import { ResumptionRecord } from "./session/SessionManager.js";
+import { Fabric } from "./fabric/Fabric.js";
+import { Channel } from "./net/Channel.js";
+import { NetInterface } from "./net/NetInterface.js";
+import { ProtocolHandler } from "./protocol/ProtocolHandler.js";
+import { Broadcaster } from "./common/Broadcaster.js";
+import { Scanner } from "./common/Scanner.js";
+import { VendorId } from "./datatype/VendorId.js";
+import { FabricIndex } from "./datatype/FabricIndex.js";
+import { NodeId } from "./datatype/NodeId.js";
+import { ByteArray } from "./util/ByteArray.js";
+import { StorageManager } from "./storage/StorageManager.js";
+export declare class MatterDevice {
+    private readonly deviceName;
+    private readonly deviceType;
+    private readonly vendorId;
+    private readonly productId;
+    private readonly discriminator;
+    private readonly storageManager;
+    private readonly scanners;
+    private readonly broadcasters;
+    private readonly netInterfaces;
+    private readonly fabricManager;
+    private readonly sessionManager;
+    private readonly channelManager;
+    private readonly exchangeManager;
+    private announceInterval;
+    private announcementStartedTime;
+    private commissioningWindowOpened;
+    constructor(deviceName: string, deviceType: number, vendorId: VendorId, productId: number, discriminator: number, storageManager: StorageManager);
+    addScanner(scanner: Scanner): this;
+    addBroadcaster(broadcaster: Broadcaster): this;
+    addNetInterface(netInterface: NetInterface): this;
+    addProtocolHandler(protocol: ProtocolHandler<MatterDevice>): this;
+    start(): Promise<void>;
+    startAnnouncement(): void;
+    announce(announceOnce?: boolean): void;
+    getNextAvailableSessionId(): any;
+    createSecureSession(sessionId: number, fabric: Fabric | undefined, peerNodeId: NodeId, peerSessionId: number, sharedSecret: ByteArray, salt: ByteArray, isInitiator: boolean, isResumption: boolean, idleRetransTimeoutMs?: number, activeRetransTimeoutMs?: number): any;
+    findFabricFromDestinationId(destinationId: ByteArray, peerRandom: ByteArray): any;
+    addFabric(fabric: Fabric): FabricIndex;
+    getFabricByIndex(fabricIndex: FabricIndex): any;
+    initiateExchange(fabric: Fabric, nodeId: NodeId, protocolId: number): any;
+    findResumptionRecordById(resumptionId: ByteArray): any;
+    saveResumptionRecord(resumptionRecord: ResumptionRecord): any;
+    armFailSafe(): any;
+    getFabricBuilder(): any;
+    getFabrics(): any;
+    completeCommission(): any;
+    isCommissioned(): boolean;
+    openCommissioningModeWindow(mode: number, discriminator: number, timeout: number): void;
+    findDevice(fabric: Fabric, nodeId: NodeId, timeOutSeconds?: number): Promise<undefined | {
+        session: Session<MatterDevice>;
+        channel: Channel<ByteArray>;
+    }>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=MatterDevice.d.ts.map

package/dist/cjs/MatterDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatterDevice.d.ts","sourceRoot":"","sources":["../../src/MatterDevice.ts"],"names":[],"mappings":"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"}

package/dist/cjs/MatterDevice.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatterDevice = void 0;
+const SessionManager_js_1 = require("./session/SessionManager.js");
+const FabricManager_js_1 = require("./fabric/FabricManager.js");
+const ChannelManager_js_1 = require("./protocol/ChannelManager.js");
+const ExchangeManager_js_1 = require("./protocol/ExchangeManager.js");
+const Logger_js_1 = require("./log/Logger.js");
+const Time_js_1 = require("./time/Time.js");
+const logger = Logger_js_1.Logger.get("MatterDevice");
+const DEVICE_ANNOUNCEMENT_DURATION = 15 * 60 * 1000; /** 15 minutes */
+const DEVICE_ANNOUNCEMENT_INTERVAL = 60 * 1000; /** 1 minute */
+class MatterDevice {
+    constructor(deviceName, deviceType, vendorId, productId, discriminator, storageManager) {
+        this.deviceName = deviceName;
+        this.deviceType = deviceType;
+        this.vendorId = vendorId;
+        this.productId = productId;
+        this.discriminator = discriminator;
+        this.storageManager = storageManager;
+        this.scanners = new Array();
+        this.broadcasters = new Array();
+        this.netInterfaces = new Array();
+        this.channelManager = new ChannelManager_js_1.ChannelManager();
+        this.announceInterval = null;
+        this.announcementStartedTime = null;
+        this.commissioningWindowOpened = false;
+        this.fabricManager = new FabricManager_js_1.FabricManager(this.storageManager);
+        this.sessionManager = new SessionManager_js_1.SessionManager(this, this.storageManager);
+        this.sessionManager.initFromStorage(this.fabricManager.getFabrics());
+        this.exchangeManager = new ExchangeManager_js_1.ExchangeManager(this.sessionManager, this.channelManager);
+    }
+    addScanner(scanner) {
+        this.scanners.push(scanner);
+        return this;
+    }
+    addBroadcaster(broadcaster) {
+        this.broadcasters.push(broadcaster);
+        return this;
+    }
+    addNetInterface(netInterface) {
+        this.exchangeManager.addNetInterface(netInterface);
+        this.netInterfaces.push(netInterface);
+        return this;
+    }
+    addProtocolHandler(protocol) {
+        this.exchangeManager.addProtocolHandler(protocol);
+        return this;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            /*for (const broadcaster of this.broadcasters) {
+                broadcaster.setCommissionMode(0, this.deviceName, this.deviceType, this.vendorId, this.productId, this.discriminator);
+                broadcaster.announce();
+            }*/
+            this.startAnnouncement();
+        });
+    }
+    startAnnouncement() {
+        this.announcementStartedTime = Time_js_1.Time.nowMs();
+        this.announceInterval = Time_js_1.Time.getPeriodicTimer(DEVICE_ANNOUNCEMENT_INTERVAL, () => this.announce()).start();
+        this.announce();
+    }
+    announce(announceOnce = false) {
+        var _a;
+        if (!announceOnce) {
+            // Stop announcement if duration is reached
+            if (this.announcementStartedTime !== null && Time_js_1.Time.nowMs() - this.announcementStartedTime > DEVICE_ANNOUNCEMENT_DURATION) {
+                (_a = this.announceInterval) === null || _a === void 0 ? void 0 : _a.stop();
+                this.announcementStartedTime = null;
+                logger.debug("Announcement duration reached, stop announcing");
+                return;
+            }
+            if (this.commissioningWindowOpened) {
+                // Re-Announce but do not re-set Fabrics
+                for (const broadcaster of this.broadcasters) {
+                    broadcaster.announce();
+                }
+                return;
+            }
+        }
+        const fabrics = this.fabricManager.getFabrics();
+        if (fabrics.length) {
+            const fabricsToAnnounce = [];
+            for (const fabric of fabrics) {
+                const session = this.sessionManager.getSessionForNode(fabric, fabric.rootNodeId);
+                if (session) {
+                    // We have a session, no need to re-announce
+                    logger.debug("Skipping announce for fabric", fabric.fabricId.id, "because we have a session", session.getId());
+                    continue;
+                }
+                logger.debug("Announcing fabric", fabric.fabricId.id);
+                fabricsToAnnounce.push(fabric);
+            }
+            for (const broadcaster of this.broadcasters) {
+                broadcaster.setFabrics(fabricsToAnnounce);
+                broadcaster.announce();
+            }
+        }
+        else {
+            // No fabric paired yeet, so announce as "ready for commissioning"
+            for (const broadcaster of this.broadcasters) {
+                broadcaster.setCommissionMode(1, this.deviceName, this.deviceType, this.vendorId, this.productId, this.discriminator);
+                broadcaster.announce();
+            }
+        }
+    }
+    getNextAvailableSessionId() {
+        return this.sessionManager.getNextAvailableSessionId();
+    }
+    createSecureSession(sessionId, fabric, peerNodeId, peerSessionId, sharedSecret, salt, isInitiator, isResumption, idleRetransTimeoutMs, activeRetransTimeoutMs) {
+        return this.sessionManager.createSecureSession(sessionId, fabric, peerNodeId, peerSessionId, sharedSecret, salt, isInitiator, isResumption, idleRetransTimeoutMs, activeRetransTimeoutMs);
+    }
+    findFabricFromDestinationId(destinationId, peerRandom) {
+        return this.fabricManager.findFabricFromDestinationId(destinationId, peerRandom);
+    }
+    addFabric(fabric) {
+        this.fabricManager.addFabric(fabric);
+        this.broadcasters.forEach(broadcaster => {
+            broadcaster.setFabrics([fabric]);
+            broadcaster.announce();
+        });
+        return fabric.fabricIndex;
+    }
+    getFabricByIndex(fabricIndex) {
+        return this.fabricManager.getFabrics().find(fabric => fabric.fabricIndex.index === fabricIndex.index);
+    }
+    initiateExchange(fabric, nodeId, protocolId) {
+        return this.exchangeManager.initiateExchange(fabric, nodeId, protocolId);
+    }
+    findResumptionRecordById(resumptionId) {
+        return this.sessionManager.findResumptionRecordById(resumptionId);
+    }
+    saveResumptionRecord(resumptionRecord) {
+        return this.sessionManager.saveResumptionRecord(resumptionRecord);
+    }
+    armFailSafe() {
+        return this.fabricManager.armFailSafe();
+    }
+    getFabricBuilder() {
+        return this.fabricManager.getFabricBuilder();
+    }
+    getFabrics() {
+        return this.fabricManager.getFabrics();
+    }
+    completeCommission() {
+        this.commissioningWindowOpened = false;
+        return this.fabricManager.completeCommission();
+    }
+    isCommissioned() {
+        return !!this.fabricManager.getFabrics().length;
+    }
+    openCommissioningModeWindow(mode, discriminator, timeout) {
+        this.commissioningWindowOpened = true;
+        this.broadcasters.forEach(broadcaster => {
+            broadcaster.setCommissionMode(mode, this.deviceName, this.deviceType, this.vendorId, this.productId, discriminator);
+        });
+        this.startAnnouncement();
+        Time_js_1.Time.getTimer(timeout * 1000, () => this.commissioningWindowOpened = false).start();
+    }
+    findDevice(fabric, nodeId, timeOutSeconds = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: return the first not undefined answer or undefined
+            const matterServer = yield this.scanners[0].findDevice(fabric, nodeId, timeOutSeconds);
+            if (matterServer === undefined)
+                return undefined;
+            const { ip, port } = matterServer;
+            const session = this.sessionManager.getSessionForNode(fabric, nodeId);
+            if (session === undefined)
+                return undefined;
+            // TODO: have the interface and scanner linked
+            return { session, channel: yield this.netInterfaces[0].openChannel(ip, port) };
+        });
+    }
+    stop() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.exchangeManager.close();
+            (_a = this.announceInterval) === null || _a === void 0 ? void 0 : _a.stop();
+            this.broadcasters.forEach(broadcaster => broadcaster.close());
+        });
+    }
+}
+exports.MatterDevice = MatterDevice;

package/dist/cjs/certificate/AttestationCertificateManager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray.js";
+import { VendorId } from "../datatype/VendorId.js";
+export declare class AttestationCertificateManager {
+    private readonly vendorId;
+    private paaCertId;
+    private readonly paaKeyPair;
+    private readonly paaKeyIdentifier;
+    private readonly paiCertId;
+    private readonly paiKeyPair;
+    private readonly paiKeyIdentifier;
+    private readonly paiCertBytes;
+    private nextCertificateId;
+    constructor(vendorId: VendorId);
+    getPAICert(): any;
+    getDACert(productId: number): {
+        keyPair: import("../crypto/Crypto.js").KeyPair;
+        dac: Uint8Array;
+    };
+    private generatePAACert;
+    private generatePAICert;
+    generateDaCert(publicKey: ByteArray, vendorId: VendorId, productId: number): Uint8Array;
+}
+//# sourceMappingURL=AttestationCertificateManager.d.ts.map