@project-chip/matter-node.js-examples 0.7.5 → 0.8.0-alpha.0-20240310-474da21a

package/src/examples/MultiDeviceNodeLegacy.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * IMPORTANT: This example uses a Legacy API which will be deprecated in the future.
+ * It is just still here to support developers in converting their code to the new API!
+ */
+
+/**
+ * This example shows how to create a new device node that is composed of multiple devices.
+ * It creates multiple endpoints on the server. When you want to add a composed devices to a Aggregator you need to
+ * add all endpoints of the composed device to an "ComposedDevice" instance! (not shown in this example).
+ * It can be used as CLI script and starting point for your own device node implementation.
+ */
+
+/**
+ * Import needed modules from @project-chip/matter-node.js
+ */
+// Include this first to auto-register Crypto, Network and Time Node.js implementations
+import { CommissioningServer, MatterServer } from "@project-chip/matter-node.js";
+
+import { DeviceTypes, OnOffLightDevice, OnOffPluginUnitDevice } from "@project-chip/matter-node.js/device";
+import { Format, Level, Logger } from "@project-chip/matter-node.js/log";
+import { QrCode } from "@project-chip/matter-node.js/schema";
+import { StorageBackendDisk, StorageManager } from "@project-chip/matter-node.js/storage";
+import { Time } from "@project-chip/matter-node.js/time";
+import {
+    commandExecutor,
+    getIntParameter,
+    getParameter,
+    hasParameter,
+    requireMinNodeVersion,
+} from "@project-chip/matter-node.js/util";
+import { VendorId } from "@project-chip/matter.js/datatype";
+
+const logger = Logger.get("MultiDevice");
+
+requireMinNodeVersion(16);
+
+/** Configure logging */
+switch (getParameter("loglevel")) {
+    case "fatal":
+        Logger.defaultLogLevel = Level.FATAL;
+        break;
+    case "error":
+        Logger.defaultLogLevel = Level.ERROR;
+        break;
+    case "warn":
+        Logger.defaultLogLevel = Level.WARN;
+        break;
+    case "info":
+        Logger.defaultLogLevel = Level.INFO;
+        break;
+}
+
+switch (getParameter("logformat")) {
+    case "plain":
+        Logger.format = Format.PLAIN;
+        break;
+    case "html":
+        Logger.format = Format.HTML;
+        break;
+    default:
+        if (process.stdin?.isTTY) Logger.format = Format.ANSI;
+}
+
+const storageLocation = getParameter("store") ?? ".device-node";
+const storage = new StorageBackendDisk(storageLocation, hasParameter("clearstorage"));
+logger.info(`Storage location: ${storageLocation} (Directory)`);
+logger.info(
+    'Use the parameter "-store NAME" to specify a different storage location, use -clearstorage to start with an empty storage.',
+);
+
+class Device {
+    private matterServer: MatterServer | undefined;
+
+    async start() {
+        logger.info(`node-matter`);
+
+        /**
+         * Initialize the storage system.
+         *
+         * The storage manager is then also used by the Matter server, so this code block in general is required,
+         * but you can choose a different storage backend as long as it implements the required API.
+         */
+
+        const storageManager = new StorageManager(storage);
+        await storageManager.initialize();
+
+        /**
+         * Collect all needed data
+         *
+         * This block makes sure to collect all needed data from cli or storage. Replace this with where ever your data
+         * come from.
+         *
+         * Note: This example also uses the initialized storage system to store the device parameter data for convenience
+         * and easy reuse. When you also do that be careful to not overlap with Matter-Server own contexts
+         * (so maybe better not ;-)).
+         */
+        const netInterface = getParameter("netinterface");
+
+        const deviceStorage = storageManager.createContext("Device");
+
+        /**
+         * Create Matter Server and CommissioningServer Node
+         *
+         * To allow the device to be announced, found, paired and operated we need a MatterServer instance and add a
+         * commissioningServer to it and add the just created device instance to it.
+         * The CommissioningServer node defines the port where the server listens for the UDP packages of the Matter protocol
+         * and initializes deice specific certificates and such.
+         *
+         * The below logic also adds command handlers for commands of clusters that normally are handled internally
+         * like testEventTrigger (General Diagnostic Cluster) that can be implemented with the logic when these commands
+         * are called.
+         */
+
+        this.matterServer = new MatterServer(storageManager, { mdnsInterface: netInterface });
+
+        /**
+         * Create Device instance and add needed Listener
+         *
+         * Create an instance of the matter device class you want to use.
+         * This example uses the OnOffLightDevice or OnOffPluginUnitDevice depending on the value of the type  parameter.
+         * To execute the on/off scripts defined as parameters a listener for the onOff attribute is registered via the
+         * device specific API.
+         *
+         * The below logic also adds command handlers for commands of clusters that normally are handled device internally
+         * like identify that can be implemented with the logic when these commands are called.
+         */
+
+        const commissioningServers = new Array<CommissioningServer>();
+
+        let defaultPasscode = 20202021;
+        let defaultDiscriminator = 3840;
+        let defaultPort = 5550;
+
+        const numDevices = getIntParameter("num") || 2;
+        for (let i = 1; i <= numDevices; i++) {
+            if (deviceStorage.has(`isSocket${i}`)) {
+                logger.info("Device type found in storage. -type parameter is ignored.");
+            }
+            const isSocket = deviceStorage.get(`isSocket${i}`, getParameter(`type${i}`) === "socket");
+            const deviceName = `Matter ${getParameter(`type${i}`) ?? "light"} device ${i}`;
+            const deviceType =
+                getParameter(`type${i}`) === "socket"
+                    ? DeviceTypes.ON_OFF_PLUGIN_UNIT.code
+                    : DeviceTypes.ON_OFF_LIGHT.code;
+            const vendorName = "matter-node.js";
+            const passcode = getIntParameter(`passcode${i}`) ?? deviceStorage.get(`passcode${i}`, defaultPasscode++);
+            const discriminator =
+                getIntParameter(`discriminator${i}`) ?? deviceStorage.get(`discriminator${i}`, defaultDiscriminator++);
+            // product name / id and vendor id should match what is in the device certificate
+            const vendorId = getIntParameter(`vendorid${i}`) ?? deviceStorage.get(`vendorid${i}`, 0xfff1);
+            const productName = `node-matter OnOff-Device ${i}`;
+            const productId = getIntParameter(`productid${i}`) ?? deviceStorage.get(`productid${i}`, 0x8000);
+
+            const port = getIntParameter(`port${i}`) ?? defaultPort++;
+
+            const uniqueId =
+                getIntParameter(`uniqueid${i}`) ?? deviceStorage.get(`uniqueid${i}`, `${i}-${Time.nowMs()}`);
+
+            deviceStorage.set(`passcode${i}`, passcode);
+            deviceStorage.set(`discriminator${i}`, discriminator);
+            deviceStorage.set(`vendorid${i}`, vendorId);
+            deviceStorage.set(`productid${i}`, productId);
+            deviceStorage.set(`isSocket${i}`, isSocket);
+            deviceStorage.set(`uniqueid${i}`, uniqueId);
+
+            const commissioningServer = new CommissioningServer({
+                port,
+                deviceName,
+                deviceType,
+                passcode,
+                discriminator,
+                basicInformation: {
+                    vendorName,
+                    vendorId: VendorId(vendorId),
+                    nodeLabel: productName,
+                    productName,
+                    productLabel: productName,
+                    productId,
+                    serialNumber: `node-matter-${uniqueId}`,
+                },
+            });
+
+            console.log(
+                `Added device ${i} on port ${port} and unique id ${uniqueId}: Passcode: ${passcode}, Discriminator: ${discriminator}`,
+            );
+
+            const onOffDevice =
+                getParameter(`type${i}`) === "socket" ? new OnOffPluginUnitDevice() : new OnOffLightDevice();
+            onOffDevice.addFixedLabel("orientation", getParameter(`orientation${i}`) ?? `orientation ${i}`);
+            onOffDevice.addOnOffListener(on => commandExecutor(on ? `on${i}` : `off${i}`)?.());
+            commissioningServer.addDevice(onOffDevice);
+
+            await this.matterServer.addCommissioningServer(commissioningServer);
+
+            commissioningServers.push(commissioningServer);
+        }
+
+        /**
+         * Start the Matter Server
+         *
+         * After everything was plugged together we can start the server. When not delayed announcement is set for the
+         * CommissioningServer node then this command also starts the announcement of the device into the network.
+         */
+
+        await this.matterServer.start();
+
+        /**
+         * Print Pairing Information
+         *
+         * If the device is not already commissioned (this info is stored in the storage system) then get and print the
+         * pairing details. This includes the QR code that can be scanned by the Matter app to pair the device.
+         */
+
+        logger.info("Listening");
+        console.log();
+        commissioningServers.forEach((commissioningServer, index) => {
+            console.log("----------------------------");
+            console.log(`Device ${index + 1}:`);
+            if (!commissioningServer.isCommissioned()) {
+                const pairingData = commissioningServer.getPairingCode();
+                const { qrPairingCode, manualPairingCode } = pairingData;
+
+                console.log(QrCode.get(qrPairingCode));
+                console.log(
+                    `QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`,
+                );
+                console.log(`Manual pairing code: ${manualPairingCode}`);
+            } else {
+                console.log("Device is already commissioned. Waiting for controllers to connect ...");
+            }
+            console.log();
+        });
+    }
+
+    async stop() {
+        await this.matterServer?.close();
+    }
+}
+
+const device = new Device();
+device
+    .start()
+    .then(() => {
+        /* done */
+    })
+    .catch(err => console.error(err));
+
+process.on("SIGINT", () => {
+    // Clean up on CTRL-C
+    device
+        .stop()
+        .then(() => {
+            // Pragmatic way to make sure the storage is correctly closed before the process ends.
+            storage
+                .close()
+                .then(() => process.exit(0))
+                .catch(err => console.error(err));
+        })
+        .catch(err => console.error(err));
+});

package/src/examples/SensorDeviceNode.ts

@@ -0,0 +1,236 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * This example shows how to create a simple Sensor Matter device as temperature or humidity device.
+ * It can be used as CLI script and starting point for your own device node implementation.
+ * This example is CJS conform and do not use top level await's.
+ */
+
+/**
+ * Import needed modules from @project-chip/matter-node.js
+ */
+// Include this first to auto-register Crypto, Network and Time Node.js implementations
+import "@project-chip/matter-node.js";
+
+import { requireMinNodeVersion } from "@project-chip/matter-node.js/util";
+import { DeviceTypeId, VendorId } from "@project-chip/matter.js/datatype";
+import { logEndpoint } from "@project-chip/matter.js/device";
+import { HumiditySensorDevice } from "@project-chip/matter.js/devices/HumiditySensorDevice";
+import { TemperatureSensorDevice } from "@project-chip/matter.js/devices/TemperatureSensorDevice";
+import { Endpoint, EndpointServer } from "@project-chip/matter.js/endpoint";
+import { Environment, StorageService } from "@project-chip/matter.js/environment";
+import { ServerNode } from "@project-chip/matter.js/node";
+import { Time } from "@project-chip/matter.js/time";
+import { execSync } from "child_process";
+
+requireMinNodeVersion(16);
+
+async function main() {
+    /** Initialize configuration values */
+    const {
+        isTemperature,
+        interval,
+        deviceName,
+        vendorName,
+        passcode,
+        discriminator,
+        vendorId,
+        productName,
+        productId,
+        port,
+        uniqueId,
+    } = await getConfiguration();
+
+    /**
+     * Create a Matter ServerNode, which contains the Root Endpoint and all relevant data and configuration
+     */
+    const server = await ServerNode.create({
+        // Required: Give the Node a unique ID which is used to store the state of this node
+        id: uniqueId,
+
+        // Provide Network relevant configuration like the port
+        // Optional when operating only one device on a host, Default port is 5540
+        network: {
+            port,
+        },
+
+        // Provide Commissioning relevant settings
+        // Optional for development/testing purposes
+        commissioning: {
+            passcode,
+            discriminator,
+        },
+
+        // Provide Node announcement settings
+        // Optional: If Ommitted some development defaults are used
+        productDescription: {
+            name: deviceName,
+            deviceType: DeviceTypeId(
+                isTemperature ? TemperatureSensorDevice.deviceType : HumiditySensorDevice.deviceType,
+            ),
+        },
+
+        // Provide defaults for the BasicInformation cluster on the Root endpoint
+        // Optional: If Omitted some development defaults are used
+        basicInformation: {
+            vendorName,
+            vendorId: VendorId(vendorId),
+            nodeLabel: productName,
+            productName,
+            productLabel: productName,
+            productId,
+            serialNumber: `matterjs-${uniqueId}`,
+            uniqueId,
+        },
+    });
+
+    /**
+     * Matter Nodes are a composition of endpoints. Create and add a single endpoint to the node. This example uses the
+     * OnOffLightDevice or OnOffPlugInUnitDevice depending on the value of the type parameter. It also assigns this Part a
+     * unique ID to store the endpoint number for it in the storage to restore the device on restart.
+     * In this case we directly use the default command implementation from matter.js. Check out the DeviceNodeFull example
+     * to see how to customize the command handlers.
+     */
+    let endpoint: Endpoint;
+    if (isTemperature) {
+        endpoint = new Endpoint(TemperatureSensorDevice, {
+            id: "tempsensor",
+            temperatureMeasurement: { measuredValue: getIntValueFromCommandOrRandom("value") },
+        });
+    } else {
+        endpoint = new Endpoint(HumiditySensorDevice, {
+            id: "humsensor",
+            relativeHumidityMeasurement: { measuredValue: getIntValueFromCommandOrRandom("value", false) },
+        });
+    }
+
+    await server.add(endpoint);
+
+    /**
+     * Log the endpoint structure for debugging reasons and to allow to verify anything is correct
+     */
+    logEndpoint(EndpointServer.forEndpoint(server));
+
+    const updateInterval = setInterval(() => {
+        let setter: Promise<void>;
+        if (isTemperature) {
+            setter = endpoint.set({
+                temperatureMeasurement: {
+                    measuredValue: getIntValueFromCommandOrRandom("value"),
+                },
+            });
+        } else {
+            setter = endpoint.set({
+                relativeHumidityMeasurement: {
+                    measuredValue: getIntValueFromCommandOrRandom("value", false),
+                },
+            });
+        }
+        setter.catch(error => console.error("Error updating measured value:", error));
+    }, interval * 1000);
+
+    // Cleanup our update interval when node goes offline
+    server.lifecycle.offline.on(() => clearTimeout(updateInterval));
+
+    /**
+     * In order to start the node and announce it into the network we use the run method which resolves when the node goes
+     * offline again because we do not need anything more here. See the Full example for other starting options.
+     * The QR Code is printed automatically.
+     */
+    await server.run();
+}
+
+main().catch(error => console.error(error));
+
+/*********************************************************************************************************
+ * Convenience Methods
+ *********************************************************************************************************/
+
+/** Defined a shell command from an environment variable and execute it and log the response. */
+
+function getIntValueFromCommandOrRandom(scriptParamName: string, allowNegativeValues = true) {
+    const script = Environment.default.vars.string(scriptParamName);
+    if (script === undefined) {
+        if (!allowNegativeValues) return Math.round(Math.random() * 100);
+        return (Math.round(Math.random() * 100) - 50) * 100;
+    }
+    let result = execSync(script).toString().trim();
+    if ((result.startsWith("'") && result.endsWith("'")) || (result.startsWith('"') && result.endsWith('"')))
+        result = result.slice(1, -1);
+    console.log(`Command result: ${result}`);
+    let value = Math.round(parseFloat(result));
+    if (!allowNegativeValues && value < 0) value = 0;
+    return value;
+}
+
+async function getConfiguration() {
+    /**
+     * Collect all needed data
+     *
+     * This block collects all needed data from cli, environment or storage. Replace this with where ever your data come from.
+     *
+     * Note: This example uses the matter.js process storage system to store the device parameter data for convenience
+     * and easy reuse. When you also do that be careful to not overlap with Matter-Server own storage contexts
+     * (so maybe better not do it ;-)).
+     */
+    const environment = Environment.default;
+
+    const storageService = environment.get(StorageService);
+    console.log(`Storage location: ${storageService.location} (Directory)`);
+    console.log(
+        'Use the parameter "--storage-path=NAME-OR-PATH" to specify a different storage location in this directory, use --storage-clear to start with an empty storage.',
+    );
+    const deviceStorage = (await storageService.open("device")).createContext("data");
+
+    const isTemperature = deviceStorage.get("isTemperature", environment.vars.get("type") !== "humidity");
+    if (deviceStorage.has("isTemperature")) {
+        console.log(
+            `Device type ${isTemperature ? "temperature" : "humidity"} found in storage. --type parameter is ignored.`,
+        );
+    }
+    let interval = environment.vars.number("interval") ?? deviceStorage.get("interval", 60);
+    if (interval < 1) {
+        console.log(`Invalid Interval ${interval}, set to 60s`);
+        interval = 60;
+    }
+
+    const deviceName = "Matter test device";
+    const vendorName = "matter-node.js";
+    const passcode = environment.vars.number("passcode") ?? deviceStorage.get("passcode", 20202021);
+    const discriminator = environment.vars.number("discriminator") ?? deviceStorage.get("discriminator", 3840);
+    // product name / id and vendor id should match what is in the device certificate
+    const vendorId = environment.vars.number("vendorid") ?? deviceStorage.get("vendorid", 0xfff1);
+    const productName = `node-matter OnOff ${isTemperature ? "Temperature" : "Humidity"}`;
+    const productId = environment.vars.number("productid") ?? deviceStorage.get("productid", 0x8000);
+
+    const port = environment.vars.number("port") ?? 5540;
+
+    const uniqueId = environment.vars.string("uniqueid") ?? deviceStorage.get("uniqueid", Time.nowMs().toString());
+
+    // Persist basic data to keep them also on restart
+    deviceStorage.set("passcode", passcode);
+    deviceStorage.set("discriminator", discriminator);
+    deviceStorage.set("vendorid", vendorId);
+    deviceStorage.set("productid", productId);
+    deviceStorage.set("interval", interval);
+    deviceStorage.set("isTemperature", isTemperature);
+    deviceStorage.set("uniqueid", uniqueId);
+
+    return {
+        isTemperature,
+        interval,
+        deviceName,
+        vendorName,
+        passcode,
+        discriminator,
+        vendorId,
+        productName,
+        productId,
+        port,
+        uniqueId,
+    };
+}

package/src/examples/cluster/DummyThreadNetworkCommissioningServer.ts

@@ -0,0 +1,156 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GeneralCommissioningBehavior } from "@project-chip/matter.js/behavior/definitions/general-commissioning";
+import {
+    AddOrUpdateThreadNetworkRequest,
+    ConnectNetworkRequest,
+    NetworkCommissioningBehavior,
+    RemoveNetworkRequest,
+    ReorderNetworkRequest,
+    ScanNetworksRequest,
+    ScanNetworksResponse,
+} from "@project-chip/matter.js/behavior/definitions/network-commissioning";
+import { NetworkCommissioning } from "@project-chip/matter.js/cluster";
+import { Logger } from "@project-chip/matter.js/log";
+import { ByteArray } from "@project-chip/matter.js/util";
+
+const firstNetworkId = new ByteArray(32);
+
+/**
+ * This represents a Dummy version of a Wifi Network Commissioning Cluster Server without real Wifi related logic, beside
+ * returning some values provided as CLI parameters. This dummy implementation is only there for tests/as showcase for BLE
+ * commissioning of a device.
+ */
+export class DummyThreadNetworkCommissioningServer extends NetworkCommissioningBehavior.with(
+    NetworkCommissioning.Feature.ThreadNetworkInterface,
+) {
+    override scanNetworks({ breadcrumb }: ScanNetworksRequest): ScanNetworksResponse {
+        console.log(`---> scanNetworks called on NetworkCommissioning cluster: ${breadcrumb}`);
+
+        // Simulate successful scan
+        if (breadcrumb !== undefined) {
+            const generalCommissioningCluster = this.agent.get(GeneralCommissioningBehavior);
+            generalCommissioningCluster.state.breadcrumb = breadcrumb;
+        }
+
+        const networkingStatus = NetworkCommissioning.NetworkCommissioningStatus.Success;
+        this.state.lastNetworkingStatus = networkingStatus;
+
+        const threadScanResults = [
+            {
+                panId: this.endpoint.env.vars.number("ble.thread.panId"),
+                extendedPanId: BigInt(this.endpoint.env.vars.string("ble.thread.extendedPanId")),
+                networkName: this.endpoint.env.vars.string("ble.thread.networkName"),
+                channel: this.endpoint.env.vars.number("ble.thread.channel"),
+                version: 130,
+                extendedAddress: ByteArray.fromString(
+                    (this.endpoint.env.vars.string("ble.thread.address") ?? "000000000000").toLowerCase(),
+                ),
+                rssi: -50,
+                lqi: 50,
+            },
+        ];
+        console.log(Logger.toJSON(threadScanResults));
+
+        return {
+            networkingStatus,
+            threadScanResults,
+        };
+    }
+
+    override addOrUpdateThreadNetwork({ operationalDataset, breadcrumb }: AddOrUpdateThreadNetworkRequest) {
+        console.log(
+            `---> addOrUpdateWiFiNetwork called on NetworkCommissioning cluster: ${operationalDataset.toHex()} ${breadcrumb}`,
+        );
+
+        this.session.context.assertFailSafeArmed("Failsafe timer needs to be armed to add or update networks.");
+
+        // Simulate successful add or update
+        if (breadcrumb !== undefined) {
+            const generalCommissioningCluster = this.agent.get(GeneralCommissioningBehavior);
+            generalCommissioningCluster.state.breadcrumb = breadcrumb;
+        }
+
+        const networkingStatus = NetworkCommissioning.NetworkCommissioningStatus.Success;
+        this.state.lastNetworkingStatus = networkingStatus;
+        this.state.lastNetworkId = firstNetworkId;
+
+        return {
+            networkingStatus,
+            networkIndex: 0,
+        };
+    }
+
+    override removeNetwork({ networkId, breadcrumb }: RemoveNetworkRequest) {
+        console.log(`---> removeNetwork called on NetworkCommissioning cluster: ${networkId.toHex()} ${breadcrumb}`);
+
+        this.session.context.assertFailSafeArmed("Failsafe timer needs to be armed to add or update networks.");
+
+        // Simulate successful add or update
+        if (breadcrumb !== undefined) {
+            const generalCommissioningCluster = this.agent.get(GeneralCommissioningBehavior);
+            generalCommissioningCluster.state.breadcrumb = breadcrumb;
+        }
+
+        const networkingStatus = NetworkCommissioning.NetworkCommissioningStatus.Success;
+        this.state.lastNetworkingStatus = networkingStatus;
+        this.state.lastNetworkId = firstNetworkId;
+
+        return {
+            networkingStatus,
+            networkIndex: 0,
+        };
+    }
+
+    override async connectNetwork({ networkId, breadcrumb }: ConnectNetworkRequest) {
+        console.log(`---> connectNetwork called on NetworkCommissioning cluster: ${networkId.toHex()} ${breadcrumb}`);
+
+        this.session.context.assertFailSafeArmed("Failsafe timer needs to be armed to add or update networks.");
+
+        // Simulate successful connection
+        if (breadcrumb !== undefined) {
+            const generalCommissioningCluster = this.agent.get(GeneralCommissioningBehavior);
+            generalCommissioningCluster.state.breadcrumb = breadcrumb;
+        }
+
+        this.state.networks[0].connected = true;
+
+        const networkingStatus = NetworkCommissioning.NetworkCommissioningStatus.Success;
+        this.state.lastNetworkingStatus = networkingStatus;
+        this.state.lastNetworkId = firstNetworkId;
+        this.state.lastConnectErrorValue = null;
+
+        // Announce operational in IP network
+        const device = this.session.context;
+        await device.startAnnouncement();
+
+        return {
+            networkingStatus,
+            errorValue: null,
+        };
+    }
+
+    override reorderNetwork({ networkId, networkIndex, breadcrumb }: ReorderNetworkRequest) {
+        console.log(
+            `---> reorderNetwork called on NetworkCommissioning cluster: ${networkId.toHex()} ${networkIndex} ${breadcrumb}`,
+        );
+
+        // Simulate successful connection
+        if (breadcrumb !== undefined) {
+            const generalCommissioningCluster = this.agent.get(GeneralCommissioningBehavior);
+            generalCommissioningCluster.state.breadcrumb = breadcrumb;
+        }
+
+        const networkingStatus = NetworkCommissioning.NetworkCommissioningStatus.Success;
+        this.state.lastNetworkingStatus = networkingStatus;
+
+        return {
+            networkingStatus,
+            networkIndex: 0,
+        };
+    }
+}