@matter/protocol 0.11.0-alpha.0-20241005-e3e4e4a7a

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

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AsyncObservable, MatterError, NoResponseTimeoutError } from "#general";
+import { NodeId } from "#types";
+import { Message } from "../codec/MessageCodec.js";
+import { SessionParameters } from "../session/Session.js";
+import { MessageChannel } from "./ExchangeManager.js";
+export declare class RetransmissionLimitReachedError extends NoResponseTimeoutError {
+}
+export declare class UnexpectedMessageError extends MatterError {
+    readonly receivedMessage: Message;
+    constructor(message: string, receivedMessage: Message);
+}
+export type ExchangeSendOptions = {
+    /**
+     * The response to this send should be an ack only and no StatusResponse or such. If a StatusResponse is returned
+     * then this is handled as error.
+     */
+    expectAckOnly?: boolean;
+    /**
+     * Defined an expected processing time by the responder for the message. This is used to calculate the final
+     * timeout for responses together with the normal retransmission logic when MRP is used.
+     */
+    expectedProcessingTimeMs?: number;
+    /** Allows to specify if the send message requires to be acknowledged by the receiver or not. */
+    requiresAck?: boolean;
+    /** Use the provided acknowledge MessageId instead checking the latest to send one */
+    includeAcknowledgeMessageId?: number;
+};
+/**
+ * Default expected processing time for a messages in milliseconds. The value is derived from kExpectedIMProcessingTime
+ * from chip implementation. This is basically the default used with different names, also kExpectedLowProcessingTime or
+ * kExpectedSigma1ProcessingTime.
+ */
+export declare const DEFAULT_EXPECTED_PROCESSING_TIME_MS = 2000;
+/**
+ * Message size overhead of a Matter message:
+ * 26 (Matter Message Header) + 12 (Matter Payload Header) taken from https://github.com/project-chip/connectedhomeip/blob/2d97cda23024e72f36216900ca667bf1a0d9499f/src/system/SystemConfig.h#L327
+ * 16 byte MIC is then also needed to be excluded from the max payload size
+ * Secure Extensions and Message Extensions need to be handled by exchange additionally!
+ */
+export declare const MATTER_MESSAGE_OVERHEAD: number;
+/**
+ * Interfaces {@link MessageExchange} with other components.
+ */
+export interface MessageExchangeContext {
+    channel: MessageChannel;
+    resubmissionStarted(): void;
+    localSessionParameters: SessionParameters;
+}
+export declare class MessageExchange {
+    #private;
+    readonly context: MessageExchangeContext;
+    readonly isInitiator: boolean;
+    static fromInitialMessage(context: MessageExchangeContext, initialMessage: Message): MessageExchange;
+    static initiate(context: MessageExchangeContext, exchangeId: number, protocolId: number): MessageExchange;
+    constructor(context: MessageExchangeContext, isInitiator: boolean, peerSessionId: number, nodeId: NodeId | undefined, peerNodeId: NodeId | undefined, exchangeId: number, protocolId: number);
+    get closed(): AsyncObservable<[], void>;
+    get isClosing(): boolean;
+    get id(): number;
+    get channel(): MessageChannel;
+    get session(): import("../session/Session.js").Session;
+    /**
+     * Max Payload size of the exchange which bases on the maximum payload size of the channel reduced by Matter
+     * protocol overhead.
+     */
+    get maxPayloadSize(): number;
+    sendStandaloneAckForMessage(message: Message): Promise<void>;
+    onMessageReceived(message: Message, isDuplicate?: boolean): Promise<void>;
+    send(messageType: number, payload: Uint8Array, options?: ExchangeSendOptions): Promise<void>;
+    nextMessage(expectedProcessingTimeMs?: number): Promise<Message>;
+    calculateMaximumPeerResponseTime(expectedProcessingTimeMs?: number): number;
+    destroy(): Promise<void>;
+    startTimedInteraction(timeoutMs: number): void;
+    clearTimedInteraction(): void;
+    hasTimedInteraction(): boolean;
+    hasActiveTimedInteraction(): boolean;
+    hasExpiredTimedInteraction(): boolean;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=MessageExchange.d.ts.map

package/dist/esm/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,EACH,eAAe,EAMf,WAAW,EAEX,sBAAsB,EAIzB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,MAAM,EAAkF,MAAM,QAAQ,CAAC;AAChH,OAAO,EAAE,OAAO,EAA6B,MAAM,0BAA0B,CAAC;AAE9E,OAAO,EAIH,iBAAiB,EACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAA4B,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAIhF,qBAAa,+BAAgC,SAAQ,sBAAsB;CAAG;AAE9E,qBAAa,sBAAuB,SAAQ,WAAW;aAG/B,eAAe,EAAE,OAAO;gBADxC,OAAO,EAAE,MAAM,EACC,eAAe,EAAE,OAAO;CAI/C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC,gGAAgG;IAChG,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,qFAAqF;IACrF,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACxC,CAAC;AAuBF;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,OAAQ,CAAC;AAQzD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAAyC,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,OAAO,EAAE,cAAc,CAAC;IACxB,mBAAmB,IAAI,IAAI,CAAC;IAC5B,sBAAsB,EAAE,iBAAiB,CAAC;CAC7C;AAED,qBAAa,eAAe;;IAiEpB,QAAQ,CAAC,OAAO,EAAE,sBAAsB;IACxC,QAAQ,CAAC,WAAW,EAAE,OAAO;IAjEjC,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,OAAO;IAelF,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;gBAiD1E,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,OAAO,EAC7B,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM;IAoCtB,IAAI,MAAM,8BAET;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,EAAE,WAEL;IAED,IAAI,OAAO,mBAEV;IAED,IAAI,OAAO,4CAEV;IAED;;;OAGG;IACH,IAAI,cAAc,WAIjB;IAEK,2BAA2B,CAAC,OAAO,EAAE,OAAO;IAU5C,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,UAAQ;IAiFvD,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,mBAAmB;IA8FlF,WAAW,CAAC,wBAAwB,CAAC,EAAE,MAAM;IAkD7C,gCAAgC,CAAC,wBAAwB,SAAsC;IAgFzF,OAAO;IAcb,qBAAqB,CAAC,SAAS,EAAE,MAAM;IAkBvC,qBAAqB;IAUrB,mBAAmB;IAInB,yBAAyB;IAIzB,0BAA0B;IAIpB,KAAK;CAwCd"}

package/dist/esm/protocol/MessageExchange.js

@@ -0,0 +1,504 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  AsyncObservable,
+  CRYPTO_AEAD_MIC_LENGTH_BYTES,
+  DataReadQueue,
+  Diagnostic,
+  InternalError,
+  Logger,
+  MatterError,
+  MatterFlowError,
+  NoResponseTimeoutError,
+  Time,
+  createPromise
+} from "#general";
+import { SECURE_CHANNEL_PROTOCOL_ID, SecureMessageType, StatusCode, StatusResponseError } from "#types";
+import { MessageCodec, SessionType } from "../codec/MessageCodec.js";
+import { SecureChannelProtocol } from "../securechannel/SecureChannelProtocol.js";
+import {
+  SESSION_ACTIVE_INTERVAL_MS,
+  SESSION_ACTIVE_THRESHOLD_MS,
+  SESSION_IDLE_INTERVAL_MS
+} from "../session/Session.js";
+import { ChannelNotConnectedError } from "./ExchangeManager.js";
+const logger = Logger.get("MessageExchange");
+class RetransmissionLimitReachedError extends NoResponseTimeoutError {
+}
+class UnexpectedMessageError extends MatterError {
+  constructor(message, receivedMessage) {
+    super(`(${MessageCodec.messageDiagnostics(receivedMessage)}) ${message}`);
+    this.receivedMessage = receivedMessage;
+  }
+}
+const MRP_MAX_TRANSMISSIONS = 5;
+const MRP_BACKOFF_BASE = 1.6;
+const MRP_BACKOFF_JITTER = 0.25;
+const MRP_BACKOFF_MARGIN = 1.1;
+const MRP_BACKOFF_THRESHOLD = 1;
+const MRP_STANDALONE_ACK_TIMEOUT_MS = 200;
+const DEFAULT_EXPECTED_PROCESSING_TIME_MS = 2e3;
+const PEER_RESPONSE_TIME_BUFFER_MS = 5e3;
+const MATTER_MESSAGE_OVERHEAD = 26 + 12 + CRYPTO_AEAD_MIC_LENGTH_BYTES;
+class MessageExchange {
+  constructor(context, isInitiator, peerSessionId, nodeId, peerNodeId, exchangeId, protocolId) {
+    this.context = context;
+    this.isInitiator = isInitiator;
+    const { channel } = context;
+    const { session } = channel;
+    this.#peerSessionId = peerSessionId;
+    this.#nodeId = nodeId;
+    this.#peerNodeId = peerNodeId;
+    this.#exchangeId = exchangeId;
+    this.#protocolId = protocolId;
+    const { activeIntervalMs, idleIntervalMs, activeThresholdMs } = session.parameters;
+    this.#activeIntervalMs = activeIntervalMs ?? SESSION_ACTIVE_INTERVAL_MS;
+    this.#idleIntervalMs = idleIntervalMs ?? SESSION_IDLE_INTERVAL_MS;
+    this.#activeThresholdMs = activeThresholdMs ?? SESSION_ACTIVE_THRESHOLD_MS;
+    this.#maxTransmissions = MRP_MAX_TRANSMISSIONS;
+    this.#useMRP = session.supportsMRP && !channel.isReliable;
+    logger.debug(
+      "New exchange",
+      Diagnostic.dict({
+        channel: channel.name,
+        protocol: this.#protocolId,
+        id: this.#exchangeId,
+        session: session.name,
+        peerSessionId: this.#peerSessionId,
+        "active threshold ms": this.#activeThresholdMs,
+        "active interval ms": this.#activeIntervalMs,
+        "idle interval ms": this.#idleIntervalMs,
+        maxTransmissions: this.#maxTransmissions,
+        useMrp: this.#useMRP
+      })
+    );
+  }
+  static fromInitialMessage(context, initialMessage) {
+    const {
+      channel: { session }
+    } = context;
+    return new MessageExchange(
+      context,
+      false,
+      session.id,
+      initialMessage.packetHeader.destNodeId,
+      initialMessage.packetHeader.sourceNodeId,
+      initialMessage.payloadHeader.exchangeId,
+      initialMessage.payloadHeader.protocolId
+    );
+  }
+  static initiate(context, exchangeId, protocolId) {
+    const {
+      channel: { session }
+    } = context;
+    return new MessageExchange(
+      context,
+      true,
+      session.peerSessionId,
+      session.nodeId,
+      session.peerNodeId,
+      exchangeId,
+      protocolId
+    );
+  }
+  #activeIntervalMs;
+  #idleIntervalMs;
+  #activeThresholdMs;
+  #maxTransmissions;
+  #messagesQueue = new DataReadQueue();
+  #receivedMessageToAck;
+  #receivedMessageAckTimer = Time.getTimer("Ack receipt timeout", MRP_STANDALONE_ACK_TIMEOUT_MS, () => {
+    if (this.#receivedMessageToAck !== void 0) {
+      const messageToAck = this.#receivedMessageToAck;
+      this.#receivedMessageToAck = void 0;
+      this.sendStandaloneAckForMessage(messageToAck).catch(
+        (error) => logger.error("An error happened when sending a standalone ack", error)
+      );
+    }
+  });
+  #sentMessageToAck;
+  #sentMessageAckSuccess;
+  #sentMessageAckFailure;
+  #retransmissionTimer;
+  #retransmissionCounter = 0;
+  #closeTimer;
+  #isClosing = false;
+  #timedInteractionTimer;
+  #peerSessionId;
+  #nodeId;
+  #peerNodeId;
+  #exchangeId;
+  #protocolId;
+  #closed = AsyncObservable();
+  #useMRP;
+  get closed() {
+    return this.#closed;
+  }
+  get isClosing() {
+    return this.#isClosing;
+  }
+  get id() {
+    return this.#exchangeId;
+  }
+  get channel() {
+    return this.context.channel;
+  }
+  get session() {
+    return this.channel.session;
+  }
+  /**
+   * Max Payload size of the exchange which bases on the maximum payload size of the channel reduced by Matter
+   * protocol overhead.
+   */
+  get maxPayloadSize() {
+    return this.channel.maxPayloadSize - MATTER_MESSAGE_OVERHEAD;
+  }
+  async sendStandaloneAckForMessage(message) {
+    const {
+      packetHeader: { messageId },
+      payloadHeader: { requiresAck }
+    } = message;
+    if (!requiresAck || !this.#useMRP) return;
+    await this.send(SecureMessageType.StandaloneAck, new Uint8Array(0), { includeAcknowledgeMessageId: messageId });
+  }
+  async onMessageReceived(message, isDuplicate = false) {
+    logger.debug("Message \xAB", MessageCodec.messageDiagnostics(message, isDuplicate));
+    if (message.payloadHeader.requiresAck && !this.#useMRP) {
+      logger.debug("Ignoring ack-required flag because MRP is not used for this exchange");
+      message.payloadHeader.requiresAck = false;
+    }
+    const {
+      packetHeader: { messageId },
+      payloadHeader: { requiresAck, ackedMessageId, protocolId, messageType }
+    } = message;
+    const isStandaloneAck = SecureChannelProtocol.isStandaloneAck(protocolId, messageType);
+    if (protocolId !== this.#protocolId && !isStandaloneAck) {
+      throw new MatterFlowError(
+        `Drop received a message for an unexpected protocol. Expected: ${this.#protocolId}, received: ${protocolId}`
+      );
+    }
+    this.session.notifyActivity(true);
+    if (isDuplicate) {
+      if (requiresAck) {
+        await this.sendStandaloneAckForMessage(message);
+      }
+      return;
+    }
+    if (messageId === this.#sentMessageToAck?.payloadHeader.ackedMessageId) {
+      await this.channel.send(this.#sentMessageToAck);
+      return;
+    }
+    const sentMessageIdToAck = this.#sentMessageToAck?.packetHeader.messageId;
+    if (sentMessageIdToAck !== void 0) {
+      if (ackedMessageId === void 0) {
+        throw new MatterFlowError("Previous message ack is missing");
+      } else if (ackedMessageId !== sentMessageIdToAck) {
+        if (isStandaloneAck) {
+        } else {
+          throw new MatterFlowError(
+            `Incorrect ack received. Expected ${sentMessageIdToAck}, received: ${ackedMessageId}`
+          );
+        }
+      } else {
+        this.#retransmissionTimer?.stop();
+        this.#retransmissionCounter = 0;
+        this.#sentMessageAckSuccess?.(message);
+        this.#sentMessageAckSuccess = void 0;
+        this.#sentMessageAckFailure = void 0;
+        this.#sentMessageToAck = void 0;
+        if (isStandaloneAck && this.#closeTimer !== void 0) {
+          return this.#close();
+        }
+      }
+    }
+    if (isStandaloneAck) {
+      return;
+    }
+    if (requiresAck) {
+      if (this.#receivedMessageToAck !== void 0) {
+        this.#receivedMessageAckTimer.stop();
+        await this.sendStandaloneAckForMessage(this.#receivedMessageToAck);
+        return;
+      }
+      this.#receivedMessageToAck = message;
+      this.#receivedMessageAckTimer.start();
+    }
+    await this.#messagesQueue.write(message);
+  }
+  async send(messageType, payload, options) {
+    if (options?.requiresAck && !this.#useMRP) {
+      options.requiresAck = false;
+    }
+    const {
+      expectAckOnly = false,
+      expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+      requiresAck,
+      includeAcknowledgeMessageId
+    } = options ?? {};
+    if (!this.#useMRP && includeAcknowledgeMessageId !== void 0) {
+      throw new InternalError("Cannot include an acknowledge message ID when MRP is not used");
+    }
+    if (messageType === SecureMessageType.StandaloneAck) {
+      if (!this.#useMRP) {
+        return;
+      }
+      if (requiresAck) {
+        throw new MatterFlowError("A standalone ack may not require acknowledgement.");
+      }
+    }
+    if (this.#sentMessageToAck !== void 0 && messageType !== SecureMessageType.StandaloneAck)
+      throw new MatterFlowError("The previous message has not been acked yet, cannot send a new message.");
+    this.session.notifyActivity(false);
+    let ackedMessageId = includeAcknowledgeMessageId;
+    if (ackedMessageId === void 0 && this.#useMRP) {
+      ackedMessageId = this.#receivedMessageToAck?.packetHeader.messageId;
+      if (ackedMessageId !== void 0) {
+        this.#receivedMessageAckTimer.stop();
+        this.#receivedMessageToAck = void 0;
+      }
+    }
+    const message = {
+      packetHeader: {
+        sessionId: this.#peerSessionId,
+        sessionType: SessionType.Unicast,
+        // TODO: support multicast/groups
+        messageId: await this.session.getIncrementedMessageCounter(),
+        destNodeId: this.#peerNodeId,
+        sourceNodeId: this.#nodeId,
+        hasPrivacyEnhancements: false,
+        isControlMessage: false,
+        hasMessageExtensions: false
+      },
+      payloadHeader: {
+        exchangeId: this.#exchangeId,
+        protocolId: messageType === SecureMessageType.StandaloneAck ? SECURE_CHANNEL_PROTOCOL_ID : this.#protocolId,
+        messageType,
+        isInitiatorMessage: this.isInitiator,
+        requiresAck: requiresAck ?? (this.#useMRP && messageType !== SecureMessageType.StandaloneAck),
+        ackedMessageId,
+        hasSecuredExtension: false
+      },
+      payload
+    };
+    let ackPromise;
+    if (this.#useMRP && message.payloadHeader.requiresAck) {
+      this.#sentMessageToAck = message;
+      this.#retransmissionTimer = Time.getTimer(
+        "Message retransmission",
+        this.#getResubmissionBackOffTime(0),
+        () => this.#retransmitMessage(message, expectedProcessingTimeMs)
+      );
+      const { promise, resolver, rejecter } = createPromise();
+      ackPromise = promise;
+      this.#sentMessageAckSuccess = resolver;
+      this.#sentMessageAckFailure = rejecter;
+    }
+    await this.channel.send(message);
+    if (ackPromise !== void 0) {
+      this.#retransmissionCounter = 0;
+      this.#retransmissionTimer?.start();
+      const responseMessage = await ackPromise;
+      this.#sentMessageAckSuccess = void 0;
+      this.#sentMessageAckFailure = void 0;
+      const {
+        payloadHeader: { protocolId, messageType: messageType2 }
+      } = responseMessage;
+      if (expectAckOnly && !SecureChannelProtocol.isStandaloneAck(protocolId, messageType2)) {
+        throw new UnexpectedMessageError("Expected ack only", responseMessage);
+      }
+    }
+  }
+  nextMessage(expectedProcessingTimeMs) {
+    let timeout;
+    switch (this.channel.type) {
+      case "tcp":
+        timeout = 3e4;
+        break;
+      case "udp":
+        if (!this.#useMRP) {
+          throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
+        }
+        timeout = this.calculateMaximumPeerResponseTime(expectedProcessingTimeMs);
+        break;
+      case "ble":
+        timeout = 3e4;
+        break;
+      default:
+        throw new MatterFlowError(
+          `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`
+        );
+    }
+    timeout += PEER_RESPONSE_TIME_BUFFER_MS;
+    return this.#messagesQueue.read(timeout);
+  }
+  /**
+   * Calculates the backoff time for a resubmission based on the current retransmission count.
+   * If no session parameters are provided, the parameters of the current session are used.
+   * If session parameters are provided, the method can be used to calculate the maximum backoff time for the other
+   * side of the exchange.
+   *
+   * @see {@link MatterSpecification.v10.Core}, section 4.11.2.1
+   */
+  #getResubmissionBackOffTime(retransmissionCount, sessionParameters) {
+    const { activeIntervalMs, idleIntervalMs } = sessionParameters ?? {
+      activeIntervalMs: this.#activeIntervalMs,
+      idleIntervalMs: this.#idleIntervalMs
+    };
+    const baseInterval = sessionParameters !== void 0 || this.session.isPeerActive() ? activeIntervalMs : idleIntervalMs;
+    return Math.floor(
+      MRP_BACKOFF_MARGIN * baseInterval * Math.pow(MRP_BACKOFF_BASE, Math.max(0, retransmissionCount - MRP_BACKOFF_THRESHOLD)) * (1 + (sessionParameters !== void 0 ? 1 : Math.random()) * MRP_BACKOFF_JITTER)
+    );
+  }
+  calculateMaximumPeerResponseTime(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
+    let finalWaitTime = expectedProcessingTimeMs;
+    for (let i = 0; i < this.#maxTransmissions; i++) {
+      finalWaitTime += this.#getResubmissionBackOffTime(i, this.context.localSessionParameters);
+    }
+    return finalWaitTime;
+  }
+  #retransmitMessage(message, expectedProcessingTimeMs) {
+    this.#retransmissionCounter++;
+    if (this.#retransmissionCounter >= this.#maxTransmissions) {
+      if (expectedProcessingTimeMs !== void 0) {
+        const finalWaitTime = this.calculateMaximumPeerResponseTime(expectedProcessingTimeMs) - (this.#retransmissionTimer?.intervalMs ?? 0);
+        if (finalWaitTime > 0) {
+          this.#retransmissionCounter--;
+          logger.debug(
+            `Wait additional ${finalWaitTime}ms for processing time and peer resubmissions after all our resubmissions`
+          );
+          this.#retransmissionTimer = Time.getTimer(
+            "Message wait time after resubmissions",
+            finalWaitTime,
+            () => this.#retransmitMessage(message)
+          ).start();
+          return;
+        }
+      }
+      if (this.#sentMessageToAck !== void 0 && this.#sentMessageAckFailure !== void 0) {
+        this.#receivedMessageToAck = void 0;
+        this.#sentMessageAckFailure(new RetransmissionLimitReachedError());
+        this.#sentMessageAckFailure = void 0;
+        this.#sentMessageAckSuccess = void 0;
+      }
+      if (this.#closeTimer !== void 0) {
+        this.#close().catch((error) => logger.error("An error happened when closing the exchange", error));
+      }
+      return;
+    }
+    this.session.notifyActivity(false);
+    if (this.#retransmissionCounter === 1) {
+      this.context.resubmissionStarted();
+    }
+    const resubmissionBackoffTime = this.#getResubmissionBackOffTime(this.#retransmissionCounter);
+    logger.debug(
+      `Resubmit message ${message.packetHeader.messageId} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${resubmissionBackoffTime}ms))`
+    );
+    this.channel.send(message).then(() => this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTimeMs)).catch((error) => {
+      logger.error("An error happened when retransmitting a message", error);
+      if (error instanceof ChannelNotConnectedError) {
+        this.#close().catch((error2) => logger.error("An error happened when closing the exchange", error2));
+      } else {
+        this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTimeMs);
+      }
+    });
+  }
+  #initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTimeMs) {
+    this.#retransmissionTimer = Time.getTimer(
+      "Message retransmission",
+      resubmissionBackoffTime,
+      () => this.#retransmitMessage(message, expectedProcessingTimeMs)
+    ).start();
+  }
+  async destroy() {
+    if (this.#closeTimer === void 0 && this.#receivedMessageToAck !== void 0) {
+      this.#receivedMessageAckTimer.stop();
+      const messageToAck = this.#receivedMessageToAck;
+      this.#receivedMessageToAck = void 0;
+      try {
+        await this.sendStandaloneAckForMessage(messageToAck);
+      } catch (error) {
+        logger.error("An error happened when closing the exchange", error);
+      }
+    }
+    await this.#close();
+  }
+  startTimedInteraction(timeoutMs) {
+    if (this.#timedInteractionTimer !== void 0 && this.#timedInteractionTimer.isRunning) {
+      this.#timedInteractionTimer.stop();
+      throw new StatusResponseError(
+        "Timed interaction already running for this exchange",
+        StatusCode.InvalidAction
+      );
+    }
+    logger.debug(
+      `Starting timed interaction with Transaction ID ${this.#exchangeId} for ${timeoutMs}ms from ${this.channel.name}`
+    );
+    this.#timedInteractionTimer = Time.getTimer("Timed interaction", timeoutMs, () => {
+      logger.debug(
+        `Timed interaction with Transaction ID ${this.#exchangeId} from ${this.channel.name} timed out`
+      );
+    }).start();
+  }
+  clearTimedInteraction() {
+    if (this.#timedInteractionTimer !== void 0) {
+      logger.debug(
+        `Clearing timed interaction with Transaction ID ${this.#exchangeId} from ${this.channel.name}`
+      );
+      this.#timedInteractionTimer.stop();
+      this.#timedInteractionTimer = void 0;
+    }
+  }
+  hasTimedInteraction() {
+    return this.#timedInteractionTimer !== void 0;
+  }
+  hasActiveTimedInteraction() {
+    return this.#timedInteractionTimer !== void 0 && this.#timedInteractionTimer.isRunning;
+  }
+  hasExpiredTimedInteraction() {
+    return this.#timedInteractionTimer !== void 0 && !this.#timedInteractionTimer.isRunning;
+  }
+  async close() {
+    if (this.#closeTimer !== void 0) return;
+    this.#isClosing = true;
+    if (this.#receivedMessageToAck !== void 0) {
+      this.#receivedMessageAckTimer.stop();
+      const messageToAck = this.#receivedMessageToAck;
+      this.#receivedMessageToAck = void 0;
+      try {
+        await this.sendStandaloneAckForMessage(messageToAck);
+      } catch (error) {
+        logger.error("An error happened when closing the exchange", error);
+      }
+    } else if (this.#sentMessageToAck === void 0) {
+      return this.#close();
+    }
+    let maxResubmissionTime = 0;
+    for (let i = this.#retransmissionCounter; i <= this.#maxTransmissions; i++) {
+      maxResubmissionTime += this.#getResubmissionBackOffTime(i);
+    }
+    this.#closeTimer = Time.getTimer(
+      "Message exchange cleanup",
+      maxResubmissionTime,
+      async () => await this.#close()
+    ).start();
+  }
+  async #close() {
+    this.#isClosing = true;
+    this.#retransmissionTimer?.stop();
+    this.#closeTimer?.stop();
+    this.#timedInteractionTimer?.stop();
+    this.#messagesQueue.close();
+    await this.#closed.emit();
+  }
+}
+export {
+  DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+  MATTER_MESSAGE_OVERHEAD,
+  MessageExchange,
+  RetransmissionLimitReachedError,
+  UnexpectedMessageError
+};
+//# sourceMappingURL=MessageExchange.js.map

package/dist/esm/protocol/MessageExchange.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol/MessageExchange.ts"],
+  "mappings": "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",
+  "names": ["messageType", "error"]
+}

package/dist/esm/protocol/MessageReceptionState.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "#general";
+export declare class DuplicateMessageError extends MatterError {
+}
+export declare abstract class MessageReceptionState {
+    abstract updateMessageCounter(messageCounter: number): void;
+}
+/**
+ * Implements a message reception state for encrypted messages without rollover.
+ * A counter in the range [(max_message_counter + 1) to (232 - 1)] SHALL be considered new, and cause the
+ * max_message_counter value to be updated.
+ * Message counters within the range of the bitmap SHALL be considered duplicate if the corresponding bit
+ * offset is set to true. All other message counters SHALL be considered duplicate.
+ */
+export declare class MessageReceptionStateEncryptedWithoutRollover extends MessageReceptionState {
+    protected maximumMessageCounter: number | undefined;
+    private messageCounterBitmap;
+    constructor(messageCounter?: number);
+    /** Initialize the message counter state. */
+    private initialize;
+    /**
+     * Calculate plain diff without rollover.
+     * This method is mainly overridden for other counter types and follow the following semantic
+     * Return number is:
+     * * negative if the new message counter is smaller than the current maximum. Smaller values within the Window size
+     *   are check separately within the window. Other smaller values are considered DUPLICATE
+     * * positive if the new message counter is larger than the current maximum and are always NEW
+     */
+    protected calculateDiff(messageCounter: number): number;
+    /** Update or move the message counter window. */
+    private calculateMessageCounterBitmap;
+    /** Update the message counter and window. */
+    private updateMessageCounterAndBitmap;
+    /** Check if the message counter is known in the bitmap. */
+    private isCounterKnownInBitmap;
+    /**
+     * Returns true if the message counter is a duplicate.
+     */
+    updateMessageCounter(messageCounter: number): void;
+}
+/**
+ * Implements a message reception state for encrypted messages with rollover.
+ * A message counter with rollover is a free running message counter that monotonically increases, but rolls
+ * over to zero when it exceeds the maximum value of the counter (32-bits). If the difference is below 2^31 then it is
+ * considered a rollover and not a smaller value
+ */
+export declare class MessageReceptionStateEncryptedWithRollover extends MessageReceptionStateEncryptedWithoutRollover {
+    protected calculateDiff(messageCounter: number): number;
+}
+/**
+ * Implements a message reception state for unencrypted messages without rollover.
+ * Any message counter equal to max_message_counter or within the message counter window, where the corresponding bit
+ * is set to true SHALL be considered duplicate. All other message counters, whether behind the window or ahead of
+ * max_message_counter, are considered new and SHALL update max_message_counter and shift the window accordingly.
+ * Messages with a counter behind the window are likely caused by a node rebooting and are thus processed as rolling
+ * back the window to the current location.
+ */
+export declare class MessageReceptionStateUnencryptedWithRollover extends MessageReceptionStateEncryptedWithoutRollover {
+    protected calculateDiff(messageCounter: number): number;
+}
+//# sourceMappingURL=MessageReceptionState.d.ts.map