zwave-js 10.3.0 → 10.4.0

package/build/lib/controller/Controller.js

@@ -18,6 +18,7 @@ const shared_1 = require("@zwave-js/shared");
 const arrays_1 = require("alcalzone-shared/arrays");
 const async_1 = require("alcalzone-shared/async");
 const deferred_promise_1 = require("alcalzone-shared/deferred-promise");
+const math_1 = require("alcalzone-shared/math");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const crypto_1 = __importDefault(require("crypto"));
 const semver_1 = __importDefault(require("semver"));
@@ -27,6 +28,7 @@ const DeviceClass_1 = require("../node/DeviceClass");
 const Node_1 = require("../node/Node");
 const VirtualNode_1 = require("../node/VirtualNode");
 const _Types_1 = require("../node/_Types");
+const ApplicationUpdateRequest_1 = require("../serialapi/application/ApplicationUpdateRequest");
 const GetControllerCapabilitiesMessages_1 = require("../serialapi/capability/GetControllerCapabilitiesMessages");
 const GetControllerVersionMessages_1 = require("../serialapi/capability/GetControllerVersionMessages");
 const GetProtocolVersionMessages_1 = require("../serialapi/capability/GetProtocolVersionMessages");
@@ -56,6 +58,7 @@ const ExtNVMReadLongBufferMessages_1 = require("../serialapi/nvm/ExtNVMReadLongB
 const ExtNVMReadLongByteMessages_1 = require("../serialapi/nvm/ExtNVMReadLongByteMessages");
 const ExtNVMWriteLongBufferMessages_1 = require("../serialapi/nvm/ExtNVMWriteLongBufferMessages");
 const ExtNVMWriteLongByteMessages_1 = require("../serialapi/nvm/ExtNVMWriteLongByteMessages");
+const FirmwareUpdateNVMMessages_1 = require("../serialapi/nvm/FirmwareUpdateNVMMessages");
 const GetNVMIdMessages_1 = require("../serialapi/nvm/GetNVMIdMessages");
 const NVMOperationsMessages_1 = require("../serialapi/nvm/NVMOperationsMessages");
 const _Types_2 = require("../serialapi/_Types");
@@ -66,9 +69,10 @@ const Inclusion_1 = require("./Inclusion");
 const NodeInformationFrame_1 = require("./NodeInformationFrame");
 const utils_1 = require("./utils");
 const ZWaveSDKVersions_1 = require("./ZWaveSDKVersions");
+const _Types_3 = require("./_Types");
 let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
     /** @internal */
-    constructor(driver) {
+    constructor(driver, bootloaderOnly = false) {
         super();
         this.driver = driver;
         this._healNetworkActive = false;
@@ -76,9 +80,13 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         this._smartStartEnabled = false;
         this._includeController = false;
         this._healNetworkProgress = new Map();
+        this._firmwareUpdateInProgress = false;
         this._nodes = (0, shared_1.createThrowingMap)((nodeId) => {
             throw new core_1.ZWaveError(`Node ${nodeId} was not found!`, core_1.ZWaveErrorCodes.Controller_NodeNotFound);
         });
+        // Limit interaction with the controller in bootloader-only mode
+        if (bootloaderOnly)
+            return;
         // register message handlers
         driver.registerRequestHandler(serial_1.FunctionType.AddNodeToNetwork, this.handleAddNodeStatusReport.bind(this));
         driver.registerRequestHandler(serial_1.FunctionType.RemoveNodeFromNetwork, this.handleRemoveNodeStatusReport.bind(this));
@@ -87,6 +95,9 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
     get type() {
         return this._type;
     }
+    get protocolVersion() {
+        return this._protocolVersion;
+    }
     get sdkVersion() {
         return this._sdkVersion;
     }
@@ -130,32 +141,28 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         if (this._sdkVersion === undefined) {
             return undefined;
         }
-        const sdkVersion = (0, ZWaveSDKVersions_1.protocolVersionToSDKVersion)(this._sdkVersion);
-        return semver_1.default.gt((0, shared_1.padVersion)(sdkVersion), (0, shared_1.padVersion)(version));
+        return semver_1.default.gt((0, shared_1.padVersion)(this._sdkVersion), (0, shared_1.padVersion)(version));
     }
     /** Checks if the SDK version is greater than or equal to the given one */
     sdkVersionGte(version) {
         if (this._sdkVersion === undefined) {
             return undefined;
         }
-        const sdkVersion = (0, ZWaveSDKVersions_1.protocolVersionToSDKVersion)(this._sdkVersion);
-        return semver_1.default.gte((0, shared_1.padVersion)(sdkVersion), (0, shared_1.padVersion)(version));
+        return semver_1.default.gte((0, shared_1.padVersion)(this._sdkVersion), (0, shared_1.padVersion)(version));
     }
     /** Checks if the SDK version is lower than the given one */
     sdkVersionLt(version) {
         if (this._sdkVersion === undefined) {
             return undefined;
         }
-        const sdkVersion = (0, ZWaveSDKVersions_1.protocolVersionToSDKVersion)(this._sdkVersion);
-        return semver_1.default.lt((0, shared_1.padVersion)(sdkVersion), (0, shared_1.padVersion)(version));
+        return semver_1.default.lt((0, shared_1.padVersion)(this._sdkVersion), (0, shared_1.padVersion)(version));
     }
     /** Checks if the SDK version is lower than or equal to the given one */
     sdkVersionLte(version) {
         if (this._sdkVersion === undefined) {
             return undefined;
         }
-        const sdkVersion = (0, ZWaveSDKVersions_1.protocolVersionToSDKVersion)(this._sdkVersion);
-        return semver_1.default.lte((0, shared_1.padVersion)(sdkVersion), (0, shared_1.padVersion)(version));
+        return semver_1.default.lte((0, shared_1.padVersion)(this._sdkVersion), (0, shared_1.padVersion)(version));
     }
     get manufacturerId() {
         return this._manufacturerId;
@@ -219,6 +226,10 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
     set supportsSoftReset(value) {
         this.driver.cacheSet(NetworkCache_1.cacheKeys.controller.supportsSoftReset, value);
     }
+    /** Which RF region the controller is currently set to, or `undefined` if it could not be determined (yet). This value is cached and can be changed through {@link setRFRegion}. */
+    get rfRegion() {
+        return this._rfRegion;
+    }
     /** A dictionary of the nodes connected to this controller */
     get nodes() {
         return this._nodes;
@@ -416,18 +427,16 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         const version = await this.driver.sendMessage(new GetControllerVersionMessages_1.GetControllerVersionRequest(this.driver), {
             supportCheck: false,
         });
-        this._sdkVersion = version.libraryVersion;
+        this._protocolVersion = version.libraryVersion;
         this._type = version.controllerType;
         this.driver.controllerLog.print(`received version info:
   controller type: ${(0, shared_1.getEnumMemberName)(_Types_2.ZWaveLibraryTypes, this._type)}
-  library version: ${this._sdkVersion}`);
+  library version: ${this._protocolVersion}`);
         // If supported, get more fine-grained version info
         if (this.isFunctionSupported(serial_1.FunctionType.GetProtocolVersion)) {
             this.driver.controllerLog.print(`querying protocol version info...`);
             const protocol = await this.driver.sendMessage(new GetProtocolVersionMessages_1.GetProtocolVersionRequest(this.driver));
-            // Overwrite the SDK version with the more fine grained protocol version. We can assume this to be
-            // valid for 7.x firmwares, where SDK and protocol version are the same.
-            this._sdkVersion = protocol.protocolVersion;
+            this._protocolVersion = protocol.protocolVersion;
             let message = `received protocol version info:
   protocol type:             ${(0, shared_1.getEnumMemberName)(core_1.ProtocolType, protocol.protocolType)}
   protocol version:          ${protocol.protocolVersion}`;
@@ -441,6 +450,8 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             }
             this.driver.controllerLog.print(message);
         }
+        // The SDK version cannot be queried directly, but we can deduce it from the protocol version
+        this._sdkVersion = (0, ZWaveSDKVersions_1.protocolVersionToSDKVersion)(this._protocolVersion);
         this.driver.controllerLog.print(`supported Z-Wave features: ${Object.keys(Features_1.ZWaveFeature)
             .filter((k) => /^\d+$/.test(k))
             .map((k) => parseInt(k))
@@ -484,6 +495,17 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             }));
             this.driver.controllerLog.print(`Enabling TX status report ${resp.success ? "successful" : "failed"}...`);
         }
+        // Also query the controller's current RF region if possible
+        if (this.isSerialAPISetupCommandSupported(SerialAPISetupMessages_1.SerialAPISetupCommand.GetRFRegion)) {
+            this.driver.controllerLog.print(`Querying configured RF region...`);
+            const resp = await this.getRFRegion().catch(() => undefined);
+            if (resp != undefined) {
+                this.driver.controllerLog.print(`The controller is using RF region ${(0, shared_1.getEnumMemberName)(core_1.RFRegion, resp)}`);
+            }
+            else {
+                this.driver.controllerLog.print(`Querying the RF region failed!`, "warn");
+            }
+        }
         // find the SUC
         this.driver.controllerLog.print(`finding SUC...`);
         const suc = await this.driver.sendMessage(new GetSUCNodeIdMessages_1.GetSUCNodeIdRequest(this.driver), { supportCheck: false });
@@ -569,6 +591,8 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         controllerValueDB.setValue(cc_1.VersionCCValues.firmwareVersions.id, [
             this._firmwareVersion,
         ]);
+        controllerValueDB.setMetadata(cc_1.VersionCCValues.zWaveProtocolVersion.id, cc_1.VersionCCValues.zWaveProtocolVersion.meta);
+        controllerValueDB.setValue(cc_1.VersionCCValues.zWaveProtocolVersion.id, this._protocolVersion);
         controllerValueDB.setMetadata(cc_1.VersionCCValues.sdkVersion.id, cc_1.VersionCCValues.sdkVersion.meta);
         controllerValueDB.setValue(cc_1.VersionCCValues.sdkVersion.id, this._sdkVersion);
         if (this.type !== _Types_2.ZWaveLibraryTypes["Bridge Controller"] &&
@@ -964,6 +988,299 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             throw e;
         }
     }
+    /** @internal */
+    async handleApplicationUpdateRequest(msg) {
+        const nodeId = msg.getNodeId();
+        let node;
+        if (nodeId != undefined) {
+            node = this.nodes.get(nodeId);
+        }
+        if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestNodeInfoReceived) {
+            if (node) {
+                this.driver.controllerLog.logNode(node.id, {
+                    message: "Received updated node info",
+                    direction: "inbound",
+                });
+                node.updateNodeInfo(msg.nodeInformation);
+                // Tell the send thread that we received a NIF from the node
+                this.driver["sendThread"].send({
+                    type: "NIF",
+                    nodeId: node.id,
+                });
+                if (node.canSleep &&
+                    node.supportsCC(core_1.CommandClasses["Wake Up"])) {
+                    // In case this is a sleeping node and there are no messages in the queue, the node may go back to sleep very soon
+                    this.driver.debounceSendNodeToSleep(node);
+                }
+                return;
+            }
+        }
+        else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestSmartStartHomeIDReceived) {
+            // the controller is in Smart Start learn mode and a node requests inclusion via Smart Start
+            this.driver.controllerLog.print("Received Smart Start inclusion request");
+            if (this.inclusionState !== Inclusion_1.InclusionState.Idle &&
+                this.inclusionState !== Inclusion_1.InclusionState.SmartStart) {
+                this.driver.controllerLog.print("Controller is busy and cannot handle this inclusion request right now...");
+                return;
+            }
+            // Check if the node is on the provisioning list
+            const provisioningEntry = this.provisioningList.find((entry) => (0, core_1.nwiHomeIdFromDSK)((0, core_1.dskFromString)(entry.dsk)).equals(msg.nwiHomeId));
+            if (!provisioningEntry) {
+                this.driver.controllerLog.print("NWI Home ID not found in provisioning list, ignoring request...");
+                return;
+            }
+            else if (provisioningEntry.status === Inclusion_1.ProvisioningEntryStatus.Inactive) {
+                this.driver.controllerLog.print("The provisioning entry for this node is inactive, ignoring request...");
+                return;
+            }
+            this.driver.controllerLog.print("NWI Home ID found in provisioning list, including node...");
+            try {
+                const result = await this.beginInclusionSmartStart(provisioningEntry);
+                if (!result) {
+                    this.driver.controllerLog.print("Smart Start inclusion could not be started", "error");
+                }
+            }
+            catch (e) {
+                this.driver.controllerLog.print(`Smart Start inclusion could not be started: ${(0, shared_1.getErrorMessage)(e)}`, "error");
+            }
+        }
+        else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestNodeRemoved) {
+            // A node was removed by another controller
+            const node = this.nodes.get(msg.nodeId);
+            if (node) {
+                this.driver.controllerLog.logNode(node.id, "was removed from the network by another controller");
+                this.emit("node removed", node, false);
+            }
+        }
+        else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestNodeAdded) {
+            // A node was included by another controller
+            const nodeId = msg.nodeId;
+            const nodeInfo = msg.nodeInformation;
+            this.setInclusionState(Inclusion_1.InclusionState.Busy);
+            const deviceClass = new DeviceClass_1.DeviceClass(this.driver.configManager, nodeInfo.basicDeviceClass, nodeInfo.genericDeviceClass, nodeInfo.specificDeviceClass);
+            const newNode = new Node_1.ZWaveNode(nodeId, this.driver, deviceClass, nodeInfo.supportedCCs, undefined, 
+            // Create an empty value DB and specify that it contains no values
+            // to avoid indexing the existing values
+            this.createValueDBForNode(nodeId, new Set()));
+            this._nodes.set(nodeId, newNode);
+            this.emit("node found", {
+                id: nodeId,
+                deviceClass,
+                supportedCCs: nodeInfo.supportedCCs,
+            });
+            this.driver.controllerLog.print(`Node ${newNode.id} was included by another controller:
+basic device class:    ${newNode.deviceClass?.basic.label}
+generic device class:  ${newNode.deviceClass?.generic.label}
+specific device class: ${newNode.deviceClass?.specific.label}
+supported CCs: ${nodeInfo.supportedCCs
+                .map((cc) => `\n  · ${core_1.CommandClasses[cc]} (${(0, shared_1.num2hex)(cc)})`)
+                .join("")}`);
+            this.driver.controllerLog.logNode(nodeId, "Waiting for initiate command to bootstrap node...");
+            // Handle inclusion in the background
+            process.nextTick(async () => {
+                // If an Inclusion Controller that does not support the Inclusion Controller Command Class includes a
+                // new node in a network, the SIS will never receive an Inclusion Controller Initiate Command. If no
+                // Initiate Command has been received approximately 10 seconds after a new node has been added to a
+                // network, the SIS SHOULD start interviewing the newly included node
+                const initiate = await this.driver
+                    .waitForCommand((cc) => cc instanceof cc_1.InclusionControllerCCInitiate &&
+                    cc.isSinglecast() &&
+                    cc.includedNodeId === nodeId &&
+                    cc.step === cc_1.InclusionControllerStep.ProxyInclusion, 10000)
+                    .catch(() => undefined);
+                // Assume the device is alive
+                // If it is actually a sleeping device, it will be marked as such later
+                newNode.markAsAlive();
+                let inclCtrlr;
+                let lowSecurity = false;
+                if (initiate) {
+                    inclCtrlr = this.nodes.getOrThrow(initiate.nodeId);
+                    this.driver.controllerLog.logNode(nodeId, `Initiate command received from node ${inclCtrlr.id}`);
+                    // Inclusion is handled by the inclusion controller, which (hopefully) sets the SUC return route
+                    newNode.hasSUCReturnRoute = true;
+                    // SIS, A, MUST request a Node Info Frame from Joining Node, B
+                    const requestedNodeInfo = await newNode
+                        .requestNodeInfo()
+                        .catch(() => undefined);
+                    if (requestedNodeInfo)
+                        newNode.updateNodeInfo(requestedNodeInfo);
+                    // Perform S0/S2 bootstrapping
+                    lowSecurity = (await this.proxyBootstrap(newNode, inclCtrlr)).lowSecurity;
+                }
+                else {
+                    // No command received, bootstrap node by ourselves
+                    this.driver.controllerLog.logNode(nodeId, "no initiate command received, bootstrapping node...");
+                    // Assign SUC return route to make sure the node knows where to get its routes from
+                    newNode.hasSUCReturnRoute = await this.assignSUCReturnRoute(newNode.id);
+                    // Include using the default inclusion strategy:
+                    // * Use S2 if possible,
+                    // * only use S0 if necessary,
+                    // * use no encryption otherwise
+                    if (newNode.supportsCC(core_1.CommandClasses["Security 2"])) {
+                        await this.secureBootstrapS2(newNode);
+                        const actualSecurityClass = newNode.getHighestSecurityClass();
+                        if (actualSecurityClass == undefined ||
+                            actualSecurityClass <
+                                core_1.SecurityClass.S2_Unauthenticated) {
+                            lowSecurity = true;
+                        }
+                    }
+                    else if (newNode.supportsCC(core_1.CommandClasses.Security) &&
+                        (deviceClass.specific ?? deviceClass.generic)
+                            .requiresSecurity) {
+                        await this.secureBootstrapS0(newNode);
+                        const actualSecurityClass = newNode.getHighestSecurityClass();
+                        if (actualSecurityClass == undefined ||
+                            actualSecurityClass < core_1.SecurityClass.S0_Legacy) {
+                            lowSecurity = true;
+                        }
+                    }
+                    else {
+                        // Remember that no security classes were granted
+                        for (const secClass of core_1.securityClassOrder) {
+                            newNode.securityClasses.set(secClass, false);
+                        }
+                    }
+                }
+                // Bootstrap the node's lifelines, so it knows where the controller is
+                await this.bootstrapLifelineAndWakeup(newNode);
+                // We're done adding this node, notify listeners
+                const result = {};
+                if (lowSecurity)
+                    result.lowSecurity = true;
+                this.emit("node added", newNode, result);
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                if (inclCtrlr && initiate) {
+                    const inclCtrlrId = inclCtrlr.id;
+                    const step = initiate.step;
+                    newNode.once("ready", () => {
+                        this.driver.controllerLog.logNode(nodeId, `Notifying node ${inclCtrlrId} of finished inclusion`);
+                        void inclCtrlr.commandClasses["Inclusion Controller"]
+                            .completeStep(step, cc_1.InclusionControllerStatus.OK)
+                            // eslint-disable-next-line @typescript-eslint/no-empty-function
+                            .catch(() => { });
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * @internal
+     * Handles replace requests from an inclusion controller
+     */
+    handleInclusionControllerCCInitiateReplace(initiate) {
+        if (initiate.step !== cc_1.InclusionControllerStep.ProxyInclusionReplace) {
+            throw new core_1.ZWaveError("Expected an inclusion controller replace request, but got a different step", core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.setInclusionState(Inclusion_1.InclusionState.Busy);
+        const inclCtrlr = this.nodes.getOrThrow(initiate.nodeId);
+        const replacedNodeId = initiate.includedNodeId;
+        const oldNode = this.nodes.get(replacedNodeId);
+        if (oldNode) {
+            this.emit("node removed", oldNode, true);
+            this._nodes.delete(oldNode.id);
+        }
+        // Create a fresh node instance and forget the old one
+        const newNode = new Node_1.ZWaveNode(replacedNodeId, this.driver, undefined, undefined, undefined, 
+        // Create an empty value DB and specify that it contains no values
+        // to avoid indexing the existing values
+        this.createValueDBForNode(replacedNodeId, new Set()));
+        this._nodes.set(newNode.id, newNode);
+        this.emit("node found", {
+            id: newNode.id,
+        });
+        // Assume the device is alive
+        // If it is actually a sleeping device, it will be marked as such later
+        newNode.markAsAlive();
+        // Inclusion is handled by the inclusion controller, which (hopefully) sets the SUC return route
+        newNode.hasSUCReturnRoute = true;
+        // Handle communication with the node in the background
+        process.nextTick(async () => {
+            // SIS, A, MUST request a Node Info Frame from Joining Node, B
+            const requestedNodeInfo = await newNode
+                .requestNodeInfo()
+                .catch(() => undefined);
+            if (requestedNodeInfo) {
+                newNode.updateNodeInfo(requestedNodeInfo);
+                // TODO: Check if this stuff works for a normal replace too
+                const deviceClass = new DeviceClass_1.DeviceClass(this.driver.configManager, requestedNodeInfo.basicDeviceClass, requestedNodeInfo.genericDeviceClass, requestedNodeInfo.specificDeviceClass);
+                newNode["applyDeviceClass"](deviceClass);
+            }
+            // Perform S0/S2 bootstrapping
+            const lowSecurity = (await this.proxyBootstrap(newNode, inclCtrlr))
+                .lowSecurity;
+            // Bootstrap the node's lifelines, so it knows where the controller is
+            await this.bootstrapLifelineAndWakeup(newNode);
+            // We're done adding this node, notify listeners
+            const result = {};
+            if (lowSecurity)
+                result.lowSecurity = true;
+            this.emit("node added", newNode, result);
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            // And notify the inclusion controller after we're done interviewing
+            newNode.once("ready", () => {
+                this.driver.controllerLog.logNode(inclCtrlr.nodeId, `Notifying inclusion controller of finished inclusion`);
+                void inclCtrlr.commandClasses["Inclusion Controller"]
+                    .completeStep(initiate.step, cc_1.InclusionControllerStatus.OK)
+                    // eslint-disable-next-line @typescript-eslint/no-empty-function
+                    .catch(() => { });
+            });
+        });
+    }
+    /**
+     * Handles bootstrapping the security keys for a node that was included by an inclusion controller
+     */
+    async proxyBootstrap(newNode, inclCtrlr) {
+        // This part is to be done before the interview
+        const deviceClass = newNode.deviceClass;
+        let lowSecurity = false;
+        // Include using the default inclusion strategy:
+        // * Use S2 if possible,
+        // * only use S0 if necessary,
+        // * use no encryption otherwise
+        if (newNode.supportsCC(core_1.CommandClasses["Security 2"])) {
+            await this.secureBootstrapS2(newNode);
+            const actualSecurityClass = newNode.getHighestSecurityClass();
+            if (actualSecurityClass == undefined ||
+                actualSecurityClass < core_1.SecurityClass.S2_Unauthenticated) {
+                lowSecurity = true;
+            }
+        }
+        else if (newNode.supportsCC(core_1.CommandClasses.Security) &&
+            (deviceClass.specific ?? deviceClass.generic).requiresSecurity) {
+            // S0 bootstrapping is deferred to the inclusion controller
+            this.driver.controllerLog.logNode(newNode.id, `Waiting for node ${inclCtrlr.id} to perform S0 bootstrapping...`);
+            await inclCtrlr.commandClasses["Inclusion Controller"].initiateStep(newNode.id, cc_1.InclusionControllerStep.S0Inclusion);
+            // Wait 60s for the S0 bootstrapping to complete
+            const s0result = await this.driver
+                .waitForCommand((cc) => cc.nodeId === inclCtrlr.id &&
+                cc instanceof cc_1.InclusionControllerCCComplete &&
+                cc.step === cc_1.InclusionControllerStep.S0Inclusion, 60000)
+                .catch(() => undefined);
+            this.driver.controllerLog.logNode(newNode.id, `S0 bootstrapping ${s0result == undefined
+                ? "timed out"
+                : s0result.status === cc_1.InclusionControllerStatus.OK
+                    ? "succeeded"
+                    : "failed"}`);
+            // When bootstrapping with S0, no other keys are granted
+            for (const secClass of core_1.securityClassOrder) {
+                if (secClass !== core_1.SecurityClass.S0_Legacy) {
+                    newNode.securityClasses.set(secClass, false);
+                }
+            }
+            // Whether the S0 key is granted depends on the result
+            // received from the inclusion controller
+            newNode.securityClasses.set(core_1.SecurityClass.S0_Legacy, s0result?.status === cc_1.InclusionControllerStatus.OK);
+            lowSecurity = !newNode.hasSecurityClass(core_1.SecurityClass.S0_Legacy);
+        }
+        else {
+            // Remember that no security classes were granted
+            for (const secClass of core_1.securityClassOrder) {
+                newNode.securityClasses.set(secClass, false);
+            }
+        }
+        return { lowSecurity };
+    }
     async secureBootstrapS0(node, assumeSupported = false) {
         // When bootstrapping with S0, no other keys are granted
         for (const secClass of core_1.securityClassOrder) {
@@ -1237,13 +1554,21 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 const dsk = (0, core_1.dskToString)(nodePublicKey.slice(0, 16)).slice(5);
                 // The time the user has to enter the PIN is limited by the timeout TAI2
                 const tai2RemainingMs = cc_1.inclusionTimeouts.TAI2 - (Date.now() - timerStartTAI2);
-                const pinResult = await Promise.race([
-                    (0, async_1.wait)(tai2RemainingMs, true).then(() => false),
-                    userCallbacks
-                        .validateDSKAndEnterPIN(dsk)
-                        // ignore errors in application callbacks
-                        .catch(() => false),
-                ]);
+                let pinResult;
+                if ("dsk" in inclusionOptions &&
+                    typeof inclusionOptions.dsk === "string" &&
+                    (0, core_1.isValidDSK)(inclusionOptions.dsk)) {
+                    pinResult = inclusionOptions.dsk.slice(0, 5);
+                }
+                else {
+                    pinResult = await Promise.race([
+                        (0, async_1.wait)(tai2RemainingMs, true).then(() => false),
+                        userCallbacks
+                            .validateDSKAndEnterPIN(dsk)
+                            // ignore errors in application callbacks
+                            .catch(() => false),
+                    ]);
+                }
                 if (typeof pinResult !== "string" ||
                     !/^\d{5}$/.test(pinResult)) {
                     // There was a timeout, the user did not confirm the DSK or entered an invalid PIN
@@ -2442,6 +2767,7 @@ ${associatedNodes.join(", ")}`,
         }
         if (result.success)
             await this.driver.trySoftReset();
+        this._rfRegion = region;
         return result.success;
     }
     /** Request the current RF region configured at the Z-Wave API Module */
@@ -2450,6 +2776,7 @@ ${associatedNodes.join(", ")}`,
         if (result instanceof SerialAPISetupMessages_1.SerialAPISetup_CommandUnsupportedResponse) {
             throw new core_1.ZWaveError(`Your hardware does not support getting the RF region!`, core_1.ZWaveErrorCodes.Driver_NotSupported);
         }
+        this._rfRegion = result.region;
         return result.region;
     }
     /** Configure the Powerlevel setting of the Z-Wave API */
@@ -2586,6 +2913,67 @@ ${associatedNodes.join(", ")}`,
             return false;
         }
     }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Initialize the Firmware Update functionality and determine if the firmware can be updated.
+     */
+    async firmwareUpdateNVMInit() {
+        const ret = await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_InitRequest(this.driver));
+        return ret.supported;
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Set the NEWIMAGE marker in the NVM (to the given value), which is used to signal that a new firmware image is present
+     */
+    async firmwareUpdateNVMSetNewImage(value = true) {
+        await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_SetNewImageRequest(this.driver, {
+            newImage: value,
+        }));
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Return the value of the NEWIMAGE marker in the NVM, which is used to signal that a new firmware image is present
+     */
+    async firmwareUpdateNVMGetNewImage() {
+        const ret = await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_GetNewImageRequest(this.driver));
+        return ret.newImage;
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Calculates the CRC-16 for the specified block of data in the NVM
+     */
+    async firmwareUpdateNVMUpdateCRC16(offset, blockLength, crcSeed) {
+        const ret = await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_UpdateCRC16Request(this.driver, {
+            offset,
+            blockLength,
+            crcSeed,
+        }));
+        return ret.crc16;
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Writes the given data into the firmware update region of the NVM.
+     */
+    async firmwareUpdateNVMWrite(offset, buffer) {
+        await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_WriteRequest(this.driver, {
+            offset,
+            buffer,
+        }));
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Checks if the firmware present in the NVM is valid
+     */
+    async firmwareUpdateNVMIsValidCRC16() {
+        const ret = await this.driver.sendMessage(new FirmwareUpdateNVMMessages_1.FirmwareUpdateNVM_IsValidCRC16Request(this.driver));
+        return ret.isValid;
+    }
     /**
      * **Z-Wave 500 series only**
      *
@@ -3035,6 +3423,7 @@ ${associatedNodes.join(", ")}`,
                 productType,
                 productId,
                 firmwareVersion,
+                rfRegion: this.rfRegion,
             }, {
                 userAgent: this.driver.getUserAgentStringWithComponents(options?.additionalUserAgentComponents),
                 apiKey: options?.apiKey ??
@@ -3070,6 +3459,18 @@ ${associatedNodes.join(", ")}`,
      * @deprecated Use {@link firmwareUpdateOTA} instead, which properly handles multi-target updates
      */
     async beginOTAFirmwareUpdate(nodeId, update) {
+        // Don't let two firmware updates happen in parallel
+        if (this.isAnyOTAFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: A firmware update is already in progress on this network!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
+        // Don't allow updating firmware when the controller is currently updating its own firmware
+        if (this.isFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: The controller is currently being updated!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
         const node = this.nodes.getOrThrow(nodeId);
         let firmware;
         try {
@@ -3111,6 +3512,18 @@ ${associatedNodes.join(", ")}`,
         if (updates.length === 0) {
             throw new core_1.ZWaveError(`At least one update must be provided`, core_1.ZWaveErrorCodes.Argument_Invalid);
         }
+        // Don't let two firmware updates happen in parallel
+        if (this.isAnyOTAFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: A firmware update is already in progress on this network!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
+        // Don't allow updating firmware when the controller is currently updating its own firmware
+        if (this.isFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: The controller is currently being updated!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
         const node = this.nodes.getOrThrow(nodeId);
         this.driver.controllerLog.logNode(nodeId, `OTA firmware update started, downloading ${updates.length} updates...`);
         const loglevel = this.driver.getLogConfig().level;
@@ -3154,6 +3567,242 @@ ${associatedNodes.join(", ")}`,
         this.driver.controllerLog.logNode(nodeId, `All updates downloaded, installing...`);
         return node.updateFirmware(firmwares);
     }
+    /**
+     * Returns whether a firmware update is in progress for the controller.
+     */
+    isFirmwareUpdateInProgress() {
+        return this._firmwareUpdateInProgress;
+    }
+    /**
+     * Updates the firmware of the controller using the given firmware file.
+     *
+     * The return value indicates whether the update was successful.
+     * **WARNING:** After a successful update, the Z-Wave driver will destroy itself so it can be restarted.
+     *
+     * **WARNING:** A failure during this process may put your controller in recovery mode, rendering it unusable until a correct firmware image is uploaded. Use at your own risk!
+     */
+    async firmwareUpdateOTW(data) {
+        // Don't let two firmware updates happen in parallel
+        if (this.isAnyOTAFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: A firmware update is already in progress on this network!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.OTW_Update_Busy);
+        }
+        // Don't allow updating firmware when the controller is currently updating its own firmware
+        if (this.isFirmwareUpdateInProgress()) {
+            const message = `Failed to start the update: The controller is currently being updated!`;
+            this.driver.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.OTW_Update_Busy);
+        }
+        if (this.sdkVersionGte("7.0")) {
+            return this.firmwareUpdateOTW700(data);
+        }
+        else if (this.sdkVersionGte("6.50.0") &&
+            this.supportedFunctionTypes?.includes(serial_1.FunctionType.FirmwareUpdateNVM)) {
+            // This is 500 series
+            const wasUpdated = await this.firmwareUpdateOTW500(data);
+            if (wasUpdated) {
+                // After updating the firmware on 500 series sticks, we MUST soft-reset them
+                await this.driver.softResetAndRestart("Activating new firmware and restarting driver...", "Controller firmware updates require a driver restart!");
+            }
+            return wasUpdated;
+        }
+        else {
+            throw new core_1.ZWaveError(`Firmware updates are not supported on this controller`, core_1.ZWaveErrorCodes.Controller_NotSupported);
+        }
+    }
+    async firmwareUpdateOTW500(data) {
+        this._firmwareUpdateInProgress = true;
+        let turnedRadioOff = false;
+        try {
+            this.driver.controllerLog.print("Beginning firmware update");
+            const canUpdate = await this.firmwareUpdateNVMInit();
+            if (!canUpdate) {
+                this.driver.controllerLog.print("OTW update failed: This controller does not support firmware updates", "error");
+                this.emit("firmware update finished", {
+                    success: false,
+                    status: _Types_3.ControllerFirmwareUpdateStatus.Error_NotSupported,
+                });
+                return false;
+            }
+            // Avoid interruption by incoming messages
+            await this.toggleRF(false);
+            turnedRadioOff = true;
+            // Upload the firmware data
+            const BLOCK_SIZE = 64;
+            const numFragments = Math.ceil(data.length / BLOCK_SIZE);
+            for (let fragment = 0; fragment < numFragments; fragment++) {
+                const fragmentData = data.slice(fragment * BLOCK_SIZE, (fragment + 1) * BLOCK_SIZE);
+                await this.firmwareUpdateNVMWrite(fragment * BLOCK_SIZE, fragmentData);
+                // This progress is technically too low, but we can keep 100% for after CRC checking this way
+                const progress = {
+                    sentFragments: fragment,
+                    totalFragments: numFragments,
+                    progress: (0, math_1.roundTo)((fragment / numFragments) * 100, 2),
+                };
+                this.emit("firmware update progress", progress);
+            }
+            // Check if a valid image was written
+            const isValidCRC = await this.firmwareUpdateNVMIsValidCRC16();
+            if (!isValidCRC) {
+                this.driver.controllerLog.print("OTW update failed: The firmware image is invalid", "error");
+                this.emit("firmware update finished", {
+                    success: false,
+                    status: _Types_3.ControllerFirmwareUpdateStatus.Error_Aborted,
+                });
+                return false;
+            }
+            this.emit("firmware update progress", {
+                sentFragments: numFragments,
+                totalFragments: numFragments,
+                progress: 100,
+            });
+            // Enable the image
+            await this.firmwareUpdateNVMSetNewImage();
+            this.driver.controllerLog.print("Firmware update succeeded");
+            this.emit("firmware update finished", {
+                success: true,
+                status: _Types_3.ControllerFirmwareUpdateStatus.OK,
+            });
+            return true;
+        }
+        finally {
+            this._firmwareUpdateInProgress = false;
+            if (turnedRadioOff)
+                await this.toggleRF(true);
+        }
+    }
+    async firmwareUpdateOTW700(data) {
+        this._firmwareUpdateInProgress = true;
+        let destroy = false;
+        try {
+            if (!this.driver.isInBootloader()) {
+                await this.driver.enterBootloader();
+            }
+            // Start the update process
+            this.driver.controllerLog.print("Beginning firmware upload");
+            await this.driver.bootloader.beginUpload();
+            // Wait for the bootloader to accept fragments
+            try {
+                await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Message &&
+                    c.message === "begin upload", 5000);
+                await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.FlowControl &&
+                    c.command === serial_1.XModemMessageHeaders.C, 1000);
+            }
+            catch {
+                this.driver.controllerLog.print("OTW update failed: Expected response not received from the bootloader", "error");
+                this.emit("firmware update finished", {
+                    success: false,
+                    status: _Types_3.ControllerFirmwareUpdateStatus.Error_Timeout,
+                });
+                return false;
+            }
+            const BLOCK_SIZE = 128;
+            if (data.length % BLOCK_SIZE !== 0) {
+                // Pad the data to a multiple of BLOCK_SIZE
+                data = Buffer.concat([
+                    data,
+                    Buffer.alloc(BLOCK_SIZE - (data.length % BLOCK_SIZE), 0xff),
+                ]);
+            }
+            const numFragments = Math.ceil(data.length / BLOCK_SIZE);
+            let aborted = false;
+            transfer: for (let fragment = 1; fragment <= numFragments; fragment++) {
+                const fragmentData = data.slice((fragment - 1) * BLOCK_SIZE, fragment * BLOCK_SIZE);
+                retry: for (let retry = 0; retry < 3; retry++) {
+                    await this.driver.bootloader.uploadFragment(fragment, fragmentData);
+                    let result;
+                    try {
+                        result = await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.FlowControl, 1000);
+                    }
+                    catch (e) {
+                        this.driver.controllerLog.print("OTW update failed: The bootloader did not acknowledge the start of transfer.", "error");
+                        this.emit("firmware update finished", {
+                            success: false,
+                            status: _Types_3.ControllerFirmwareUpdateStatus.Error_Timeout,
+                        });
+                        return false;
+                    }
+                    switch (result.command) {
+                        case serial_1.XModemMessageHeaders.ACK: {
+                            // The fragment was accepted
+                            const progress = {
+                                sentFragments: fragment,
+                                totalFragments: numFragments,
+                                progress: (0, math_1.roundTo)((fragment / numFragments) * 100, 2),
+                            };
+                            this.emit("firmware update progress", progress);
+                            // we've transmitted at least one fragment, so we need to destroy the driver afterwards
+                            destroy = true;
+                            continue transfer;
+                        }
+                        case serial_1.XModemMessageHeaders.NAK:
+                            // The fragment was rejected, try again
+                            continue retry;
+                        case serial_1.XModemMessageHeaders.CAN:
+                            // The bootloader aborted the update. We'll receive the reason afterwards as a message
+                            aborted = true;
+                            break transfer;
+                    }
+                }
+                this.driver.controllerLog.print("OTW update failed: Maximum retry attempts reached", "error");
+                this.emit("firmware update finished", {
+                    success: false,
+                    status: _Types_3.ControllerFirmwareUpdateStatus.Error_RetryLimitReached,
+                });
+                return false;
+            }
+            if (aborted) {
+                // wait for the reason to craft a good error message
+                const error = await this.driver
+                    .waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Message &&
+                    c.message.includes("error 0x"), 1000)
+                    .catch(() => undefined);
+                // wait for the menu screen so it doesn't show up in logs
+                await this.driver
+                    .waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Menu, 1000)
+                    .catch(() => undefined);
+                let message = `OTW update was aborted by the bootloader.`;
+                if (error) {
+                    message += ` ${error.message}`;
+                    // TODO: parse error code
+                }
+                this.driver.controllerLog.print(message, "error");
+                this.emit("firmware update finished", {
+                    success: false,
+                    status: _Types_3.ControllerFirmwareUpdateStatus.Error_Aborted,
+                });
+                return false;
+            }
+            else {
+                // We're done, send EOT and wait for the menu screen
+                await this.driver.bootloader.finishUpload();
+                try {
+                    await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Message &&
+                        c.message.includes("upload complete"), 1000);
+                    await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Menu, 1000);
+                }
+                catch (e) {
+                    this.driver.controllerLog.print("OTW update failed: The bootloader did not acknowledge the end of transfer.", "error");
+                    this.emit("firmware update finished", {
+                        success: false,
+                        status: _Types_3.ControllerFirmwareUpdateStatus.Error_Timeout,
+                    });
+                    return false;
+                }
+            }
+            this.driver.controllerLog.print("Firmware update succeeded");
+            this.emit("firmware update finished", {
+                success: true,
+                status: _Types_3.ControllerFirmwareUpdateStatus.OK,
+            });
+            return true;
+        }
+        finally {
+            await this.driver.leaveBootloader(destroy);
+            this._firmwareUpdateInProgress = false;
+        }
+    }
 };
 ZWaveController = __decorate([
     (0, shared_1.Mixin)([ControllerStatistics_1.ControllerStatisticsHost])