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

package/dist/cjs/protocol/ExchangeManager.js

@@ -0,0 +1,407 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ExchangeManager_exports = {};
+__export(ExchangeManager_exports, {
+  ChannelNotConnectedError: () => ChannelNotConnectedError,
+  ExchangeCounter: () => ExchangeCounter,
+  ExchangeManager: () => ExchangeManager,
+  ExchangeProvider: () => ExchangeProvider,
+  MessageChannel: () => MessageChannel
+});
+module.exports = __toCommonJS(ExchangeManager_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_MessageCodec = require("../codec/MessageCodec.js");
+var import_SecureChannelMessenger = require("../securechannel/SecureChannelMessenger.js");
+var import_SessionManager = require("../session/SessionManager.js");
+var import_ChannelManager = require("./ChannelManager.js");
+var import_MessageExchange = require("./MessageExchange.js");
+var import_MessageReceptionState = require("./MessageReceptionState.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("ExchangeManager");
+const MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION = 5;
+class ChannelNotConnectedError extends import_general.MatterError {
+}
+class MessageChannel {
+  constructor(channel, session, closeCallback) {
+    this.channel = channel;
+    this.session = session;
+    this.#closeCallback = closeCallback;
+  }
+  closed = false;
+  #closeCallback;
+  set closeCallback(callback) {
+    this.#closeCallback = callback;
+  }
+  /** Is the underlying transport reliable? */
+  get isReliable() {
+    return this.channel.isReliable;
+  }
+  get type() {
+    return this.channel.type;
+  }
+  /**
+   * Max Payload size of the exchange which bases on the maximum payload size of the channel. The full encoded matter
+   * message payload sent here can be as huge as allowed by the channel.
+   */
+  get maxPayloadSize() {
+    return this.channel.maxPayloadSize;
+  }
+  send(message) {
+    logger.debug("Message \xBB", import_MessageCodec.MessageCodec.messageDiagnostics(message));
+    const packet = this.session.encode(message);
+    const bytes = import_MessageCodec.MessageCodec.encodePacket(packet);
+    if (bytes.length > this.maxPayloadSize) {
+      logger.warn(
+        `Matter message to send to ${this.name} is ${bytes.length}bytes long, which is larger than the maximum allowed size of ${this.maxPayloadSize}. This only works if both nodes support it.`
+      );
+    }
+    return this.channel.send(bytes);
+  }
+  get name() {
+    return `${this.channel.name} on session ${this.session.name}`;
+  }
+  async close() {
+    const wasAlreadyClosed = this.closed;
+    this.closed = true;
+    await this.channel.close();
+    if (!wasAlreadyClosed) {
+      await this.#closeCallback?.();
+    }
+  }
+}
+class ExchangeManager {
+  #transportInterfaces;
+  #sessionManager;
+  #channelManager;
+  #exchangeCounter = new ExchangeCounter();
+  #exchanges = /* @__PURE__ */ new Map();
+  #protocols = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Map();
+  #closers = /* @__PURE__ */ new Set();
+  #observers = new import_general.ObserverGroup(this);
+  constructor(context) {
+    this.#transportInterfaces = context.transportInterfaces;
+    this.#sessionManager = context.sessionManager;
+    this.#channelManager = context.channelManager;
+    for (const transportInterface of this.#transportInterfaces) {
+      this.#addListener(transportInterface);
+    }
+    this.#observers.on(this.#transportInterfaces.added, this.#addListener);
+    this.#observers.on(this.#transportInterfaces.deleted, this.#deleteListener);
+    this.#observers.on(this.#sessionManager.sessions.deleted, (session) => {
+      if (!session.closingAfterExchangeFinished) {
+        session.closer = this.#closeSession(session);
+      }
+    });
+  }
+  [import_general.Environmental.create](env) {
+    const instance = new ExchangeManager({
+      transportInterfaces: env.get(import_general.TransportInterfaceSet),
+      sessionManager: env.get(import_SessionManager.SessionManager),
+      channelManager: env.get(import_ChannelManager.ChannelManager)
+    });
+    env.set(ExchangeManager, instance);
+    return instance;
+  }
+  hasProtocolHandler(protocolId) {
+    return this.#protocols.has(protocolId);
+  }
+  getProtocolHandler(protocolId) {
+    return this.#protocols.get(protocolId);
+  }
+  addProtocolHandler(protocol) {
+    if (this.hasProtocolHandler(protocol.getId())) {
+      throw new import_general.ImplementationError(`Handler for protocol ${protocol.getId()} already registered.`);
+    }
+    this.#protocols.set(protocol.getId(), protocol);
+  }
+  initiateExchange(address, protocolId) {
+    return this.initiateExchangeWithChannel(this.#channelManager.getChannel(address), protocolId);
+  }
+  initiateExchangeWithChannel(channel, protocolId) {
+    const exchangeId = this.#exchangeCounter.getIncrementedCounter();
+    const exchangeIndex = exchangeId | 65536;
+    const exchange = import_MessageExchange.MessageExchange.initiate(this.#messageExchangeContextFor(channel), exchangeId, protocolId);
+    this.#addExchange(exchangeIndex, exchange);
+    return exchange;
+  }
+  async close() {
+    for (const protocol of this.#protocols.values()) {
+      await protocol.close();
+    }
+    for (const listeners of this.#listeners.keys()) {
+      this.#deleteListener(listeners);
+    }
+    await Promise.allSettled(this.#closers);
+    for (const exchange of this.#exchanges.values()) {
+      await exchange.destroy();
+    }
+    this.#exchanges.clear();
+  }
+  async onMessage(channel, messageBytes) {
+    const packet = import_MessageCodec.MessageCodec.decodePacket(messageBytes);
+    if (packet.header.sessionType === import_MessageCodec.SessionType.Group)
+      throw new import_general.NotImplementedError("Group messages are not supported");
+    let session;
+    if (packet.header.sessionType === import_MessageCodec.SessionType.Unicast) {
+      if (packet.header.sessionId === import_SessionManager.UNICAST_UNSECURE_SESSION_ID) {
+        const initiatorNodeId = packet.header.sourceNodeId ?? import_types.NodeId.UNSPECIFIED_NODE_ID;
+        session = this.#sessionManager.getUnsecureSession(initiatorNodeId) ?? this.#sessionManager.createInsecureSession({
+          initiatorNodeId
+        });
+      } else {
+        session = this.#sessionManager.getSession(packet.header.sessionId);
+      }
+    } else if (packet.header.sessionType === import_MessageCodec.SessionType.Group) {
+      if (packet.header.sourceNodeId !== void 0) {
+      }
+    }
+    if (session === void 0) {
+      throw new import_general.MatterFlowError(
+        `Cannot find a session for ID ${packet.header.sessionId}${packet.header.sourceNodeId !== void 0 ? ` and source NodeId ${packet.header.sourceNodeId}` : ""}`
+      );
+    }
+    const messageId = packet.header.messageId;
+    let isDuplicate;
+    try {
+      session?.updateMessageCounter(packet.header.messageId, packet.header.sourceNodeId);
+      isDuplicate = false;
+    } catch (e) {
+      import_MessageReceptionState.DuplicateMessageError.accept(e);
+      isDuplicate = true;
+    }
+    const aad = messageBytes.slice(0, messageBytes.length - packet.applicationPayload.length);
+    const message = session.decode(packet, aad);
+    const exchangeIndex = message.payloadHeader.isInitiatorMessage ? message.payloadHeader.exchangeId : message.payloadHeader.exchangeId | 65536;
+    let exchange = this.#exchanges.get(exchangeIndex);
+    if (exchange !== void 0 && (exchange.session.id !== session.id || exchange.isInitiator === message.payloadHeader.isInitiatorMessage)) {
+      exchange = void 0;
+    }
+    if (exchange !== void 0) {
+      await exchange.onMessageReceived(message, isDuplicate);
+    } else {
+      if (session.closingAfterExchangeFinished) {
+        throw new import_general.MatterFlowError(
+          `Session with ID ${packet.header.sessionId} marked for closure, decline new exchange creation.`
+        );
+      }
+      const protocolHandler = this.#protocols.get(message.payloadHeader.protocolId);
+      if (protocolHandler !== void 0 && message.payloadHeader.isInitiatorMessage && !isDuplicate) {
+        if (message.payloadHeader.messageType == import_types.SecureMessageType.StandaloneAck && !message.payloadHeader.requiresAck) {
+          logger.debug(
+            `Ignoring unsolicited standalone ack message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId}.`
+          );
+          return;
+        }
+        const exchange2 = import_MessageExchange.MessageExchange.fromInitialMessage(
+          this.#messageExchangeContextFor(await this.#channelManager.getOrCreateChannel(channel, session)),
+          message
+        );
+        this.#addExchange(exchangeIndex, exchange2);
+        await exchange2.onMessageReceived(message);
+        await protocolHandler.onNewExchange(exchange2, message);
+      } else if (message.payloadHeader.requiresAck) {
+        const exchange2 = import_MessageExchange.MessageExchange.fromInitialMessage(
+          this.#messageExchangeContextFor(await this.#channelManager.getOrCreateChannel(channel, session)),
+          message
+        );
+        this.#addExchange(exchangeIndex, exchange2);
+        await exchange2.send(import_types.SecureMessageType.StandaloneAck, new Uint8Array(0), {
+          includeAcknowledgeMessageId: message.packetHeader.messageId
+        });
+        await exchange2.close();
+        logger.debug(
+          `Ignoring unsolicited message ${messageId} for protocol ${message.payloadHeader.protocolId}.`
+        );
+      } else {
+        if (protocolHandler === void 0) {
+          throw new import_general.MatterFlowError(`Unsupported protocol ${message.payloadHeader.protocolId}`);
+        }
+        if (isDuplicate) {
+          logger.info(
+            `Ignoring duplicate message ${messageId} (requires no ack) for protocol ${message.payloadHeader.protocolId}.`
+          );
+          return;
+        } else {
+          logger.info(
+            `Discarding unexpected message ${messageId} for protocol ${message.payloadHeader.protocolId}, exchangeIndex ${exchangeIndex} and sessionId ${session.id} : ${import_general.Logger.toJSON(message)}`
+          );
+        }
+      }
+    }
+  }
+  async deleteExchange(exchangeIndex) {
+    const exchange = this.#exchanges.get(exchangeIndex);
+    if (exchange === void 0) {
+      logger.info(`Exchange with index ${exchangeIndex} to delete not found or already deleted.`);
+      return;
+    }
+    const { session } = exchange;
+    if (session.isSecure && session.closingAfterExchangeFinished) {
+      logger.debug(
+        `Exchange index ${exchangeIndex} Session ${session.name} is already marked for closure. Close session now.`
+      );
+      try {
+        await this.#closeSession(session);
+      } catch (error) {
+        logger.error(`Error closing session ${session.name}. Ignoring.`, error);
+      }
+    }
+    this.#exchanges.delete(exchangeIndex);
+  }
+  async #closeSession(session) {
+    const sessionId = session.id;
+    const sessionName = session.name;
+    const asExchangeSession = session;
+    if (asExchangeSession.closedByExchange) {
+      return;
+    }
+    asExchangeSession.closedByExchange = true;
+    for (const [_exchangeIndex, exchange] of this.#exchanges.entries()) {
+      if (exchange.session.id === sessionId) {
+        await exchange.destroy();
+      }
+    }
+    if (session.sendCloseMessageWhenClosing) {
+      const channel = this.#channelManager.getChannelForSession(session);
+      logger.debug(`Channel for session ${session.name} is ${channel?.name}`);
+      if (channel !== void 0) {
+        const exchange = this.initiateExchangeWithChannel(channel, import_types.SECURE_CHANNEL_PROTOCOL_ID);
+        logger.debug(`Initiated exchange ${!!exchange} to close session ${sessionName}`);
+        if (exchange !== void 0) {
+          try {
+            const messenger = new import_SecureChannelMessenger.SecureChannelMessenger(exchange);
+            await messenger.sendCloseSession();
+            await messenger.close();
+          } catch (error) {
+            if (error instanceof ChannelNotConnectedError) {
+              logger.debug("Session already closed because channel is disconnected.");
+            } else {
+              logger.error("Error closing session", error);
+            }
+          }
+        }
+        await exchange.destroy();
+      }
+    }
+    if (session.closingAfterExchangeFinished) {
+      await session.destroy(false, false);
+    }
+  }
+  #addExchange(exchangeIndex, exchange) {
+    exchange.closed.on(() => this.deleteExchange(exchangeIndex));
+    this.#exchanges.set(exchangeIndex, exchange);
+    this.#cleanupSessionExchanges(exchange.session.id);
+  }
+  #cleanupSessionExchanges(sessionId) {
+    if (sessionId === import_SessionManager.UNICAST_UNSECURE_SESSION_ID) {
+      return;
+    }
+    const sessionExchanges = Array.from(this.#exchanges.values()).filter(
+      (exchange) => exchange.session.id === sessionId && !exchange.isClosing
+    );
+    if (sessionExchanges.length <= MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION) {
+      return;
+    }
+    const exchangeToClose = sessionExchanges[0];
+    logger.debug(`Closing oldest exchange ${exchangeToClose.id} for session ${sessionId}`);
+    exchangeToClose.close().catch((error) => logger.error("Error closing exchange", error));
+  }
+  #messageExchangeContextFor(channel) {
+    return {
+      channel,
+      localSessionParameters: this.#sessionManager.sessionParameters,
+      resubmissionStarted: () => this.#sessionManager.resubmissionStarted.emit(channel.session)
+    };
+  }
+  #addListener(transportInterface) {
+    const udpInterface = transportInterface instanceof import_general.UdpInterface;
+    this.#listeners.set(
+      transportInterface,
+      transportInterface.onData((socket, data) => {
+        if (udpInterface && data.length > socket.maxPayloadSize) {
+          logger.warn(
+            `Ignoring UDP message with size ${data.length} from ${socket.name}, which is larger than the maximum allowed size of ${socket.maxPayloadSize}.`
+          );
+          return;
+        }
+        try {
+          this.onMessage(socket, data).catch((error) => logger.error(error));
+        } catch (error) {
+          logger.warn("Ignoring UDP message with error", error);
+        }
+      })
+    );
+  }
+  #deleteListener(transportInterface) {
+    const listener = this.#listeners.get(transportInterface);
+    if (listener === void 0) {
+      return;
+    }
+    this.#listeners.delete(transportInterface);
+    const closer = listener.close().catch((e) => logger.error("Error closing network listener", e)).finally(() => this.#closers.delete(closer));
+    this.#closers.add(closer);
+  }
+}
+class ExchangeCounter {
+  exchangeCounter = import_general.Crypto.getRandomUInt16();
+  getIncrementedCounter() {
+    this.exchangeCounter++;
+    if (this.exchangeCounter > 65535) {
+      this.exchangeCounter = 0;
+    }
+    return this.exchangeCounter;
+  }
+}
+class ExchangeProvider {
+  constructor(exchangeManager, channel, reconnectChannelFunc) {
+    this.exchangeManager = exchangeManager;
+    this.channel = channel;
+    this.reconnectChannelFunc = reconnectChannelFunc;
+  }
+  hasProtocolHandler(protocolId) {
+    return this.exchangeManager.hasProtocolHandler(protocolId);
+  }
+  getProtocolHandler(protocolId) {
+    return this.exchangeManager.getProtocolHandler(protocolId);
+  }
+  addProtocolHandler(handler) {
+    this.exchangeManager.addProtocolHandler(handler);
+  }
+  initiateExchange() {
+    return this.exchangeManager.initiateExchangeWithChannel(this.channel, import_types.INTERACTION_PROTOCOL_ID);
+  }
+  async reconnectChannel() {
+    if (this.reconnectChannelFunc === void 0) return false;
+    this.channel = await this.reconnectChannelFunc();
+    return true;
+  }
+  get session() {
+    return this.channel.session;
+  }
+  get channelType() {
+    return this.channel.type;
+  }
+}
+//# sourceMappingURL=ExchangeManager.js.map

package/dist/cjs/protocol/ExchangeManager.js.map

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

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

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Construction, StorageContext } from "#general";
+/** Maximum 32 bit counter value. */
+export declare const MAX_COUNTER_VALUE_32BIT = 4294967294;
+export declare enum MessageCounterTypes {
+    /**
+     * Used for "Unsecure" sessions
+     * Rollover allowed, Persistence: Optional
+     */
+    GlobalUnencrypted = 0,
+    /**
+     * Used for "Group" sessions to encode regular data messages encrypted with a group key.
+     * Lifetime: Operational Group Key, Rollover allowed, Persistence: Mandatory
+     */
+    GlobalEncryptedData = 1,
+    /**
+     * Used for "Group" sessions to encode control messages encrypted with a group key.
+     * Lifetime: Operational Group Key, Rollover allowed, Persistence: Mandatory
+     */
+    GlobalEncryptedControl = 2,
+    /**
+     * Used for "Unicast" sessions
+     * Lifetime: Session Key, Rollover expires, Persistence: Optional
+     */
+    SecureSession = 3
+}
+/**
+ * Represents a message counter which gets randomly initialized and then incremented for each message.
+ * Rollover can be allowed or forbidden and a callback can be provided to be notified before a rollover would happen.
+ */
+export declare class MessageCounter {
+    protected readonly aboutToRolloverCallback?: (() => void) | undefined;
+    protected readonly rolloverInfoDifference: number;
+    protected messageCounter: number;
+    /**
+     * Creates a new message counter with a random start value. If a aboutToRolloverCallback is provided this
+     * counter is not allowed to rollover and the callback is called before a rollover would happen. Optionally provide
+     * a number of messages before the rollover callback is called (Default 1000).
+     */
+    constructor(aboutToRolloverCallback?: (() => void) | undefined, rolloverInfoDifference?: number);
+    getIncrementedCounter(): Promise<number>;
+}
+/** Enhanced Message counter that can be persisted and will be initialized from the persisted value (if existing). */
+export declare class PersistedMessageCounter extends MessageCounter {
+    #private;
+    private readonly storageContext;
+    private readonly storageKey;
+    get construction(): Construction<PersistedMessageCounter>;
+    static create(storageContext: StorageContext, storageKey: string, aboutToRolloverCallback?: () => void, rolloverInfoDifference?: number): Promise<PersistedMessageCounter>;
+    constructor(storageContext: StorageContext, storageKey: string, aboutToRolloverCallback?: () => void, rolloverInfoDifference?: number);
+    getIncrementedCounter(): Promise<number>;
+}
+//# sourceMappingURL=MessageCounter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MessageCounter.d.ts","sourceRoot":"","sources":["../../../src/protocol/MessageCounter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAyB,cAAc,EAAY,MAAM,UAAU,CAAC;AAEzF,oCAAoC;AACpC,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAKlD,oBAAY,mBAAmB;IAC3B;;;OAGG;IACH,iBAAiB,IAAA;IAEjB;;;OAGG;IACH,mBAAmB,IAAA;IAEnB;;;OAGG;IACH,sBAAsB,IAAA;IAEtB;;;OAGG;IACH,aAAa,IAAA;CAChB;AAED;;;GAGG;AACH,qBAAa,cAAc;IASnB,SAAS,CAAC,QAAQ,CAAC,uBAAuB,CAAC,GAAE,MAAM,IAAI;IACvD,SAAS,CAAC,QAAQ,CAAC,sBAAsB;IAT7C,SAAS,CAAC,cAAc,SAAwC;IAEhE;;;;OAIG;gBAEoB,uBAAuB,CAAC,GAAE,MAAM,IAAI,aAAA,EACpC,sBAAsB,SAA2B;IAGlE,qBAAqB;CAgB9B;AAED,qHAAqH;AACrH,qBAAa,uBAAwB,SAAQ,cAAc;;IAuBnD,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU;IArB/B,IAAI,YAAY,0CAEf;WAEY,MAAM,CACf,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,MAAM,EAClB,uBAAuB,CAAC,EAAE,MAAM,IAAI,EACpC,sBAAsB,SAA2B;gBAYhC,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,MAAM,EACnC,uBAAuB,CAAC,EAAE,MAAM,IAAI,EACpC,sBAAsB,SAA2B;IAoBtC,qBAAqB;CAKvC"}

package/dist/cjs/protocol/MessageCounter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MessageCounter_exports = {};
+__export(MessageCounter_exports, {
+  MAX_COUNTER_VALUE_32BIT: () => MAX_COUNTER_VALUE_32BIT,
+  MessageCounter: () => MessageCounter,
+  MessageCounterTypes: () => MessageCounterTypes,
+  PersistedMessageCounter: () => PersistedMessageCounter
+});
+module.exports = __toCommonJS(MessageCounter_exports);
+var import_general = require("#general");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MAX_COUNTER_VALUE_32BIT = 4294967294;
+const ROLLOVER_INFO_DIFFERENCE = 1e3;
+var MessageCounterTypes = /* @__PURE__ */ ((MessageCounterTypes2) => {
+  MessageCounterTypes2[MessageCounterTypes2["GlobalUnencrypted"] = 0] = "GlobalUnencrypted";
+  MessageCounterTypes2[MessageCounterTypes2["GlobalEncryptedData"] = 1] = "GlobalEncryptedData";
+  MessageCounterTypes2[MessageCounterTypes2["GlobalEncryptedControl"] = 2] = "GlobalEncryptedControl";
+  MessageCounterTypes2[MessageCounterTypes2["SecureSession"] = 3] = "SecureSession";
+  return MessageCounterTypes2;
+})(MessageCounterTypes || {});
+class MessageCounter {
+  // 28 bit random number plus 1
+  /**
+   * Creates a new message counter with a random start value. If a aboutToRolloverCallback is provided this
+   * counter is not allowed to rollover and the callback is called before a rollover would happen. Optionally provide
+   * a number of messages before the rollover callback is called (Default 1000).
+   */
+  constructor(aboutToRolloverCallback, rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE) {
+    this.aboutToRolloverCallback = aboutToRolloverCallback;
+    this.rolloverInfoDifference = rolloverInfoDifference;
+  }
+  messageCounter = (import_general.Crypto.getRandomUInt32() >>> 4) + 1;
+  async getIncrementedCounter() {
+    this.messageCounter++;
+    if (this.messageCounter > MAX_COUNTER_VALUE_32BIT) {
+      if (this.aboutToRolloverCallback !== void 0) {
+        this.messageCounter = 0;
+      } else {
+        throw new import_general.InternalError("Message counter rollover not allowed.");
+      }
+    } else if (this.aboutToRolloverCallback !== void 0 && this.messageCounter === MAX_COUNTER_VALUE_32BIT - this.rolloverInfoDifference) {
+      this.aboutToRolloverCallback();
+    }
+    return this.messageCounter;
+  }
+}
+class PersistedMessageCounter extends MessageCounter {
+  constructor(storageContext, storageKey, aboutToRolloverCallback, rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE) {
+    super(aboutToRolloverCallback, rolloverInfoDifference);
+    this.storageContext = storageContext;
+    this.storageKey = storageKey;
+    this.#construction = (0, import_general.Construction)(this, async () => {
+      if (await storageContext.has(storageKey)) {
+        this.messageCounter = await storageContext.get(storageKey);
+        if (this.messageCounter < 0 || this.messageCounter > MAX_COUNTER_VALUE_32BIT) {
+          throw new import_general.InternalError(`Invalid message counter value: ${this.messageCounter}`);
+        }
+        if (this.aboutToRolloverCallback !== void 0 && this.messageCounter >= MAX_COUNTER_VALUE_32BIT - this.rolloverInfoDifference) {
+          this.aboutToRolloverCallback();
+        }
+      }
+    });
+  }
+  #construction;
+  get construction() {
+    return this.#construction;
+  }
+  static async create(storageContext, storageKey, aboutToRolloverCallback, rolloverInfoDifference = ROLLOVER_INFO_DIFFERENCE) {
+    return (0, import_general.asyncNew)(
+      PersistedMessageCounter,
+      storageContext,
+      storageKey,
+      aboutToRolloverCallback,
+      rolloverInfoDifference
+    );
+  }
+  async getIncrementedCounter() {
+    const counter = await super.getIncrementedCounter();
+    await this.storageContext.set(this.storageKey, counter);
+    return counter;
+  }
+}
+//# sourceMappingURL=MessageCounter.js.map

package/dist/cjs/protocol/MessageCounter.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol/MessageCounter.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA8E;AAN9E;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,0BAA0B;AAGvC,MAAM,2BAA2B;AAE1B,IAAK,sBAAL,kBAAKA,yBAAL;AAKH,EAAAA,0CAAA;AAMA,EAAAA,0CAAA;AAMA,EAAAA,0CAAA;AAMA,EAAAA,0CAAA;AAvBQ,SAAAA;AAAA,GAAA;AA8BL,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQxB,YACuB,yBACA,yBAAyB,0BAC9C;AAFqB;AACA;AAAA,EACpB;AAAA,EAVO,kBAAkB,sBAAO,gBAAgB,MAAM,KAAK;AAAA,EAY9D,MAAM,wBAAwB;AAC1B,SAAK;AACL,QAAI,KAAK,iBAAiB,yBAAyB;AAC/C,UAAI,KAAK,4BAA4B,QAAW;AAC5C,aAAK,iBAAiB;AAAA,MAC1B,OAAO;AACH,cAAM,IAAI,6BAAc,uCAAuC;AAAA,MACnE;AAAA,IACJ,WACI,KAAK,4BAA4B,UACjC,KAAK,mBAAmB,0BAA0B,KAAK,wBACzD;AACE,WAAK,wBAAwB;AAAA,IACjC;AACA,WAAO,KAAK;AAAA,EAChB;AACJ;AAGO,MAAM,gCAAgC,eAAe;AAAA,EAsBxD,YACqB,gBACA,YACjB,yBACA,yBAAyB,0BAC3B;AACE,UAAM,yBAAyB,sBAAsB;AALpC;AACA;AAKjB,SAAK,oBAAgB,6BAAa,MAAM,YAAY;AAChD,UAAI,MAAM,eAAe,IAAI,UAAU,GAAG;AACtC,aAAK,iBAAiB,MAAM,eAAe,IAAY,UAAU;AACjE,YAAI,KAAK,iBAAiB,KAAK,KAAK,iBAAiB,yBAAyB;AAC1E,gBAAM,IAAI,6BAAc,kCAAkC,KAAK,cAAc,EAAE;AAAA,QACnF;AAEA,YACI,KAAK,4BAA4B,UACjC,KAAK,kBAAkB,0BAA0B,KAAK,wBACxD;AACE,eAAK,wBAAwB;AAAA,QACjC;AAAA,MACJ;AAAA,IACJ,CAAC;AAAA,EACL;AAAA,EA3CA;AAAA,EAEA,IAAI,eAAe;AACf,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,aAAa,OACT,gBACA,YACA,yBACA,yBAAyB,0BAC3B;AACE,eAAO;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACJ;AAAA,EACJ;AAAA,EA0BA,MAAe,wBAAwB;AACnC,UAAM,UAAU,MAAM,MAAM,sBAAsB;AAClD,UAAM,KAAK,eAAe,IAAI,KAAK,YAAY,OAAO;AACtD,WAAO;AAAA,EACX;AACJ;",
+  "names": ["MessageCounterTypes"]
+}