/** * @license * Copyright 2022-2026 Matter.js Authors * SPDX-License-Identifier: Apache-2.0 */ import type { ExchangeLogContext } from "#protocol/MessageExchange.js"; import { Bytes } from "@matter/general"; import { NodeId } from "@matter/types"; export interface PacketHeader { sessionId: number; sessionType: SessionType; hasPrivacyEnhancements: boolean; isControlMessage: boolean; hasMessageExtensions: boolean; messageId: number; sourceNodeId?: NodeId; destNodeId?: NodeId; destGroupId?: number; } export interface DecodedPacketHeader extends PacketHeader { securityFlags: number; } export interface PayloadHeader { exchangeId: number; protocolId: number; messageType: number; isInitiatorMessage: boolean; requiresAck: boolean; ackedMessageId?: number; hasSecuredExtension: boolean; } export interface Packet { header: PacketHeader; messageExtension?: Bytes; applicationPayload: Bytes; /** Optional pre-serialized (and possibly privacy-obfuscated) header bytes; used instead of re-encoding `header`. */ headerBytes?: Bytes; } export interface DecodedPacket extends Packet { header: DecodedPacketHeader; /** For privacy-enhanced packets: the still-obfuscated header region (message counter + node/group IDs). */ privacyHeader?: Bytes; } export interface Message { packetHeader: PacketHeader; payloadHeader: PayloadHeader; securityExtension?: Bytes; payload: Bytes; /** * Source IP address of the datagram an inbound group message arrived in. Group sessions have no channel and serve * every datagram of one source node and key, so the address belongs to the message, not the session. */ receivedFrom?: string; } export declare namespace Message { function via({ via }: { via: string; }, { packetHeader: { messageId } }: Message): string; function diagnosticsOf(context: { via: string; }, message: Message, logContext?: ExchangeLogContext): Record; } export interface DecodedMessage extends Message { packetHeader: DecodedPacketHeader; } export declare enum SessionType { Group = 1, Unicast = 0 } export declare class MessageCodec { /** * Decode the cleartext header prefix (flags, sessionId, securityFlags) and optionally the obfuscated * header region for privacy-enhanced packets. Returns parsed fields for cleartext portion and raw * obfuscated region for privacy packets. */ static decodeFixedHeader(data: Bytes): { flags: number; sessionType: SessionType; hasPrivacyEnhancements: boolean; hasMessageExtensions: boolean; sessionId: number; securityFlags: number; messageId?: number; sourceNodeId?: bigint; destNodeId?: bigint; destGroupId?: number; obfuscatedRegion?: Bytes; /** Bytes following the fixed (and, for privacy packets, obfuscated) header — the encrypted/cleartext tail. */ applicationPayload: Bytes; }; static decodePacket(data: Bytes): DecodedPacket; /** * Decode the message counter and node/group IDs from a deobfuscated privacy header region. Presence of each field * is determined from the (cleartext) message flags byte. */ static decodeObfuscatedHeaderFields(messageFlags: number, region: Bytes): Pick; static decodePayload({ header, applicationPayload }: DecodedPacket): DecodedMessage; static encodePayload({ packetHeader, payloadHeader, payload, securityExtension }: Message): Packet; static encodePacket({ header, applicationPayload, messageExtension, headerBytes }: Packet): Bytes; private static decodePayloadHeader; static encodePacketHeader({ messageId: messageCounter, sessionId, destGroupId, destNodeId, sourceNodeId, sessionType, hasPrivacyEnhancements, }: PacketHeader): Uint8Array; private static encodePayloadHeader; } //# sourceMappingURL=MessageCodec.d.ts.map