eufy-security-client 3.6.0 → 3.7.1

package/build/p2p/session.js

@@ -5,7 +5,7 @@ const dgram_1 = require("dgram");
 const tiny_typed_emitter_1 = require("tiny-typed-emitter");
 const stream_1 = require("stream");
 const sweet_collections_1 = require("sweet-collections");
-const { parse } = require('date-and-time');
+const { parse } = require("date-and-time");
 const utils_1 = require("./utils");
 const types_1 = require("./types");
 const types_2 = require("../http/types");
@@ -45,12 +45,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     MAX_SEQUENCE_NUMBER = 65535;
     LOOP_RUNAWAY_LIMIT = 1000;
     /*
-    * SEQUENCE_PROCESSING_BOUNDARY is used to determine if an incoming sequence number
-    * that is lower than the expected one was already processed.
-    * If it is within the boundary, it is determined as 'already processed',
-    * If it is even lower, it is assumed that the sequence count has reached
-    * MAX_SEQUENCE_NUMBER and restarted at 0.
-    * */
+     * SEQUENCE_PROCESSING_BOUNDARY is used to determine if an incoming sequence number
+     * that is lower than the expected one was already processed.
+     * If it is within the boundary, it is determined as 'already processed',
+     * If it is even lower, it is assumed that the sequence count has reached
+     * MAX_SEQUENCE_NUMBER and restarted at 0.
+     * */
     SEQUENCE_PROCESSING_BOUNDARY = 20000; // worth of approx. 90 seconds of continous streaming
     socket;
     binded = false;
@@ -115,7 +115,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             this.listeningPort = listeningPort;
         this.enableEmbeddedPKCS1Support = enableEmbeddedPKCS1Support;
         this.cloudAddresses = (0, utils_1.decodeP2PCloudIPs)(rawStation.app_conn);
-        logging_1.rootP2PLogger.debug("Loaded P2P cloud ip addresses", { stationSN: rawStation.station_sn, ipAddress: ipAddress, cloudAddresses: this.cloudAddresses });
+        logging_1.rootP2PLogger.debug("Loaded P2P cloud ip addresses", {
+            stationSN: rawStation.station_sn,
+            ipAddress: ipAddress,
+            cloudAddresses: this.cloudAddresses,
+        });
         this.updateRawStation(rawStation);
         this.socket = (0, dgram_1.createSocket)("udp4");
         this.socket.on("message", (msg, rinfo) => this.handleMsg(msg, rinfo));
@@ -136,13 +140,15 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         return true;
     }
     _wasSequenceNumberAlreadyProcessed(expectedSequence, receivedSequence) {
-        if ((expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY) > 0) { // complete boundary without squence number reset
+        if (expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY > 0) {
+            // complete boundary without squence number reset
             return this._isBetween(receivedSequence, expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY, expectedSequence);
         }
-        else { // there was a sequence number reset recently
+        else {
+            // there was a sequence number reset recently
             const isInRangeAfterReset = this._isBetween(receivedSequence, 0, expectedSequence);
             const isInRangeBeforeReset = this._isBetween(receivedSequence, this.MAX_SEQUENCE_NUMBER + (expectedSequence - this.SEQUENCE_PROCESSING_BOUNDARY), this.MAX_SEQUENCE_NUMBER);
-            return (isInRangeBeforeReset || isInRangeAfterReset);
+            return isInRangeBeforeReset || isInRangeAfterReset;
         }
     }
     _initialize() {
@@ -186,10 +192,10 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 bytesToRead: 0,
                 channel: 0,
                 signCode: 0,
-                type: 0
+                type: 0,
             },
             bytesRead: 0,
-            messages: {}
+            messages: {},
         };
     }
     initializeMessageState(datatype, rsaKey = null) {
@@ -210,14 +216,14 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 videoFPS: 15,
                 videoHeight: 1080,
                 videoWidth: 1920,
-                audioCodec: types_1.AudioCodec.NONE
+                audioCodec: types_1.AudioCodec.NONE,
             },
             rtspStream: {},
             rtspStreaming: {},
             receivedFirstIFrame: false,
             preFrameVideoData: Buffer.from([]),
             p2pTalkback: false,
-            p2pTalkbackChannel: -1
+            p2pTalkbackChannel: -1,
         };
     }
     _clearTimeout(timeout) {
@@ -278,7 +284,13 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     async sendMessage(errorSubject, address, msgID, payload) {
         await (0, utils_1.sendMessage)(this.socket, address, msgID, payload).catch((err) => {
             const error = (0, error_1.ensureError)(err);
-            logging_1.rootP2PLogger.error(`${errorSubject} - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, address: address, msgID: msgID.toString("hex"), payload: payload?.toString("hex") });
+            logging_1.rootP2PLogger.error(`${errorSubject} - Error`, {
+                error: (0, utils_3.getError)(error),
+                stationSN: this.rawStation.station_sn,
+                address: address,
+                msgID: msgID.toString("hex"),
+                payload: payload?.toString("hex"),
+            });
         });
     }
     _disconnected() {
@@ -302,7 +314,8 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         for (const channel in this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming) {
             this.endRTSPStream(Number.parseInt(channel));
         }
-        this.sendQueue = this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING);
+        this.sendQueue = this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING &&
+            queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING);
         if (this.connected) {
             this.emit("close");
         }
@@ -312,7 +325,8 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         this._initialize();
     }
     closeEnergySavingDevice() {
-        if (this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length === 0 &&
+        if (this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING &&
+            queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length === 0 &&
             this.energySavingDevice &&
             !this.isCurrentlyStreaming() &&
             Array.from(this.messageStates.values()).filter((msgState) => msgState.acknowledged === false).length === 0) {
@@ -329,8 +343,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         }
     }
     async renewDSKKey() {
-        if (this.dskKey === "" || (this.dskExpiration && (new Date()).getTime() >= this.dskExpiration.getTime())) {
-            logging_1.rootP2PLogger.debug(`DSK keys not present or expired, get/renew it`, { stationSN: this.rawStation.station_sn, dskKey: this.dskKey, dskExpiration: this.dskExpiration });
+        if (this.dskKey === "" || (this.dskExpiration && new Date().getTime() >= this.dskExpiration.getTime())) {
+            logging_1.rootP2PLogger.debug(`DSK keys not present or expired, get/renew it`, {
+                stationSN: this.rawStation.station_sn,
+                dskKey: this.dskKey,
+                dskExpiration: this.dskExpiration,
+            });
             await this.getDSKKeys();
         }
     }
@@ -394,7 +412,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             }, this.MAX_CONNECTION_TIMEOUT);
     }
     _connect(address, p2p_did) {
-        logging_1.rootP2PLogger.debug(`Connecting to host ${address.host} on port ${address.port} (CHECK_CAM)`, { stationSN: this.rawStation.station_sn, address: address, p2pDid: p2p_did });
+        logging_1.rootP2PLogger.debug(`Connecting to host ${address.host} on port ${address.port} (CHECK_CAM)`, {
+            stationSN: this.rawStation.station_sn,
+            address: address,
+            p2pDid: p2p_did,
+        });
         this.sendCamCheck(address, p2p_did);
         for (let i = address.port - 3; i < address.port; i++)
             this.sendCamCheck({ host: address.host, port: i }, p2p_did);
@@ -444,7 +466,13 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`connect - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, host: host, currentRecBufferSize: this.socket.getRecvBufferSize(), recBufferRequestedSize: this.UDP_RECVBUFFERSIZE_BYTES });
+                        logging_1.rootP2PLogger.error(`connect - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            host: host,
+                            currentRecBufferSize: this.socket.getRecvBufferSize(),
+                            recBufferRequestedSize: this.UDP_RECVBUFFERSIZE_BYTES,
+                        });
                     }
                     this.lookup(host);
                 });
@@ -462,8 +490,10 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         await this.sendMessage(`Send cam check (2)`, address, types_1.RequestMessageType.CHECK_CAM2, payload);
     }
     async sendPing(address) {
-        if ((this.lastPong && ((new Date().getTime() - this.lastPong) / this.getHeartbeatInterval() >= this.MAX_RETRIES)) ||
-            (this.connectTime && !this.lastPong && ((new Date().getTime() - this.connectTime) / this.getHeartbeatInterval() >= this.MAX_RETRIES))) {
+        if ((this.lastPong && (new Date().getTime() - this.lastPong) / this.getHeartbeatInterval() >= this.MAX_RETRIES) ||
+            (this.connectTime &&
+                !this.lastPong &&
+                (new Date().getTime() - this.connectTime) / this.getHeartbeatInterval() >= this.MAX_RETRIES)) {
             if (!this.energySavingDevice)
                 logging_1.rootP2PLogger.warn(`Heartbeat check failed for station ${this.rawStation.station_sn}. Connection seems lost. Try to reconnect...`);
             this._disconnected();
@@ -502,7 +532,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             }
             catch (err) {
                 const error = (0, error_1.ensureError)(err);
-                logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_SET_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, p2pcommand: p2pcommand, customData: customData });
+                logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_SET_PAYLOAD - Error`, {
+                    error: (0, utils_3.getError)(error),
+                    stationSN: this.rawStation.station_sn,
+                    p2pcommand: p2pcommand,
+                    customData: customData,
+                });
             }
         }
         else if (p2pcommand.commandType == types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD) {
@@ -512,7 +547,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             }
             catch (err) {
                 const error = (0, error_1.ensureError)(err);
-                logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_DOORBELL_SET_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, p2pcommand: p2pcommand, customData: customData });
+                logging_1.rootP2PLogger.error(`sendCommandWithStringPayload CMD_DOORBELL_SET_PAYLOAD - Error`, {
+                    error: (0, utils_3.getError)(error),
+                    stationSN: this.rawStation.station_sn,
+                    p2pcommand: p2pcommand,
+                    customData: customData,
+                });
             }
         }
         this.sendCommand(p2pcommand, types_1.InternalP2PCommandType.WithStringPayload, nested_commandType, customData, nested_commandType2);
@@ -529,19 +569,19 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     sendCommandPing(channel = this.channel) {
         this.sendCommand({
             commandType: types_1.CommandType.CMD_PING,
-            channel: channel
+            channel: channel,
         }, types_1.InternalP2PCommandType.WithoutData);
     }
     sendCommandDevicePing(channel = this.channel) {
         this.sendCommand({
             commandType: types_1.CommandType.CMD_GET_DEVICE_PING,
-            channel: channel
+            channel: channel,
         }, types_1.InternalP2PCommandType.WithoutData);
     }
     sendCommandWithoutData(commandType, channel = this.channel) {
         this.sendCommand({
             commandType: commandType,
-            channel: channel
+            channel: channel,
         }, types_1.InternalP2PCommandType.WithoutData);
     }
     sendQueuedMessage() {
@@ -551,8 +591,10 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 while ((queuedMessage = this.sendQueue.shift()) !== undefined) {
                     let exists = false;
                     let waitingAcknowledge = false;
-                    this.messageStates.forEach(stateMessage => {
-                        if (stateMessage.commandType === queuedMessage.p2pCommand.commandType && stateMessage.nestedCommandType === queuedMessage.nestedCommandType && !stateMessage.acknowledged) {
+                    this.messageStates.forEach((stateMessage) => {
+                        if (stateMessage.commandType === queuedMessage.p2pCommand.commandType &&
+                            stateMessage.nestedCommandType === queuedMessage.nestedCommandType &&
+                            !stateMessage.acknowledged) {
                             exists = true;
                         }
                         if (!stateMessage.acknowledged || stateMessage.commandType === types_1.CommandType.CMD_GATEWAYINFO) {
@@ -569,8 +611,14 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }
                 }
             }
-            else if (!this.connected && this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length > 0) {
-                logging_1.rootP2PLogger.debug(`Initiate station p2p connection to send queued data`, { stationSN: this.rawStation.station_sn, queuedDataCount: this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING && queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length });
+            else if (!this.connected &&
+                this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING &&
+                    queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length > 0) {
+                logging_1.rootP2PLogger.debug(`Initiate station p2p connection to send queued data`, {
+                    stationSN: this.rawStation.station_sn,
+                    queuedDataCount: this.sendQueue.filter((queue) => queue.p2pCommand.commandType !== types_1.CommandType.CMD_PING &&
+                        queue.p2pCommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING).length,
+                });
                 this.connect();
             }
         }
@@ -581,9 +629,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             p2pCommand: p2pcommand,
             nestedCommandType: nestedCommandType,
             nestedCommandType2: nested_commandType2,
-            timestamp: +new Date,
+            timestamp: +new Date(),
             customData: customData,
-            p2pCommandType: p2pcommandType
+            p2pCommandType: p2pcommandType,
         };
         this.sendQueue.push(message);
         if (p2pcommand.commandType !== types_1.CommandType.CMD_PING && p2pcommand.commandType !== types_1.CommandType.CMD_GET_DEVICE_PING)
@@ -598,7 +646,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 if (this.connectAddress) {
                     (0, utils_1.sendMessage)(this.socket, this.connectAddress, types_1.RequestMessageType.DATA, messageState.data).catch((err) => {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`resendNotAcknowledgedCommand - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, sequence: sequence });
+                        logging_1.rootP2PLogger.error(`resendNotAcknowledgedCommand - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            sequence: sequence,
+                        });
                     });
                     this.resendNotAcknowledgedCommand(sequence);
                 }
@@ -607,7 +659,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     }
     async _sendCommand(message) {
         if ((0, utils_1.isP2PQueueMessage)(message)) {
-            const ageing = +new Date - message.timestamp;
+            const ageing = +new Date() - message.timestamp;
             if (ageing <= this.MAX_COMMAND_QUEUE_TIMEOUT) {
                 const commandHeader = (0, utils_1.buildCommandHeader)(this.seqNumber, message.p2pCommand.commandType);
                 let payload;
@@ -620,7 +672,8 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         payload = (0, utils_1.buildIntStringCommandPayload)(this.encryption, this.p2pKey, this.rawStation.station_sn, this.rawStation.p2p_did, message.p2pCommand.commandType, message.p2pCommand.value, message.p2pCommand.valueSub === undefined ? 0 : message.p2pCommand.valueSub, message.p2pCommand.strValue === undefined ? "" : message.p2pCommand.strValue, message.p2pCommand.strValueSub === undefined ? "" : message.p2pCommand.strValueSub, channel);
                         //TODO: Check if this "if" can be moved elsewhere
                         if (message.p2pCommand.commandType === types_1.CommandType.CMD_NAS_TEST) {
-                            this.currentMessageState[types_1.P2PDataType.DATA].rtspStream[channel] = message.p2pCommand.value === 1 ? true : false;
+                            this.currentMessageState[types_1.P2PDataType.DATA].rtspStream[channel] =
+                                message.p2pCommand.value === 1 ? true : false;
                         }
                         break;
                     case types_1.InternalP2PCommandType.WithString:
@@ -643,21 +696,28 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     data: data,
                     retries: 0,
                     acknowledged: false,
-                    customData: message.customData
+                    customData: message.customData,
                 };
                 message = messageState;
                 this.seqNumber = this._incrementSequence(this.seqNumber);
             }
-            else if (message.p2pCommand.commandType === types_1.CommandType.CMD_PING || message.p2pCommand.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
+            else if (message.p2pCommand.commandType === types_1.CommandType.CMD_PING ||
+                message.p2pCommand.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
                 return;
             }
             else {
-                logging_1.rootP2PLogger.warn(`Command aged out from send queue for station ${this.rawStation.station_sn}`, { commandType: message.p2pCommand.commandType, nestedCommandType: message.nestedCommandType, channel: message.p2pCommand.channel, ageing: ageing, maxAgeing: this.MAX_COMMAND_QUEUE_TIMEOUT });
+                logging_1.rootP2PLogger.warn(`Command aged out from send queue for station ${this.rawStation.station_sn}`, {
+                    commandType: message.p2pCommand.commandType,
+                    nestedCommandType: message.nestedCommandType,
+                    channel: message.p2pCommand.channel,
+                    ageing: ageing,
+                    maxAgeing: this.MAX_COMMAND_QUEUE_TIMEOUT,
+                });
                 this.emit("command", {
                     command_type: message.nestedCommandType !== undefined ? message.nestedCommandType : message.p2pCommand.commandType,
                     channel: message.p2pCommand.channel,
                     return_code: types_1.ErrorCode.ERROR_CONNECT_TIMEOUT,
-                    customData: message.customData
+                    customData: message.customData,
                 });
                 return;
             }
@@ -674,23 +734,34 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 message.retries++;
             }
             else {
-                logging_1.rootP2PLogger.error(`Max p2p command send retries reached.`, { stationSN: this.rawStation.station_sn, sequence: message.sequence, commandType: message.commandType, channel: message.channel, retries: message.retries, returnCode: message.returnCode });
+                logging_1.rootP2PLogger.error(`Max p2p command send retries reached.`, {
+                    stationSN: this.rawStation.station_sn,
+                    sequence: message.sequence,
+                    commandType: message.commandType,
+                    channel: message.channel,
+                    retries: message.retries,
+                    returnCode: message.returnCode,
+                });
                 this.emit("command", {
                     command_type: message.nestedCommandType !== undefined ? message.nestedCommandType : message.commandType,
                     channel: message.channel,
                     return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
-                    customData: message.customData
+                    customData: message.customData,
                 });
                 if (message.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
-                    (message.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && message.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
+                    (message.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA &&
+                        message.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
                     message.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
-                    (message.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && message.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
-                    if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming && message.channel === this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
+                    (message.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM &&
+                        message.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
+                    if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming &&
+                        message.channel === this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
                         this.endStream(types_1.P2PDataType.VIDEO);
                     }
                 }
                 else if (message.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
-                    if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming && message.channel === this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
+                    if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming &&
+                        message.channel === this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
                         this.endStream(types_1.P2PDataType.BINARY);
                     }
                 }
@@ -712,32 +783,52 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         }, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
         if (messageState.commandType !== types_1.CommandType.CMD_PING) {
             this.p2pSeqMapping.set(this.p2pDataSeqNumber, message.sequence);
-            logging_1.rootP2PLogger.trace(`Added sequence number mapping`, { stationSN: this.rawStation.station_sn, commandType: message.commandType, seqNumber: message.sequence, p2pDataSeqNumber: this.p2pDataSeqNumber, p2pSeqMappingCount: this.p2pSeqMapping.size });
+            logging_1.rootP2PLogger.trace(`Added sequence number mapping`, {
+                stationSN: this.rawStation.station_sn,
+                commandType: message.commandType,
+                seqNumber: message.sequence,
+                p2pDataSeqNumber: this.p2pDataSeqNumber,
+                p2pSeqMappingCount: this.p2pSeqMapping.size,
+            });
             this.p2pDataSeqNumber = this._incrementSequence(this.p2pDataSeqNumber);
         }
-        logging_1.rootP2PLogger.debug("Sending p2p command...", { station: this.rawStation.station_sn, sequence: messageState.sequence, commandType: messageState.commandType, channel: messageState.channel, retries: messageState.retries, messageStatesSize: this.messageStates.size });
+        logging_1.rootP2PLogger.debug("Sending p2p command...", {
+            station: this.rawStation.station_sn,
+            sequence: messageState.sequence,
+            commandType: messageState.commandType,
+            channel: messageState.channel,
+            retries: messageState.retries,
+            messageStatesSize: this.messageStates.size,
+        });
         await this.sendMessage(`Send p2p command`, this.connectAddress, types_1.RequestMessageType.DATA, messageState.data);
         if (messageState.retries === 0) {
             if (messageState.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
-                (messageState.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && messageState.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
+                (messageState.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA &&
+                    messageState.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
                 messageState.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
-                (messageState.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && messageState.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
-                if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming && messageState.channel !== this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
+                (messageState.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM &&
+                    messageState.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
+                if (this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming &&
+                    messageState.channel !== this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel) {
                     this.endStream(types_1.P2PDataType.VIDEO);
                 }
                 this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreaming = true;
                 this.currentMessageState[types_1.P2PDataType.VIDEO].p2pStreamChannel = messageState.channel;
                 this.waitForStreamData(types_1.P2PDataType.VIDEO);
             }
-            else if (messageState.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
-                if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming && messageState.channel !== this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
+            else if (messageState.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO ||
+                (messageState.nestedCommandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO &&
+                    messageState.commandType === types_1.CommandType.CMD_SET_PAYLOAD)) {
+                if (this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming &&
+                    messageState.channel !== this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel) {
                     this.endStream(types_1.P2PDataType.BINARY);
                 }
                 this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming = true;
                 this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel = message.channel;
                 this.waitForStreamData(types_1.P2PDataType.BINARY);
             }
-            else if (messageState.commandType === types_1.CommandType.CMD_STOP_REALTIME_MEDIA) { //TODO: CommandType.CMD_RECORD_PLAY_CTRL only if stop
+            else if (messageState.commandType === types_1.CommandType.CMD_STOP_REALTIME_MEDIA) {
+                //TODO: CommandType.CMD_RECORD_PLAY_CTRL only if stop
                 this.endStream(types_1.P2PDataType.VIDEO);
             }
             else if (messageState.commandType === types_1.CommandType.CMD_DOWNLOAD_CANCEL) {
@@ -759,14 +850,35 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             if (!this.connected) {
                 this._clearLookupTimeout();
                 this._clearLocalLookupRetryTimeout();
-                const p2pDid = `${msg.subarray(4, 12).toString("utf8").replace(/[\0]+$/g, "")}-${msg.subarray(12, 16).readUInt32BE().toString().padStart(6, "0")}-${msg.subarray(16, 24).toString("utf8").replace(/[\0]+$/g, "")}`;
-                logging_1.rootP2PLogger.trace(`Received message - LOCAL_LOOKUP_RESP - Got response`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
+                const p2pDid = `${msg
+                    .subarray(4, 12)
+                    .toString("utf8")
+                    .replace(/[\0]+$/g, "")}-${msg.subarray(12, 16).readUInt32BE().toString().padStart(6, "0")}-${msg
+                    .subarray(16, 24)
+                    .toString("utf8")
+                    .replace(/[\0]+$/g, "")}`;
+                logging_1.rootP2PLogger.trace(`Received message - LOCAL_LOOKUP_RESP - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    ip: rinfo.address,
+                    port: rinfo.port,
+                    p2pDid: p2pDid,
+                });
                 if (p2pDid === this.rawStation.p2p_did) {
-                    logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Wanted device was found, connect to it`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
+                    logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Wanted device was found, connect to it`, {
+                        stationSN: this.rawStation.station_sn,
+                        ip: rinfo.address,
+                        port: rinfo.port,
+                        p2pDid: p2pDid,
+                    });
                     this._connect({ host: rinfo.address, port: rinfo.port }, p2pDid);
                 }
                 else {
-                    logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Unwanted device was found, don't connect to it`, { stationSN: this.rawStation.station_sn, ip: rinfo.address, port: rinfo.port, p2pDid: p2pDid });
+                    logging_1.rootP2PLogger.debug(`Received message - LOCAL_LOOKUP_RESP - Unwanted device was found, don't connect to it`, {
+                        stationSN: this.rawStation.station_sn,
+                        ip: rinfo.address,
+                        port: rinfo.port,
+                        p2pDid: p2pDid,
+                    });
                 }
             }
         }
@@ -774,9 +886,19 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             if (!this.connected) {
                 const port = msg.subarray(6, 8).readUInt16LE();
                 const ip = `${msg[11]}.${msg[10]}.${msg[9]}.${msg[8]}`;
-                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port } });
+                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    response: { ip: ip, port: port },
+                });
                 if (ip === "0.0.0.0") {
-                    logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got invalid ip address 0.0.0.0, ignoring response...`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port } });
+                    logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR - Got invalid ip address 0.0.0.0, ignoring response...`, {
+                        stationSN: this.rawStation.station_sn,
+                        remoteAddress: rinfo.address,
+                        remotePort: rinfo.port,
+                        response: { ip: ip, port: port },
+                    });
                     return;
                 }
                 if ((0, utils_1.isPrivateIp)(ip))
@@ -785,14 +907,22 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     if ((0, utils_1.isPrivateIp)(ip)) {
                         this._clearLookupTimeout();
                         this._clearLookupRetryTimeout();
-                        logging_1.rootP2PLogger.debug(`Trying to connect in ONLY_LOCAL mode...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port });
+                        logging_1.rootP2PLogger.debug(`Trying to connect in ONLY_LOCAL mode...`, {
+                            stationSN: this.rawStation.station_sn,
+                            ip: ip,
+                            port: port,
+                        });
                         this._connect({ host: ip, port: port }, this.rawStation.p2p_did);
                     }
                 }
                 else if (this.connectionType === types_1.P2PConnectionType.QUICKEST) {
                     this._clearLookupTimeout();
                     this._clearLookupRetryTimeout();
-                    logging_1.rootP2PLogger.debug(`Trying to connect in QUICKEST mode...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port });
+                    logging_1.rootP2PLogger.debug(`Trying to connect in QUICKEST mode...`, {
+                        stationSN: this.rawStation.station_sn,
+                        ip: ip,
+                        port: port,
+                    });
                     this._connect({ host: ip, port: port }, this.rawStation.p2p_did);
                 }
             }
@@ -835,15 +965,21 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     const tmpSendQueue = [...this.sendQueue];
                     this.sendQueue = [];
                     this.sendCommandPing(http_1.Station.CHANNEL);
-                    tmpSendQueue.forEach(element => {
+                    tmpSendQueue.forEach((element) => {
                         this.sendQueue.push(element);
                     });
                 }
-                else if (device_1.Device.isLockWifiR10(this.rawStation.device_type) || device_1.Device.isLockWifiR20(this.rawStation.device_type)) {
+                else if (device_1.Device.isLockWifiR10(this.rawStation.device_type) ||
+                    device_1.Device.isLockWifiR20(this.rawStation.device_type)) {
                     const tmpSendQueue = [...this.sendQueue];
                     this.sendQueue = [];
                     const payload = (0, utils_1.buildVoidCommandPayload)(http_1.Station.CHANNEL);
-                    const data = Buffer.concat([(0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO), payload.subarray(0, payload.length - 2), (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2), payload]);
+                    const data = Buffer.concat([
+                        (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO),
+                        payload.subarray(0, payload.length - 2),
+                        (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2),
+                        payload,
+                    ]);
                     const message = {
                         sequence: this.seqNumber,
                         commandType: types_1.CommandType.CMD_PING,
@@ -858,15 +994,24 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
                     this.seqNumber = this._incrementSequence(this.seqNumber);
                     this.sendMessage(`Send lock wifi gateway v12 command to station`, this.connectAddress, types_1.RequestMessageType.DATA, data);
-                    tmpSendQueue.forEach(element => {
+                    tmpSendQueue.forEach((element) => {
                         this.sendQueue.push(element);
                     });
                 }
-                else if (this.rawStation.devices !== undefined && this.rawStation.devices !== null && this.rawStation.devices.length !== undefined && this.rawStation.devices.length > 0 && device_1.Device.isLockWifiVideo(this.rawStation.devices[0]?.device_type)) {
+                else if (this.rawStation.devices !== undefined &&
+                    this.rawStation.devices !== null &&
+                    this.rawStation.devices.length !== undefined &&
+                    this.rawStation.devices.length > 0 &&
+                    device_1.Device.isLockWifiVideo(this.rawStation.devices[0]?.device_type)) {
                     const tmpSendQueue = [...this.sendQueue];
                     this.sendQueue = [];
                     const payload = (0, utils_1.buildVoidCommandPayload)(http_1.Station.CHANNEL);
-                    const data = Buffer.concat([(0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO), payload.subarray(0, payload.length - 2), (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2), payload]);
+                    const data = Buffer.concat([
+                        (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_GATEWAYINFO),
+                        payload.subarray(0, payload.length - 2),
+                        (0, utils_1.buildCommandHeader)(0, types_1.CommandType.CMD_PING).subarray(2),
+                        payload,
+                    ]);
                     const message = {
                         sequence: this.seqNumber,
                         commandType: types_1.CommandType.CMD_PING,
@@ -881,7 +1026,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }, this.RESEND_NOT_ACKNOWLEDGED_COMMAND);
                     this.seqNumber = this._incrementSequence(this.seqNumber);
                     this.sendMessage(`Send lock wifi gateway command to station`, this.connectAddress, types_1.RequestMessageType.DATA, data);
-                    tmpSendQueue.forEach(element => {
+                    tmpSendQueue.forEach((element) => {
                         this.sendQueue.push(element);
                     });
                 }
@@ -889,7 +1034,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     const tmpSendQueue = [...this.sendQueue];
                     this.sendQueue = [];
                     this.sendCommandWithoutData(types_1.CommandType.CMD_GATEWAYINFO, http_1.Station.CHANNEL);
-                    tmpSendQueue.forEach(element => {
+                    tmpSendQueue.forEach((element) => {
                         this.sendQueue.push(element);
                     });
                 }
@@ -916,7 +1061,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         }
         else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.END)) {
             // Connection is closed by device
-            logging_1.rootP2PLogger.debug(`Received message - END`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port });
+            logging_1.rootP2PLogger.debug(`Received message - END`, {
+                stationSN: this.rawStation.station_sn,
+                remoteAddress: rinfo.address,
+                remotePort: rinfo.port,
+            });
             if (this.energySavingDevice && this.connected) {
                 this.closeEnergySavingDevice();
             }
@@ -935,13 +1084,20 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 const seqBuffer = msg.subarray(idx, idx + 2);
                 const ackedSeqNo = seqBuffer.readUIntBE(0, seqBuffer.length);
                 // -> Message with seqNo was received at the station
-                logging_1.rootP2PLogger.trace(`Received message - ACK ${types_1.P2PDataType[dataType]} - sequence ${ackedSeqNo}`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, ackedSeqNo: ackedSeqNo, dataType: types_1.P2PDataType[dataType] });
+                logging_1.rootP2PLogger.trace(`Received message - ACK ${types_1.P2PDataType[dataType]} - sequence ${ackedSeqNo}`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    ackedSeqNo: ackedSeqNo,
+                    dataType: types_1.P2PDataType[dataType],
+                });
                 if (dataType === types_1.P2PDataType.DATA) {
                     const msg_state = this.messageStates.get(ackedSeqNo);
                     if (msg_state && !msg_state.acknowledged) {
                         this._clearTimeout(msg_state.retryTimeout);
                         this._clearTimeout(msg_state.timeout);
-                        if (msg_state.commandType === types_1.CommandType.CMD_PING || msg_state.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
+                        if (msg_state.commandType === types_1.CommandType.CMD_PING ||
+                            msg_state.commandType === types_1.CommandType.CMD_GET_DEVICE_PING) {
                             this.messageStates.delete(ackedSeqNo);
                             this.sendQueuedMessage();
                         }
@@ -950,12 +1106,24 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             msg_state.timeout = setTimeout(() => {
                                 //TODO: Retry command in these case?
                                 if (msg_state.commandType !== types_1.CommandType.CMD_GATEWAYINFO) {
-                                    logging_1.rootP2PLogger.warn(`Result data for command not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data } });
+                                    logging_1.rootP2PLogger.warn(`Result data for command not received`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        message: {
+                                            sequence: msg_state.sequence,
+                                            commandType: msg_state.commandType,
+                                            nestedCommandType: msg_state.nestedCommandType,
+                                            channel: msg_state.channel,
+                                            acknowledged: msg_state.acknowledged,
+                                            retries: msg_state.retries,
+                                            returnCode: msg_state.returnCode,
+                                            data: msg_state.data,
+                                        },
+                                    });
                                     this.emit("command", {
                                         command_type: msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType,
                                         channel: msg_state.channel,
                                         return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
-                                        customData: msg_state.customData
+                                        customData: msg_state.customData,
                                     });
                                 }
                                 else {
@@ -965,11 +1133,25 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                         }
                                     });
                                     this.p2pDataSeqNumber--;
-                                    logging_1.rootP2PLogger.debug(`Result data for command CMD_GATEWAYINFO not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data } });
+                                    logging_1.rootP2PLogger.debug(`Result data for command CMD_GATEWAYINFO not received`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        message: {
+                                            sequence: msg_state.sequence,
+                                            commandType: msg_state.commandType,
+                                            nestedCommandType: msg_state.nestedCommandType,
+                                            channel: msg_state.channel,
+                                            acknowledged: msg_state.acknowledged,
+                                            retries: msg_state.retries,
+                                            returnCode: msg_state.returnCode,
+                                            data: msg_state.data,
+                                        },
+                                    });
                                 }
                                 this.messageStates.delete(ackedSeqNo);
                                 this.sendQueuedMessage();
-                            }, msg_state.commandType !== types_1.CommandType.CMD_GATEWAYINFO ? this.MAX_COMMAND_RESULT_WAIT : this.MAX_GATEWAY_COMMAND_RESULT_WAIT);
+                            }, msg_state.commandType !== types_1.CommandType.CMD_GATEWAYINFO
+                                ? this.MAX_COMMAND_RESULT_WAIT
+                                : this.MAX_GATEWAY_COMMAND_RESULT_WAIT);
                             this.messageStates.set(ackedSeqNo, msg_state);
                             this.sendQueuedMessage();
                         }
@@ -993,10 +1175,16 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     bytesToRead: msg.subarray(2, 4).readUInt16BE(),
                     type: dataType,
                     seqNo: seqNo,
-                    data: msg.subarray(8)
+                    data: msg.subarray(8),
                 };
                 this.sendAck({ host: rinfo.address, port: rinfo.port }, dataTypeBuffer, seqNo);
-                logging_1.rootP2PLogger.debug(`Received message - DATA ${types_1.P2PDataType[message.type]} - Processing sequence ${message.seqNo}...`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo });
+                logging_1.rootP2PLogger.debug(`Received message - DATA ${types_1.P2PDataType[message.type]} - Processing sequence ${message.seqNo}...`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    dataType: types_1.P2PDataType[message.type],
+                    seqNo: message.seqNo,
+                });
                 if (message.seqNo === this.expectedSeqNo[dataType]) {
                     // expected seq packet arrived
                     const timeout = this.currentMessageState[dataType].waitForSeqNoTimeout;
@@ -1006,10 +1194,26 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }
                     this.expectedSeqNo[dataType] = this._incrementSequence(this.expectedSeqNo[dataType]);
                     this.parseDataMessage(message);
-                    logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received expected sequence`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
+                    logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received expected sequence`, {
+                        stationSN: this.rawStation.station_sn,
+                        remoteAddress: rinfo.address,
+                        remotePort: rinfo.port,
+                        dataType: types_1.P2PDataType[message.type],
+                        seqNo: message.seqNo,
+                        expectedSeqNo: this.expectedSeqNo[dataType],
+                        queuedDataSize: this.currentMessageState[dataType].queuedData.size,
+                    });
                     let queuedMessage = this.currentMessageState[dataType].queuedData.get(this.expectedSeqNo[dataType]);
                     while (queuedMessage) {
-                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[queuedMessage.type]} - Work off queued data`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: queuedMessage.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
+                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[queuedMessage.type]} - Work off queued data`, {
+                            stationSN: this.rawStation.station_sn,
+                            remoteAddress: rinfo.address,
+                            remotePort: rinfo.port,
+                            dataType: types_1.P2PDataType[message.type],
+                            seqNo: queuedMessage.seqNo,
+                            expectedSeqNo: this.expectedSeqNo[dataType],
+                            queuedDataSize: this.currentMessageState[dataType].queuedData.size,
+                        });
                         this.expectedSeqNo[dataType] = this._incrementSequence(this.expectedSeqNo[dataType]);
                         this.parseDataMessage(queuedMessage);
                         this.currentMessageState[dataType].queuedData.delete(queuedMessage.seqNo);
@@ -1020,7 +1224,15 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     // We have already seen this message, skip!
                     // This can happen because the device is sending the message till it gets a ACK
                     // which can take some time.
-                    logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received already processed sequence`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
+                    logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received already processed sequence`, {
+                        stationSN: this.rawStation.station_sn,
+                        remoteAddress: rinfo.address,
+                        remotePort: rinfo.port,
+                        dataType: types_1.P2PDataType[message.type],
+                        seqNo: message.seqNo,
+                        expectedSeqNo: this.expectedSeqNo[dataType],
+                        queuedDataSize: this.currentMessageState[dataType].queuedData.size,
+                    });
                     return;
                 }
                 else {
@@ -1031,10 +1243,26 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         }, this.MAX_EXPECTED_SEQNO_WAIT);
                     if (!this.currentMessageState[dataType].queuedData.get(message.seqNo)) {
                         this.currentMessageState[dataType].queuedData.set(message.seqNo, message);
-                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, added to the queue for future processing`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
+                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, added to the queue for future processing`, {
+                            stationSN: this.rawStation.station_sn,
+                            remoteAddress: rinfo.address,
+                            remotePort: rinfo.port,
+                            dataType: types_1.P2PDataType[message.type],
+                            seqNo: message.seqNo,
+                            expectedSeqNo: this.expectedSeqNo[dataType],
+                            queuedDataSize: this.currentMessageState[dataType].queuedData.size,
+                        });
                     }
                     else {
-                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, discarded since already present in queue for future processing`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, dataType: types_1.P2PDataType[message.type], seqNo: message.seqNo, expectedSeqNo: this.expectedSeqNo[dataType], queuedDataSize: this.currentMessageState[dataType].queuedData.size });
+                        logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, discarded since already present in queue for future processing`, {
+                            stationSN: this.rawStation.station_sn,
+                            remoteAddress: rinfo.address,
+                            remotePort: rinfo.port,
+                            dataType: types_1.P2PDataType[message.type],
+                            seqNo: message.seqNo,
+                            expectedSeqNo: this.expectedSeqNo[dataType],
+                            queuedDataSize: this.currentMessageState[dataType].queuedData.size,
+                        });
                     }
                 }
             }
@@ -1047,8 +1275,18 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 this._clearLookupTimeout();
                 this._clearLookupRetryTimeout();
                 this._clearLookup2RetryTimeout();
-                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR2 - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { ip: ip, port: port, data: data.toString("hex") } });
-                logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port, data: data.toString("hex") });
+                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_ADDR2 - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    response: { ip: ip, port: port, data: data.toString("hex") },
+                });
+                logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, {
+                    stationSN: this.rawStation.station_sn,
+                    ip: ip,
+                    port: port,
+                    data: data.toString("hex"),
+                });
                 for (let i = 0; i < 4; i++)
                     this.sendCamCheck2({ host: ip, port: port }, data);
                 this._startConnectTimeout();
@@ -1060,7 +1298,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         }
         else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_OK)) {
             if (!this.connected && !this.p2pTurnConfirmed) {
-                logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_OK - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { message: msg.toString("hex"), length: msg.length } });
+                logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_OK - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    response: { message: msg.toString("hex"), length: msg.length },
+                });
                 this.sendMessage(`Send TURN_CLIENT_OK`, { host: rinfo.address, port: rinfo.port }, types_1.RequestMessageType.TURN_CLIENT_OK);
                 this.p2pTurnConfirmed = true;
             }
@@ -1070,29 +1313,59 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 const ip = `${msg[7]}.${msg[6]}.${msg[5]}.${msg[4]}`;
                 const port = msg.subarray(8, 10).readUInt16BE();
                 const binaryIP = msg.subarray(4, 8);
-                logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, { stationSN: this.rawStation.station_sn, ip: ip, port: port, binaryIP: binaryIP.toString("hex") });
+                logging_1.rootP2PLogger.debug(`Connecting to host ${ip} on port ${port} (CHECK_CAM2)...`, {
+                    stationSN: this.rawStation.station_sn,
+                    ip: ip,
+                    port: port,
+                    binaryIP: binaryIP.toString("hex"),
+                });
                 for (let i = 0; i < 4; i++)
                     this.sendCamCheck2({ host: rinfo.address, port: port }, binaryIP);
-                logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_TOKEN - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { port: port, binaryIP: binaryIP.toString("hex") } });
+                logging_1.rootP2PLogger.trace(`Received message - TURN_SERVER_TOKEN - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    response: { port: port, binaryIP: binaryIP.toString("hex") },
+                });
                 this.cloudLookupWithTurnServer({ host: rinfo.address, port: port }, binaryIP);
             }
         }
-        else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LOOKUP_OK) || (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.UNKNOWN_83) || (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LIST)) {
+        else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LOOKUP_OK) ||
+            (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.UNKNOWN_83) ||
+            (0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.TURN_SERVER_LIST)) {
             // Do nothing / ignore
         }
         else if ((0, utils_1.hasHeader)(msg, types_1.ResponseMessageType.LOOKUP_RESP)) {
             if (!this.connected) {
                 const responseCode = msg.subarray(4, 6).readUInt16LE();
-                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_RESP - Got response`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { responseCode: responseCode } });
+                logging_1.rootP2PLogger.trace(`Received message - LOOKUP_RESP - Got response`, {
+                    stationSN: this.rawStation.station_sn,
+                    remoteAddress: rinfo.address,
+                    remotePort: rinfo.port,
+                    response: { responseCode: responseCode },
+                });
             }
         }
         else {
-            logging_1.rootP2PLogger.debug(`Received unknown message`, { stationSN: this.rawStation.station_sn, remoteAddress: rinfo.address, remotePort: rinfo.port, response: { message: msg.toString("hex"), length: msg.length } });
+            logging_1.rootP2PLogger.debug(`Received unknown message`, {
+                stationSN: this.rawStation.station_sn,
+                remoteAddress: rinfo.address,
+                remotePort: rinfo.port,
+                response: { message: msg.toString("hex"), length: msg.length },
+            });
         }
     }
     parseDataMessage(message) {
-        if ((message.type === types_1.P2PDataType.BINARY || message.type === types_1.P2PDataType.VIDEO) && !this.currentMessageState[message.type].p2pStreaming) {
-            logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Stream not started ignore this data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: message.bytesToRead, messageSize: message.data.length });
+        if ((message.type === types_1.P2PDataType.BINARY || message.type === types_1.P2PDataType.VIDEO) &&
+            !this.currentMessageState[message.type].p2pStreaming) {
+            logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Stream not started ignore this data`, {
+                stationSN: this.rawStation.station_sn,
+                seqNo: message.seqNo,
+                header: this.currentMessageBuilder[message.type].header,
+                bytesRead: this.currentMessageBuilder[message.type].bytesRead,
+                bytesToRead: message.bytesToRead,
+                messageSize: message.data.length,
+            });
         }
         else {
             if (this.currentMessageState[message.type].leftoverData.length > 0) {
@@ -1110,7 +1383,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         bytesToRead: 0,
                         channel: 0,
                         signCode: 0,
-                        type: 0
+                        type: 0,
                     };
                     header.commandId = data.subarray(4, 6).readUIntLE(0, 2);
                     header.bytesToRead = data.subarray(6, 10).readUIntLE(0, 4);
@@ -1142,12 +1415,23 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 }
                 else {
                     // finish message and print
-                    if (this.currentMessageBuilder[message.type].header.bytesToRead - this.currentMessageBuilder[message.type].bytesRead === 0 && data.length > this.P2P_DATA_HEADER_BYTES) {
-                        logging_1.rootP2PLogger.debug(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Discarding unexpected data (infinite loop prevention)`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, dataSize: data.length, data: data.toString("hex") });
+                    if (this.currentMessageBuilder[message.type].header.bytesToRead -
+                        this.currentMessageBuilder[message.type].bytesRead ===
+                        0 &&
+                        data.length > this.P2P_DATA_HEADER_BYTES) {
+                        logging_1.rootP2PLogger.debug(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Discarding unexpected data (infinite loop prevention)`, {
+                            stationSN: this.rawStation.station_sn,
+                            seqNo: message.seqNo,
+                            dataSize: data.length,
+                            data: data.toString("hex"),
+                        });
                         data = Buffer.from([]);
                     }
-                    else if (this.currentMessageBuilder[message.type].header.bytesToRead - this.currentMessageBuilder[message.type].bytesRead <= data.length) {
-                        const payload = data.subarray(0, this.currentMessageBuilder[message.type].header.bytesToRead - this.currentMessageBuilder[message.type].bytesRead);
+                    else if (this.currentMessageBuilder[message.type].header.bytesToRead -
+                        this.currentMessageBuilder[message.type].bytesRead <=
+                        data.length) {
+                        const payload = data.subarray(0, this.currentMessageBuilder[message.type].header.bytesToRead -
+                            this.currentMessageBuilder[message.type].bytesRead);
                         this.currentMessageBuilder[message.type].messages[message.seqNo] = payload;
                         this.currentMessageBuilder[message.type].bytesRead += payload.byteLength;
                         data = data.subarray(payload.byteLength);
@@ -1167,26 +1451,54 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         data = Buffer.from([]);
                     }
                 }
-                logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Received data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead, firstPartMessage: firstPartMessage, messageSize: message.data.length, runaway_limit: runaway_limit });
-                if (this.currentMessageBuilder[message.type].bytesRead === this.currentMessageBuilder[message.type].header.bytesToRead) {
+                logging_1.rootP2PLogger.trace(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Received data`, {
+                    stationSN: this.rawStation.station_sn,
+                    seqNo: message.seqNo,
+                    header: this.currentMessageBuilder[message.type].header,
+                    bytesRead: this.currentMessageBuilder[message.type].bytesRead,
+                    bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead,
+                    firstPartMessage: firstPartMessage,
+                    messageSize: message.data.length,
+                    runaway_limit: runaway_limit,
+                });
+                if (this.currentMessageBuilder[message.type].bytesRead ===
+                    this.currentMessageBuilder[message.type].header.bytesToRead) {
                     const completeMessage = (0, utils_1.sortP2PMessageParts)(this.currentMessageBuilder[message.type].messages);
                     const data_message = {
                         ...this.currentMessageBuilder[message.type].header,
-                        seqNo: (message.seqNo + this.offsetDataSeqNumber),
+                        seqNo: message.seqNo + this.offsetDataSeqNumber,
                         dataType: message.type,
-                        data: completeMessage
+                        data: completeMessage,
                     };
                     this.handleData(data_message);
                     this.initializeMessageBuilder(message.type);
                     if (data.length > 0 && message.type === types_1.P2PDataType.DATA) {
-                        logging_1.rootP2PLogger.debug(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Parsed data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, data_message: data_message, datalen: data.length, data: data.toString("hex"), offsetDataSeqNumber: this.offsetDataSeqNumber, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber });
+                        logging_1.rootP2PLogger.debug(`Parsing message - DATA ${types_1.P2PDataType[message.type]} - Parsed data`, {
+                            stationSN: this.rawStation.station_sn,
+                            seqNo: message.seqNo,
+                            data_message: data_message,
+                            datalen: data.length,
+                            data: data.toString("hex"),
+                            offsetDataSeqNumber: this.offsetDataSeqNumber,
+                            seqNumber: this.seqNumber,
+                            p2pDataSeqNumber: this.p2pDataSeqNumber,
+                        });
                         this.offsetDataSeqNumber++;
                     }
                 }
                 runaway_limit++;
-            } while ((data.length > 0) && (runaway_limit < this.LOOP_RUNAWAY_LIMIT));
+            } while (data.length > 0 && runaway_limit < this.LOOP_RUNAWAY_LIMIT);
             if (runaway_limit >= this.LOOP_RUNAWAY_LIMIT) {
-                logging_1.rootP2PLogger.warn(`Infinite loop detected (limit >= ${this.LOOP_RUNAWAY_LIMIT}) during parsing of p2p message`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, dataType: types_1.P2PDataType[message.type], header: this.currentMessageBuilder[message.type].header, bytesRead: this.currentMessageBuilder[message.type].bytesRead, bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead, message: message.data.toString("hex"), messageSize: message.data.length });
+                logging_1.rootP2PLogger.warn(`Infinite loop detected (limit >= ${this.LOOP_RUNAWAY_LIMIT}) during parsing of p2p message`, {
+                    stationSN: this.rawStation.station_sn,
+                    seqNo: message.seqNo,
+                    dataType: types_1.P2PDataType[message.type],
+                    header: this.currentMessageBuilder[message.type].header,
+                    bytesRead: this.currentMessageBuilder[message.type].bytesRead,
+                    bytesToRead: this.currentMessageBuilder[message.type].header.bytesToRead,
+                    message: message.data.toString("hex"),
+                    messageSize: message.data.length,
+                });
                 this.initializeMessageBuilder(message.type);
             }
         }
@@ -1202,33 +1514,91 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 let return_code = 0;
                 let resultData;
                 if (message.bytesToRead > 0) {
-                    if (message.signCode > 0) {
-                        try {
-                            message.data = (0, utils_1.decryptP2PData)(message.data, this.p2pKey);
+                    if (message.signCode > 0 && message.data.length > 0) {
+                        if (message.data.length % 16 === 0) {
+                            try {
+                                message.data = (0, utils_1.decryptP2PData)(message.data, this.p2pKey);
+                            }
+                            catch (err) {
+                                const error = (0, error_1.ensureError)(err);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, {
+                                    error: (0, utils_3.getError)(error),
+                                    stationSN: this.rawStation.station_sn,
+                                    message: {
+                                        seqNo: message.seqNo,
+                                        channel: message.channel,
+                                        commandType: types_1.CommandType[message.commandId],
+                                        signCode: message.signCode,
+                                        type: message.type,
+                                        dataType: types_1.P2PDataType[message.dataType],
+                                        data: message.data.toString("hex"),
+                                    },
+                                });
+                            }
                         }
-                        catch (err) {
-                            const error = (0, error_1.ensureError)(err);
-                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        else {
+                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Skipping decryption, data not block-aligned`, {
+                                stationSN: this.rawStation.station_sn,
+                                seqNo: message.seqNo,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                dataLength: message.data.length,
+                                mod16: message.data.length % 16,
+                            });
                         }
                     }
                     return_code = message.data.subarray(0, 4).readUInt32LE() | 0;
                     resultData = message.data.subarray(4);
                 }
                 const error_codeStr = types_1.ErrorCode[return_code];
-                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, { stationSN: this.rawStation.station_sn, seqNo: message.seqNo, commandIdName: commandStr, commandId: message.commandId, resultCodeName: error_codeStr, resultCode: return_code, resultData: resultData?.toString("hex"), data: message.data.toString("hex"), seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber });
+                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, {
+                    stationSN: this.rawStation.station_sn,
+                    seqNo: message.seqNo,
+                    commandIdName: commandStr,
+                    commandId: message.commandId,
+                    resultCodeName: error_codeStr,
+                    resultCode: return_code,
+                    resultData: resultData?.toString("hex"),
+                    data: message.data.toString("hex"),
+                    seqNumber: this.seqNumber,
+                    p2pDataSeqNumber: this.p2pDataSeqNumber,
+                    offsetDataSeqNumber: this.offsetDataSeqNumber,
+                });
                 let msg_state = this.messageStates.get(message.seqNo);
                 const goodSeqNumber = this.p2pSeqMapping.get(message.seqNo);
                 if (goodSeqNumber) {
                     this.p2pSeqMapping.delete(message.seqNo);
                     msg_state = this.messageStates.get(goodSeqNumber);
-                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data received - Detecting correct sequence number`, { stationSN: this.rawStation.station_sn, commandIdName: commandStr, commandId: message.commandId, seqNumber: message.seqNo, newSeqNumber: goodSeqNumber, p2pSeqMappingCount: this.p2pSeqMapping.size });
+                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data received - Detecting correct sequence number`, {
+                        stationSN: this.rawStation.station_sn,
+                        commandIdName: commandStr,
+                        commandId: message.commandId,
+                        seqNumber: message.seqNo,
+                        newSeqNumber: goodSeqNumber,
+                        p2pSeqMappingCount: this.p2pSeqMapping.size,
+                    });
                     message.seqNo = goodSeqNumber;
                 }
                 if (msg_state) {
                     if (msg_state.commandType === message.commandId) {
                         this._clearTimeout(msg_state.timeout);
                         const command_type = msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType;
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for command received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: return_code, data: msg_state.data, customData: msg_state.customData }, resultCodeName: error_codeStr, resultCode: return_code });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for command received`, {
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                sequence: msg_state.sequence,
+                                commandType: msg_state.commandType,
+                                nestedCommandType: msg_state.nestedCommandType,
+                                channel: msg_state.channel,
+                                acknowledged: msg_state.acknowledged,
+                                retries: msg_state.retries,
+                                returnCode: return_code,
+                                data: msg_state.data,
+                                customData: msg_state.customData,
+                            },
+                            resultCodeName: error_codeStr,
+                            resultCode: return_code,
+                        });
                         if (return_code === types_1.ErrorCode.ERROR_FAILED_TO_REQUEST) {
                             msg_state.returnCode = return_code;
                             this._sendCommand(msg_state);
@@ -1239,11 +1609,13 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     command_type: command_type,
                                     channel: msg_state.channel,
                                     return_code: return_code,
-                                    customData: msg_state.customData
+                                    customData: msg_state.customData,
                                 });
                             }
                             this.messageStates.delete(message.seqNo);
-                            if (command_type === types_1.CommandType.CMD_SMARTSAFE_SETTINGS || command_type === types_1.CommandType.CMD_SET_PAYLOAD_LOCKV12 || command_type === types_1.CommandType.CMD_TRANSFER_PAYLOAD) {
+                            if (command_type === types_1.CommandType.CMD_SMARTSAFE_SETTINGS ||
+                                command_type === types_1.CommandType.CMD_SET_PAYLOAD_LOCKV12 ||
+                                command_type === types_1.CommandType.CMD_TRANSFER_PAYLOAD) {
                                 if (msg_state.customData) {
                                     for (const index of Object.keys(this.customDataStaging)) {
                                         const id = Number.parseInt(index);
@@ -1251,20 +1623,39 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                             delete this.customDataStaging[id];
                                         }
                                     }
-                                    this.customDataStaging[msg_state.nestedCommandType2 ? msg_state.nestedCommandType2 : msg_state.nestedCommandType ? msg_state.nestedCommandType : msg_state.commandType] = {
+                                    this.customDataStaging[msg_state.nestedCommandType2
+                                        ? msg_state.nestedCommandType2
+                                        : msg_state.nestedCommandType
+                                            ? msg_state.nestedCommandType
+                                            : msg_state.commandType] = {
                                         channel: msg_state.channel,
                                         customData: msg_state.customData,
                                         timestamp: new Date().getTime(),
                                     };
                                 }
                                 this.secondaryCommandTimeout = setTimeout(() => {
-                                    logging_1.rootP2PLogger.warn(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for secondary command not received`, { stationSN: this.rawStation.station_sn, message: { sequence: msg_state.sequence, commandType: msg_state.commandType, nestedCommandType: msg_state.nestedCommandType, channel: msg_state.channel, acknowledged: msg_state.acknowledged, retries: msg_state.retries, returnCode: msg_state.returnCode, data: msg_state.data, customData: msg_state.customData } });
+                                    logging_1.rootP2PLogger.warn(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Result data for secondary command not received`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        message: {
+                                            sequence: msg_state.sequence,
+                                            commandType: msg_state.commandType,
+                                            nestedCommandType: msg_state.nestedCommandType,
+                                            channel: msg_state.channel,
+                                            acknowledged: msg_state.acknowledged,
+                                            retries: msg_state.retries,
+                                            returnCode: msg_state.returnCode,
+                                            data: msg_state.data,
+                                            customData: msg_state.customData,
+                                        },
+                                    });
                                     this.secondaryCommandTimeout = undefined;
                                     this.emit("secondary command", {
-                                        command_type: msg_state.nestedCommandType !== undefined ? msg_state.nestedCommandType : msg_state.commandType,
+                                        command_type: msg_state.nestedCommandType !== undefined
+                                            ? msg_state.nestedCommandType
+                                            : msg_state.commandType,
                                         channel: msg_state.channel,
                                         return_code: types_1.ErrorCode.ERROR_COMMAND_TIMEOUT,
-                                        customData: msg_state.customData
+                                        customData: msg_state.customData,
                                     });
                                     this._clearESDDisconnectTimeout();
                                     this.sendQueuedMessage();
@@ -1275,29 +1666,41 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 this.sendQueuedMessage();
                             }
                             if (msg_state.commandType === types_1.CommandType.CMD_START_REALTIME_MEDIA ||
-                                (msg_state.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA && msg_state.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
+                                (msg_state.nestedCommandType === types_1.CommandType.CMD_START_REALTIME_MEDIA &&
+                                    msg_state.commandType === types_1.CommandType.CMD_SET_PAYLOAD) ||
                                 msg_state.commandType === types_1.CommandType.CMD_RECORD_VIEW ||
-                                (msg_state.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM && msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
+                                (msg_state.nestedCommandType === http_1.ParamType.COMMAND_START_LIVESTREAM &&
+                                    msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD)) {
                                 this.waitForStreamData(types_1.P2PDataType.VIDEO, true);
                             }
                             else if (msg_state.commandType === types_1.CommandType.CMD_DOWNLOAD_VIDEO) {
                                 this.waitForStreamData(types_1.P2PDataType.BINARY, true);
                             }
-                            else if (msg_state.commandType === types_1.CommandType.CMD_START_TALKBACK || (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD && msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_START_SPEAK)) {
+                            else if (msg_state.commandType === types_1.CommandType.CMD_START_TALKBACK ||
+                                (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD &&
+                                    msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_START_SPEAK)) {
                                 if (return_code === types_1.ErrorCode.ERROR_PPCS_SUCCESSFUL) {
                                     this.startTalkback(msg_state.channel);
                                 }
                                 else if (return_code === types_1.ErrorCode.ERROR_NOT_FIND_DEV) {
-                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Someone is responding now.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
+                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Someone is responding now.", {
+                                        context: { station: this.rawStation.station_sn, channel: msg_state.channel },
+                                    }));
                                 }
                                 else if (return_code === types_1.ErrorCode.ERROR_DEV_BUSY) {
-                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Wait a second, device is busy.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
+                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Wait a second, device is busy.", {
+                                        context: { station: this.rawStation.station_sn, channel: msg_state.channel },
+                                    }));
                                 }
                                 else {
-                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Connect failed please try again later.", { context: { station: this.rawStation.station_sn, channel: msg_state.channel } }));
+                                    this.emit("talkback error", msg_state.channel, new error_1.TalkbackError("Connect failed please try again later.", {
+                                        context: { station: this.rawStation.station_sn, channel: msg_state.channel },
+                                    }));
                                 }
                             }
-                            else if (msg_state.commandType === types_1.CommandType.CMD_STOP_TALKBACK || (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD && msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_END_SPEAK)) {
+                            else if (msg_state.commandType === types_1.CommandType.CMD_STOP_TALKBACK ||
+                                (msg_state.commandType === types_1.CommandType.CMD_DOORBELL_SET_PAYLOAD &&
+                                    msg_state.nestedCommandType === types_1.IndoorSoloSmartdropCommandType.CMD_END_SPEAK)) {
                                 this.stopTalkback(msg_state.channel);
                             }
                             else if (msg_state.commandType === types_1.CommandType.CMD_SDINFO_EX && resultData && resultData.length >= 8) {
@@ -1311,31 +1714,90 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }
                     else {
                         this.messageStates.delete(message.seqNo);
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Expected different command type for received sequencenumber!`, { stationSN: this.rawStation.station_sn, msg_sequence: msg_state.sequence, msg_channel: msg_state.channel, msg_commandType: msg_state.commandType, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber, message: { seqNo: message.seqNo, commandType: types_1.CommandType[message.commandId], channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Expected different command type for received sequencenumber!`, {
+                            stationSN: this.rawStation.station_sn,
+                            msg_sequence: msg_state.sequence,
+                            msg_channel: msg_state.channel,
+                            msg_commandType: msg_state.commandType,
+                            seqNumber: this.seqNumber,
+                            p2pDataSeqNumber: this.p2pDataSeqNumber,
+                            offsetDataSeqNumber: this.offsetDataSeqNumber,
+                            message: {
+                                seqNo: message.seqNo,
+                                commandType: types_1.CommandType[message.commandId],
+                                channel: message.channel,
+                                signCode: message.signCode,
+                                data: message.data.toString("hex"),
+                            },
+                        });
                         logging_1.rootP2PLogger.warn(`P2P protocol instability detected for station ${this.rawStation.station_sn}. Please reinitialise the connection to solve the problem!`);
                     }
                 }
-                else if (message.commandId !== types_1.CommandType.CMD_PING && message.commandId !== types_1.CommandType.CMD_GET_DEVICE_PING && message.commandId !== types_1.CommandType.CMD_GATEWAYINFO) {
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received unexpected data!`, { stationSN: this.rawStation.station_sn, seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber, message: { seqNo: message.seqNo, commandType: types_1.CommandType[message.commandId], channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
+                else if (message.commandId !== types_1.CommandType.CMD_PING &&
+                    message.commandId !== types_1.CommandType.CMD_GET_DEVICE_PING &&
+                    message.commandId !== types_1.CommandType.CMD_GATEWAYINFO) {
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received unexpected data!`, {
+                        stationSN: this.rawStation.station_sn,
+                        seqNumber: this.seqNumber,
+                        p2pDataSeqNumber: this.p2pDataSeqNumber,
+                        offsetDataSeqNumber: this.offsetDataSeqNumber,
+                        message: {
+                            seqNo: message.seqNo,
+                            commandType: types_1.CommandType[message.commandId],
+                            channel: message.channel,
+                            signCode: message.signCode,
+                            data: message.data.toString("hex"),
+                        },
+                    });
                 }
             }
             else {
-                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Unsupported response`, { stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, commandType: message.commandId, channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
+                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Unsupported response`, {
+                    stationSN: this.rawStation.station_sn,
+                    message: {
+                        seqNo: message.seqNo,
+                        commandType: message.commandId,
+                        channel: message.channel,
+                        signCode: message.signCode,
+                        data: message.data.toString("hex"),
+                    },
+                });
             }
         }
         else if (message.dataType === types_1.P2PDataType.VIDEO || message.dataType === types_1.P2PDataType.BINARY) {
             this.handleDataBinaryAndVideo(message);
         }
         else {
-            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented data type`, { stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, commandType: message.commandId, channel: message.channel, signCode: message.signCode, data: message.data.toString("hex") } });
+            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented data type`, {
+                stationSN: this.rawStation.station_sn,
+                message: {
+                    seqNo: message.seqNo,
+                    commandType: message.commandId,
+                    channel: message.channel,
+                    signCode: message.signCode,
+                    data: message.data.toString("hex"),
+                },
+            });
         }
     }
     isIFrame(data, isKeyFrame) {
-        if (this.rawStation.station_sn.startsWith("T8410") || this.rawStation.station_sn.startsWith("T8400") || this.rawStation.station_sn.startsWith("T8401") || this.rawStation.station_sn.startsWith("T8411") ||
-            this.rawStation.station_sn.startsWith("T8202") || this.rawStation.station_sn.startsWith("T8422") || this.rawStation.station_sn.startsWith("T8424") || this.rawStation.station_sn.startsWith("T8423") ||
-            this.rawStation.station_sn.startsWith("T8130") || this.rawStation.station_sn.startsWith("T8131") || this.rawStation.station_sn.startsWith("T8420") || this.rawStation.station_sn.startsWith("T8440") ||
-            this.rawStation.station_sn.startsWith("T8171") || this.rawStation.station_sn.startsWith("T8426") ||
-            this.rawStation.station_sn.startsWith("T8441") || this.rawStation.station_sn.startsWith("T8442") || (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
+        if (this.rawStation.station_sn.startsWith("T8410") ||
+            this.rawStation.station_sn.startsWith("T8400") ||
+            this.rawStation.station_sn.startsWith("T8401") ||
+            this.rawStation.station_sn.startsWith("T8411") ||
+            this.rawStation.station_sn.startsWith("T8202") ||
+            this.rawStation.station_sn.startsWith("T8422") ||
+            this.rawStation.station_sn.startsWith("T8424") ||
+            this.rawStation.station_sn.startsWith("T8423") ||
+            this.rawStation.station_sn.startsWith("T8130") ||
+            this.rawStation.station_sn.startsWith("T8131") ||
+            this.rawStation.station_sn.startsWith("T8420") ||
+            this.rawStation.station_sn.startsWith("T8440") ||
+            this.rawStation.station_sn.startsWith("T8171") ||
+            this.rawStation.station_sn.startsWith("T8426") ||
+            this.rawStation.station_sn.startsWith("T8441") ||
+            this.rawStation.station_sn.startsWith("T8442") ||
+            (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
             //TODO: Need to add battery doorbells as seen in source => T8210,T8220,T8221,T8222
             return isKeyFrame;
         }
@@ -1368,7 +1830,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         videoHeight: 1080,
                         videoTimestamp: 0,
                         videoDataLength: 0,
-                        aesKey: ""
+                        aesKey: "",
                     };
                     const data_length = message.data.readUInt32LE();
                     const isKeyFrame = message.data.subarray(4, 5).readUInt8() === 1 ? true : false;
@@ -1386,13 +1848,22 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         if (rsaKey) {
                             try {
                                 videoMetaData.aesKey = rsaKey.decrypt(key).toString("hex");
-                                logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypted AES key`, { stationSN: this.rawStation.station_sn, key: videoMetaData.aesKey });
+                                logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypted AES key`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    key: videoMetaData.aesKey,
+                                });
                             }
                             catch (err) {
                                 const error = (0, error_1.ensureError)(err);
-                                logging_1.rootP2PLogger.warn(`Error: AES key could not be decrypted! The entire stream is discarded.`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, key: key.toString("hex") });
+                                logging_1.rootP2PLogger.warn(`Error: AES key could not be decrypted! The entire stream is discarded.`, {
+                                    error: (0, utils_3.getError)(error),
+                                    stationSN: this.rawStation.station_sn,
+                                    key: key.toString("hex"),
+                                });
                                 this.currentMessageState[message.dataType].invalidStream = true;
-                                this.emit("livestream error", message.channel, new error_1.LivestreamError("Station AES key could not be decrypted! The entire stream is discarded.", { context: { station: this.rawStation.station_sn } }));
+                                this.emit("livestream error", message.channel, new error_1.LivestreamError("Station AES key could not be decrypted! The entire stream is discarded.", {
+                                    context: { station: this.rawStation.station_sn },
+                                }));
                                 return;
                             }
                         }
@@ -1413,36 +1884,93 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     else {
                         video_data = message.data.subarray(payloadStart, payloadStart + videoMetaData.videoDataLength);
                     }
-                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME`, { stationSN: this.rawStation.station_sn, dataSize: message.data.length, metadata: videoMetaData, videoDataSize: video_data.length });
+                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME`, {
+                        stationSN: this.rawStation.station_sn,
+                        dataSize: message.data.length,
+                        metadata: videoMetaData,
+                        videoDataSize: video_data.length,
+                    });
                     this.currentMessageState[message.dataType].p2pStreamMetadata.videoFPS = videoMetaData.videoFPS;
                     this.currentMessageState[message.dataType].p2pStreamMetadata.videoHeight = videoMetaData.videoHeight;
                     this.currentMessageState[message.dataType].p2pStreamMetadata.videoWidth = videoMetaData.videoWidth;
                     if (!this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
-                        if (this.rawStation.station_sn.startsWith("T8410") || this.rawStation.station_sn.startsWith("T8400") || this.rawStation.station_sn.startsWith("T8401") || this.rawStation.station_sn.startsWith("T8411") ||
-                            this.rawStation.station_sn.startsWith("T8202") || this.rawStation.station_sn.startsWith("T8422") || this.rawStation.station_sn.startsWith("T8424") || this.rawStation.station_sn.startsWith("T8423") ||
-                            this.rawStation.station_sn.startsWith("T8130") || this.rawStation.station_sn.startsWith("T8131") || this.rawStation.station_sn.startsWith("T8420") || this.rawStation.station_sn.startsWith("T8440") ||
-                            this.rawStation.station_sn.startsWith("T8171") || this.rawStation.station_sn.startsWith("T8426") ||
-                            this.rawStation.station_sn.startsWith("T8441") || this.rawStation.station_sn.startsWith("T8442") || (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
-                            this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = videoMetaData.streamType === 1 ? types_1.VideoCodec.H264 : videoMetaData.streamType === 2 ? types_1.VideoCodec.H265 : (0, utils_1.getVideoCodec)(video_data);
-                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec information received from packet`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
+                        if (this.rawStation.station_sn.startsWith("T8410") ||
+                            this.rawStation.station_sn.startsWith("T8400") ||
+                            this.rawStation.station_sn.startsWith("T8401") ||
+                            this.rawStation.station_sn.startsWith("T8411") ||
+                            this.rawStation.station_sn.startsWith("T8202") ||
+                            this.rawStation.station_sn.startsWith("T8422") ||
+                            this.rawStation.station_sn.startsWith("T8424") ||
+                            this.rawStation.station_sn.startsWith("T8423") ||
+                            this.rawStation.station_sn.startsWith("T8130") ||
+                            this.rawStation.station_sn.startsWith("T8131") ||
+                            this.rawStation.station_sn.startsWith("T8420") ||
+                            this.rawStation.station_sn.startsWith("T8440") ||
+                            this.rawStation.station_sn.startsWith("T8171") ||
+                            this.rawStation.station_sn.startsWith("T8426") ||
+                            this.rawStation.station_sn.startsWith("T8441") ||
+                            this.rawStation.station_sn.startsWith("T8442") ||
+                            (0, utils_1.checkT8420)(this.rawStation.station_sn)) {
+                            this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec =
+                                videoMetaData.streamType === 1
+                                    ? types_1.VideoCodec.H264
+                                    : videoMetaData.streamType === 2
+                                        ? types_1.VideoCodec.H265
+                                        : (0, utils_1.getVideoCodec)(video_data);
+                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec information received from packet`, {
+                                stationSN: this.rawStation.station_sn,
+                                commandIdName: types_1.CommandType[message.commandId],
+                                commandId: message.commandId,
+                                channel: message.channel,
+                                metadata: videoMetaData,
+                            });
                         }
                         else if (this.isIFrame(video_data, isKeyFrame)) {
                             this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = (0, utils_1.getVideoCodec)(video_data);
-                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec extracted from video data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
+                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Video codec extracted from video data`, {
+                                stationSN: this.rawStation.station_sn,
+                                commandIdName: types_1.CommandType[message.commandId],
+                                commandId: message.commandId,
+                                channel: message.channel,
+                                metadata: videoMetaData,
+                            });
                         }
                         else {
                             this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = (0, utils_1.getVideoCodec)(video_data);
                             if (this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec === types_1.VideoCodec.UNKNOWN) {
-                                this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec = videoMetaData.streamType === 1 ? types_1.VideoCodec.H264 : videoMetaData.streamType === 2 ? types_1.VideoCodec.H265 : types_1.VideoCodec.UNKNOWN;
+                                this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec =
+                                    videoMetaData.streamType === 1
+                                        ? types_1.VideoCodec.H264
+                                        : videoMetaData.streamType === 2
+                                            ? types_1.VideoCodec.H265
+                                            : types_1.VideoCodec.UNKNOWN;
                                 if (this.currentMessageState[message.dataType].p2pStreamMetadata.videoCodec === types_1.VideoCodec.UNKNOWN) {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Unknown video codec`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Unknown video codec`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[message.commandId],
+                                        commandId: message.commandId,
+                                        channel: message.channel,
+                                        metadata: videoMetaData,
+                                    });
                                 }
                                 else {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, using video codec information received from packet`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, using video codec information received from packet`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[message.commandId],
+                                        commandId: message.commandId,
+                                        channel: message.channel,
+                                        metadata: videoMetaData,
+                                    });
                                 }
                             }
                             else {
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, video codec extracted from video data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, metadata: videoMetaData });
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME - Fallback, video codec extracted from video data`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    commandIdName: types_1.CommandType[message.commandId],
+                                    commandId: message.commandId,
+                                    channel: message.channel,
+                                    metadata: videoMetaData,
+                                });
                             }
                         }
                         this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived = true;
@@ -1451,20 +1979,27 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 this.currentMessageState[message.dataType].waitForAudioData = undefined;
                                 this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec = types_1.AudioCodec.NONE;
                                 this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived = true;
-                                if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived && this.currentMessageState[message.dataType].p2pStreamNotStarted) {
+                                if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived &&
+                                    this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived &&
+                                    this.currentMessageState[message.dataType].p2pStreamNotStarted) {
                                     this.emitStreamStartEvent(message.dataType);
                                 }
                             }, this.AUDIO_CODEC_ANALYZE_TIMEOUT);
                         }
                     }
                     if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
-                        if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
+                        if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived &&
+                            this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
                             this.emitStreamStartEvent(message.dataType);
                         }
                     }
                     if (message.dataType === types_1.P2PDataType.VIDEO) {
                         if ((0, utils_1.findStartCode)(video_data)) {
-                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: startcode found`, { stationSN: this.rawStation.station_sn, isKeyFrame: isKeyFrame, preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length });
+                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: startcode found`, {
+                                stationSN: this.rawStation.station_sn,
+                                isKeyFrame: isKeyFrame,
+                                preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length,
+                            });
                             if (!this.currentMessageState[message.dataType].receivedFirstIFrame)
                                 this.currentMessageState[message.dataType].receivedFirstIFrame = this.isIFrame(video_data, isKeyFrame);
                             if (this.currentMessageState[message.dataType].receivedFirstIFrame) {
@@ -1480,9 +2015,16 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             }
                         }
                         else {
-                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: No startcode found`, { stationSN: this.rawStation.station_sn, isKeyFrame: isKeyFrame, preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length });
+                            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_VIDEO_FRAME: No startcode found`, {
+                                stationSN: this.rawStation.station_sn,
+                                isKeyFrame: isKeyFrame,
+                                preFrameVideoDataLength: this.currentMessageState[message.dataType].preFrameVideoData.length,
+                            });
                             if (this.currentMessageState[message.dataType].preFrameVideoData.length > 0) {
-                                this.currentMessageState[message.dataType].preFrameVideoData = Buffer.concat([this.currentMessageState[message.dataType].preFrameVideoData, video_data]);
+                                this.currentMessageState[message.dataType].preFrameVideoData = Buffer.concat([
+                                    this.currentMessageState[message.dataType].preFrameVideoData,
+                                    video_data,
+                                ]);
                             }
                         }
                     }
@@ -1496,35 +2038,60 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         audioType: types_1.AudioCodec.NONE,
                         audioSeqNo: 0,
                         audioTimestamp: 0,
-                        audioDataLength: 0
+                        audioDataLength: 0,
                     };
                     audioMetaData.audioDataLength = message.data.subarray(0, 4).readUInt32LE();
                     audioMetaData.audioType = message.data.subarray(5, 6).readUInt8();
                     audioMetaData.audioSeqNo = message.data.subarray(6, 8).readUInt16LE();
                     audioMetaData.audioTimestamp = message.data.subarray(8, 14).readUIntLE(0, 6);
                     const audio_data = Buffer.from(message.data.subarray(16));
-                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_AUDIO_FRAME`, { stationSN: this.rawStation.station_sn, dataSize: message.data.length, metadata: audioMetaData, audioDataSize: audio_data.length });
+                    logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_AUDIO_FRAME`, {
+                        stationSN: this.rawStation.station_sn,
+                        dataSize: message.data.length,
+                        metadata: audioMetaData,
+                        audioDataSize: audio_data.length,
+                    });
                     if (this.currentMessageState[message.dataType].waitForAudioData !== undefined) {
                         clearTimeout(this.currentMessageState[message.dataType].waitForAudioData);
                     }
                     if (!this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived) {
                         this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived = true;
-                        this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec = audioMetaData.audioType === 0 ? types_1.AudioCodec.AAC : audioMetaData.audioType === 1 ? types_1.AudioCodec.AAC_LC : audioMetaData.audioType === 7 ? types_1.AudioCodec.AAC_ELD : types_1.AudioCodec.UNKNOWN;
+                        this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec =
+                            audioMetaData.audioType === 0
+                                ? types_1.AudioCodec.AAC
+                                : audioMetaData.audioType === 1
+                                    ? types_1.AudioCodec.AAC_LC
+                                    : audioMetaData.audioType === 7
+                                        ? types_1.AudioCodec.AAC_ELD
+                                        : types_1.AudioCodec.UNKNOWN;
                     }
                     if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
-                        if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived && this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
+                        if (this.currentMessageState[message.dataType].p2pStreamFirstAudioDataReceived &&
+                            this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
                             this.emitStreamStartEvent(message.dataType);
                         }
                     }
                     this.currentMessageState[message.dataType].audioStream?.push(audio_data);
                     break;
                 default:
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented message`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: message.data.toString("hex") });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented message`, {
+                        stationSN: this.rawStation.station_sn,
+                        commandIdName: types_1.CommandType[message.commandId],
+                        commandId: message.commandId,
+                        channel: message.channel,
+                        data: message.data.toString("hex"),
+                    });
                     break;
             }
         }
         else {
-            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Invalid stream data, dropping complete stream`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: message.data.toString("hex") });
+            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Invalid stream data, dropping complete stream`, {
+                stationSN: this.rawStation.station_sn,
+                commandIdName: types_1.CommandType[message.commandId],
+                commandId: message.commandId,
+                channel: message.channel,
+                data: message.data.toString("hex"),
+            });
         }
     }
     handleDataControl(message) {
@@ -1537,125 +2104,277 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 }
                 catch (err) {
                     const error = (0, error_1.ensureError)(err);
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, {
+                        error: (0, utils_3.getError)(error),
+                        stationSN: this.rawStation.station_sn,
+                        message: {
+                            seqNo: message.seqNo,
+                            channel: message.channel,
+                            commandType: types_1.CommandType[message.commandId],
+                            signCode: message.signCode,
+                            type: message.type,
+                            dataType: types_1.P2PDataType[message.dataType],
+                            data: message.data.toString("hex"),
+                        },
+                    });
                 }
             }
-            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, data: message.data.toString("hex"), seqNumber: this.seqNumber, p2pDataSeqNumber: this.p2pDataSeqNumber, offsetDataSeqNumber: this.offsetDataSeqNumber });
+            logging_1.rootP2PLogger.trace(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Received data`, {
+                stationSN: this.rawStation.station_sn,
+                commandIdName: types_1.CommandType[message.commandId],
+                commandId: message.commandId,
+                data: message.data.toString("hex"),
+                seqNumber: this.seqNumber,
+                p2pDataSeqNumber: this.p2pDataSeqNumber,
+                offsetDataSeqNumber: this.offsetDataSeqNumber,
+            });
             switch (message.commandId) {
                 case types_1.CommandType.CMD_GET_ALARM_MODE:
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Alarm mode changed to: ${types_2.AlarmMode[data.readUIntBE(0, 1)]}`, { stationSN: this.rawStation.station_sn, });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Alarm mode changed to: ${types_2.AlarmMode[data.readUIntBE(0, 1)]}`, { stationSN: this.rawStation.station_sn });
                     this.emit("alarm mode", data.readUIntBE(0, 1));
                     break;
                 case types_1.CommandType.CMD_CAMERA_INFO:
                     try {
                         const cameraData = (0, utils_1.getNullTerminatedString)(data, "utf8");
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info`, { stationSN: this.rawStation.station_sn, cameraInfo: cameraData });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info`, {
+                            stationSN: this.rawStation.station_sn,
+                            cameraInfo: cameraData,
+                        });
                         this.emit("camera info", (0, utils_3.parseJSON)(cameraData, logging_1.rootP2PLogger));
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Camera info - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_CONVERT_MP4_OK:
                     const totalBytes = data.subarray(1).readUInt32LE();
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_CONVERT_MP4_OK`, { stationSN: this.rawStation.station_sn, channel: message.channel, totalBytes: totalBytes });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_CONVERT_MP4_OK`, {
+                        stationSN: this.rawStation.station_sn,
+                        channel: message.channel,
+                        totalBytes: totalBytes,
+                    });
                     this.downloadTotalBytes = totalBytes;
                     this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreaming = true;
-                    this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel = message.channel;
+                    // HB3 sends channel 255 (broadcast) which is not a valid device channel
+                    if (message.channel !== 255) {
+                        this.currentMessageState[types_1.P2PDataType.BINARY].p2pStreamChannel = message.channel;
+                    }
                     break;
                 case types_1.CommandType.CMD_WIFI_CONFIG:
                     const rssi = data.readInt32LE();
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_WIFI_CONFIG`, { stationSN: this.rawStation.station_sn, channel: message.channel, rssi: rssi });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_WIFI_CONFIG`, {
+                        stationSN: this.rawStation.station_sn,
+                        channel: message.channel,
+                        rssi: rssi,
+                    });
                     this.emit("wifi rssi", message.channel, rssi);
                     break;
                 case types_1.CommandType.CMD_DOWNLOAD_FINISH:
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOWNLOAD_FINISH`, { stationSN: this.rawStation.station_sn, channel: message.channel });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOWNLOAD_FINISH`, {
+                        stationSN: this.rawStation.station_sn,
+                        channel: message.channel,
+                    });
                     this.endStream(types_1.P2PDataType.BINARY);
                     break;
                 case types_1.CommandType.CMD_DOORBELL_NOTIFY_PAYLOAD:
                     try {
                         const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD`, { stationSN: this.rawStation.station_sn, payload: str });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: str,
+                        });
                         //TODO: Finish implementation, emit an event...
                         //VDBStreamInfo (1005) and VoltageEvent (1015)
                         //this.emit("", parseJSON(str, this.log) as xy);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORBELL_NOTIFY_PAYLOAD - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_NAS_SWITCH:
                     try {
                         const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH`, { stationSN: this.rawStation.station_sn, payload: str });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: str,
+                        });
                         this.emit("rtsp url", message.channel, str);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NAS_SWITCH - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.SUB1G_REP_UNPLUG_POWER_LINE:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString(),
+                        });
                         const chargeType = data.subarray(0, 4).readUInt32LE();
                         const batteryLevel = data.subarray(4, 8).readUInt32LE();
                         this.emit("charging state", message.channel, chargeType, batteryLevel);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_UNPLUG_POWER_LINE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.SUB1G_REP_RUNTIME_STATE:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString(),
+                        });
                         const batteryLevel = data.subarray(0, 4).readUInt32LE();
                         const temperature = data.subarray(4, 8).readUInt32LE();
                         this.emit("runtime state", message.channel, batteryLevel, temperature);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - SUB1G_REP_RUNTIME_STATE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_SET_FLOODLIGHT_MANUAL_SWITCH:
                     try {
                         const enabled = data.readUIntBE(0, 1) === 1 ? true : false;
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH`, { stationSN: this.rawStation.station_sn, enabled: enabled, payload: data.toString() });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH`, {
+                            stationSN: this.rawStation.station_sn,
+                            enabled: enabled,
+                            payload: data.toString(),
+                        });
                         this.emit("floodlight manual switch", message.channel, enabled);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_FLOODLIGHT_MANUAL_SWITCH - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_GET_DEVICE_PING:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString(),
+                        });
                         this.sendCommandDevicePing(message.channel);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DEVICE_PING - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_NOTIFY_PAYLOAD:
                     try {
-                        logging_1.rootP2PLogger.debug(`Station Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD`, { stationSN: this.rawStation.station_sn, payload: data.toString() });
+                        logging_1.rootP2PLogger.debug(`Station Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString(),
+                        });
                         const json = (0, utils_3.parseJSON)((0, utils_1.getNullTerminatedString)(data, "utf8"), logging_1.rootP2PLogger);
                         if (json !== undefined) {
                             if (device_1.Device.isLockWifi(this.rawStation.device_type, this.rawStation.station_sn)) {
                                 //TODO: Implement notification payload or T8520
-                                if (json.cmd === types_1.CommandType.P2P_ADD_PW || json.cmd === types_1.CommandType.P2P_QUERY_PW || json.cmd === types_1.CommandType.P2P_GET_LOCK_PARAM || json.cmd === types_1.CommandType.P2P_GET_USER_AND_PW_ID) {
+                                if (json.cmd === types_1.CommandType.P2P_ADD_PW ||
+                                    json.cmd === types_1.CommandType.P2P_QUERY_PW ||
+                                    json.cmd === types_1.CommandType.P2P_GET_LOCK_PARAM ||
+                                    json.cmd === types_1.CommandType.P2P_GET_USER_AND_PW_ID) {
                                     // encrypted data
                                     //TODO: Handle decryption of encrypted Data (AES) - For decryption use the cached aeskey used for sending the command!
                                     const aesKey = this.getLockAESKey(json.cmd);
                                     if (aesKey !== undefined) {
                                         const decryptedPayload = (0, utils_1.decryptPayloadData)(Buffer.from(json.payload, "base64"), Buffer.from(aesKey, "hex"), Buffer.from((0, utils_1.getLockVectorBytes)(this.rawStation.station_sn), "hex")).toString();
-                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock - Received`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decryptedPayload: decryptedPayload, aesKey: aesKey });
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock - Received`, {
+                                            stationSN: this.rawStation.station_sn,
+                                            commandIdName: types_1.CommandType[json.cmd],
+                                            commandId: json.cmd,
+                                            decryptedPayload: decryptedPayload,
+                                            aesKey: aesKey,
+                                        });
                                         switch (json.cmd) {
                                             case types_1.CommandType.P2P_ADD_PW:
                                                 // decryptedPayload: {"code":0,"passwordId":"002C"}
@@ -1670,7 +2389,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_STATUS, payload.slState);
                                 }
                                 else {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[json.cmd],
+                                        commandId: json.cmd,
+                                        message: data.toString(),
+                                    });
                                 }
                             }
                             else if (json.cmd === types_1.CommandType.P2P_QUERY_STATUS_IN_LOCK) {
@@ -1681,7 +2405,8 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_NIGHT_VISION_SIDE, payload.slOpenDirection);
                             }
                             else if (json.cmd === types_1.CommandType.CMD_DOORLOCK_P2P_SEQ) {
-                                if (device_1.Device.isLockWifi(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) || device_1.Device.isLockWifiNoFinger(this.rawStation.devices[0]?.device_type)) {
+                                if (device_1.Device.isLockWifi(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) ||
+                                    device_1.Device.isLockWifiNoFinger(this.rawStation.devices[0]?.device_type)) {
                                     const payload = json.payload;
                                     if (payload.seq_num !== undefined) {
                                         this.lockSeqNumber = payload.seq_num;
@@ -1694,18 +2419,34 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 else {
                                     const payload = json.payload;
                                     if (payload.seq_num !== undefined) {
-                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number`, { stationSN: this.rawStation.station_sn, oldSequenceNumber: this.lockSeqNumber, newSequenceNumber: this.lockSeqNumber + 1, payload: payload });
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number`, {
+                                            stationSN: this.rawStation.station_sn,
+                                            oldSequenceNumber: this.lockSeqNumber,
+                                            newSequenceNumber: this.lockSeqNumber + 1,
+                                            payload: payload,
+                                        });
                                         this.lockSeqNumber = payload.seq_num + 1;
                                     }
                                     if (payload.lock_cmd > 0) {
-                                        if (device_1.Device.isLockWifiR10(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiR20(this.rawStation.devices[0]?.device_type)) {
+                                        if (device_1.Device.isLockWifiR10(this.rawStation.devices[0]?.device_type) ||
+                                            device_1.Device.isLockWifiR20(this.rawStation.devices[0]?.device_type)) {
                                             this.emit("sequence error", message.channel, types_1.ESLCommand[types_1.ESLBleCommand[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
                                         }
-                                        else if (device_1.Device.isLockWifiT8506(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiT8502(this.rawStation.devices[0]?.device_type) || device_1.Device.isLockWifiT8510P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) || device_1.Device.isLockWifiT8520P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn)) {
-                                            this.emit("sequence error", message.channel, types_1.SmartLockCommand[payload.bus_type == types_1.SmartLockFunctionType.TYPE_2 ? types_1.SmartLockBleCommandFunctionType2[payload.lock_cmd] : types_1.SmartLockBleCommandFunctionType1[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
+                                        else if (device_1.Device.isLockWifiT8506(this.rawStation.devices[0]?.device_type) ||
+                                            device_1.Device.isLockWifiT8502(this.rawStation.devices[0]?.device_type) ||
+                                            device_1.Device.isLockWifiT8510P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) ||
+                                            device_1.Device.isLockWifiT8520P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn)) {
+                                            this.emit("sequence error", message.channel, types_1.SmartLockCommand[payload.bus_type == types_1.SmartLockFunctionType.TYPE_2
+                                                ? types_1.SmartLockBleCommandFunctionType2[payload.lock_cmd]
+                                                : types_1.SmartLockBleCommandFunctionType1[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
                                         }
                                         else {
-                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number - Unknwon device`, { stationSN: this.rawStation.station_sn, oldSequenceNumber: this.lockSeqNumber, newSequenceNumber: this.lockSeqNumber + 1, payload: payload });
+                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Lock sequence number - Unknwon device`, {
+                                                stationSN: this.rawStation.station_sn,
+                                                oldSequenceNumber: this.lockSeqNumber,
+                                                newSequenceNumber: this.lockSeqNumber + 1,
+                                                payload: payload,
+                                            });
                                         }
                                     }
                                 }
@@ -1717,7 +2458,14 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                         const decoded = (0, utils_1.decodeBase64)((0, utils_1.decodeLockPayload)(Buffer.from(payload.lock_payload)));
                                         const key = (0, utils_1.generateBasicLockAESKey)(this.deviceSNs[message.channel].adminUserId, this.rawStation.station_sn);
                                         const iv = (0, utils_1.getLockVectorBytes)(this.rawStation.station_sn);
-                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORLOCK_DATA_PASS_THROUGH`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, key: key, iv: iv, decoded: decoded.toString("hex") });
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DOORLOCK_DATA_PASS_THROUGH`, {
+                                            stationSN: this.rawStation.station_sn,
+                                            commandIdName: types_1.CommandType[json.cmd],
+                                            commandId: json.cmd,
+                                            key: key,
+                                            iv: iv,
+                                            decoded: decoded.toString("hex"),
+                                        });
                                         payload.lock_payload = (0, utils_1.decryptLockAESData)(key, iv, decoded).toString("hex");
                                         switch (payload.lock_cmd) {
                                             case types_1.ESLBleCommand.NOTIFY:
@@ -1747,19 +2495,28 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                             const returnCode = data.readInt8(0);
                                             const commandType = Number.parseInt(types_1.ESLCommand[types_1.ESLBleCommand[fac.getCommandCode()]]);
                                             const customData = {
-                                                ...this.customDataStaging[commandType]
+                                                ...this.customDataStaging[commandType],
                                             };
                                             if (this.customDataStaging[commandType]) {
                                                 const result = {
                                                     channel: customData.channel,
                                                     command_type: commandType,
                                                     return_code: returnCode,
-                                                    customData: customData.customData
+                                                    customData: customData.customData,
                                                 };
                                                 this.emit("secondary command", result);
                                                 delete this.customDataStaging[commandType];
                                             }
-                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 return code: ${returnCode}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data.toString("hex"), bleCommandCode: types_1.ESLBleCommand[fac.getCommandCode()], returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
+                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 return code: ${returnCode}`, {
+                                                stationSN: this.rawStation.station_sn,
+                                                commandIdName: types_1.CommandType[json.cmd],
+                                                commandId: json.cmd,
+                                                decoded: data.toString("hex"),
+                                                bleCommandCode: types_1.ESLBleCommand[fac.getCommandCode()],
+                                                returnCode: returnCode,
+                                                channel: customData?.channel,
+                                                customData: customData?.customData,
+                                            });
                                             const parsePayload = new utils_2.ParsePayload(data.subarray(1));
                                             switch (fac.getCommandCode()) {
                                                 case types_1.ESLBleCommand.QUERY_STATUS_IN_LOCK:
@@ -1783,18 +2540,33 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                                     //this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_WIFI_STATUS, parsePayload.readInt8(BleParameterIndex.THIRTEEN).toString());
                                                     break;
                                                 case types_1.ESLBleCommand.ADD_PW:
-                                                    if (customData && customData.customData && customData.customData.command && customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
+                                                    if (customData &&
+                                                        customData.customData &&
+                                                        customData.customData.command &&
+                                                        customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
                                                         this.api.updateUserPassword(customData.customData.command.value?.deviceSN, customData.customData.command.value?.shortUserId, parsePayload.readStringHex(ble_1.BleParameterIndex.ONE), customData.customData.command.value?.schedule);
                                                     }
                                                     break;
                                                 default:
-                                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
+                                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, {
+                                                        stationSN: this.rawStation.station_sn,
+                                                        fac: fac.toString(),
+                                                        returnCode: returnCode,
+                                                        channel: customData?.channel,
+                                                        customData: customData?.customData,
+                                                    });
                                                     break;
                                             }
                                         }
                                         catch (err) {
                                             const error = (0, error_1.ensureError)(err);
-                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 unable to decrypt (maybe event from other lock connection)`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
+                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 unable to decrypt (maybe event from other lock connection)`, {
+                                                error: (0, utils_3.getError)(error),
+                                                stationSN: this.rawStation.station_sn,
+                                                commandIdName: types_1.CommandType[json.cmd],
+                                                commandId: json.cmd,
+                                                payload: payload,
+                                            });
                                         }
                                         this._clearSecondaryCommandTimeout();
                                         this.sendQueuedMessage();
@@ -1804,7 +2576,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     }
                                 }
                                 else {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 - Unexpected response`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Lock V12 - Unexpected response`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[json.cmd],
+                                        commandId: json.cmd,
+                                        message: data.toString(),
+                                    });
                                 }
                             }
                             else if (json.cmd === types_1.CommandType.CMD_TRANSFER_PAYLOAD) {
@@ -1825,22 +2602,32 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                                 }
                                                 if (data.length > 0 && fac.getDataType() !== undefined) {
                                                     const returnCode = data.readInt8(0);
-                                                    const functionTypeCommand = fac.getDataType() === types_1.SmartLockFunctionType.TYPE_2 ? types_1.SmartLockBleCommandFunctionType2 : types_1.SmartLockBleCommandFunctionType1;
+                                                    const functionTypeCommand = fac.getDataType() === types_1.SmartLockFunctionType.TYPE_2
+                                                        ? types_1.SmartLockBleCommandFunctionType2
+                                                        : types_1.SmartLockBleCommandFunctionType1;
                                                     const commandType = Number.parseInt(types_1.SmartLockCommand[functionTypeCommand[fac.getCommandCode()]]);
                                                     const customData = {
-                                                        ...this.customDataStaging[commandType]
+                                                        ...this.customDataStaging[commandType],
                                                     };
                                                     if (this.customDataStaging[commandType]) {
                                                         const result = {
                                                             channel: customData.channel,
                                                             command_type: commandType,
                                                             return_code: returnCode,
-                                                            customData: customData.customData
+                                                            customData: customData.customData,
                                                         };
                                                         this.emit("secondary command", result);
                                                         delete this.customDataStaging[commandType];
                                                     }
-                                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock  return code: ${returnCode}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data.toString("hex"), bleCommandCode: functionTypeCommand[fac.getCommandCode()], returnCode: returnCode, channel: message.channel });
+                                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock  return code: ${returnCode}`, {
+                                                        stationSN: this.rawStation.station_sn,
+                                                        commandIdName: types_1.CommandType[json.cmd],
+                                                        commandId: json.cmd,
+                                                        decoded: data.toString("hex"),
+                                                        bleCommandCode: functionTypeCommand[fac.getCommandCode()],
+                                                        returnCode: returnCode,
+                                                        channel: message.channel,
+                                                    });
                                                     const parsePayload = new utils_2.ParsePayload(data.subarray(1));
                                                     if (fac.getDataType() === types_1.SmartLockFunctionType.TYPE_2) {
                                                         switch (fac.getCommandCode()) {
@@ -1865,17 +2652,32 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                                                 //this.emit("parameter", message.channel, CommandType.CMD_SMARTLOCK_LOG, parsePayload.readInt8(BleParameterIndex.THIRTEEN).toString());
                                                                 break;
                                                             case types_1.SmartLockBleCommandFunctionType2.ADD_PW:
-                                                                if (customData && customData.customData && customData.customData.command && customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
+                                                                if (customData &&
+                                                                    customData.customData &&
+                                                                    customData.customData.command &&
+                                                                    customData.customData.command.name === http_1.CommandName.DeviceAddUser) {
                                                                     this.api.updateUserPassword(customData.customData.command.value?.deviceSN, customData.customData.command.value?.shortUserId, parsePayload.readStringHex(ble_1.BleParameterIndex.ONE), customData.customData.command.value?.schedule);
                                                                 }
                                                                 break;
                                                             default:
-                                                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
+                                                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, {
+                                                                    stationSN: this.rawStation.station_sn,
+                                                                    fac: fac.toString(),
+                                                                    returnCode: returnCode,
+                                                                    channel: customData?.channel,
+                                                                    customData: customData?.customData,
+                                                                });
                                                                 break;
                                                         }
                                                     }
                                                     else {
-                                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, { stationSN: this.rawStation.station_sn, fac: fac.toString(), returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
+                                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock - Not implemented`, {
+                                                            stationSN: this.rawStation.station_sn,
+                                                            fac: fac.toString(),
+                                                            returnCode: returnCode,
+                                                            channel: customData?.channel,
+                                                            customData: customData?.customData,
+                                                        });
                                                     }
                                                 }
                                                 else {
@@ -1892,94 +2694,121 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     }
                                     catch (err) {
                                         const error = (0, error_1.ensureError)(err);
-                                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
+                                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock Error`, {
+                                            error: (0, utils_3.getError)(error),
+                                            stationSN: this.rawStation.station_sn,
+                                            commandIdName: types_1.CommandType[json.cmd],
+                                            commandId: json.cmd,
+                                            payload: payload,
+                                        });
                                     }
                                     this._clearSecondaryCommandTimeout();
                                     this.sendQueuedMessage();
                                 }
                                 else {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock  - Unexpected response`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Smart Lock  - Unexpected response`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[json.cmd],
+                                        commandId: json.cmd,
+                                        message: data.toString(),
+                                    });
                                 }
                             }
                             else if (device_1.Device.isSmartSafe(this.rawStation.device_type)) {
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd });
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    commandIdName: types_1.CommandType[json.cmd],
+                                    commandId: json.cmd,
+                                });
                                 switch (json.cmd) {
-                                    case types_1.CommandType.CMD_SMARTSAFE_SETTINGS:
-                                        {
-                                            const payload = json.payload;
-                                            try {
-                                                const data = (0, utils_1.decodeSmartSafeData)(this.rawStation.station_sn, Buffer.from(payload.data, "hex"));
-                                                const returnCode = data.data.readInt8(0);
-                                                const customData = {
-                                                    ...this.customDataStaging[payload.prj_id]
+                                    case types_1.CommandType.CMD_SMARTSAFE_SETTINGS: {
+                                        const payload = json.payload;
+                                        try {
+                                            const data = (0, utils_1.decodeSmartSafeData)(this.rawStation.station_sn, Buffer.from(payload.data, "hex"));
+                                            const returnCode = data.data.readInt8(0);
+                                            const customData = {
+                                                ...this.customDataStaging[payload.prj_id],
+                                            };
+                                            if (this.customDataStaging[payload.prj_id]) {
+                                                const result = {
+                                                    channel: customData.channel,
+                                                    command_type: payload.prj_id,
+                                                    return_code: returnCode,
+                                                    customData: customData.customData,
                                                 };
-                                                if (this.customDataStaging[payload.prj_id]) {
-                                                    const result = {
-                                                        channel: customData.channel,
-                                                        command_type: payload.prj_id,
-                                                        return_code: returnCode,
-                                                        customData: customData.customData
-                                                    };
-                                                    this.emit("secondary command", result);
-                                                    delete this.customDataStaging[payload.prj_id];
-                                                }
-                                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe return code: ${data.data.readInt8(0)}`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, decoded: data, commandCode: types_1.SmartSafeCommandCode[data.commandCode], returnCode: returnCode, channel: customData?.channel, customData: customData?.customData });
-                                            }
-                                            catch (err) {
-                                                const error = (0, error_1.ensureError)(err);
-                                                logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, payload: payload });
+                                                this.emit("secondary command", result);
+                                                delete this.customDataStaging[payload.prj_id];
                                             }
-                                            this._clearSecondaryCommandTimeout();
-                                            this.sendQueuedMessage();
-                                            break;
+                                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe return code: ${data.data.readInt8(0)}`, {
+                                                stationSN: this.rawStation.station_sn,
+                                                commandIdName: types_1.CommandType[json.cmd],
+                                                commandId: json.cmd,
+                                                decoded: data,
+                                                commandCode: types_1.SmartSafeCommandCode[data.commandCode],
+                                                returnCode: returnCode,
+                                                channel: customData?.channel,
+                                                customData: customData?.customData,
+                                            });
                                         }
-                                    case types_1.CommandType.CMD_SMARTSAFE_STATUS_UPDATE:
-                                        {
-                                            const payload = json.payload;
-                                            switch (payload.event_type) {
-                                                case types_3.SmartSafeEvent.LOCK_STATUS:
-                                                    {
-                                                        const eventValues = payload.event_value;
-                                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - LOCK_STATUS`, { stationSN: this.rawStation.station_sn, eventValues: eventValues });
-                                                        /*
-                                                            type values:
-                                                                1: Unlocked by PIN
-                                                                2: Unlocked by User
-                                                                3: Unlocked by key
-                                                                4: Unlocked by App
-                                                                5: Unlocked by Dual Unlock
-                                                        */
-                                                        if (eventValues.action === 0) {
-                                                            this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "0");
-                                                        }
-                                                        else if (eventValues.action === 1) {
-                                                            this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "1");
-                                                        }
-                                                        else if (eventValues.action === 2) {
-                                                            this.emit("jammed", message.channel);
-                                                        }
-                                                        else if (eventValues.action === 3) {
-                                                            this.emit("low battery", message.channel);
-                                                        }
-                                                        break;
-                                                    }
-                                                case types_3.SmartSafeEvent.SHAKE_ALARM:
-                                                    this.emit("shake alarm", message.channel, payload.event_value);
-                                                    break;
-                                                case types_3.SmartSafeEvent.ALARM_911:
-                                                    this.emit("911 alarm", message.channel, payload.event_value);
-                                                    break;
-                                                //case SmartSafeEvent.BATTERY_STATUS:
-                                                //    break;
-                                                case types_3.SmartSafeEvent.INPUT_ERR_MAX:
-                                                    this.emit("wrong try-protect alarm", message.channel);
-                                                    break;
-                                                default:
-                                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
-                                                    break;
+                                        catch (err) {
+                                            const error = (0, error_1.ensureError)(err);
+                                            logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Error`, {
+                                                error: (0, utils_3.getError)(error),
+                                                stationSN: this.rawStation.station_sn,
+                                                commandIdName: types_1.CommandType[json.cmd],
+                                                commandId: json.cmd,
+                                                payload: payload,
+                                            });
+                                        }
+                                        this._clearSecondaryCommandTimeout();
+                                        this.sendQueuedMessage();
+                                        break;
+                                    }
+                                    case types_1.CommandType.CMD_SMARTSAFE_STATUS_UPDATE: {
+                                        const payload = json.payload;
+                                        switch (payload.event_type) {
+                                            case types_3.SmartSafeEvent.LOCK_STATUS: {
+                                                const eventValues = payload.event_value;
+                                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - LOCK_STATUS`, { stationSN: this.rawStation.station_sn, eventValues: eventValues });
+                                                /*
+                                                                            type values:
+                                                                                1: Unlocked by PIN
+                                                                                2: Unlocked by User
+                                                                                3: Unlocked by key
+                                                                                4: Unlocked by App
+                                                                                5: Unlocked by Dual Unlock
+                                                                        */
+                                                if (eventValues.action === 0) {
+                                                    this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "0");
+                                                }
+                                                else if (eventValues.action === 1) {
+                                                    this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTSAFE_LOCK_STATUS, "1");
+                                                }
+                                                else if (eventValues.action === 2) {
+                                                    this.emit("jammed", message.channel);
+                                                }
+                                                else if (eventValues.action === 3) {
+                                                    this.emit("low battery", message.channel);
+                                                }
+                                                break;
                                             }
-                                            break;
+                                            case types_3.SmartSafeEvent.SHAKE_ALARM:
+                                                this.emit("shake alarm", message.channel, payload.event_value);
+                                                break;
+                                            case types_3.SmartSafeEvent.ALARM_911:
+                                                this.emit("911 alarm", message.channel, payload.event_value);
+                                                break;
+                                            //case SmartSafeEvent.BATTERY_STATUS:
+                                            //    break;
+                                            case types_3.SmartSafeEvent.INPUT_ERR_MAX:
+                                                this.emit("wrong try-protect alarm", message.channel);
+                                                break;
+                                            default:
+                                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe Status update - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
+                                                break;
                                         }
+                                        break;
+                                    }
                                     default:
                                         logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD SmartSafe - Not implemented`, { stationSN: this.rawStation.station_sn, message: data.toString() });
                                         break;
@@ -1996,7 +2825,12 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             else if (json.cmd === types_1.CommandType.CMD_CAMERA_GARAGE_DOOR_STATUS) {
                                 // {"cmd":7500,"payload":{"type":24,"notify_tag":"","door_id":2}}
                                 const payload = json.payload;
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD GarageDoor Status update`, { stationSN: this.rawStation.station_sn, doorId: payload?.door_id, status: payload?.type, notify_tag: payload?.notify_tag });
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD GarageDoor Status update`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    doorId: payload?.door_id,
+                                    status: payload?.type,
+                                    notify_tag: payload?.notify_tag,
+                                });
                                 if (payload) {
                                     this.emit("garage door status", message.channel, payload.door_id, payload.type);
                                 }
@@ -2009,18 +2843,38 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 }
                             }
                             else {
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[json.cmd], commandId: json.cmd, message: data.toString() });
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    commandIdName: types_1.CommandType[json.cmd],
+                                    commandId: json.cmd,
+                                    message: data.toString(),
+                                });
                             }
                         }
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString(),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_GET_DELAY_ALARM:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM :`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString("hex"),
+                        });
                         //When the alarm is armed, CMD_GET_DELAY_ALARM is called with event data 0, so ignore it
                         const alarmEventNumber = data.subarray(0, 4).readUInt32LE();
                         const alarmDelay = data.subarray(4, 8).readUInt32LE();
@@ -2033,29 +2887,71 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_DELAY_ALARM - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_SET_TONE_FILE:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE :`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString("hex"),
+                        });
                         const alarmEventNumber = data.subarray(0, 4).readUInt32LE();
                         this.emit("alarm event", alarmEventNumber);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_TONE_FILE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_SET_SNOOZE_MODE:
                     // Received for station managed devices when snooze time ends
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE`, { stationSN: this.rawStation.station_sn, payload: Buffer.from(data.toString(), "base64").toString() });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: Buffer.from(data.toString(), "base64").toString(),
+                        });
                         this.emit("parameter", message.channel, types_1.CommandType.CMD_SET_SNOOZE_MODE, data.toString());
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_SET_SNOOZE_MODE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_PING:
@@ -2065,57 +2961,89 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     // Received data for preview image download
                     try {
                         const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE`, { stationSN: this.rawStation.station_sn, message: str });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE`, {
+                            stationSN: this.rawStation.station_sn,
+                            message: str,
+                        });
                         const image = (0, utils_3.parseJSON)(str, logging_1.rootP2PLogger);
                         this.emit("image download", image.file, (0, utils_2.decodeImage)(this.rawStation.p2p_did, Buffer.from(image.content, "base64")));
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE_IMAGE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString(),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_GET_TFCARD_STATUS:
                     try {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS :`, { stationSN: this.rawStation.station_sn, payload: data.toString("hex") });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS :`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: data.toString("hex"),
+                        });
                         const tfCardStatus = data.subarray(0, 4).readUInt32LE();
                         this.emit("tfcard status", message.channel, tfCardStatus);
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GET_TFCARD_STATUS - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_DATABASE:
                     try {
                         const str = (0, utils_1.getNullTerminatedString)(data, "utf8");
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE :`, { stationSN: this.rawStation.station_sn, payload: str });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE :`, {
+                            stationSN: this.rawStation.station_sn,
+                            payload: str,
+                        });
                         const databaseResponse = (0, utils_3.parseJSON)(str, logging_1.rootP2PLogger);
                         switch (databaseResponse.cmd) {
-                            case types_1.CommandType.CMD_DATABASE_QUERY_LATEST_INFO:
-                                {
-                                    let data = [];
-                                    if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
-                                        data = databaseResponse.data;
-                                    const result = [];
-                                    for (const record of data) {
-                                        if (record.payload.crop_hb3_path !== "") {
-                                            result.push({
-                                                device_sn: record.device_sn,
-                                                event_count: record.payload.event_count,
-                                                crop_local_path: record.payload.crop_hb3_path
-                                            });
-                                        }
-                                        else {
-                                            result.push({
-                                                device_sn: record.device_sn,
-                                                event_count: record.payload.event_count,
-                                                crop_cloud_path: record.payload.crop_cloud_path
-                                            });
-                                        }
+                            case types_1.CommandType.CMD_DATABASE_QUERY_LATEST_INFO: {
+                                let data = [];
+                                if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
+                                    data = databaseResponse.data;
+                                const result = [];
+                                for (const record of data) {
+                                    if (record.payload.crop_hb3_path !== "") {
+                                        result.push({
+                                            device_sn: record.device_sn,
+                                            event_count: record.payload.event_count,
+                                            crop_local_path: record.payload.crop_hb3_path,
+                                        });
+                                    }
+                                    else {
+                                        result.push({
+                                            device_sn: record.device_sn,
+                                            event_count: record.payload.event_count,
+                                            crop_cloud_path: record.payload.crop_cloud_path,
+                                        });
                                     }
-                                    this.emit("database query latest", databaseResponse.mIntRet, result);
-                                    break;
                                 }
+                                this.emit("database query latest", databaseResponse.mIntRet, result);
+                                break;
+                            }
                             case types_1.CommandType.CMD_DATABASE_COUNT_BY_DATE: {
                                 let data = [];
                                 if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
@@ -2124,7 +3052,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 for (const record of data) {
                                     result.push({
                                         day: parse(record.days, "YYYYMMDD"),
-                                        count: record.count
+                                        count: record.count,
                                     });
                                 }
                                 this.emit("database count by date", databaseResponse.mIntRet, result);
@@ -2189,7 +3117,8 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                                 person_id: tableRecord.person_id,
                                                 crop_path: tableRecord.crop_path,
                                                 event_time: parse(tableRecord.event_time, "YYYY-MM-DD HH:mm:ss"),
-                                                person_recog_flag: tableRecord.person_recog_flag,
+                                                person_recog_flag: tableRecord
+                                                    .person_recog_flag,
                                                 crop_pic_quality: tableRecord.crop_pic_quality,
                                                 pic_marking_flag: tableRecord.pic_marking_flag,
                                                 group_id: tableRecord.group_id,
@@ -2211,6 +3140,33 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 this.emit("database query local", databaseResponse.mIntRet, Array.from(result.values()));
                                 break;
                             }
+                            case types_1.CommandType.CMD_DATABASE_QUERY_BY_DATE: {
+                                let data = [];
+                                if (databaseResponse.data !== undefined && databaseResponse.data !== "[]")
+                                    data = databaseResponse.data;
+                                const result = [];
+                                for (const record of data) {
+                                    result.push({
+                                        device_sn: record.device_sn,
+                                        device_type: record.device_type,
+                                        start_time: parse(record.start_time, "YYYY-MM-DD HH:mm:ss"),
+                                        end_time: parse(record.end_time, "YYYY-MM-DD HH:mm:ss"),
+                                        storage_path: record.storage_path,
+                                        thumb_path: record.thumb_path,
+                                        cipher_id: record.cipher_id,
+                                        folder_size: record.folder_size,
+                                        frame_num: record.frame_num,
+                                        trigger_type: record.trigger_type,
+                                        video_type: record.video_type,
+                                        record_id: record.record_id,
+                                        station_sn: record.station_sn,
+                                        storage_type: record.storage_type,
+                                        storage_cloud: record.storage_cloud,
+                                    });
+                                }
+                                this.emit("database query by date", databaseResponse.mIntRet, result);
+                                break;
+                            }
                             case types_1.CommandType.CMD_DATABASE_DELETE: {
                                 const data = databaseResponse.data;
                                 let failed_delete = [];
@@ -2220,27 +3176,98 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                 break;
                             }
                             default:
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented - CMD_DATABASE message`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, databaseResponse: databaseResponse });
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented - CMD_DATABASE message`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    commandIdName: types_1.CommandType[message.commandId],
+                                    commandId: message.commandId,
+                                    channel: message.channel,
+                                    databaseResponse: databaseResponse,
+                                });
                                 break;
                         }
                     }
                     catch (err) {
                         const error = (0, error_1.ensureError)(err);
-                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString() } });
+                        logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_DATABASE - Error`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString(),
+                            },
+                        });
                     }
                     break;
                 case types_1.CommandType.CMD_GATEWAYINFO:
                     const cipherID = data.subarray(0, 2).readUInt16LE();
                     //const unknownNumber = data.subarray(2, 2).readUInt16LE();
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - cipherID`, { stationSN: this.rawStation.station_sn, channel: message.channel, data: data.toString("hex"), cipherID: cipherID });
-                    const encryptedKey = (0, utils_1.readNullTerminatedBuffer)(data.subarray(4));
-                    this.api.getCipher(/*this.rawStation.station_sn, */ cipherID, this.rawStation.member.admin_user_id).then((cipher) => {
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - get cipher with cipherID`, { stationSN: this.rawStation.station_sn, channel: message.channel, data: data.toString("hex"), cipherID: cipherID, cipher: JSON.stringify(cipher) });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - cipherID`, {
+                        stationSN: this.rawStation.station_sn,
+                        channel: message.channel,
+                        data: data.toString("hex"),
+                        cipherID: cipherID,
+                    });
+                    // Keep full raw buffer for ECDH — readNullTerminatedBuffer truncates binary ECIES envelopes at 0x00 bytes
+                    const rawEncryptedKey = data.subarray(4);
+                    const encryptedKey = (0, utils_1.readNullTerminatedBuffer)(rawEncryptedKey);
+                    this.api
+                        .getCipher(/*this.rawStation.station_sn, */ cipherID, this.rawStation.member.admin_user_id)
+                        .then((cipher) => {
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - get cipher with cipherID`, {
+                            stationSN: this.rawStation.station_sn,
+                            channel: message.channel,
+                            data: data.toString("hex"),
+                            cipherID: cipherID,
+                            cipher: JSON.stringify(cipher),
+                        });
                         if (cipher !== undefined) {
-                            this.encryption = types_1.EncryptionType.LEVEL_2;
-                            const rsa = (0, utils_1.getRSAPrivateKey)(cipher.private_key, this.enableEmbeddedPKCS1Support);
-                            this.p2pKey = rsa.decrypt(encryptedKey);
-                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 2`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                            // Try RSA first
+                            try {
+                                this.encryption = types_1.EncryptionType.LEVEL_2;
+                                const rsa = (0, utils_1.getRSAPrivateKey)(cipher.private_key, this.enableEmbeddedPKCS1Support);
+                                this.p2pKey = rsa.decrypt(encryptedKey);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - RSA success - set encryption level 2`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                            }
+                            catch (rsaErr) {
+                                const rsaError = (0, error_1.ensureError)(rsaErr);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - RSA decrypt failed, trying ECDH`, {
+                                    error: (0, utils_3.getError)(rsaError),
+                                    stationSN: this.rawStation.station_sn,
+                                    hasEccKey: !!cipher.ecc_private_key,
+                                });
+                                // Try ECDH if ecc_private_key is available
+                                if (cipher.ecc_private_key) {
+                                    try {
+                                        this.encryption = types_1.EncryptionType.LEVEL_2;
+                                        this.p2pKey = (0, utils_1.decryptP2PKeyECDH)(rawEncryptedKey, cipher.ecc_private_key);
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - ECDH success - set encryption level 2`, {
+                                            stationSN: this.rawStation.station_sn,
+                                            key: this.p2pKey.toString("hex"),
+                                            keyLength: this.p2pKey.length,
+                                        });
+                                    }
+                                    catch (ecdhErr) {
+                                        const ecdhError = (0, error_1.ensureError)(ecdhErr);
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - ECDH also failed, falling back to Level 1`, {
+                                            error: (0, utils_3.getError)(ecdhError),
+                                            stationSN: this.rawStation.station_sn,
+                                        });
+                                        this.encryption = types_1.EncryptionType.LEVEL_1;
+                                        this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
+                                    }
+                                }
+                                else {
+                                    // No ECC key available, fall back to Level 1
+                                    this.encryption = types_1.EncryptionType.LEVEL_1;
+                                    this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - No ECC key, set encryption level 1`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                                }
+                            }
                         }
                         else {
                             this.encryption = types_1.EncryptionType.LEVEL_1;
@@ -2256,11 +3283,25 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         this.p2pDataSeqNumber--;
                         this.messageStates.delete(message.seqNo);
                         this.sendQueuedMessage();
-                    }).catch((err) => {
+                    })
+                        .catch((err) => {
                         const error = (0, error_1.ensureError)(err);
                         this.encryption = types_1.EncryptionType.LEVEL_1;
                         this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
-                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 1 (fallback)`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") }, key: this.p2pKey.toString("hex") });
+                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 1 (fallback)`, {
+                            error: (0, utils_3.getError)(error),
+                            stationSN: this.rawStation.station_sn,
+                            message: {
+                                seqNo: message.seqNo,
+                                channel: message.channel,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                type: message.type,
+                                dataType: types_1.P2PDataType[message.dataType],
+                                data: message.data.toString("hex"),
+                            },
+                            key: this.p2pKey.toString("hex"),
+                        });
                         this._clearTimeout(this.messageStates.get(message.seqNo)?.timeout);
                         this.p2pSeqMapping.forEach((value, key, map) => {
                             if (value === message.seqNo) {
@@ -2273,13 +3314,31 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     });
                     break;
                 default:
-                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented`, { stationSN: this.rawStation.station_sn, commandIdName: types_1.CommandType[message.commandId], commandId: message.commandId, channel: message.channel, data: data.toString("hex") });
+                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented`, {
+                        stationSN: this.rawStation.station_sn,
+                        commandIdName: types_1.CommandType[message.commandId],
+                        commandId: message.commandId,
+                        channel: message.channel,
+                        data: data.toString("hex"),
+                    });
                     break;
             }
         }
         catch (err) {
             const error = (0, error_1.ensureError)(err);
-            logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn, message: { seqNo: message.seqNo, channel: message.channel, commandType: types_1.CommandType[message.commandId], signCode: message.signCode, type: message.type, dataType: types_1.P2PDataType[message.dataType], data: message.data.toString("hex") } });
+            logging_1.rootP2PLogger.error(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Error`, {
+                error: (0, utils_3.getError)(error),
+                stationSN: this.rawStation.station_sn,
+                message: {
+                    seqNo: message.seqNo,
+                    channel: message.channel,
+                    commandType: types_1.CommandType[message.commandId],
+                    signCode: message.signCode,
+                    type: message.type,
+                    dataType: types_1.P2PDataType[message.dataType],
+                    data: message.data.toString("hex"),
+                },
+            });
         }
     }
     async sendAck(address, dataType, seqNo) {
@@ -2351,7 +3410,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             }, this.getHeartbeatInterval());
         }
         else {
-            logging_1.rootP2PLogger.debug(`Heartbeat not activated because no connection is present!`, { stationSN: this.rawStation.station_sn });
+            logging_1.rootP2PLogger.debug(`Heartbeat not activated because no connection is present!`, {
+                stationSN: this.rawStation.station_sn,
+            });
         }
     }
     scheduleP2PKeepalive() {
@@ -2363,7 +3424,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             this.closeEnergySavingDevice();
         }
         else {
-            logging_1.rootP2PLogger.debug(`P2P keepalive not activated because no connection is present`, { stationSN: this.rawStation.station_sn });
+            logging_1.rootP2PLogger.debug(`P2P keepalive not activated because no connection is present`, {
+                stationSN: this.rawStation.station_sn,
+            });
         }
     }
     getDownloadRSAPrivateKey() {
@@ -2383,27 +3446,29 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         this.currentMessageState[datatype].audioStream?.destroy();
         this.currentMessageState[datatype].videoStream = null;
         this.currentMessageState[datatype].audioStream = null;
-        this.currentMessageState[datatype].videoStream = new stream_1.Readable({ autoDestroy: true,
+        this.currentMessageState[datatype].videoStream = new stream_1.Readable({
+            autoDestroy: true,
             read() { } /*,
-
-            destroy(this, error, _callback) {
-                if (error) {
-                    this.emit("error", error);
-                }
-                this.emit("end");
-                this.emit("close");
-            }*/
+      
+                  destroy(this, error, _callback) {
+                      if (error) {
+                          this.emit("error", error);
+                      }
+                      this.emit("end");
+                      this.emit("close");
+                  }*/,
         });
-        this.currentMessageState[datatype].audioStream = new stream_1.Readable({ autoDestroy: true,
+        this.currentMessageState[datatype].audioStream = new stream_1.Readable({
+            autoDestroy: true,
             read() { } /*,
-
-            destroy(this, error, _callback) {
-                if (error) {
-                    this.emit("error", error);
-                }
-                this.emit("end");
-                this.emit("close");
-            }*/
+      
+                  destroy(this, error, _callback) {
+                      if (error) {
+                          this.emit("error", error);
+                      }
+                      this.emit("end");
+                      this.emit("close");
+                  }*/,
         });
         this.currentMessageState[datatype].p2pStreaming = false;
         if (this.currentMessageState[datatype].waitForSeqNoTimeout !== undefined) {
@@ -2423,11 +3488,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         this.sendCommandWithInt({
                             commandType: types_1.CommandType.CMD_STOP_REALTIME_MEDIA,
                             value: this.currentMessageState[datatype].p2pStreamChannel,
-                            channel: this.currentMessageState[datatype].p2pStreamChannel
+                            channel: this.currentMessageState[datatype].p2pStreamChannel,
                         }, {
                             command: {
-                                name: http_1.CommandName.DeviceStopLivestream
-                            }
+                                name: http_1.CommandName.DeviceStopLivestream,
+                            },
                         });
                         break;
                     case types_1.P2PDataType.BINARY:
@@ -2435,11 +3500,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             commandType: types_1.CommandType.CMD_DOWNLOAD_CANCEL,
                             value: this.currentMessageState[datatype].p2pStreamChannel,
                             strValueSub: this.rawStation.member.admin_user_id,
-                            channel: this.currentMessageState[datatype].p2pStreamChannel
+                            channel: this.currentMessageState[datatype].p2pStreamChannel,
                         }, {
                             command: {
-                                name: http_1.CommandName.DeviceCancelDownload
-                            }
+                                name: http_1.CommandName.DeviceCancelDownload,
+                            },
                         });
                         break;
                 }
@@ -2502,7 +3567,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         return false;
     }
     isRTSPLiveStreaming(channel) {
-        return this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel] ? this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel] : false;
+        return this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel]
+            ? this.currentMessageState[types_1.P2PDataType.DATA].rtspStreaming[channel]
+            : false;
     }
     isDownloading(channel) {
         return this.isStreaming(channel, types_1.P2PDataType.BINARY);
@@ -2542,38 +3609,53 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 const data = {
                     invalid_dsks: {},
                     station_sns: [this.rawStation.station_sn],
-                    transaction: `${new Date().getTime()}`
+                    transaction: `${new Date().getTime()}`,
                 };
                 data.invalid_dsks[this.rawStation.station_sn] = "";
                 const response = await this.api.request({
                     method: "post",
                     endpoint: "v1/app/equipment/get_dsk_keys",
-                    data: data
+                    data: data,
                 });
                 logging_1.rootP2PLogger.debug(`Get DSK keys - Response:`, { stationSN: this.rawStation.station_sn, data: response.data });
                 if (response.status == 200) {
                     const result = response.data;
                     if (result.code == 0) {
                         const dataresult = result.data;
-                        dataresult.dsk_keys.forEach(key => {
+                        dataresult.dsk_keys.forEach((key) => {
                             if (key.station_sn == this.rawStation.station_sn) {
                                 this.dskKey = key.dsk_key;
                                 this.dskExpiration = new Date(key.expiration * 1000);
-                                logging_1.rootP2PLogger.debug(`Get DSK keys - received key and expiration`, { stationSN: this.rawStation.station_sn, dskKey: this.dskKey, dskExpiration: this.dskExpiration });
+                                logging_1.rootP2PLogger.debug(`Get DSK keys - received key and expiration`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    dskKey: this.dskKey,
+                                    dskExpiration: this.dskExpiration,
+                                });
                             }
                         });
                     }
                     else {
-                        logging_1.rootP2PLogger.error(`Get DSK keys - Response code not ok`, { stationSN: this.rawStation.station_sn, code: result.code, msg: result.msg });
+                        logging_1.rootP2PLogger.error(`Get DSK keys - Response code not ok`, {
+                            stationSN: this.rawStation.station_sn,
+                            code: result.code,
+                            msg: result.msg,
+                        });
                     }
                 }
                 else {
-                    logging_1.rootP2PLogger.error(`Get DSK keys - Status return code not 200`, { stationSN: this.rawStation.station_sn, status: response.status, statusText: response.statusText });
+                    logging_1.rootP2PLogger.error(`Get DSK keys - Status return code not 200`, {
+                        stationSN: this.rawStation.station_sn,
+                        status: response.status,
+                        statusText: response.statusText,
+                    });
                 }
             }
             catch (err) {
                 const error = (0, error_1.ensureError)(err);
-                logging_1.rootP2PLogger.error(`Get DSK keys - Generic Error`, { error: (0, utils_3.getError)(error), stationSN: this.rawStation.station_sn });
+                logging_1.rootP2PLogger.error(`Get DSK keys - Generic Error`, {
+                    error: (0, utils_3.getError)(error),
+                    stationSN: this.rawStation.station_sn,
+                });
             }
         }
     }
@@ -2595,15 +3677,21 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             for (const device of this.rawStation.devices) {
                 this.deviceSNs[device.device_channel] = {
                     sn: device.device_sn,
-                    adminUserId: this.rawStation.member.admin_user_id
+                    adminUserId: this.rawStation.member.admin_user_id,
                 };
             }
     }
     initializeTalkbackStream(channel = 0) {
         this.talkbackStream = new talkback_1.TalkbackStream();
-        this.talkbackStream.on("data", (audioData) => { this.sendTalkbackAudioFrame(audioData, channel); });
-        this.talkbackStream.on("error", (error) => { this.onTalkbackStreamError(error); });
-        this.talkbackStream.on("close", () => { this.onTalkbackStreamClose(); });
+        this.talkbackStream.on("data", (audioData) => {
+            this.sendTalkbackAudioFrame(audioData, channel);
+        });
+        this.talkbackStream.on("error", (error) => {
+            this.onTalkbackStreamError(error);
+        });
+        this.talkbackStream.on("close", () => {
+            this.onTalkbackStreamClose();
+        });
     }
     sendTalkbackAudioFrame(audioData, channel) {
         const messageHeader = (0, utils_1.buildCommandHeader)(this.videoSeqNumber, types_1.CommandType.CMD_AUDIO_FRAME, types_1.P2PDataTypeHeader.VIDEO);
@@ -2613,7 +3701,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             sequence: this.videoSeqNumber,
             channel: channel,
             data: messageData,
-            retries: 0
+            retries: 0,
         };
         this.videoSeqNumber = this._incrementSequence(this.videoSeqNumber);
         this._sendVideoData(message);
@@ -2630,9 +3718,16 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             message.retries++;
         }
         else {
-            logging_1.rootP2PLogger.error(`Sending video data - Max send video data retries ${this.messageVideoStates.get(message.sequence)?.retries} reached. Discard data.`, { stationSN: this.rawStation.station_sn, sequence: message.sequence, channel: message.channel, retries: message.retries });
+            logging_1.rootP2PLogger.error(`Sending video data - Max send video data retries ${this.messageVideoStates.get(message.sequence)?.retries} reached. Discard data.`, {
+                stationSN: this.rawStation.station_sn,
+                sequence: message.sequence,
+                channel: message.channel,
+                retries: message.retries,
+            });
             this.messageVideoStates.delete(message.sequence);
-            this.emit("talkback error", message.channel, new error_1.TalkbackError("Max send video data retries reached. Discard data packet.", { context: { station: this.rawStation.station_sn, channel: message.channel, retries: message.retries } }));
+            this.emit("talkback error", message.channel, new error_1.TalkbackError("Max send video data retries reached. Discard data packet.", {
+                context: { station: this.rawStation.station_sn, channel: message.channel, retries: message.retries },
+            }));
             return;
         }
         message = message;
@@ -2640,7 +3735,13 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             this._sendVideoData(message);
         }, this.MAX_AKNOWLEDGE_TIMEOUT);
         this.messageVideoStates.set(message.sequence, message);
-        logging_1.rootP2PLogger.trace("Sending p2p video data...", { station: this.rawStation.station_sn, sequence: message.sequence, channel: message.channel, retries: message.retries, messageVideoStatesSize: this.messageVideoStates.size });
+        logging_1.rootP2PLogger.trace("Sending p2p video data...", {
+            station: this.rawStation.station_sn,
+            sequence: message.sequence,
+            channel: message.channel,
+            retries: message.retries,
+            messageVideoStatesSize: this.messageVideoStates.size,
+        });
         await this.sendMessage(`Send video data`, this.connectAddress, types_1.RequestMessageType.DATA, message.data);
     }
     isTalkbackOngoing(channel) {