@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/es/protocol/ExchangeManager.js

@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { MessageCodec } from "../codec/MessageCodec.js";
+import { Crypto } from "../crypto/Crypto.js";
+import { MessageExchange } from "./MessageExchange.js";
+import { Logger } from "../log/Logger.js";
+import { INTERACTION_PROTOCOL_ID } from "../protocol/interaction/InteractionServer.js";
+const logger = Logger.get("ExchangeManager");
+export class MessageChannel {
+    constructor(channel, session) {
+        this.channel = channel;
+        this.session = session;
+    }
+    send(message) {
+        logger.debug("sending", MessageCodec.messageToString(message));
+        const packet = this.session.encode(message);
+        const bytes = MessageCodec.encodePacket(packet);
+        return this.channel.send(bytes);
+    }
+    getName() {
+        return `${this.channel.getName()} on session ${this.session.getName()}`;
+    }
+}
+export class ExchangeManager {
+    constructor(sessionManager, channelManager) {
+        this.sessionManager = sessionManager;
+        this.channelManager = channelManager;
+        this.exchangeCounter = new ExchangeCounter();
+        this.messageCounter = new MessageCounter();
+        this.exchanges = new Map();
+        this.protocols = new Map();
+        this.netListeners = new Array();
+    }
+    addNetInterface(netInterface) {
+        this.netListeners.push(netInterface.onData((socket, data) => {
+            this.onMessage(socket, data)
+                .catch(error => logger.error(error));
+        }));
+    }
+    addProtocolHandler(protocol) {
+        this.protocols.set(protocol.getId(), protocol);
+    }
+    initiateExchange(fabric, nodeId, protocolId) {
+        return this.initiateExchangeWithChannel(this.channelManager.getChannel(fabric, nodeId), protocolId);
+    }
+    initiateExchangeWithChannel(channel, protocolId) {
+        const exchangeId = this.exchangeCounter.getIncrementedCounter();
+        const exchangeIndex = exchangeId | 0x10000; // Ensure initiated and received exchange index are different, since the exchangeID can be the same
+        const exchange = MessageExchange.initiate(channel, exchangeId, protocolId, this.messageCounter, () => this.exchanges.delete(exchangeIndex));
+        // Ensure exchangeIds are not colliding in the Map by adding 1 in front of exchanges initiated by this device.
+        this.exchanges.set(exchangeIndex, exchange);
+        return exchange;
+    }
+    close() {
+        this.netListeners.forEach(netListener => netListener.close());
+        this.netListeners.length = 0;
+        [...this.exchanges.values()].forEach(exchange => exchange.close());
+        this.exchanges.clear();
+    }
+    onMessage(channel, messageBytes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packet = MessageCodec.decodePacket(messageBytes);
+            if (packet.header.sessionType === 1 /* SessionType.Group */)
+                throw new Error("Group messages are not supported");
+            const session = this.sessionManager.getSession(packet.header.sessionId);
+            if (session === undefined)
+                throw new Error(`Cannot find a session for ID ${packet.header.sessionId}`);
+            const message = session.decode(packet);
+            const exchangeIndex = message.payloadHeader.isInitiatorMessage ? message.payloadHeader.exchangeId : (message.payloadHeader.exchangeId | 0x10000);
+            const exchange = this.exchanges.get(exchangeIndex);
+            if (exchange !== undefined) {
+                yield exchange.onMessageReceived(message);
+            }
+            else {
+                const exchange = MessageExchange.fromInitialMessage(this.channelManager.getOrCreateChannel(channel, session), this.messageCounter, message, () => this.exchanges.delete(exchangeIndex));
+                this.exchanges.set(exchangeIndex, exchange);
+                yield exchange.onMessageReceived(message);
+                const protocolHandler = this.protocols.get(message.payloadHeader.protocolId);
+                if (protocolHandler === undefined)
+                    throw new Error(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+                yield protocolHandler.onNewExchange(exchange, message);
+            }
+        });
+    }
+}
+export class ExchangeCounter {
+    constructor() {
+        this.exchangeCounter = Crypto.getRandomUInt16();
+    }
+    getIncrementedCounter() {
+        this.exchangeCounter++;
+        if (this.exchangeCounter > 0xFFFF) {
+            this.exchangeCounter = 0;
+        }
+        return this.exchangeCounter;
+    }
+}
+export class MessageCounter {
+    constructor() {
+        this.messageCounter = Crypto.getRandomUInt32();
+    }
+    getIncrementedCounter() {
+        this.messageCounter++;
+        if (this.messageCounter > 0xFFFFFFFF) {
+            this.messageCounter = 0;
+        }
+        return this.messageCounter;
+    }
+}
+export class ExchangeProvider {
+    constructor(exchangeManager, channel, reconnectChannelFunc) {
+        this.exchangeManager = exchangeManager;
+        this.channel = channel;
+        this.reconnectChannelFunc = reconnectChannelFunc;
+    }
+    addProtocolHandler(handler) {
+        this.exchangeManager.addProtocolHandler(handler);
+    }
+    initiateExchange() {
+        return this.exchangeManager.initiateExchangeWithChannel(this.channel, INTERACTION_PROTOCOL_ID);
+    }
+    reconnectChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.reconnectChannelFunc === undefined)
+                return false;
+            this.channel = yield this.reconnectChannelFunc();
+            return true;
+        });
+    }
+}

package/dist/es/protocol/MessageExchange.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from "../codec/MessageCodec.js";
+import { Session } from "../session/Session.js";
+import { MessageChannel, MessageCounter } from "./ExchangeManager.js";
+import { NodeId } from "../datatype/NodeId.js";
+import { MatterError } from "../common/MatterError.js";
+import { ByteArray } from "../util/ByteArray.js";
+export declare class RetransmissionLimitReachedError extends MatterError {
+}
+export declare class UnexpectedMessageError extends MatterError {
+    readonly receivedMessage: Message;
+    constructor(message: string, receivedMessage: Message);
+}
+export declare class MessageExchange<ContextT> {
+    readonly session: Session<ContextT>;
+    readonly channel: MessageChannel<ContextT>;
+    private readonly messageCounter;
+    private readonly isInitiator;
+    private readonly peerSessionId;
+    private readonly nodeId;
+    private readonly peerNodeId;
+    private readonly exchangeId;
+    private readonly protocolId;
+    private readonly closeCallback;
+    static fromInitialMessage<ContextT>(channel: MessageChannel<ContextT>, messageCounter: MessageCounter, initialMessage: Message, closeCallback: () => void): MessageExchange<ContextT>;
+    static initiate<ContextT>(channel: MessageChannel<ContextT>, exchangeId: number, protocolId: number, messageCounter: MessageCounter, closeCallback: () => void): MessageExchange<ContextT>;
+    private readonly activeRetransmissionTimeoutMs;
+    private readonly idleRetransmissionTimeoutMs;
+    private readonly retransmissionRetries;
+    private readonly messagesQueue;
+    private receivedMessageToAck;
+    private sentMessageToAck;
+    private sentMessageAckSuccess;
+    private sentMessageAckFailure;
+    private retransmissionTimer;
+    constructor(session: Session<ContextT>, channel: MessageChannel<ContextT>, messageCounter: MessageCounter, isInitiator: boolean, peerSessionId: number, nodeId: NodeId | undefined, peerNodeId: NodeId | undefined, exchangeId: number, protocolId: number, closeCallback: () => void);
+    onMessageReceived(message: Message): Promise<void>;
+    send(messageType: number, payload: ByteArray, expectAckOnly?: boolean): Promise<void>;
+    nextMessage(): Promise<Message>;
+    waitFor(messageType: number): Promise<Message>;
+    /** @see {@link MatterCoreSpecificationV1_0}, section 4.11.2.1 */
+    private getResubmissionBackOffTime;
+    private retransmitMessage;
+    close(): void;
+    private closeInternal;
+}
+//# sourceMappingURL=MessageExchange.d.ts.map

package/dist/es/protocol/MessageExchange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageExchange.d.ts","sourceRoot":"","sources":["../../../src/protocol/MessageExchange.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAA6B,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAE,OAAO,EAAsD,MAAM,uBAAuB,CAAC;AAEpG,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAMjD,qBAAa,+BAAgC,SAAQ,WAAW;CAAI;AAEpE,qBAAa,sBAAuB,SAAQ,WAAW;aAG/B,eAAe,EAAE,OAAO;gBADxC,OAAO,EAAE,MAAM,EACC,eAAe,EAAE,OAAO;CAI/C;AAiBD,qBAAa,eAAe,CAAC,QAAQ;IAwD7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAhElC,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAC9B,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EACjC,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,OAAO,EACvB,aAAa,EAAE,MAAM,IAAI;IAkB7B,MAAM,CAAC,QAAQ,CAAC,QAAQ,EACpB,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,cAAc,EAC9B,aAAa,EAAE,MAAM,IAAI;IAiB7B,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAS;IACvD,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAS;IACrD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAwB;IACtD,OAAO,CAAC,oBAAoB,CAAsB;IAClD,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,qBAAqB,CAAyC;IACtE,OAAO,CAAC,qBAAqB,CAAwC;IACrE,OAAO,CAAC,mBAAmB,CAAoB;gBAGlC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EACzB,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,IAAI;IASxC,iBAAiB,CAAC,OAAO,EAAE,OAAO;IAqDlC,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,UAAQ;IAoDzE,WAAW;IAIL,OAAO,CAAC,WAAW,EAAE,MAAM;IAQjC,iEAAiE;IACjE,OAAO,CAAC,0BAA0B;IAKlC,OAAO,CAAC,iBAAiB;IA4BzB,KAAK;IAUL,OAAO,CAAC,aAAa;CAKxB"}

package/dist/es/protocol/MessageExchange.js

@@ -0,0 +1,234 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { MessageCodec } from "../codec/MessageCodec.js";
+import { SLEEPY_ACTIVE_INTERVAL_MS, SLEEPY_IDLE_INTERVAL_MS } from "../session/Session.js";
+import { SecureChannelProtocol } from "./securechannel/SecureChannelProtocol.js";
+import { MatterError } from "../common/MatterError.js";
+import { Logger } from "../log/Logger.js";
+import { Queue } from "../util/Queue.js";
+import { Time } from "../time/Time.js";
+import { ByteArray } from "../util/ByteArray.js";
+import { SECURE_CHANNEL_PROTOCOL_ID } from "./securechannel/SecureChannelMessages.js";
+import { getPromiseResolver } from "../util/Promises.js";
+const logger = Logger.get("MessageExchange");
+export class RetransmissionLimitReachedError extends MatterError {
+}
+export class UnexpectedMessageError extends MatterError {
+    constructor(message, receivedMessage) {
+        super(`(${MessageCodec.messageToString(receivedMessage)}) ${message}`);
+        this.receivedMessage = receivedMessage;
+    }
+}
+/** The base number for the exponential backoff equation. */
+const MRP_BACKOFF_BASE = 1.6;
+/** The scaler for random jitter in the backoff equation. */
+const MRP_BACKOFF_JITTER = 0.25;
+/** The scaler margin increase to backoff over the peer sleepy interval. */
+const MRP_BACKOFF_MARGIN = 1.1;
+/** The number of retransmissions before transitioning from linear to exponential backoff. */
+const MRP_BACKOFF_THRESHOLD = 1;
+/** @see {@link MatterCoreSpecificationV1_0}, section 4.11.2.1 */
+const MAXIMUM_TRANSMISSION_TIME_MS = 9495; // 413 + 825 + 1485 + 2541 + 4231 ms as per specs
+export class MessageExchange {
+    static fromInitialMessage(channel, messageCounter, initialMessage, closeCallback) {
+        const { session } = channel;
+        const exchange = new MessageExchange(session, channel, messageCounter, false, session.getId(), initialMessage.packetHeader.destNodeId, initialMessage.packetHeader.sourceNodeId, initialMessage.payloadHeader.exchangeId, initialMessage.payloadHeader.protocolId, closeCallback);
+        return exchange;
+    }
+    static initiate(channel, exchangeId, protocolId, messageCounter, closeCallback) {
+        const { session } = channel;
+        return new MessageExchange(session, channel, messageCounter, true, session.getPeerSessionId(), session.getNodeId(), session.getPeerNodeId(), exchangeId, protocolId, closeCallback);
+    }
+    constructor(session, channel, messageCounter, isInitiator, peerSessionId, nodeId, peerNodeId, exchangeId, protocolId, closeCallback) {
+        this.session = session;
+        this.channel = channel;
+        this.messageCounter = messageCounter;
+        this.isInitiator = isInitiator;
+        this.peerSessionId = peerSessionId;
+        this.nodeId = nodeId;
+        this.peerNodeId = peerNodeId;
+        this.exchangeId = exchangeId;
+        this.protocolId = protocolId;
+        this.closeCallback = closeCallback;
+        this.messagesQueue = new Queue();
+        const { activeRetransmissionTimeoutMs, idleRetransmissionTimeoutMs, retransmissionRetries } = session.getMrpParameters();
+        this.activeRetransmissionTimeoutMs = activeRetransmissionTimeoutMs !== null && activeRetransmissionTimeoutMs !== void 0 ? activeRetransmissionTimeoutMs : SLEEPY_ACTIVE_INTERVAL_MS;
+        this.idleRetransmissionTimeoutMs = idleRetransmissionTimeoutMs !== null && idleRetransmissionTimeoutMs !== void 0 ? idleRetransmissionTimeoutMs : SLEEPY_IDLE_INTERVAL_MS;
+        this.retransmissionRetries = retransmissionRetries;
+        logger.debug("new MessageExchange", this.protocolId, this.exchangeId, this.activeRetransmissionTimeoutMs, this.idleRetransmissionTimeoutMs, this.retransmissionRetries);
+    }
+    onMessageReceived(message) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { packetHeader: { messageId }, payloadHeader: { requiresAck, ackedMessageId, protocolId, messageType } } = message;
+            logger.debug("onMessageReceived", this.protocolId, MessageCodec.messageToString(message));
+            this.session.notifyActivity(true);
+            if (messageId === ((_a = this.receivedMessageToAck) === null || _a === void 0 ? void 0 : _a.packetHeader.messageId)) {
+                // Received a message retransmission but the reply is not ready yet, ignoring
+                if (requiresAck) {
+                    yield this.send(16 /* MessageType.StandaloneAck */, new ByteArray(0));
+                }
+                return;
+            }
+            if (messageId === ((_b = this.sentMessageToAck) === null || _b === void 0 ? void 0 : _b.payloadHeader.ackedMessageId)) {
+                // Received a message retransmission, this means that the other side didn't get our ack
+                // Resending the previous reply message which contains the ack
+                yield this.channel.send(this.sentMessageToAck);
+                return;
+            }
+            const sentMessageIdToAck = (_c = this.sentMessageToAck) === null || _c === void 0 ? void 0 : _c.packetHeader.messageId;
+            if (sentMessageIdToAck !== undefined) {
+                if (ackedMessageId === undefined) {
+                    // The message has no ack, but one previous message sent still needs to be acked.
+                    throw new Error("Previous message ack is missing");
+                }
+                else if (ackedMessageId !== sentMessageIdToAck) {
+                    // The message has an ack for another message.
+                    if (SecureChannelProtocol.isStandaloneAck(protocolId, messageType)) {
+                        // Ignore if this is a standalone ack, probably this was a retransmission.
+                    }
+                    else {
+                        throw new Error(`Incorrect ack received. Expected ${sentMessageIdToAck}, received: ${ackedMessageId}`);
+                    }
+                }
+                else {
+                    // The other side has received our previous message
+                    (_d = this.retransmissionTimer) === null || _d === void 0 ? void 0 : _d.stop();
+                    (_e = this.sentMessageAckSuccess) === null || _e === void 0 ? void 0 : _e.call(this, message);
+                    this.sentMessageAckSuccess = undefined;
+                    this.sentMessageAckFailure = undefined;
+                    this.sentMessageToAck = undefined;
+                }
+            }
+            if (SecureChannelProtocol.isStandaloneAck(protocolId, messageType)) {
+                // Don't include standalone acks in the message stream
+                return;
+            }
+            if (protocolId !== this.protocolId) {
+                throw new Error(`Received a message for an unexpected protocol. Expected: ${this.protocolId}, received: ${protocolId}`);
+            }
+            if (requiresAck) {
+                this.receivedMessageToAck = message;
+            }
+            yield this.messagesQueue.write(message);
+        });
+    }
+    send(messageType, payload, expectAckOnly = false) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sentMessageToAck !== undefined)
+                throw new Error("The previous message has not been acked yet, cannot send a new message");
+            this.session.notifyActivity(false);
+            const message = {
+                packetHeader: {
+                    sessionId: this.peerSessionId,
+                    sessionType: 0 /* SessionType.Unicast */,
+                    messageId: this.messageCounter.getIncrementedCounter(),
+                    destNodeId: this.peerNodeId,
+                    sourceNodeId: this.nodeId,
+                },
+                payloadHeader: {
+                    exchangeId: this.exchangeId,
+                    protocolId: messageType === 16 /* MessageType.StandaloneAck */ ? SECURE_CHANNEL_PROTOCOL_ID : this.protocolId,
+                    messageType,
+                    isInitiatorMessage: this.isInitiator,
+                    requiresAck: messageType !== 16 /* MessageType.StandaloneAck */,
+                    ackedMessageId: (_a = this.receivedMessageToAck) === null || _a === void 0 ? void 0 : _a.packetHeader.messageId,
+                },
+                payload,
+            };
+            if (messageType !== 16 /* MessageType.StandaloneAck */) {
+                this.receivedMessageToAck = undefined;
+            }
+            let ackPromise;
+            if (message.payloadHeader.requiresAck) {
+                this.sentMessageToAck = message;
+                this.retransmissionTimer = Time.getTimer(this.getResubmissionBackOffTime(0), () => this.retransmitMessage(message, 0));
+                const { promise, resolver, rejecter } = yield getPromiseResolver();
+                ackPromise = promise;
+                this.sentMessageAckSuccess = resolver;
+                this.sentMessageAckFailure = rejecter;
+            }
+            yield this.channel.send(message);
+            if (ackPromise !== undefined) {
+                (_b = this.retransmissionTimer) === null || _b === void 0 ? void 0 : _b.start();
+                // Await Response to be received (or Message retransmit limit reached which rejects the promise)
+                const responseMessage = yield ackPromise;
+                this.sentMessageAckSuccess = undefined;
+                this.sentMessageAckFailure = undefined;
+                // If we only expect an Ack without data but got data, throw an error
+                const { payloadHeader: { protocolId, messageType } } = responseMessage;
+                if (expectAckOnly && !SecureChannelProtocol.isStandaloneAck(protocolId, messageType)) {
+                    throw new UnexpectedMessageError("Expected ack only", responseMessage);
+                }
+            }
+        });
+    }
+    nextMessage() {
+        return this.messagesQueue.read();
+    }
+    waitFor(messageType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = yield this.messagesQueue.read();
+            const { payloadHeader: { messageType: receivedMessageType } } = message;
+            if (receivedMessageType !== messageType)
+                throw new Error(`Received unexpected message type ${receivedMessageType.toString(16)}. Expected ${messageType.toString(16)}`);
+            return message;
+        });
+    }
+    /** @see {@link MatterCoreSpecificationV1_0}, section 4.11.2.1 */
+    getResubmissionBackOffTime(retransmissionCount) {
+        const baseInterval = this.session.isPeerActive() ? this.activeRetransmissionTimeoutMs : this.idleRetransmissionTimeoutMs;
+        return Math.floor(MRP_BACKOFF_MARGIN * baseInterval * Math.pow(MRP_BACKOFF_BASE, Math.max(0, retransmissionCount - MRP_BACKOFF_THRESHOLD)) * (1 + Math.random() * MRP_BACKOFF_JITTER));
+    }
+    retransmitMessage(message, retransmissionCount) {
+        retransmissionCount++;
+        if (retransmissionCount === this.retransmissionRetries) {
+            if (this.sentMessageToAck !== undefined && this.sentMessageAckFailure !== undefined) {
+                this.receivedMessageToAck = undefined;
+                this.sentMessageAckFailure(new RetransmissionLimitReachedError());
+                this.sentMessageAckFailure = undefined;
+                this.sentMessageAckSuccess = undefined;
+            }
+            return;
+        }
+        this.session.notifyActivity(false);
+        if (retransmissionCount === 1) {
+            // this.session.getContext().announce(); // TODO: announce
+        }
+        const resubmissionBackoffTime = this.getResubmissionBackOffTime(retransmissionCount);
+        logger.debug(`Resubmit message ${message.packetHeader.messageId} (attempt ${retransmissionCount}, next backoff time ${resubmissionBackoffTime}ms))`);
+        this.channel.send(message)
+            .then(() => {
+            this.retransmissionTimer = Time.getTimer(resubmissionBackoffTime, () => this.retransmitMessage(message, retransmissionCount))
+                .start();
+        })
+            .catch(error => logger.error("An error happened when retransmitting a message", error));
+    }
+    close() {
+        if (this.receivedMessageToAck !== undefined) {
+            this.send(16 /* MessageType.StandaloneAck */, new ByteArray(0))
+                .catch(error => logger.error("An error happened when closing the exchange", error));
+        }
+        // Wait until all potential Resubmissions are done, also for Standalone-Acks
+        Time.getTimer(MAXIMUM_TRANSMISSION_TIME_MS, () => this.closeInternal()).start();
+    }
+    closeInternal() {
+        var _a;
+        (_a = this.retransmissionTimer) === null || _a === void 0 ? void 0 : _a.stop();
+        this.messagesQueue.close();
+        this.closeCallback();
+    }
+}

package/dist/es/protocol/ProtocolHandler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from "../codec/MessageCodec.js";
+import { MessageExchange } from "./MessageExchange.js";
+export interface ProtocolHandler<ContextT> {
+    getId(): number;
+    onNewExchange(exchange: MessageExchange<ContextT>, message: Message): Promise<void>;
+}
+//# sourceMappingURL=ProtocolHandler.d.ts.map

package/dist/es/protocol/ProtocolHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolHandler.d.ts","sourceRoot":"","sources":["../../../src/protocol/ProtocolHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe,CAAC,QAAQ;IACrC,KAAK,IAAI,MAAM,CAAC;IAChB,aAAa,CAAC,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvF"}

package/dist/es/protocol/ProtocolHandler.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/es/protocol/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ChannelManager.js";
+export * from "./ExchangeManager.js";
+export * from "./MessageExchange.js";
+export * from "./ProtocolHandler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/es/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/protocol/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}

package/dist/es/protocol/index.js

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ChannelManager.js";
+export * from "./ExchangeManager.js";
+export * from "./MessageExchange.js";
+export * from "./ProtocolHandler.js";

package/dist/es/protocol/interaction/AttributeDataDecoder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Attribute, AttributeJsType } from "../../cluster/Cluster.js";
+import { NodeId } from "../../datatype/NodeId.js";
+import { ArraySchema } from "../../tlv/TlvArray.js";
+import { TlvSchema, TypeFromSchema } from "../../tlv/TlvSchema.js";
+import { TlvAttributeData, TlvAttributeReport } from "./InteractionProtocol.js";
+export interface DecodedAttributeReportValue {
+    path: {
+        nodeId?: NodeId;
+        endpointId: number;
+        clusterId: number;
+        attributeId: number;
+        attributeName: string;
+    };
+    version: number;
+    value: any;
+}
+export interface DecodedAttributeValue {
+    path: {
+        nodeId?: NodeId;
+        endpointId: number;
+        clusterId: number;
+        attributeId: number;
+        attributeName: string;
+    };
+    version?: number;
+    value: any;
+}
+export declare function normalizeAndDecodeReadAttributeReport(data: TypeFromSchema<typeof TlvAttributeReport>[]): DecodedAttributeReportValue[];
+export declare function normalizeAttributeData(data: TypeFromSchema<typeof TlvAttributeData>[], acceptWildcardPaths?: boolean): TypeFromSchema<typeof TlvAttributeData>[][];
+export declare function normalizeAndDecodeAttributeData(data: TypeFromSchema<typeof TlvAttributeData>[]): DecodedAttributeValue[];
+export declare function decodeValueForAttribute<A extends Attribute<any>>(attribute: A, values: TypeFromSchema<typeof TlvAttributeData>[]): AttributeJsType<A> | undefined;
+export declare function decodeValueForSchema<T>(schema: TlvSchema<T>, values: TypeFromSchema<typeof TlvAttributeData>[], defaultValue?: T): T | undefined;
+export declare function decodeChunkedArray<T>(schema: ArraySchema<T>, values: TypeFromSchema<typeof TlvAttributeData>[]): T[];
+//# sourceMappingURL=AttributeDataDecoder.d.ts.map

package/dist/es/protocol/interaction/AttributeDataDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeDataDecoder.d.ts","sourceRoot":"","sources":["../../../../src/protocol/interaction/AttributeDataDecoder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAIhF,MAAM,WAAW,2BAA2B;IACxC,IAAI,EAAE;QACF,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAA;KACxB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE;QACF,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAA;KACxB,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,GAAG,CAAC;CACd;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAAC,EAAE,GAAG,2BAA2B,EAAE,CAKtI;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,mBAAmB,UAAQ,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,CA+BhK;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,qBAAqB,EAAE,CA6BxH;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAWjK;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAgBhJ;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,EAAE,GAAG,CAAC,EAAE,CAoBpH"}

package/dist/es/protocol/interaction/AttributeDataDecoder.js

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getClusterAttributeById, getClusterById } from "../../cluster/ClusterHelper.js";
+import { ArraySchema } from "../../tlv/TlvArray.js";
+import { Logger } from "../../log/Logger.js";
+const logger = Logger.get("DataReportDecoder");
+export function normalizeAndDecodeReadAttributeReport(data) {
+    // TODO Decide how to handle the attribute report status field, right now we ignore it
+    const dataValues = data.flatMap(({ attributeData }) => attributeData !== undefined ? attributeData : []);
+    return normalizeAndDecodeAttributeData(dataValues); // dataVersion existing in incoming data, so must also in outgoing data
+}
+export function normalizeAttributeData(data, acceptWildcardPaths = false) {
+    // Fill in missing path elements when tag compression is used
+    let lastPath;
+    data.forEach((value) => {
+        if (value === undefined)
+            return;
+        const { path } = value;
+        if (path.enableTagCompression) {
+            if (lastPath === undefined)
+                throw new Error('Tag compression enabled, but no previous path');
+            if (path.nodeId === undefined && lastPath.nodeId !== undefined)
+                path.nodeId = lastPath.nodeId;
+            if (path.endpointId === undefined)
+                path.endpointId = lastPath.endpointId;
+            if (path.clusterId === undefined)
+                path.clusterId = lastPath.clusterId;
+            if (path.attributeId === undefined)
+                path.attributeId = lastPath.attributeId;
+        }
+        else if (path.endpointId !== undefined && path.clusterId !== undefined && path.attributeId !== undefined) {
+            lastPath = { nodeId: path.nodeId, endpointId: path.endpointId, clusterId: path.clusterId, attributeId: path.attributeId };
+        }
+        else if (!acceptWildcardPaths) {
+            throw new Error('Tag compression disabled, but path is incomplete: ' + Logger.toJSON(path));
+        }
+    });
+    // Put all returned values into a map to group by path
+    const responseList = new Map(); // TODO CHECK
+    data.forEach((value) => {
+        if (!value)
+            return;
+        const { path: { nodeId, endpointId, clusterId, attributeId } } = value;
+        const mapId = `${nodeId}-${endpointId}-${clusterId}-${attributeId}`;
+        const list = responseList.get(mapId) || [];
+        list.push(value);
+        responseList.set(mapId, list);
+    });
+    return Array.from(responseList.values());
+}
+export function normalizeAndDecodeAttributeData(data) {
+    const responseList = normalizeAttributeData(data);
+    const result = [];
+    responseList.forEach(values => {
+        const { path: { nodeId, endpointId, clusterId, attributeId }, dataVersion } = values[0];
+        if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+            throw new Error(`Invalid attribute path ${endpointId}/${clusterId}/${attributeId}`);
+        }
+        try {
+            const cluster = getClusterById(clusterId);
+            if (cluster === undefined) {
+                logger.debug(`Unknown cluster ${clusterId} - ignore`);
+                return;
+            }
+            const attributeDetail = getClusterAttributeById(cluster, attributeId);
+            if (attributeDetail === undefined) {
+                logger.debug(`Unknown attribute ${clusterId}/${attributeId} - ignore`);
+                return;
+            }
+            const { attribute, name } = attributeDetail;
+            const value = decodeValueForAttribute(attribute, values);
+            result.push({ path: { nodeId, endpointId, clusterId, attributeId, attributeName: name }, version: dataVersion, value });
+        }
+        catch (error) {
+            logger.error(`Error decoding attribute ${endpointId}/${clusterId}/${attributeId}: ${error.message}`);
+        }
+    });
+    return result;
+}
+export function decodeValueForAttribute(attribute, values) {
+    const { schema, optional, default: conformanceValue } = attribute;
+    // No values, so use default value if available
+    if (!values.length) {
+        if (optional)
+            return undefined;
+        if (conformanceValue === undefined)
+            throw new Error(`Attribute not found`);
+        return conformanceValue;
+    }
+    return decodeValueForSchema(schema, values);
+}
+export function decodeValueForSchema(schema, values, defaultValue) {
+    // No values, so use default value if available
+    if (!values.length) {
+        return defaultValue;
+    }
+    // The value was returned as one Tlv value, so decode it normally
+    if (values.length === 1 && values[0].path.listIndex === undefined) {
+        return schema.decodeTlv(values[0].data);
+    }
+    // Return contained multiple tlv values as an array
+    if (!(schema instanceof ArraySchema)) {
+        throw new Error(`Attribute is not an list but multiple values were returned`);
+    }
+    return decodeChunkedArray(schema, values);
+}
+export function decodeChunkedArray(schema, values) {
+    if (!values.length)
+        throw new Error('No values');
+    if (values[0].path.listIndex !== undefined) {
+        throw new Error(`List index ${values[0].path.listIndex} on first array element not supported`);
+    }
+    let result = [];
+    values.forEach(({ data, path: { listIndex } }) => {
+        if (listIndex === undefined) {
+            result = schema.decodeTlv(data);
+        }
+        else if (listIndex === null) {
+            const element = schema.elementSchema.decodeTlv(data);
+            result.push(element);
+        }
+        else if (data[0].typeLength.type === 20 /* TlvType.Null */) {
+            result.splice(listIndex, 1);
+        }
+        else {
+            result[listIndex] = schema.elementSchema.decodeTlv(data);
+        }
+    });
+    schema.validate(result);
+    return result;
+}