matterbridge-roborock-vacuum-plugin 1.1.1-rc01 → 1.1.1-rc02

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -11,9 +11,9 @@ export class AbstractClient {
     messageListeners = new ChainedMessageListener();
     serializer;
     deserializer;
+    context;
     connected = false;
     logger;
-    context;
     syncMessageListener;
     constructor(logger, context) {
         this.context = context;
@@ -40,8 +40,8 @@ export class AbstractClient {
             return undefined;
         });
     }
-    registerDevice(duid, localKey, pv) {
-        this.context.registerDevice(duid, localKey, pv);
+    registerDevice(duid, localKey, pv, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
     }
     registerConnectionListener(listener) {
         this.connectionListeners.register(listener);

package/dist/roborockCommunication/broadcast/client/LocalNetworkClient.js

@@ -148,6 +148,7 @@ export class LocalNetworkClient extends AbstractClient {
         const request = new RequestMessage({
             protocol: Protocol.hello_request,
             messageId: this.messageIdSeq.next(),
+            nonce: this.context.nonce,
         });
         await this.send(this.duid, request);
     }

package/dist/roborockCommunication/broadcast/client/LocalNetworkUDPClient.js

@@ -1,5 +1,5 @@
 import * as dgram from 'node:dgram';
-import { Parser } from 'binary-parser';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
 import { AbstractClient } from '../abstractClient.js';

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -17,8 +17,11 @@ export class ClientRouter {
         this.mqttClient.registerConnectionListener(this.connectionListeners);
         this.mqttClient.registerMessageListener(this.messageListeners);
     }
-    registerDevice(duid, localKey, pv) {
-        this.context.registerDevice(duid, localKey, pv);
+    registerDevice(duid, localKey, pv, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
+    }
+    updateNonce(duid, nonce) {
+        this.context.updateNonce(duid, nonce);
     }
     registerClient(duid, ip) {
         const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);

package/dist/roborockCommunication/broadcast/model/contentMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/headerMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/messageContext.js

@@ -1,18 +1,26 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 import * as CryptoUtils from '../../helper/cryptoHelper.js';
 export class MessageContext {
     endpoint;
-    nonce;
     devices = new Map();
+    nonce;
+    serializeNonce;
     constructor(userdata) {
         this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
-        this.nonce = randomBytes(16);
+        this.nonce = randomInt(1000, 1000000);
+        this.serializeNonce = randomBytes(16);
     }
-    registerDevice(duid, localKey, pv) {
-        this.devices.set(duid, { localKey: localKey, protocolVersion: pv });
+    registerDevice(duid, localKey, pv, nonce) {
+        this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
     }
-    getNonceAsHex() {
-        return this.nonce.toString('hex').toUpperCase();
+    updateNonce(duid, nonce) {
+        const device = this.devices.get(duid);
+        if (device) {
+            device.nonce = nonce;
+        }
+    }
+    getSerializeNonceAsHex() {
+        return this.serializeNonce.toString('hex').toUpperCase();
     }
     getLocalKey(duid) {
         return this.devices.get(duid)?.localKey;
@@ -20,6 +28,9 @@ export class MessageContext {
     getProtocolVersion(duid) {
         return this.devices.get(duid)?.protocolVersion;
     }
+    getDeviceNonce(duid) {
+        return this.devices.get(duid)?.nonce;
+    }
     getEndpoint() {
         return this.endpoint;
     }

package/dist/roborockCommunication/broadcast/model/requestMessage.js

@@ -6,12 +6,16 @@ export class RequestMessage {
     method;
     params;
     secure;
+    timestamp;
+    nonce;
     constructor(args) {
         this.messageId = args.messageId ?? randomInt(10000, 32767);
         this.protocol = args.protocol ?? Protocol.rpc_request;
         this.method = args.method;
         this.params = args.params;
         this.secure = args.secure ?? false;
+        this.nonce = args.nonce ?? randomInt(10000, 32767);
+        this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
     }
     toMqttRequest() {
         return this;
@@ -24,6 +28,7 @@ export class RequestMessage {
                 method: this.method,
                 params: this.params,
                 secure: this.secure,
+                timestamp: this.timestamp,
             });
         }
         else {

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -1,26 +1,29 @@
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
-import { Parser } from 'binary-parser';
 import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import * as CryptoUtils from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
 export class MessageDeserializer {
     context;
-    messageParser;
+    headerMessageParser;
+    contentMessageParser;
     logger;
     supportedVersions = ['1.0', 'A01', 'B01'];
     constructor(context, logger) {
         this.context = context;
         this.logger = logger;
-        this.messageParser = new Parser()
+        this.headerMessageParser = new Parser()
             .endianness('big')
             .string('version', {
             length: 3,
         })
             .uint32('seq')
-            .uint32('random')
+            .uint32('nonce')
             .uint32('timestamp')
-            .uint16('protocol')
+            .uint16('protocol');
+        this.contentMessageParser = new Parser()
+            .endianness('big')
             .uint16('payloadLen')
             .buffer('payload', {
             length: 'payloadLen',
@@ -28,10 +31,21 @@ export class MessageDeserializer {
             .uint32('crc32');
     }
     deserialize(duid, message) {
-        const version = message.toString('latin1', 0, 3);
-        if (!this.supportedVersions.includes(version)) {
-            throw new Error('unknown protocol version ' + version);
+        const header = this.headerMessageParser.parse(message);
+        if (!this.supportedVersions.includes(header.version)) {
+            throw new Error('unknown protocol version ' + header.version);
+        }
+        if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+            const dpsValue = {
+                id: header.seq,
+                result: {
+                    version: header.version,
+                    nonce: header.nonce,
+                },
+            };
+            return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
         }
+        const data = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
         const expectedCrc32 = message.readUInt32BE(message.length - 4);
         if (crc32 != expectedCrc32) {
@@ -42,30 +56,29 @@ export class MessageDeserializer {
             this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
-        const data = this.messageParser.parse(message);
-        if (version == '1.0') {
-            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(data.timestamp) + localKey + CryptoUtils.SALT);
+        if (header.version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
             const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        else if (version == 'A01') {
-            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+        else if (header.version == 'A01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        else if (version == 'B01') {
-            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+        else if (header.version == 'B01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        if (data.protocol == Protocol.map_response) {
+        if (header.protocol == Protocol.map_response) {
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
-        if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
+        if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
             return this.deserializeRpcResponse(duid, data);
         }
         else {
-            this.logger.error('unknown protocol: ' + data.protocol);
+            this.logger.error('unknown protocol: ' + header.protocol);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
     }

package/dist/roborockCommunication/helper/messageSerializer.js

@@ -1,11 +1,12 @@
 import * as CryptoUtils from './cryptoHelper.js';
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
+import { Protocol } from '../broadcast/model/protocol.js';
 export class MessageSerializer {
     context;
     logger;
-    seq = 1;
-    random = 4711;
+    sequence = 1;
+    supportedVersions = ['1.0', 'A01', 'B01'];
     constructor(context, logger) {
         this.context = context;
         this.logger = logger;
@@ -26,23 +27,28 @@ export class MessageSerializer {
         if (request.secure) {
             data.security = {
                 endpoint: this.context.getEndpoint(),
-                nonce: this.context.getNonceAsHex(),
+                nonce: this.context.getSerializeNonceAsHex(),
             };
         }
-        const timestamp = Math.floor(Date.now() / 1000);
         return {
             dps: {
                 [request.protocol]: JSON.stringify(data),
             },
-            t: timestamp,
+            t: request.timestamp,
         };
     }
     buildBuffer(duid, messageId, request) {
         const version = this.context.getProtocolVersion(duid);
+        if (!version || !this.supportedVersions.includes(version)) {
+            throw new Error('unknown protocol version ' + version);
+        }
+        let encrypted;
+        if (request.protocol === Protocol.hello_response || request.protocol === Protocol.ping_response) {
+            encrypted = Buffer.alloc(0);
+        }
         const localKey = this.context.getLocalKey(duid);
         const payloadData = this.buildPayload(messageId, request);
         const payload = JSON.stringify(payloadData);
-        let encrypted;
         if (version == '1.0') {
             const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(payloadData.t) + localKey + CryptoUtils.SALT);
             const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
@@ -50,13 +56,13 @@ export class MessageSerializer {
         }
         else if (version == 'A01') {
             const encoder = new TextEncoder();
-            const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+            const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
             const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
             encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
         }
         else if (version == 'B01') {
             const encoder = new TextEncoder();
-            const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
             const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
             encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
         }
@@ -65,9 +71,9 @@ export class MessageSerializer {
         }
         const msg = Buffer.alloc(23 + encrypted.length);
         msg.write(version);
-        msg.writeUint32BE(this.seq++ & 0xffffffff, 3);
-        msg.writeUint32BE(this.random++ & 0xffffffff, 7);
-        msg.writeUint32BE(payloadData.t, 11);
+        msg.writeUint32BE(this.sequence++ & 0xffffffff, 3);
+        msg.writeUint32BE(request.nonce & 0xffffffff, 7);
+        msg.writeUint32BE(request.timestamp, 11);
         msg.writeUint16BE(request.protocol, 15);
         msg.writeUint16BE(encrypted.length, 17);
         encrypted.copy(msg, 19);

package/dist/roborockService.js

@@ -374,7 +374,7 @@ export default class RoborockService {
         }
         const self = this;
         this.messageClient = this.clientManager.get(username, userdata);
-        this.messageClient.registerDevice(device.duid, device.localKey, device.pv);
+        this.messageClient.registerDevice(device.duid, device.localKey, device.pv, undefined);
         this.messageClient.registerMessageListener({
             onMessage: (message) => {
                 if (message instanceof ResponseMessage) {
@@ -385,6 +385,11 @@ export default class RoborockService {
                         self.deviceNotify(NotifyMessageTypes.CloudMessage, message);
                     }
                 }
+                if (message instanceof ResponseMessage && message.contain(Protocol.hello_response)) {
+                    const dps = message.dps[Protocol.hello_response];
+                    const result = dps.result;
+                    self.messageClient?.updateNonce(message.duid, result.nonce);
+                }
             },
         });
         this.messageClient.connect();

package/dist/rvc.js

@@ -1,5 +1,6 @@
 import { RoboticVacuumCleaner } from 'matterbridge/devices';
 import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
+import { debugStringify } from 'matterbridge/logger';
 import { RvcOperationalState } from 'matterbridge/matter/clusters';
 export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
     username;
@@ -25,7 +26,7 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
     }
     configurateHandler(behaviorHandler) {
         this.addCommandHandler('identify', async ({ request, cluster, attributes, endpoint }) => {
-            this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${attributes}, request: ${JSON.stringify(request)}`);
+            this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${debugStringify(attributes)}, request: ${JSON.stringify(request)}`);
             behaviorHandler.executeCommand('playSoundToLocate', request.identifyTime ?? 0);
         });
         this.addCommandHandler('selectAreas', async ({ request }) => {

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.1-rc01",
+  "version": "1.1.1-rc02",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,

package/matterbridge-roborock-vacuum-plugin.schema.json

@@ -1,6 +1,6 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.1-rc01 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.1-rc02 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.1-rc01",
+  "version": "1.1.1-rc02",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",
@@ -35,7 +35,6 @@
   },
   "dependencies": {
     "@log4js-node/log4js-api": "^1.0.2",
-    "@types/binary-parser": "^1.5.5",
     "@types/node-persist": "^3.1.8",
     "axios": "^1.9.0",
     "binary-parser": "^2.2.1",

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -20,13 +20,13 @@ export abstract class AbstractClient implements Client {
   protected readonly messageListeners = new ChainedMessageListener();
   protected readonly serializer: MessageSerializer;
   protected readonly deserializer: MessageDeserializer;
+  protected readonly context: MessageContext;
   protected connected = false;
   protected logger: AnsiLogger;
 
   protected abstract clientName: string;
   protected abstract shouldReconnect: boolean;
 
-  private readonly context: MessageContext;
   private readonly syncMessageListener: SyncMessageListener;
 
   protected constructor(logger: AnsiLogger, context: MessageContext) {
@@ -62,8 +62,8 @@ export abstract class AbstractClient implements Client {
       });
   }
 
-  public registerDevice(duid: string, localKey: string, pv: string): void {
-    this.context.registerDevice(duid, localKey, pv);
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void {
+    this.context.registerDevice(duid, localKey, pv, nonce);
   }
 
   public registerConnectionListener(listener: AbstractConnectionListener): void {

package/src/roborockCommunication/broadcast/client/LocalNetworkClient.ts

@@ -17,8 +17,9 @@ export class LocalNetworkClient extends AbstractClient {
   private messageIdSeq: Sequence;
   private pingInterval?: NodeJS.Timeout;
   private keepConnectionAliveInterval: NodeJS.Timeout | undefined = undefined;
-  duid: string;
-  ip: string;
+
+  public duid: string;
+  public ip: string;
 
   constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string) {
     super(logger, context);
@@ -184,6 +185,7 @@ export class LocalNetworkClient extends AbstractClient {
     const request = new RequestMessage({
       protocol: Protocol.hello_request,
       messageId: this.messageIdSeq.next(),
+      nonce: this.context.nonce,
     });
 
     await this.send(this.duid, request);

package/src/roborockCommunication/broadcast/client/LocalNetworkUDPClient.ts

@@ -1,6 +1,6 @@
 import * as dgram from 'node:dgram';
 import { Socket } from 'node:dgram';
-import { Parser } from 'binary-parser';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
 import { AnsiLogger } from 'matterbridge/logger';
@@ -16,8 +16,8 @@ export class LocalNetworkUDPClient extends AbstractClient {
   private readonly PORT = 58866;
   private server: Socket | undefined = undefined;
 
-  private readonly V10Parser: Parser<any>;
-  private readonly L01Parser: Parser<any>;
+  private readonly V10Parser: Parser;
+  private readonly L01Parser: Parser;
 
   constructor(logger: AnsiLogger, context: MessageContext) {
     super(logger, context);

package/src/roborockCommunication/broadcast/clientRouter.ts

@@ -28,8 +28,12 @@ export class ClientRouter implements Client {
     this.mqttClient.registerMessageListener(this.messageListeners);
   }
 
-  public registerDevice(duid: string, localKey: string, pv: string): void {
-    this.context.registerDevice(duid, localKey, pv);
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void {
+    this.context.registerDevice(duid, localKey, pv, nonce);
+  }
+
+  public updateNonce(duid: string, nonce: number): void {
+    this.context.updateNonce(duid, nonce);
   }
 
   public registerClient(duid: string, ip: string): Client {

package/src/roborockCommunication/broadcast/model/contentMessage.ts

@@ -0,0 +1,5 @@
+export interface ContentMessage {
+  payloadLen?: number;
+  payload: Buffer<ArrayBufferLike>;
+  crc32: number;
+}

package/src/roborockCommunication/broadcast/model/headerMessage.ts

@@ -0,0 +1,7 @@
+export interface HeaderMessage {
+  version: string;
+  seq: number;
+  nonce: number;
+  timestamp: number;
+  protocol: number;
+}

package/src/roborockCommunication/broadcast/model/messageContext.ts

@@ -1,34 +1,47 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 import * as CryptoUtils from '../../helper/cryptoHelper.js';
 import { UserData } from '../../Zmodel/userData.js';
 
 export class MessageContext {
   private readonly endpoint: string;
-  readonly nonce: Buffer;
-  private readonly devices = new Map<string, { localKey: string; protocolVersion: string }>();
+  private readonly devices = new Map<string, { localKey: string; protocolVersion: string; nonce: number | undefined }>();
+  public readonly nonce: number;
+  public readonly serializeNonce: Buffer;
 
   constructor(userdata: UserData) {
     this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
-    this.nonce = randomBytes(16);
+    this.nonce = randomInt(1000, 1000000);
+    this.serializeNonce = randomBytes(16);
   }
 
-  registerDevice(duid: string, localKey: string, pv: string) {
-    this.devices.set(duid, { localKey: localKey, protocolVersion: pv });
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined) {
+    this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
   }
 
-  getNonceAsHex(): string {
-    return this.nonce.toString('hex').toUpperCase();
+  public updateNonce(duid: string, nonce: number): void {
+    const device = this.devices.get(duid);
+    if (device) {
+      device.nonce = nonce;
+    }
   }
 
-  getLocalKey(duid: string): string | undefined {
+  public getSerializeNonceAsHex(): string {
+    return this.serializeNonce.toString('hex').toUpperCase();
+  }
+
+  public getLocalKey(duid: string): string | undefined {
     return this.devices.get(duid)?.localKey;
   }
 
-  getProtocolVersion(duid: string): string | undefined {
+  public getProtocolVersion(duid: string): string | undefined {
     return this.devices.get(duid)?.protocolVersion;
   }
 
-  getEndpoint(): string {
+  public getDeviceNonce(duid: string): number | undefined {
+    return this.devices.get(duid)?.nonce;
+  }
+
+  public getEndpoint(): string {
     return this.endpoint;
   }
 }

package/src/roborockCommunication/broadcast/model/requestMessage.ts

@@ -7,14 +7,18 @@ export interface ProtocolRequest {
   method?: string | undefined;
   params?: unknown[] | Record<string, unknown> | undefined;
   secure?: boolean;
+  nonce?: number;
+  timestamp?: number;
 }
 
 export class RequestMessage {
-  readonly messageId: number;
-  readonly protocol: Protocol;
-  readonly method: string | undefined;
-  readonly params: unknown[] | Record<string, unknown> | undefined;
-  readonly secure: boolean;
+  public readonly messageId: number;
+  public readonly protocol: Protocol;
+  public readonly method: string | undefined;
+  public readonly params: unknown[] | Record<string, unknown> | undefined;
+  public readonly secure: boolean;
+  public readonly timestamp: number;
+  public readonly nonce: number;
 
   constructor(args: ProtocolRequest) {
     this.messageId = args.messageId ?? randomInt(10000, 32767);
@@ -22,6 +26,8 @@ export class RequestMessage {
     this.method = args.method;
     this.params = args.params;
     this.secure = args.secure ?? false;
+    this.nonce = args.nonce ?? randomInt(10000, 32767);
+    this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
   }
 
   toMqttRequest() {
@@ -36,6 +42,7 @@ export class RequestMessage {
         method: this.method,
         params: this.params,
         secure: this.secure,
+        timestamp: this.timestamp,
       });
     } else {
       return this;

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -1,26 +1,19 @@
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
-import { Parser } from 'binary-parser';
 import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import * as CryptoUtils from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
 import { MessageContext } from '../broadcast/model/messageContext.js';
 import { AnsiLogger } from 'matterbridge/logger';
-
-export interface Message {
-  version: string;
-  seq: number;
-  random: number;
-  timestamp: number;
-  protocol: number;
-  payloadLen?: number;
-  payload: Buffer<ArrayBufferLike>;
-  crc32: number;
-}
+import { Parser } from 'binary-parser/dist/binary_parser.js';
+import { ContentMessage } from '../broadcast/model/contentMessage.js';
+import { HeaderMessage } from '../broadcast/model/headerMessage.js';
+import { DpsPayload } from '../broadcast/model/dps.js';
 
 export class MessageDeserializer {
   private readonly context: MessageContext;
-  private readonly messageParser: Parser<Message>;
+  private readonly headerMessageParser: Parser;
+  private readonly contentMessageParser: Parser;
   private readonly logger: AnsiLogger;
   private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
@@ -28,15 +21,18 @@ export class MessageDeserializer {
     this.context = context;
     this.logger = logger;
 
-    this.messageParser = new Parser()
+    this.headerMessageParser = new Parser()
       .endianness('big')
       .string('version', {
         length: 3,
       })
       .uint32('seq')
-      .uint32('random')
+      .uint32('nonce')
       .uint32('timestamp')
-      .uint16('protocol')
+      .uint16('protocol');
+
+    this.contentMessageParser = new Parser()
+      .endianness('big')
       .uint16('payloadLen')
       .buffer('payload', {
         length: 'payloadLen',
@@ -45,53 +41,68 @@ export class MessageDeserializer {
   }
 
   public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
-    const version = message.toString('latin1', 0, 3);
-    if (!this.supportedVersions.includes(version)) {
-      throw new Error('unknown protocol version ' + version);
+    // check message header
+    const header: HeaderMessage = this.headerMessageParser.parse(message);
+    if (!this.supportedVersions.includes(header.version)) {
+      throw new Error('unknown protocol version ' + header.version);
     }
 
+    if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+      const dpsValue: DpsPayload = {
+        id: header.seq,
+        result: {
+          version: header.version,
+          nonce: header.nonce,
+        },
+      };
+      return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
+    }
+
+    // parse message content
+    const data: ContentMessage = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
+
+    // check crc32
     const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
     const expectedCrc32 = message.readUInt32BE(message.length - 4);
     if (crc32 != expectedCrc32) {
       throw new Error(`Wrong CRC32 ${crc32}, expected ${expectedCrc32}`);
     }
+
     const localKey = this.context.getLocalKey(duid);
     if (!localKey) {
       this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
 
-    const data: Message = this.messageParser.parse(message);
-
-    if (version == '1.0') {
-      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(data.timestamp) + localKey + CryptoUtils.SALT);
+    if (header.version == '1.0') {
+      const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
       const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
-    } else if (version == 'A01') {
-      const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+    } else if (header.version == 'A01') {
+      const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
-    } else if (version == 'B01') {
-      const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+    } else if (header.version == 'B01') {
+      const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
       const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
       // unpad ??
       data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
     }
 
     // map visualization not support
-    if (data.protocol == Protocol.map_response) {
+    if (header.protocol == Protocol.map_response) {
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
 
-    if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
+    if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
       return this.deserializeRpcResponse(duid, data);
     } else {
-      this.logger.error('unknown protocol: ' + data.protocol);
+      this.logger.error('unknown protocol: ' + header.protocol);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
   }
 
-  private deserializeRpcResponse(duid: string, data: Message): ResponseMessage {
+  private deserializeRpcResponse(duid: string, data: ContentMessage): ResponseMessage {
     const payload = JSON.parse(data.payload.toString());
     const dps = payload.dps;
     this.parseJsonInDps(dps, Protocol.general_request);

package/src/roborockCommunication/helper/messageSerializer.ts

@@ -5,19 +5,20 @@ import CRC32 from 'crc-32';
 import { DpsPayload, Payload } from '../broadcast/model/dps.js';
 import { MessageContext } from '../broadcast/model/messageContext.js';
 import { AnsiLogger } from 'matterbridge/logger';
+import { Protocol } from '../broadcast/model/protocol.js';
 
 export class MessageSerializer {
   private readonly context: MessageContext;
   private readonly logger: AnsiLogger;
-  private seq = 1;
-  private random = 4711;
+  private sequence = 1;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
   constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
     this.logger = logger;
   }
 
-  serialize(duid: string, request: RequestMessage): { messageId: number; buffer: Buffer<ArrayBufferLike> } {
+  public serialize(duid: string, request: RequestMessage): { messageId: number; buffer: Buffer<ArrayBufferLike> } {
     const messageId = request.messageId;
     const buffer = this.buildBuffer(duid, messageId, request);
     return { messageId: messageId, buffer: buffer };
@@ -35,27 +36,31 @@ export class MessageSerializer {
     if (request.secure) {
       data.security = {
         endpoint: this.context.getEndpoint(),
-        nonce: this.context.getNonceAsHex(),
+        nonce: this.context.getSerializeNonceAsHex(),
       };
     }
-
-    const timestamp = Math.floor(Date.now() / 1000);
     return {
       dps: {
         [request.protocol]: JSON.stringify(data),
       },
-      t: timestamp,
+      t: request.timestamp,
     };
   }
 
   private buildBuffer(duid: string, messageId: number, request: RequestMessage): Buffer<ArrayBufferLike> {
     const version = this.context.getProtocolVersion(duid);
-    const localKey = this.context.getLocalKey(duid);
+    if (!version || !this.supportedVersions.includes(version)) {
+      throw new Error('unknown protocol version ' + version);
+    }
+    let encrypted;
+    if (request.protocol === Protocol.hello_response || request.protocol === Protocol.ping_response) {
+      encrypted = Buffer.alloc(0);
+    }
 
+    const localKey = this.context.getLocalKey(duid);
     const payloadData = this.buildPayload(messageId, request);
     const payload = JSON.stringify(payloadData);
 
-    let encrypted;
     if (version == '1.0') {
       const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(payloadData.t) + localKey + CryptoUtils.SALT);
       const cipher = crypto.createCipheriv('aes-128-ecb', aesKey, null);
@@ -63,12 +68,12 @@ export class MessageSerializer {
     } else if (version == 'A01') {
       // 726f626f726f636b2d67a6d6da is in version 4.0 of the roborock app
       const encoder = new TextEncoder();
-      const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
       encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
     } else if (version == 'B01') {
       const encoder = new TextEncoder();
-      const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+      const iv = CryptoUtils.md5hex(request.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
       const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
       // pad ??
       encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
@@ -78,9 +83,9 @@ export class MessageSerializer {
 
     const msg = Buffer.alloc(23 + encrypted.length);
     msg.write(version);
-    msg.writeUint32BE(this.seq++ & 0xffffffff, 3);
-    msg.writeUint32BE(this.random++ & 0xffffffff, 7);
-    msg.writeUint32BE(payloadData.t, 11);
+    msg.writeUint32BE(this.sequence++ & 0xffffffff, 3);
+    msg.writeUint32BE(request.nonce & 0xffffffff, 7);
+    msg.writeUint32BE(request.timestamp, 11);
     msg.writeUint16BE(request.protocol, 15);
     msg.writeUint16BE(encrypted.length, 17);
     encrypted.copy(msg, 19);

package/src/roborockService.ts

@@ -25,6 +25,7 @@ import type { AbstractMessageHandler, AbstractMessageListener, BatteryMessage, D
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import { LocalNetworkClient } from './roborockCommunication/broadcast/client/LocalNetworkClient.js';
 import { RoomIndexMap } from './model/roomIndexMap.js';
+import { DpsPayload } from './roborockCommunication/broadcast/model/dps.js';
 export type Factory<A, T> = (logger: AnsiLogger, arg: A) => T;
 
 export default class RoborockService {
@@ -479,7 +480,7 @@ export default class RoborockService {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this.messageClient = this.clientManager.get(username, userdata);
-    this.messageClient.registerDevice(device.duid, device.localKey, device.pv);
+    this.messageClient.registerDevice(device.duid, device.localKey, device.pv, undefined);
 
     this.messageClient.registerMessageListener({
       onMessage: (message: ResponseMessage) => {
@@ -493,6 +494,12 @@ export default class RoborockService {
             self.deviceNotify(NotifyMessageTypes.CloudMessage, message);
           }
         }
+
+        if (message instanceof ResponseMessage && message.contain(Protocol.hello_response)) {
+          const dps = message.dps[Protocol.hello_response] as DpsPayload;
+          const result = dps.result as { nonce: number };
+          self.messageClient?.updateNonce(message.duid, result.nonce);
+        }
       },
     } as AbstractMessageListener);
 

package/src/rvc.ts

@@ -2,7 +2,7 @@ import { RoboticVacuumCleaner } from 'matterbridge/devices';
 import { RoomMap } from './model/RoomMap.js';
 import { Device } from './roborockCommunication/index.js';
 import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
-import { AnsiLogger } from 'matterbridge/logger';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { BehaviorFactoryResult } from './behaviorFactory.js';
 import { ModeBase, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
 import { ExperimentalFeatureSetting } from './model/ExperimentalFeatureSetting.js';
@@ -63,7 +63,7 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
 
   public configurateHandler(behaviorHandler: BehaviorFactoryResult): void {
     this.addCommandHandler('identify', async ({ request, cluster, attributes, endpoint }) => {
-      this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${attributes}, request: ${JSON.stringify(request)}`);
+      this.log.info(`Identify command received for endpoint ${endpoint}, cluster ${cluster}, attributes ${debugStringify(attributes)}, request: ${JSON.stringify(request)}`);
       behaviorHandler.executeCommand('playSoundToLocate', (request as { identifyTime?: number }).identifyTime ?? 0);
     });
 

package/src/tests/roborockCommunication/broadcast/client/LocalNetworkClient.test.ts

@@ -1,25 +1,6 @@
 import { LocalNetworkClient } from '../../../../roborockCommunication/broadcast/client/LocalNetworkClient';
 import { Protocol } from '../../../../roborockCommunication/broadcast/model/protocol';
 
-// Pseudocode plan:
-// 1. Mock dependencies: Socket, AnsiLogger, MessageContext, RequestMessage, Protocol, serializer/deserializer.
-// 2. Test constructor initializes fields correctly.
-// 3. Test connect(): should create a Socket, set up event handlers, and call socket.connect with correct params.
-// 4. Test disconnect(): should destroy socket, clear ping interval, and set socket to undefined.
-// 5. Test send():
-//    - If socket is not connected, should log error and not write.
-//    - If connected, should serialize and write the message.
-// 6. Test onConnect(): sets connected, logs, sends hello, sets ping interval, calls connectionListeners.onConnected.
-// 7. Test onDisconnect(): logs, sets connected false, destroys socket, clears ping interval, calls connectionListeners.onDisconnected.
-// 8. Test onError(): logs, sets connected false, destroys socket, calls connectionListeners.onError.
-// 9. Test onMessage():
-//    - If no socket, logs error.
-//    - If empty message, logs debug.
-//    - If valid, appends, checks completeness, deserializes, calls messageListeners.onMessage.
-// 10. Test isMessageComplete(): returns true/false for various buffer scenarios.
-// 11. Test wrapWithLengthData(): prepends length to buffer.
-// 12. Test sendHelloMessage() and sendPingRequest(): calls send with correct protocol.
-
 const Sket = jest.fn();
 
 jest.mock('node:net', () => {

package/src/tests/roborockCommunication/broadcast/client/MQTTClient.test.ts

@@ -1,37 +1,5 @@
 import { MQTTClient } from '../../../../roborockCommunication/broadcast/client/MQTTClient';
 
-// Pseudocode plan:
-// 1. Mock dependencies: mqtt, CryptoUtils, AbstractClient, serializer, deserializer, logger, connectionListeners, messageListeners.
-// 2. Test constructor: verify username/password are generated as expected.
-// 3. Test connect():
-//    - Should call mqtt.connect with correct params.
-//    - Should set up event listeners.
-//    - Should not connect if already connected.
-// 4. Test disconnect():
-//    - Should call client.end if connected.
-//    - Should not call if not connected.
-//    - Should log error if exception thrown.
-// 5. Test send():
-//    - Should publish correct topic/message if connected.
-//    - Should log error if not connected.
-// 6. Test onConnect():
-//    - Should set connected, call onConnected, subscribeToQueue.
-// 7. Test subscribeToQueue():
-//    - Should call client.subscribe with correct topic.
-// 8. Test onSubscribe():
-//    - Should log error and call onDisconnected if error.
-//    - Should do nothing if no error.
-// 9. Test onDisconnect():
-//    - Should call onDisconnected.
-// 10. Test onError():
-//    - Should log error, set connected false, call onError.
-// 11. Test onReconnect():
-//    - Should call subscribeToQueue.
-// 12. Test onMessage():
-//    - Should call deserializer and messageListeners.onMessage if message.
-//    - Should log notice if message is falsy.
-//    - Should log error if deserializer throws.
-
 const mockConnect = jest.fn();
 jest.mock('mqtt', () => {
   const actual = jest.requireActual('mqtt');