zigbee-herdsman 1.0.0 → 1.1.0

package/dist/adapter/zigate/adapter/zigateAdapter.js

@@ -27,16 +27,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const buffalo_1 = require("../../../buffalo");
 const utils_1 = require("../../../utils");
 const logger_1 = require("../../../utils/logger");
+const ZSpec = __importStar(require("../../../zspec"));
 const Zcl = __importStar(require("../../../zspec/zcl"));
+const Zdo = __importStar(require("../../../zspec/zdo"));
 const adapter_1 = __importDefault(require("../../adapter"));
 const constants_1 = require("../driver/constants");
 const zigate_1 = __importDefault(require("../driver/zigate"));
+const patchZdoBuffaloBE_1 = require("./patchZdoBuffaloBE");
 const NS = 'zh:zigate';
 const default_bind_group = 901; // https://github.com/Koenkk/zigbee-herdsman-converters/blob/master/lib/constants.js#L3
-const channelsToMask = (channels) => channels.map((x) => 2 ** x).reduce((acc, x) => acc + x, 0);
 class ZiGateAdapter extends adapter_1.default {
     driver;
     joinPermitted;
@@ -44,8 +45,9 @@ class ZiGateAdapter extends adapter_1.default {
     closing;
     queue;
     constructor(networkOptions, serialPortOptions, backupPath, adapterOptions) {
+        (0, patchZdoBuffaloBE_1.patchZdoBuffaloBE)();
         super(networkOptions, serialPortOptions, backupPath, adapterOptions);
-        this.hasZdoMessageOverhead = false;
+        this.hasZdoMessageOverhead = false; // false for requests, true for responses
         this.joinPermitted = false;
         this.closing = false;
         const concurrent = this.adapterOptions && this.adapterOptions.concurrent ? this.adapterOptions.concurrent : 2;
@@ -57,6 +59,7 @@ class ZiGateAdapter extends adapter_1.default {
         this.driver.on('LeaveIndication', this.leaveIndicationListener.bind(this));
         this.driver.on('DeviceAnnounce', this.deviceAnnounceListener.bind(this));
         this.driver.on('close', this.onZiGateClose.bind(this));
+        this.driver.on('zdoResponse', this.onZdoResponse.bind(this));
     }
     /**
      * Adapter methods
@@ -81,9 +84,9 @@ class ZiGateAdapter extends adapter_1.default {
             await this.initNetwork();
             await this.driver.sendCommand(constants_1.ZiGateCommandCode.AddGroup, {
                 addressMode: constants_1.ADDRESS_MODE.short,
-                shortAddress: 0x0000,
-                sourceEndpoint: 0x01,
-                destinationEndpoint: 0x01,
+                shortAddress: ZSpec.COORDINATOR_ADDRESS,
+                sourceEndpoint: ZSpec.HA_ENDPOINT,
+                destinationEndpoint: ZSpec.HA_ENDPOINT,
                 groupAddress: default_bind_group,
             });
         }
@@ -101,7 +104,7 @@ class ZiGateAdapter extends adapter_1.default {
         // @TODO deal hardcoded endpoints, made by analogy with deconz
         // polling the coordinator on some firmware went into a memory leak, so we don't ask this info
         const response = {
-            networkAddress: 0,
+            networkAddress: ZSpec.COORDINATOR_ADDRESS,
             manufacturerID: 0,
             ieeeAddr: networkResponse.payload.extendedAddress,
             endpoints: constants_1.coordinatorEndpoints.slice(), // copy
@@ -125,14 +128,25 @@ class ZiGateAdapter extends adapter_1.default {
         };
     }
     async permitJoin(seconds, networkAddress) {
-        const result = await this.driver.sendCommand(constants_1.ZiGateCommandCode.PermitJoin, {
-            targetShortAddress: networkAddress || 0xfffc,
-            interval: seconds,
-            TCsignificance: 0,
-        });
-        // const result = await this.driver.sendCommand(ZiGateCommandCode.PermitJoinStatus, {});
-        // Suitable only for the coordinator, not the entire network or point-to-point for routers
-        this.joinPermitted = result.payload.status === 0;
+        const clusterId = Zdo.ClusterId.PERMIT_JOINING_REQUEST;
+        if (networkAddress !== undefined) {
+            // specific device that is not `Coordinator`
+            // `authentication`: TC significance always 1 (zb specs)
+            const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, seconds, 1, []);
+            const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+            /* istanbul ignore next */
+            if (!Zdo.Buffalo.checkStatus(result)) {
+                // TODO: will disappear once moved upstream
+                throw new Zdo.StatusError(result[0]);
+            }
+        }
+        else {
+            // broadcast permit joining ZDO
+            // `authentication`: TC significance always 1 (zb specs)
+            const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, seconds, 1, []);
+            await this.sendZdo(ZSpec.BLANK_EUI64, ZSpec.BroadcastAddress.DEFAULT, clusterId, zdoPayload, true);
+        }
+        this.joinPermitted = seconds !== 0;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async addInstallCode(ieeeAddress, key) {
@@ -169,9 +183,11 @@ class ZiGateAdapter extends adapter_1.default {
     async backup() {
         throw new Error('This adapter does not support backup');
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async changeChannel(newChannel) {
-        throw new Error(`Channel change is not supported for 'zigate'`);
+        const clusterId = Zdo.ClusterId.NWK_UPDATE_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, [newChannel], 0xfe, undefined, undefined, undefined);
+        await this.sendZdo(ZSpec.BLANK_EUI64, ZSpec.BroadcastAddress.SLEEPY, clusterId, zdoPayload, true /* handled below */);
+        await (0, utils_1.Wait)(12000);
     }
     async setTransmitPower(value) {
         try {
@@ -182,252 +198,215 @@ class ZiGateAdapter extends adapter_1.default {
         }
     }
     async lqi(networkAddress) {
-        return await this.queue.execute(async () => {
-            const neighbors = [];
-            const add = (list) => {
-                for (const entry of list) {
-                    const relationByte = entry.readUInt8(18);
-                    const extAddr = entry.subarray(8, 16);
+        const clusterId = Zdo.ClusterId.LQI_TABLE_REQUEST;
+        const neighbors = [];
+        const request = async (startIndex) => {
+            const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, startIndex);
+            const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+            /* istanbul ignore else */
+            if (Zdo.Buffalo.checkStatus(result)) {
+                const payload = result[1];
+                for (const entry of payload.entryList) {
                     neighbors.push({
-                        linkquality: entry.readUInt8(21),
-                        networkAddress: entry.readUInt16LE(16),
-                        ieeeAddr: new buffalo_1.Buffalo(extAddr).readIeeeAddr(),
-                        relationship: (relationByte >> 1) & ((1 << 3) - 1),
-                        depth: entry.readUInt8(20),
+                        ieeeAddr: entry.eui64,
+                        networkAddress: entry.nwkAddress,
+                        linkquality: entry.lqi,
+                        relationship: entry.relationship,
+                        depth: entry.depth,
                     });
                 }
-            };
-            const request = async (startIndex) => {
-                try {
-                    const resultPayload = await this.driver.sendCommand(constants_1.ZiGateCommandCode.ManagementLQI, {
-                        targetAddress: networkAddress,
-                        startIndex: startIndex,
+                return [payload.neighborTableEntries, payload.entryList.length];
+            }
+            else {
+                // TODO: will disappear once moved upstream
+                throw new Zdo.StatusError(result[0]);
+            }
+        };
+        let [tableEntries, entryCount] = await request(0);
+        const size = tableEntries;
+        let nextStartIndex = entryCount;
+        while (neighbors.length < size) {
+            [tableEntries, entryCount] = await request(nextStartIndex);
+            nextStartIndex += entryCount;
+        }
+        return { neighbors };
+    }
+    async routingTable(networkAddress) {
+        const clusterId = Zdo.ClusterId.ROUTING_TABLE_REQUEST;
+        const table = [];
+        const request = async (startIndex) => {
+            const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, startIndex);
+            const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+            /* istanbul ignore else */
+            if (Zdo.Buffalo.checkStatus(result)) {
+                const payload = result[1];
+                for (const entry of payload.entryList) {
+                    table.push({
+                        destinationAddress: entry.destinationAddress,
+                        status: entry.status,
+                        nextHop: entry.nextHopAddress,
                     });
-                    const data = resultPayload.payload.payload;
-                    if (data[1] !== 0) {
-                        // status
-                        throw new Error(`LQI for '${networkAddress}' failed`);
-                    }
-                    const tableList = [];
-                    const response = {
-                        status: data[1],
-                        tableEntrys: data[2],
-                        startIndex: data[3],
-                        tableListCount: data[4],
-                        tableList: tableList,
-                    };
-                    let tableEntry = [];
-                    let counter = 0;
-                    for (let i = 5; i < response.tableListCount * 22 + 5; i++) {
-                        // one tableentry = 22 bytes
-                        tableEntry.push(data[i]);
-                        counter++;
-                        if (counter === 22) {
-                            response.tableList.push(Buffer.from(tableEntry));
-                            tableEntry = [];
-                            counter = 0;
-                        }
-                    }
-                    logger_1.logger.debug('LQI RESPONSE - addr: ' +
-                        networkAddress.toString(16) +
-                        ' status: ' +
-                        response.status +
-                        ' read ' +
-                        (response.tableListCount + response.startIndex) +
-                        '/' +
-                        response.tableEntrys +
-                        ' entrys', NS);
-                    return response;
-                }
-                catch (error) {
-                    const msg = 'LQI REQUEST FAILED - addr: 0x' + networkAddress.toString(16) + ' ' + error;
-                    logger_1.logger.error(msg, NS);
-                    throw new Error(msg);
                 }
-            };
-            let response = await request(0);
-            add(response.tableList);
-            let nextStartIndex = response.tableListCount;
-            while (neighbors.length < response.tableEntrys) {
-                response = await request(nextStartIndex);
-                add(response.tableList);
-                nextStartIndex += response.tableListCount;
+                return [payload.routingTableEntries, payload.entryList.length];
             }
-            return { neighbors };
-        }, networkAddress);
-    }
-    // @TODO
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    routingTable(networkAddress) {
-        return Promise.resolve({ table: [] });
+            else {
+                // TODO: will disappear once moved upstream
+                throw new Zdo.StatusError(result[0]);
+            }
+        };
+        let [tableEntries, entryCount] = await request(0);
+        const size = tableEntries;
+        let nextStartIndex = entryCount;
+        while (table.length < size) {
+            [tableEntries, entryCount] = await request(nextStartIndex);
+            nextStartIndex += entryCount;
+        }
+        return { table };
     }
     async nodeDescriptor(networkAddress) {
-        return await this.queue.execute(async () => {
-            try {
-                const nodeDescriptorResponse = await this.driver.sendCommand(constants_1.ZiGateCommandCode.NodeDescriptor, {
-                    targetShortAddress: networkAddress,
-                });
-                const data = nodeDescriptorResponse.payload.payload;
-                const buf = data;
-                const logicaltype = data[4] & 7;
-                let type = 'Unknown';
-                switch (logicaltype) {
-                    case 1:
-                        type = 'Router';
-                        break;
-                    case 2:
-                        type = 'EndDevice';
-                        break;
-                    case 0:
-                        type = 'Coordinator';
-                        break;
-                }
-                const manufacturer = buf.readUInt16LE(7);
-                logger_1.logger.debug('RECEIVING NODE_DESCRIPTOR - addr: 0x' +
-                    networkAddress.toString(16) +
-                    ' type: ' +
-                    type +
-                    ' manufacturer: 0x' +
-                    manufacturer.toString(16), NS);
-                return { manufacturerCode: manufacturer, type };
+        const clusterId = Zdo.ClusterId.NODE_DESCRIPTOR_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, networkAddress);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore else */
+        if (Zdo.Buffalo.checkStatus(result)) {
+            const payload = result[1];
+            let type = 'Unknown';
+            switch (payload.logicalType) {
+                case 0x0:
+                    type = 'Coordinator';
+                    break;
+                case 0x1:
+                    type = 'Router';
+                    break;
+                case 0x2:
+                    type = 'EndDevice';
+                    break;
             }
-            catch (error) {
-                const msg = 'RECEIVING NODE_DESCRIPTOR FAILED - addr: 0x' + networkAddress.toString(16) + ' ' + error;
-                logger_1.logger.error(msg, NS);
-                throw new Error(msg);
-            }
-        }, networkAddress);
+            return { type, manufacturerCode: payload.manufacturerCode };
+        }
+        else {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
     }
     async activeEndpoints(networkAddress) {
-        return await this.queue.execute(async () => {
-            const payload = {
-                targetShortAddress: networkAddress,
-            };
-            try {
-                const result = await this.driver.sendCommand(constants_1.ZiGateCommandCode.ActiveEndpoint, payload);
-                const buf = Buffer.from(result.payload.payload);
-                const epCount = buf.readUInt8(4);
-                const epList = [];
-                for (let i = 5; i < epCount + 5; i++) {
-                    epList.push(buf.readUInt8(i));
-                }
-                const payloadAE = {
-                    endpoints: epList,
-                };
-                logger_1.logger.debug(() => `ActiveEndpoints response: ${JSON.stringify(payloadAE)}`, NS);
-                return payloadAE;
-            }
-            catch (error) {
-                logger_1.logger.error(`RECEIVING ActiveEndpoints FAILED, ${error}`, NS);
-                throw new Error('RECEIVING ActiveEndpoints FAILED ' + error);
-            }
-        }, networkAddress);
+        const clusterId = Zdo.ClusterId.ACTIVE_ENDPOINTS_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, networkAddress);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore else */
+        if (Zdo.Buffalo.checkStatus(result)) {
+            const payload = result[1];
+            return { endpoints: payload.endpointList };
+        }
+        else {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
     }
     async simpleDescriptor(networkAddress, endpointID) {
-        return await this.queue.execute(async () => {
-            try {
-                const payload = {
-                    targetShortAddress: networkAddress,
-                    endpoint: endpointID,
-                };
-                const result = await this.driver.sendCommand(constants_1.ZiGateCommandCode.SimpleDescriptor, payload);
-                const buf = result.payload.payload;
-                if (buf.length > 11) {
-                    const inCount = buf.readUInt8(11);
-                    const inClusters = [];
-                    let cIndex = 12;
-                    for (let i = 0; i < inCount; i++) {
-                        inClusters[i] = buf.readUInt16LE(cIndex);
-                        cIndex += 2;
-                    }
-                    const outCount = buf.readUInt8(12 + inCount * 2);
-                    const outClusters = [];
-                    cIndex = 13 + inCount * 2;
-                    for (let l = 0; l < outCount; l++) {
-                        outClusters[l] = buf.readUInt16LE(cIndex);
-                        cIndex += 2;
-                    }
-                    const resultPayload = {
-                        profileID: buf.readUInt16LE(6),
-                        endpointID: buf.readUInt8(5),
-                        deviceID: buf.readUInt16LE(8),
-                        inputClusters: inClusters,
-                        outputClusters: outClusters,
-                    };
-                    return resultPayload;
-                }
-                throw new Error(`Invalid buffer length ${buf.length}.`);
-            }
-            catch (error) {
-                const msg = 'RECEIVING SIMPLE_DESCRIPTOR FAILED - addr: 0x' + networkAddress.toString(16) + ' EP:' + endpointID + ' ' + error;
-                logger_1.logger.error(msg, NS);
-                throw new Error(msg);
-            }
-        }, networkAddress);
+        const clusterId = Zdo.ClusterId.SIMPLE_DESCRIPTOR_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, networkAddress, endpointID);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore else */
+        if (Zdo.Buffalo.checkStatus(result)) {
+            const payload = result[1];
+            return {
+                profileID: payload.profileId,
+                endpointID: payload.endpoint,
+                deviceID: payload.deviceId,
+                inputClusters: payload.inClusterList,
+                outputClusters: payload.outClusterList,
+            };
+        }
+        else {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
     }
     async bind(destinationNetworkAddress, sourceIeeeAddress, sourceEndpoint, clusterID, destinationAddressOrGroup, type, destinationEndpoint) {
-        return await this.queue.execute(async () => {
-            const payload = {
-                targetExtendedAddress: sourceIeeeAddress,
-                targetEndpoint: sourceEndpoint,
-                clusterID: clusterID,
-                destinationAddressMode: type === 'group' ? constants_1.ADDRESS_MODE.group : constants_1.ADDRESS_MODE.ieee,
-                destinationAddress: destinationAddressOrGroup,
-            };
-            if (destinationEndpoint != undefined) {
-                payload.destinationEndpoint = destinationEndpoint;
-            }
-            const result = await this.driver.sendCommand(constants_1.ZiGateCommandCode.Bind, payload, undefined, { destinationNetworkAddress });
-            const data = result.payload.payload;
-            if (data[1] === 0) {
-                logger_1.logger.debug(`Bind ${sourceIeeeAddress} success`, NS);
-            }
-            else {
-                const msg = `Bind ${sourceIeeeAddress} failed`;
-                logger_1.logger.error(msg, NS);
-                throw new Error(msg);
-            }
-        }, destinationNetworkAddress);
+        const clusterId = Zdo.ClusterId.BIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, sourceIeeeAddress, sourceEndpoint, clusterID, type === 'group' ? Zdo.MULTICAST_BINDING : Zdo.UNICAST_BINDING, destinationAddressOrGroup, // not used with MULTICAST_BINDING
+        destinationAddressOrGroup, // not used with UNICAST_BINDING
+        destinationEndpoint ?? 0);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, destinationNetworkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore next */
+        if (!Zdo.Buffalo.checkStatus(result)) {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
     }
     async unbind(destinationNetworkAddress, sourceIeeeAddress, sourceEndpoint, clusterID, destinationAddressOrGroup, type, destinationEndpoint) {
-        return await this.queue.execute(async () => {
-            const payload = {
-                targetExtendedAddress: sourceIeeeAddress,
-                targetEndpoint: sourceEndpoint,
-                clusterID: clusterID,
-                destinationAddressMode: type === 'group' ? constants_1.ADDRESS_MODE.group : constants_1.ADDRESS_MODE.ieee,
-                destinationAddress: destinationAddressOrGroup,
-            };
-            if (destinationEndpoint != undefined) {
-                payload.destinationEndpoint = destinationEndpoint;
-            }
-            const result = await this.driver.sendCommand(constants_1.ZiGateCommandCode.UnBind, payload, undefined, { destinationNetworkAddress });
-            const data = result.payload.payload;
-            if (data[1] === 0) {
-                logger_1.logger.debug(`Unbind ${sourceIeeeAddress} success`, NS);
-            }
-            else {
-                const msg = `Unbind ${sourceIeeeAddress} failed`;
-                logger_1.logger.error(msg, NS);
-                throw new Error(msg);
-            }
-        }, destinationNetworkAddress);
+        const clusterId = Zdo.ClusterId.UNBIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, sourceIeeeAddress, sourceEndpoint, clusterID, type === 'group' ? Zdo.MULTICAST_BINDING : Zdo.UNICAST_BINDING, destinationAddressOrGroup, // not used with MULTICAST_BINDING
+        destinationAddressOrGroup, // not used with UNICAST_BINDING
+        destinationEndpoint ?? 0);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, destinationNetworkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore next */
+        if (!Zdo.Buffalo.checkStatus(result)) {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
     }
     async removeDevice(networkAddress, ieeeAddr) {
+        const clusterId = Zdo.ClusterId.LEAVE_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(this.hasZdoMessageOverhead, clusterId, ieeeAddr, Zdo.LeaveRequestFlags.WITHOUT_REJOIN);
+        const result = await this.sendZdo(ZSpec.BLANK_EUI64, networkAddress, clusterId, zdoPayload, false);
+        /* istanbul ignore next */
+        if (!Zdo.Buffalo.checkStatus(result)) {
+            // TODO: will disappear once moved upstream
+            throw new Zdo.StatusError(result[0]);
+        }
+    }
+    async sendZdo(ieeeAddress, networkAddress, clusterId, payload, disableResponse) {
         return await this.queue.execute(async () => {
-            const payload = {
-                shortAddress: networkAddress,
-                extendedAddress: ieeeAddr,
-                rejoin: 0,
-                removeChildren: 0,
-            };
-            try {
-                await this.driver.sendCommand(constants_1.ZiGateCommandCode.ManagementLeaveRequest, payload);
+            // stack-specific requirements
+            // https://zigate.fr/documentation/commandes-zigate/
+            switch (clusterId) {
+                case Zdo.ClusterId.LEAVE_REQUEST: {
+                    const prefixedPayload = Buffer.alloc(payload.length + 3); // extra zero for `removeChildren`
+                    prefixedPayload.writeUInt16BE(networkAddress, 0);
+                    prefixedPayload.set(payload, 2);
+                    payload = prefixedPayload;
+                    break;
+                }
+                case Zdo.ClusterId.BIND_REQUEST:
+                case Zdo.ClusterId.UNBIND_REQUEST: {
+                    // extra zeroes for endpoint XXX: not needed?
+                    const zeroes = 15 - payload.length;
+                    const prefixedPayload = Buffer.alloc(payload.length + zeroes);
+                    prefixedPayload.set(payload, 0);
+                    payload = prefixedPayload;
+                    break;
+                }
+                case Zdo.ClusterId.PERMIT_JOINING_REQUEST:
+                case Zdo.ClusterId.SYSTEM_SERVER_DISCOVERY_REQUEST:
+                case Zdo.ClusterId.LQI_TABLE_REQUEST:
+                case Zdo.ClusterId.ROUTING_TABLE_REQUEST:
+                case Zdo.ClusterId.BINDING_TABLE_REQUEST:
+                case Zdo.ClusterId.NWK_UPDATE_REQUEST: {
+                    const prefixedPayload = Buffer.alloc(payload.length + 2);
+                    prefixedPayload.writeUInt16BE(networkAddress, 0);
+                    prefixedPayload.set(payload, 2);
+                    payload = prefixedPayload;
+                    break;
+                }
             }
-            catch (error) {
-                new Error(`ManagementLeaveRequest failed ${error}`);
+            let waiter;
+            if (!disableResponse) {
+                const responseClusterId = Zdo.Utils.getResponseClusterId(clusterId);
+                if (responseClusterId) {
+                    waiter = this.driver.zdoWaitFor({
+                        clusterId: responseClusterId,
+                        target: responseClusterId === Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE ? ieeeAddress : networkAddress,
+                    });
+                }
             }
-        }, networkAddress);
+            await this.driver.requestZdo(clusterId, payload);
+            if (waiter) {
+                const result = await waiter.start().promise;
+                return result.zdo;
+            }
+        }, networkAddress /* TODO: replace with ieeeAddress once zdo moved upstream */);
     }
     async sendZclFrameToEndpoint(ieeeAddr, networkAddress, endpoint, zclFrame, timeout, disableResponse, disableRecovery, sourceEndpoint) {
         return await this.queue.execute(async () => {
@@ -442,9 +421,9 @@ class ZiGateAdapter extends adapter_1.default {
         const payload = {
             addressMode: constants_1.ADDRESS_MODE.short, //nwk
             targetShortAddress: networkAddress,
-            sourceEndpoint: sourceEndpoint || 0x01,
+            sourceEndpoint: sourceEndpoint || ZSpec.HA_ENDPOINT,
             destinationEndpoint: endpoint,
-            profileID: 0x0104,
+            profileID: ZSpec.HA_PROFILE_ID,
             clusterID: zclFrame.cluster.ID,
             securityMode: 0x02,
             radius: 30,
@@ -497,7 +476,7 @@ class ZiGateAdapter extends adapter_1.default {
                 targetShortAddress: destination,
                 sourceEndpoint: sourceEndpoint,
                 destinationEndpoint: endpoint,
-                profileID: /*sourceEndpoint === 242 ? 0xa1e0 :*/ 0x0104,
+                profileID: /*sourceEndpoint === ZSpec.GP_ENDPOINT ? ZSpec.GP_PROFILE_ID :*/ ZSpec.HA_PROFILE_ID,
                 clusterID: zclFrame.cluster.ID,
                 securityMode: 0x02,
                 radius: 30,
@@ -515,9 +494,9 @@ class ZiGateAdapter extends adapter_1.default {
             const payload = {
                 addressMode: constants_1.ADDRESS_MODE.group, //nwk
                 targetShortAddress: groupID,
-                sourceEndpoint: sourceEndpoint || 0x01,
+                sourceEndpoint: sourceEndpoint || ZSpec.HA_ENDPOINT,
                 destinationEndpoint: 0xff,
-                profileID: 0x0104,
+                profileID: ZSpec.HA_PROFILE_ID,
                 clusterID: zclFrame.cluster.ID,
                 securityMode: 0x02,
                 radius: 30,
@@ -533,7 +512,9 @@ class ZiGateAdapter extends adapter_1.default {
      */
     async initNetwork() {
         logger_1.logger.debug(`Set channel mask ${this.networkOptions.channelList} key`, NS);
-        await this.driver.sendCommand(constants_1.ZiGateCommandCode.SetChannelMask, { channelMask: channelsToMask(this.networkOptions.channelList) });
+        await this.driver.sendCommand(constants_1.ZiGateCommandCode.SetChannelMask, {
+            channelMask: ZSpec.Utils.channelsToUInt32Mask(this.networkOptions.channelList),
+        });
         logger_1.logger.debug(`Set security key`, NS);
         await this.driver.sendCommand(constants_1.ZiGateCommandCode.SetSecurityStateKey, {
             keyType: this.networkOptions.networkKeyDistribute
@@ -591,36 +572,40 @@ class ZiGateAdapter extends adapter_1.default {
     restoreChannelInterPAN() {
         throw new Error('Not supported');
     }
-    deviceAnnounceListener(networkAddress, ieeeAddr) {
+    deviceAnnounceListener(response) {
         // @todo debounce
-        const payload = { networkAddress, ieeeAddr };
+        const payload = { networkAddress: response.nwkAddress, ieeeAddr: response.eui64 };
         if (this.joinPermitted === true) {
             this.emit('deviceJoined', payload);
         }
         else {
-            this.emit('deviceAnnounce', payload);
+            // convert to `zdoResponse` to avoid needing extra event upstream
+            this.emit('zdoResponse', Zdo.ClusterId.END_DEVICE_ANNOUNCE, [Zdo.Status.SUCCESS, response]);
         }
     }
-    dataListener(data) {
+    onZdoResponse(clusterId, response) {
+        this.emit('zdoResponse', clusterId, response);
+    }
+    dataListener(ziGateObject) {
         const payload = {
-            address: data.ziGateObject.payload.sourceAddress,
-            clusterID: data.ziGateObject.payload.clusterID,
-            data: data.ziGateObject.payload.payload,
-            header: Zcl.Header.fromBuffer(data.ziGateObject.payload.payload),
-            endpoint: data.ziGateObject.payload.sourceEndpoint,
-            linkquality: data.ziGateObject.frame.readRSSI(), // read: frame valid
+            address: ziGateObject.payload.sourceAddress,
+            clusterID: ziGateObject.payload.clusterID,
+            data: ziGateObject.payload.payload,
+            header: Zcl.Header.fromBuffer(ziGateObject.payload.payload),
+            endpoint: ziGateObject.payload.sourceEndpoint,
+            linkquality: ziGateObject.frame.readRSSI(), // read: frame valid
             groupID: 0, // @todo
             wasBroadcast: false, // TODO
-            destinationEndpoint: data.ziGateObject.payload.destinationEndpoint,
+            destinationEndpoint: ziGateObject.payload.destinationEndpoint,
         };
         this.waitress.resolve(payload);
         this.emit('zclPayload', payload);
     }
-    leaveIndicationListener(data) {
-        logger_1.logger.debug(() => `LeaveIndication ${JSON.stringify(data)}`, NS);
+    leaveIndicationListener(ziGateObject) {
+        logger_1.logger.debug(() => `LeaveIndication ${JSON.stringify(ziGateObject)}`, NS);
         const payload = {
-            networkAddress: data.ziGateObject.payload.extendedAddress,
-            ieeeAddr: data.ziGateObject.payload.extendedAddress,
+            networkAddress: ziGateObject.payload.extendedAddress,
+            ieeeAddr: ziGateObject.payload.extendedAddress,
         };
         this.emit('deviceLeave', payload);
     }