@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/cjs/protocol/ChannelManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Channel } from "../net/Channel.js";
+import { Fabric } from "../fabric/Fabric.js";
+import { Session } from "../session/Session.js";
+import { MessageChannel } from "./ExchangeManager.js";
+import { NodeId } from "../datatype/NodeId.js";
+import { MatterError } from "../common/MatterError.js";
+import { ByteArray } from "../util/ByteArray.js";
+export declare class NoChannelError extends MatterError {
+}
+export declare class ChannelManager {
+    private readonly channels;
+    private getChannelKey;
+    setChannel(fabric: Fabric, nodeId: NodeId, channel: MessageChannel<any>): void;
+    getChannel(fabric: Fabric, nodeId: NodeId): MessageChannel<any>;
+    removeChannel(fabric: Fabric, nodeId: NodeId): void;
+    getOrCreateChannel(byteArrayChannel: Channel<ByteArray>, session: Session<any>): MessageChannel<any>;
+}
+//# sourceMappingURL=ChannelManager.d.ts.map

package/dist/cjs/protocol/ChannelManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChannelManager.d.ts","sourceRoot":"","sources":["../../../src/protocol/ChannelManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,qBAAa,cAAe,SAAQ,WAAW;CAAI;AAEnD,qBAAa,cAAc;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,OAAO,CAAC,aAAa;IAIrB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,GAAG,CAAC;IAIvE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAMzC,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAI5C,kBAAkB,CAAC,gBAAgB,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;CAcjF"}

package/dist/cjs/protocol/ChannelManager.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = exports.NoChannelError = void 0;
+const ExchangeManager_js_1 = require("./ExchangeManager.js");
+const MatterError_js_1 = require("../common/MatterError.js");
+class NoChannelError extends MatterError_js_1.MatterError {
+}
+exports.NoChannelError = NoChannelError;
+class ChannelManager {
+    constructor() {
+        this.channels = new Map();
+    }
+    getChannelKey(fabric, nodeId) {
+        return `${fabric.fabricId}/${nodeId}`;
+    }
+    setChannel(fabric, nodeId, channel) {
+        this.channels.set(this.getChannelKey(fabric, nodeId), channel);
+    }
+    getChannel(fabric, nodeId) {
+        const result = this.channels.get(this.getChannelKey(fabric, nodeId));
+        if (result === undefined)
+            throw new NoChannelError(`Can't find a channel to node ${nodeId}`);
+        return result;
+    }
+    removeChannel(fabric, nodeId) {
+        this.channels.delete(this.getChannelKey(fabric, nodeId));
+    }
+    getOrCreateChannel(byteArrayChannel, session) {
+        if (!session.isSecure())
+            return new ExchangeManager_js_1.MessageChannel(byteArrayChannel, session);
+        const secureSession = session;
+        const fabric = secureSession.getFabric();
+        const nodeId = secureSession.getPeerNodeId();
+        if (fabric === undefined)
+            return new ExchangeManager_js_1.MessageChannel(byteArrayChannel, session);
+        let result = this.channels.get(this.getChannelKey(fabric, nodeId));
+        if (result === undefined || result.session.getId() !== session.getId()) {
+            result = new ExchangeManager_js_1.MessageChannel(byteArrayChannel, session);
+            this.setChannel(fabric, nodeId, result);
+        }
+        return result;
+    }
+}
+exports.ChannelManager = ChannelManager;

package/dist/cjs/protocol/ExchangeManager.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from "../codec/MessageCodec.js";
+import { Channel } from "../net/Channel.js";
+import { NetInterface } from "../net/NetInterface.js";
+import { SessionManager } from "../session/SessionManager.js";
+import { Session } from "../session/Session.js";
+import { MessageExchange } from "./MessageExchange.js";
+import { ProtocolHandler } from "./ProtocolHandler.js";
+import { ChannelManager } from "./ChannelManager.js";
+import { Fabric } from "../fabric/Fabric.js";
+import { ByteArray } from "../util/ByteArray.js";
+import { NodeId } from "../datatype/NodeId.js";
+import { MatterController } from "../MatterController.js";
+export declare class MessageChannel<ContextT> implements Channel<Message> {
+    readonly channel: Channel<ByteArray>;
+    readonly session: Session<ContextT>;
+    constructor(channel: Channel<ByteArray>, session: Session<ContextT>);
+    send(message: Message): Promise<void>;
+    getName(): string;
+}
+export declare class ExchangeManager<ContextT> {
+    private readonly sessionManager;
+    private readonly channelManager;
+    private readonly exchangeCounter;
+    private readonly messageCounter;
+    private readonly exchanges;
+    private readonly protocols;
+    private readonly netListeners;
+    constructor(sessionManager: SessionManager<ContextT>, channelManager: ChannelManager);
+    addNetInterface(netInterface: NetInterface): void;
+    addProtocolHandler(protocol: ProtocolHandler<ContextT>): void;
+    initiateExchange(fabric: Fabric, nodeId: NodeId, protocolId: number): MessageExchange<ContextT>;
+    initiateExchangeWithChannel(channel: MessageChannel<ContextT>, protocolId: number): MessageExchange<ContextT>;
+    close(): void;
+    private onMessage;
+}
+export declare class ExchangeCounter {
+    private exchangeCounter;
+    getIncrementedCounter(): number;
+}
+export declare class MessageCounter {
+    private messageCounter;
+    getIncrementedCounter(): number;
+}
+export declare class ExchangeProvider {
+    private readonly exchangeManager;
+    private channel;
+    private readonly reconnectChannelFunc?;
+    constructor(exchangeManager: ExchangeManager<MatterController>, channel: MessageChannel<MatterController>, reconnectChannelFunc?: (() => Promise<MessageChannel<MatterController>>) | undefined);
+    addProtocolHandler(handler: ProtocolHandler<MatterController>): void;
+    initiateExchange(): MessageExchange<MatterController>;
+    reconnectChannel(): Promise<boolean>;
+}
+//# sourceMappingURL=ExchangeManager.d.ts.map

package/dist/cjs/protocol/ExchangeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExchangeManager.d.ts","sourceRoot":"","sources":["../../../src/protocol/ExchangeManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAA6B,MAAM,0BAA0B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAe,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK1D,qBAAa,cAAc,CAAC,QAAQ,CAAE,YAAW,OAAO,CAAC,OAAO,CAAC;IAEzD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC;gBAD1B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC;IAGvC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAOrC,OAAO;CAGV;AAED,qBAAa,eAAe,CAAC,QAAQ;IAQ7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,cAAc;IARnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgD;IAC1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgD;IAC1E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;gBAGpC,cAAc,EAAE,cAAc,CAAC,QAAQ,CAAC,EACxC,cAAc,EAAE,cAAc;IAGnD,eAAe,CAAC,YAAY,EAAE,YAAY;IAO1C,kBAAkB,CAAC,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC;IAItD,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAInE,2BAA2B,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,MAAM;IASjF,KAAK;YAOS,SAAS;CAsB1B;AAED,qBAAa,eAAe;IACxB,OAAO,CAAC,eAAe,CAA4B;IAEnD,qBAAqB;CAOxB;AAED,qBAAa,cAAc;IACvB,OAAO,CAAC,cAAc,CAA4B;IAElD,qBAAqB;CAOxB;AAED,qBAAa,gBAAgB;IAErB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC;gBAFrB,eAAe,EAAE,eAAe,CAAC,gBAAgB,CAAC,EAC3D,OAAO,EAAE,cAAc,CAAC,gBAAgB,CAAC,EAChC,oBAAoB,CAAC,SAAQ,QAAQ,eAAe,gBAAgB,CAAC,CAAC,aAAA;IAI3F,kBAAkB,CAAC,OAAO,EAAE,eAAe,CAAC,gBAAgB,CAAC;IAI7D,gBAAgB,IAAI,eAAe,CAAC,gBAAgB,CAAC;IAI/C,gBAAgB;CAKzB"}

package/dist/cjs/protocol/ExchangeManager.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * @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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangeProvider = exports.MessageCounter = exports.ExchangeCounter = exports.ExchangeManager = exports.MessageChannel = void 0;
+const MessageCodec_js_1 = require("../codec/MessageCodec.js");
+const Crypto_js_1 = require("../crypto/Crypto.js");
+const MessageExchange_js_1 = require("./MessageExchange.js");
+const Logger_js_1 = require("../log/Logger.js");
+const InteractionServer_js_1 = require("../protocol/interaction/InteractionServer.js");
+const logger = Logger_js_1.Logger.get("ExchangeManager");
+class MessageChannel {
+    constructor(channel, session) {
+        this.channel = channel;
+        this.session = session;
+    }
+    send(message) {
+        logger.debug("sending", MessageCodec_js_1.MessageCodec.messageToString(message));
+        const packet = this.session.encode(message);
+        const bytes = MessageCodec_js_1.MessageCodec.encodePacket(packet);
+        return this.channel.send(bytes);
+    }
+    getName() {
+        return `${this.channel.getName()} on session ${this.session.getName()}`;
+    }
+}
+exports.MessageChannel = MessageChannel;
+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_js_1.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_js_1.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_js_1.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);
+            }
+        });
+    }
+}
+exports.ExchangeManager = ExchangeManager;
+class ExchangeCounter {
+    constructor() {
+        this.exchangeCounter = Crypto_js_1.Crypto.getRandomUInt16();
+    }
+    getIncrementedCounter() {
+        this.exchangeCounter++;
+        if (this.exchangeCounter > 0xFFFF) {
+            this.exchangeCounter = 0;
+        }
+        return this.exchangeCounter;
+    }
+}
+exports.ExchangeCounter = ExchangeCounter;
+class MessageCounter {
+    constructor() {
+        this.messageCounter = Crypto_js_1.Crypto.getRandomUInt32();
+    }
+    getIncrementedCounter() {
+        this.messageCounter++;
+        if (this.messageCounter > 0xFFFFFFFF) {
+            this.messageCounter = 0;
+        }
+        return this.messageCounter;
+    }
+}
+exports.MessageCounter = MessageCounter;
+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, InteractionServer_js_1.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;
+        });
+    }
+}
+exports.ExchangeProvider = ExchangeProvider;

package/dist/cjs/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/cjs/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/cjs/protocol/MessageExchange.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * @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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageExchange = exports.UnexpectedMessageError = exports.RetransmissionLimitReachedError = void 0;
+const MessageCodec_js_1 = require("../codec/MessageCodec.js");
+const Session_js_1 = require("../session/Session.js");
+const SecureChannelProtocol_js_1 = require("./securechannel/SecureChannelProtocol.js");
+const MatterError_js_1 = require("../common/MatterError.js");
+const Logger_js_1 = require("../log/Logger.js");
+const Queue_js_1 = require("../util/Queue.js");
+const Time_js_1 = require("../time/Time.js");
+const ByteArray_js_1 = require("../util/ByteArray.js");
+const SecureChannelMessages_js_1 = require("./securechannel/SecureChannelMessages.js");
+const Promises_js_1 = require("../util/Promises.js");
+const logger = Logger_js_1.Logger.get("MessageExchange");
+class RetransmissionLimitReachedError extends MatterError_js_1.MatterError {
+}
+exports.RetransmissionLimitReachedError = RetransmissionLimitReachedError;
+class UnexpectedMessageError extends MatterError_js_1.MatterError {
+    constructor(message, receivedMessage) {
+        super(`(${MessageCodec_js_1.MessageCodec.messageToString(receivedMessage)}) ${message}`);
+        this.receivedMessage = receivedMessage;
+    }
+}
+exports.UnexpectedMessageError = UnexpectedMessageError;
+/** 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
+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_js_1.Queue();
+        const { activeRetransmissionTimeoutMs, idleRetransmissionTimeoutMs, retransmissionRetries } = session.getMrpParameters();
+        this.activeRetransmissionTimeoutMs = activeRetransmissionTimeoutMs !== null && activeRetransmissionTimeoutMs !== void 0 ? activeRetransmissionTimeoutMs : Session_js_1.SLEEPY_ACTIVE_INTERVAL_MS;
+        this.idleRetransmissionTimeoutMs = idleRetransmissionTimeoutMs !== null && idleRetransmissionTimeoutMs !== void 0 ? idleRetransmissionTimeoutMs : Session_js_1.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_js_1.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_js_1.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_js_1.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_js_1.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 */ ? SecureChannelMessages_js_1.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_js_1.Time.getTimer(this.getResubmissionBackOffTime(0), () => this.retransmitMessage(message, 0));
+                const { promise, resolver, rejecter } = yield (0, Promises_js_1.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_js_1.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_js_1.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_js_1.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_js_1.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();
+    }
+}
+exports.MessageExchange = MessageExchange;

package/dist/cjs/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/cjs/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/cjs/protocol/ProtocolHandler.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/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"}