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

package/dist/cjs/ble/BleConsts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** @see {@link MatterSpecification.v11.Core} § 4.17.3.2 */
+export declare const BLE_MATTER_SERVICE_UUID = "fff6";
+export declare const BLE_MATTER_C1_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D11";
+export declare const BLE_MATTER_C2_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D12";
+export declare const BLE_MATTER_C3_CHARACTERISTIC_UUID = "64630238-8772-45F2-B87D-748A83218F04";
+export declare const BLE_MINIMUM_ATT_MTU = 20;
+export declare const BLE_MAXIMUM_BTP_MTU = 244;
+export declare const BTP_MAXIMUM_WINDOW_SIZE = 255;
+/**
+ * The maximum amount of time after sending a BTP Session Handshake request to wait for a BTP Session Handshake response
+ * before closing the connection.
+ */
+export declare const BTP_CONN_RSP_TIMEOUT_MS = 5000;
+/** The maximum amount of time after receipt of a segment before a stand-alone ACK must be sent. */
+export declare const BTP_ACK_TIMEOUT_MS = 15000;
+export declare const BTP_SEND_ACK_TIMEOUT_MS: number;
+/**
+ * The maximum amount of time no unique data has been sent over a BTP session before the Central Device must close the
+ * BTP session.
+ */
+export declare const BTP_CONN_IDLE_TIMEOUT = 30000;
+/**
+ * The maximum message size that can be transported in a Matter message via BTP.
+ * Seems the chip code in BTPEngine limits the size currently to "one pbuf" which should mean one UDP message.
+ */
+export declare const BLE_MAX_MATTER_PAYLOAD_SIZE: number;
+//# sourceMappingURL=BleConsts.d.ts.map

package/dist/cjs/ble/BleConsts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleConsts.d.ts","sourceRoot":"","sources":["../../../src/ble/BleConsts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,2DAA2D;AAC3D,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAC9C,eAAO,MAAM,iCAAiC,yCAAyC,CAAC;AACxF,eAAO,MAAM,iCAAiC,yCAAyC,CAAC;AACxF,eAAO,MAAM,iCAAiC,yCAAyC,CAAC;AAExF,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAE7C,mGAAmG;AACnG,eAAO,MAAM,kBAAkB,QAAS,CAAC;AAEzC,eAAO,MAAM,uBAAuB,QAAyB,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,2BAA2B,QAAuB,CAAC"}

package/dist/cjs/ble/BleConsts.js

@@ -0,0 +1,53 @@
+"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 BleConsts_exports = {};
+__export(BleConsts_exports, {
+  BLE_MATTER_C1_CHARACTERISTIC_UUID: () => BLE_MATTER_C1_CHARACTERISTIC_UUID,
+  BLE_MATTER_C2_CHARACTERISTIC_UUID: () => BLE_MATTER_C2_CHARACTERISTIC_UUID,
+  BLE_MATTER_C3_CHARACTERISTIC_UUID: () => BLE_MATTER_C3_CHARACTERISTIC_UUID,
+  BLE_MATTER_SERVICE_UUID: () => BLE_MATTER_SERVICE_UUID,
+  BLE_MAXIMUM_BTP_MTU: () => BLE_MAXIMUM_BTP_MTU,
+  BLE_MAX_MATTER_PAYLOAD_SIZE: () => BLE_MAX_MATTER_PAYLOAD_SIZE,
+  BLE_MINIMUM_ATT_MTU: () => BLE_MINIMUM_ATT_MTU,
+  BTP_ACK_TIMEOUT_MS: () => BTP_ACK_TIMEOUT_MS,
+  BTP_CONN_IDLE_TIMEOUT: () => BTP_CONN_IDLE_TIMEOUT,
+  BTP_CONN_RSP_TIMEOUT_MS: () => BTP_CONN_RSP_TIMEOUT_MS,
+  BTP_MAXIMUM_WINDOW_SIZE: () => BTP_MAXIMUM_WINDOW_SIZE,
+  BTP_SEND_ACK_TIMEOUT_MS: () => BTP_SEND_ACK_TIMEOUT_MS
+});
+module.exports = __toCommonJS(BleConsts_exports);
+var import_general = require("#general");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const BLE_MATTER_SERVICE_UUID = "fff6";
+const BLE_MATTER_C1_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D11";
+const BLE_MATTER_C2_CHARACTERISTIC_UUID = "18EE2EF5-263D-4559-959F-4F9C429F9D12";
+const BLE_MATTER_C3_CHARACTERISTIC_UUID = "64630238-8772-45F2-B87D-748A83218F04";
+const BLE_MINIMUM_ATT_MTU = 20;
+const BLE_MAXIMUM_BTP_MTU = 244;
+const BTP_MAXIMUM_WINDOW_SIZE = 255;
+const BTP_CONN_RSP_TIMEOUT_MS = 5e3;
+const BTP_ACK_TIMEOUT_MS = 15e3;
+const BTP_SEND_ACK_TIMEOUT_MS = BTP_ACK_TIMEOUT_MS / 3;
+const BTP_CONN_IDLE_TIMEOUT = 3e4;
+const BLE_MAX_MATTER_PAYLOAD_SIZE = import_general.MAX_UDP_MESSAGE_SIZE;
+//# sourceMappingURL=BleConsts.js.map

package/dist/cjs/ble/BleConsts.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ble/BleConsts.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAqC;AANrC;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,0BAA0B;AAChC,MAAM,oCAAoC;AAC1C,MAAM,oCAAoC;AAC1C,MAAM,oCAAoC;AAE1C,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;AAE5B,MAAM,0BAA0B;AAMhC,MAAM,0BAA0B;AAGhC,MAAM,qBAAqB;AAE3B,MAAM,0BAA0B,qBAAqB;AAMrD,MAAM,wBAAwB;AAM9B,MAAM,8BAA8B;",
+  "names": []
+}

package/dist/cjs/ble/BtpSessionHandler.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "#general";
+export declare class BtpMatterError extends MatterError {
+}
+export declare class BtpProtocolError extends BtpMatterError {
+}
+export declare class BtpFlowError extends BtpMatterError {
+}
+export declare const BTP_SUPPORTED_VERSIONS: number[];
+export declare class BtpSessionHandler {
+    private readonly role;
+    private readonly fragmentSize;
+    private readonly clientWindowSize;
+    private readonly writeBleCallback;
+    private readonly disconnectBleCallback;
+    private readonly handleMatterMessagePayload;
+    private currentIncomingSegmentedMsgLength;
+    private currentIncomingSegmentedPayload;
+    private prevIncomingSequenceNumber;
+    private prevIncomingAckNumber;
+    private readonly ackReceiveTimer;
+    private sequenceNumber;
+    private prevAckedSequenceNumber;
+    private readonly queuedOutgoingMatterMessages;
+    private sendInProgress;
+    private readonly sendAckTimer;
+    private isActive;
+    private idleTimeout;
+    /** Factory method to create a new BTPSessionHandler from a received handshake request */
+    static createFromHandshakeRequest(maxDataSize: number | undefined, handshakeRequestPayload: Uint8Array, writeBleCallback: (data: Uint8Array) => Promise<void>, disconnectBleCallback: () => Promise<void>, handleMatterMessagePayload: (data: Uint8Array) => Promise<void>): Promise<BtpSessionHandler>;
+    static createAsCentral(handshakeResponsePayload: Uint8Array, writeBleCallback: (data: Uint8Array) => Promise<void>, disconnectBleCallback: () => Promise<void>, handleMatterMessagePayload: (data: Uint8Array) => Promise<void>): Promise<BtpSessionHandler>;
+    /**
+     * Creates a new BTP session handler
+     *
+     * @param role The role of the BTP session handler
+     * @param btpVersion The BTP protocol version to use
+     * @param fragmentSize The fragment size to use for the messages
+     * @param clientWindowSize The client window size to use
+     * @param writeBleCallback Callback to write data to the BLE transport
+     * @param disconnectBleCallback Callback to disconnect the BLE transport
+     * @param handleMatterMessagePayload Callback to handle a Matter message payload
+     */
+    constructor(role: "central" | "peripheral", btpVersion: number, fragmentSize: number, clientWindowSize: number, writeBleCallback: (data: Uint8Array) => Promise<void>, disconnectBleCallback: () => Promise<void>, handleMatterMessagePayload: (data: Uint8Array) => Promise<void>);
+    /**
+     * Handle incoming data from the transport layer and hand over completely received matter messages to the
+     * ExchangeManager layer
+     *
+     * @param data ByteArray containing the data
+     */
+    handleIncomingBleData(data: Uint8Array): Promise<void>;
+    /**
+     * Send a Matter message to the transport layer, but before that encode it into a BTP packet and potentially split
+     * it into multiple segments. This Method is indirectly called by the ExchangeManager layer when a Matter message
+     * should be sent.
+     *
+     * @param data ByteArray containing the Matter message
+     */
+    sendMatterMessage(data: Uint8Array): Promise<void>;
+    private processSendQueue;
+    /**
+     * Close the BTP session. This method is called when the BLE transport is disconnected and so the BTP session gets closed.
+     */
+    close(): Promise<void>;
+    /**
+     * If this timer expires and the peer has a pending acknowledgement, the peer SHALL immediately send that
+     * acknowledgement
+     */
+    private btpSendAckTimeoutTriggered;
+    /**
+     * If a peer’s acknowledgement-received timer expires, or if a peer receives an invalid acknowledgement,
+     * the peer SHALL close the BTP session and report an error to the application.
+     */
+    private btpAckTimeoutTriggered;
+    /**
+     * Increments sequence number for the packets and round it off to 0 when it reaches the maximum limit.
+     */
+    getNextSequenceNumber(): number;
+    /**
+     * Checks if incoming ackNumber and sent sequence number exceeds the client window size or not.
+     */
+    private exceedsWindowSize;
+}
+//# sourceMappingURL=BtpSessionHandler.d.ts.map

package/dist/cjs/ble/BtpSessionHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BtpSessionHandler.d.ts","sourceRoot":"","sources":["../../../src/ble/BtpSessionHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiD,WAAW,EAAQ,MAAM,UAAU,CAAC;AAW5F,qBAAa,cAAe,SAAQ,WAAW;CAAG;AAClD,qBAAa,gBAAiB,SAAQ,cAAc;CAAG;AACvD,qBAAa,YAAa,SAAQ,cAAc;CAAG;AAEnD,eAAO,MAAM,sBAAsB,UAAM,CAAC;AAK1C,qBAAa,iBAAiB;IAgItB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAErB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,0BAA0B;IArI/C,OAAO,CAAC,iCAAiC,CAAqB;IAC9D,OAAO,CAAC,+BAA+B,CAAyB;IAChE,OAAO,CAAC,0BAA0B,CAAO;IACzC,OAAO,CAAC,qBAAqB,CAAM;IACnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAE9B;IAEF,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,uBAAuB,CAAM;IACrC,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAA0C;IACvF,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAE3B;IACF,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,WAAW,CAGhB;IAEH,yFAAyF;WAC5E,0BAA0B,CACnC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,uBAAuB,EAAE,UAAU,EACnC,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,EACrD,qBAAqB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1C,0BAA0B,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAChE,OAAO,CAAC,iBAAiB,CAAC;WA+DhB,eAAe,CACxB,wBAAwB,EAAE,UAAU,EACpC,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,EACrD,qBAAqB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1C,0BAA0B,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;IAoBnE;;;;;;;;;;OAUG;gBAEkB,IAAI,EAAE,SAAS,GAAG,YAAY,EAC/C,UAAU,EAAE,MAAM,EACD,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,EACrD,qBAAqB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1C,0BAA0B,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;IAepF;;;;;OAKG;IACU,qBAAqB,CAAC,IAAI,EAAE,UAAU;IAwHnD;;;;;;OAMG;IACU,iBAAiB,CAAC,IAAI,EAAE,UAAU;YAcjC,gBAAgB;IA4F9B;;OAEG;IACU,KAAK;IAWlB;;;OAGG;YACW,0BAA0B;IA0BxC;;;OAGG;YACW,sBAAsB;IAOpC;;OAEG;IACH,qBAAqB;IAQrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAM5B"}

package/dist/cjs/ble/BtpSessionHandler.js

@@ -0,0 +1,432 @@
+"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 BtpSessionHandler_exports = {};
+__export(BtpSessionHandler_exports, {
+  BTP_SUPPORTED_VERSIONS: () => BTP_SUPPORTED_VERSIONS,
+  BtpFlowError: () => BtpFlowError,
+  BtpMatterError: () => BtpMatterError,
+  BtpProtocolError: () => BtpProtocolError,
+  BtpSessionHandler: () => BtpSessionHandler
+});
+module.exports = __toCommonJS(BtpSessionHandler_exports);
+var import_general = require("#general");
+var import_BtpCodec = require("../codec/BtpCodec.js");
+var import_BleConsts = require("./BleConsts.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BtpMatterError extends import_general.MatterError {
+}
+class BtpProtocolError extends BtpMatterError {
+}
+class BtpFlowError extends BtpMatterError {
+}
+const BTP_SUPPORTED_VERSIONS = [4];
+const MAXIMUM_SEQUENCE_NUMBER = 255;
+const logger = import_general.Logger.get("BtpSessionHandler");
+class BtpSessionHandler {
+  /**
+   * Creates a new BTP session handler
+   *
+   * @param role The role of the BTP session handler
+   * @param btpVersion The BTP protocol version to use
+   * @param fragmentSize The fragment size to use for the messages
+   * @param clientWindowSize The client window size to use
+   * @param writeBleCallback Callback to write data to the BLE transport
+   * @param disconnectBleCallback Callback to disconnect the BLE transport
+   * @param handleMatterMessagePayload Callback to handle a Matter message payload
+   */
+  constructor(role, btpVersion, fragmentSize, clientWindowSize, writeBleCallback, disconnectBleCallback, handleMatterMessagePayload) {
+    this.role = role;
+    this.fragmentSize = fragmentSize;
+    this.clientWindowSize = clientWindowSize;
+    this.writeBleCallback = writeBleCallback;
+    this.disconnectBleCallback = disconnectBleCallback;
+    this.handleMatterMessagePayload = handleMatterMessagePayload;
+    if (btpVersion !== 4) {
+      throw new BtpProtocolError(`Unsupported BTP version ${btpVersion}`);
+    }
+    if (role === "peripheral") {
+      this.ackReceiveTimer.start();
+    } else {
+      this.sendAckTimer.start();
+      this.prevIncomingSequenceNumber = 0;
+      this.prevIncomingAckNumber = -1;
+      this.sequenceNumber = -1;
+    }
+  }
+  currentIncomingSegmentedMsgLength;
+  currentIncomingSegmentedPayload;
+  prevIncomingSequenceNumber = 255;
+  // Incoming Sequence Number received. Set to 255 to start at 0
+  prevIncomingAckNumber = -1;
+  // Previous ackNumber received
+  ackReceiveTimer = import_general.Time.getTimer(
+    "BTP ack timeout",
+    import_BleConsts.BTP_ACK_TIMEOUT_MS,
+    () => this.btpAckTimeoutTriggered()
+  );
+  sequenceNumber = 0;
+  // Sequence number is set to 0 already for the handshake, next sequence number is 1
+  prevAckedSequenceNumber = -1;
+  // Previous (outgoing) Acked Sequence Number
+  queuedOutgoingMatterMessages = new Array();
+  sendInProgress = false;
+  sendAckTimer = import_general.Time.getTimer(
+    "BTP send timeout",
+    import_BleConsts.BTP_SEND_ACK_TIMEOUT_MS,
+    () => this.btpSendAckTimeoutTriggered()
+  );
+  isActive = true;
+  idleTimeout = import_general.Time.getTimer("Central Device Idle Timer", import_BleConsts.BTP_CONN_IDLE_TIMEOUT, async () => {
+    logger.info("Central Device Connection Idle Timer expired, closing BTP session");
+    await this.close();
+  });
+  /** Factory method to create a new BTPSessionHandler from a received handshake request */
+  static async createFromHandshakeRequest(maxDataSize, handshakeRequestPayload, writeBleCallback, disconnectBleCallback, handleMatterMessagePayload) {
+    const handshakeRequest = import_BtpCodec.BtpCodec.decodeBtpHandshakeRequest(handshakeRequestPayload);
+    const {
+      versions,
+      attMtu: handshakeMtu,
+      // Number excluding 3 header bytes
+      clientWindowSize
+    } = handshakeRequest;
+    logger.debug(`Received BTP handshake request:`, import_general.Diagnostic.dict({ maxDataSize, ...handshakeRequest }));
+    const version = BTP_SUPPORTED_VERSIONS.find((version2) => versions.includes(version2));
+    if (version === void 0) {
+      await disconnectBleCallback();
+      throw new BtpProtocolError(`No supported BTP version found in ${versions}`);
+    }
+    let attMtu = import_BleConsts.BLE_MINIMUM_ATT_MTU;
+    if (maxDataSize !== void 0) {
+      if (maxDataSize > import_BleConsts.BLE_MINIMUM_ATT_MTU) {
+        if (handshakeMtu <= import_BleConsts.BLE_MINIMUM_ATT_MTU) {
+          attMtu = Math.min(maxDataSize, import_BleConsts.BLE_MAXIMUM_BTP_MTU);
+        } else {
+          attMtu = Math.min(handshakeMtu, maxDataSize, import_BleConsts.BLE_MAXIMUM_BTP_MTU);
+        }
+      }
+    }
+    const fragmentSize = attMtu;
+    const windowSize = Math.min(import_BleConsts.BTP_MAXIMUM_WINDOW_SIZE, clientWindowSize);
+    const handshakeResponse = import_BtpCodec.BtpCodec.encodeBtpHandshakeResponse({
+      version,
+      attMtu,
+      windowSize
+    });
+    logger.debug(
+      `Sending BTP handshake response:`,
+      import_general.Diagnostic.dict({
+        version,
+        attMtu,
+        windowSize
+      })
+    );
+    const btpSession = new BtpSessionHandler(
+      "peripheral",
+      version,
+      fragmentSize,
+      windowSize,
+      writeBleCallback,
+      disconnectBleCallback,
+      handleMatterMessagePayload
+    );
+    await writeBleCallback(handshakeResponse);
+    return btpSession;
+  }
+  static async createAsCentral(handshakeResponsePayload, writeBleCallback, disconnectBleCallback, handleMatterMessagePayload) {
+    const handshakeRequest = import_BtpCodec.BtpCodec.decodeBtpHandshakeResponsePayload(handshakeResponsePayload);
+    logger.debug("Handshake request", import_general.Diagnostic.dict(handshakeRequest));
+    const { version, attMtu: handshakeMtu, windowSize } = handshakeRequest;
+    const fragmentSize = Math.min(handshakeMtu, import_BleConsts.BLE_MAXIMUM_BTP_MTU);
+    return new BtpSessionHandler(
+      "central",
+      version,
+      fragmentSize,
+      windowSize,
+      writeBleCallback,
+      disconnectBleCallback,
+      handleMatterMessagePayload
+    );
+  }
+  /**
+   * Handle incoming data from the transport layer and hand over completely received matter messages to the
+   * ExchangeManager layer
+   *
+   * @param data ByteArray containing the data
+   */
+  async handleIncomingBleData(data) {
+    if (!this.isActive) {
+      logger.debug(`BTP session is not active, ignoring incoming BLE data`);
+      return;
+    }
+    try {
+      if (data.length > this.fragmentSize) {
+        if (data.length > this.fragmentSize + 3) {
+          throw new BtpProtocolError(
+            `Received data ${data.length} bytes exceeds fragment size of ${this.fragmentSize} bytes`
+          );
+        } else {
+          logger.warn(
+            `Received data ${data.length} bytes exceeds fragment size of ${this.fragmentSize} bytes, still accepting`
+          );
+        }
+      }
+      const btpPacket = import_BtpCodec.BtpCodec.decodeBtpPacket(data);
+      logger.debug(`Received BTP packet: ${import_general.Logger.toJSON(btpPacket)}`);
+      const {
+        header: {
+          hasAckNumber,
+          isHandshakeRequest,
+          hasManagementOpcode,
+          isEndingSegment,
+          isBeginningSegment,
+          isContinuingSegment
+        },
+        payload: { ackNumber, sequenceNumber, messageLength, segmentPayload }
+      } = btpPacket;
+      if (isHandshakeRequest || hasManagementOpcode) {
+        throw new BtpProtocolError("BTP packet must not be a handshake request or have a management opcode.");
+      }
+      if (segmentPayload.length === 0 && !hasAckNumber) {
+        throw new BtpProtocolError("BTP packet must have a segment payload or an ack number.");
+      }
+      if (sequenceNumber !== (this.prevIncomingSequenceNumber + 1) % 256) {
+        logger.debug(
+          `sequenceNumber : ${sequenceNumber}, prevClientSequenceNumber : ${this.prevIncomingSequenceNumber}`
+        );
+        throw new BtpProtocolError("Expected and actual BTP packets sequence number does not match");
+      }
+      this.prevIncomingSequenceNumber = sequenceNumber;
+      if (!this.sendAckTimer.isRunning) {
+        this.sendAckTimer.start();
+      }
+      if (hasAckNumber && ackNumber !== void 0) {
+        if (ackNumber > this.sequenceNumber || this.exceedsWindowSize(this.prevIncomingAckNumber, ackNumber)) {
+          throw new BtpProtocolError(
+            `Invalid Ack Number, Ack Number: ${ackNumber}, Sequence Number: ${this.sequenceNumber}, Previous AckNumber: ${this.prevIncomingAckNumber}`
+          );
+        }
+        this.ackReceiveTimer.stop();
+        this.prevIncomingAckNumber = ackNumber;
+        if (ackNumber !== this.sequenceNumber) {
+          this.ackReceiveTimer.start();
+        }
+      }
+      if (isBeginningSegment) {
+        if (this.currentIncomingSegmentedPayload !== void 0) {
+          throw new BtpProtocolError(
+            `BTP message flow error! New beginning packet was received without previous message being completed.`
+          );
+        }
+        this.currentIncomingSegmentedMsgLength = messageLength;
+        this.currentIncomingSegmentedPayload = segmentPayload;
+      } else if (isContinuingSegment || isEndingSegment) {
+        if (this.currentIncomingSegmentedPayload === void 0) {
+          throw new BtpProtocolError(`BTP Continuing or ending packet received without beginning packet.`);
+        }
+        if (segmentPayload.length === 0) {
+          throw new BtpProtocolError(`BTP Continuing or ending packet received without payload.`);
+        }
+        this.currentIncomingSegmentedPayload = import_general.Bytes.concat(
+          this.currentIncomingSegmentedPayload,
+          segmentPayload
+        );
+      }
+      if (isEndingSegment) {
+        if (this.currentIncomingSegmentedMsgLength === void 0 || this.currentIncomingSegmentedPayload === void 0) {
+          throw new BtpProtocolError("BTP beginning packet missing but ending packet received.");
+        }
+        if (this.currentIncomingSegmentedPayload.length !== this.currentIncomingSegmentedMsgLength) {
+          throw new BtpProtocolError(
+            `BTP packet payload length does not match message length: ${this.currentIncomingSegmentedPayload.length} !== ${this.currentIncomingSegmentedMsgLength}`
+          );
+        }
+        const payloadToProcess = this.currentIncomingSegmentedPayload;
+        this.currentIncomingSegmentedMsgLength = void 0;
+        this.currentIncomingSegmentedPayload = void 0;
+        await this.handleMatterMessagePayload(payloadToProcess);
+      }
+    } catch (error) {
+      logger.error(`Error while handling incoming BTP data: ${error}`);
+      await this.close();
+      BtpProtocolError.accept(error);
+    }
+  }
+  /**
+   * Send a Matter message to the transport layer, but before that encode it into a BTP packet and potentially split
+   * it into multiple segments. This Method is indirectly called by the ExchangeManager layer when a Matter message
+   * should be sent.
+   *
+   * @param data ByteArray containing the Matter message
+   */
+  async sendMatterMessage(data) {
+    if (!this.isActive) {
+      throw new BtpFlowError("BTP session is not active");
+    }
+    logger.debug(`Got Matter message to send via BLE transport: ${import_general.Bytes.toHex(data)}`);
+    if (data.length === 0) {
+      throw new BtpFlowError("BTP packet must not be empty");
+    }
+    const dataReader = new import_general.DataReader(data, import_general.Endian.Little);
+    this.queuedOutgoingMatterMessages.push(dataReader);
+    await this.processSendQueue();
+  }
+  async processSendQueue() {
+    if (this.sendInProgress) return;
+    if (this.exceedsWindowSize(this.prevIncomingAckNumber, this.sequenceNumber)) return;
+    if (this.queuedOutgoingMatterMessages.length === 0) return;
+    this.sendInProgress = true;
+    while (this.queuedOutgoingMatterMessages.length > 0) {
+      const currentProcessedMessage = this.queuedOutgoingMatterMessages[0];
+      const remainingMessageLength = currentProcessedMessage.getRemainingBytesCount();
+      logger.debug(
+        "Sending BTP fragment: ",
+        import_general.Diagnostic.dict({
+          fullMessageLength: currentProcessedMessage.getLength(),
+          remainingLengthInBytes: remainingMessageLength
+        })
+      );
+      const hasAckNumber = this.prevIncomingSequenceNumber !== this.prevAckedSequenceNumber;
+      if (hasAckNumber) {
+        this.prevAckedSequenceNumber = this.prevIncomingSequenceNumber;
+        this.sendAckTimer.stop();
+      }
+      const isBeginningSegment = remainingMessageLength === currentProcessedMessage.getLength();
+      const btpHeaderLength = 2 + (isBeginningSegment ? 2 : 0) + (hasAckNumber ? 1 : 0);
+      const isEndingSegment = remainingMessageLength <= this.fragmentSize - btpHeaderLength;
+      const packetHeader = {
+        isHandshakeRequest: false,
+        hasManagementOpcode: false,
+        hasAckNumber,
+        isBeginningSegment,
+        isContinuingSegment: !isBeginningSegment,
+        isEndingSegment
+      };
+      logger.debug(
+        `Take up to ${this.fragmentSize - btpHeaderLength} bytes from Rest of message: ${remainingMessageLength}`
+      );
+      const segmentPayload = currentProcessedMessage.readByteArray(this.fragmentSize - btpHeaderLength);
+      const btpPacket = {
+        header: packetHeader,
+        payload: {
+          ackNumber: hasAckNumber ? this.prevIncomingSequenceNumber : void 0,
+          sequenceNumber: this.getNextSequenceNumber(),
+          messageLength: packetHeader.isBeginningSegment ? remainingMessageLength : void 0,
+          // remainingMessageLength if the fill length on beginning packet
+          segmentPayload
+        }
+      };
+      logger.debug(`Sending BTP packet: ${import_general.Logger.toJSON(btpPacket)}`);
+      const packet = import_BtpCodec.BtpCodec.encodeBtpPacket(btpPacket);
+      logger.debug(`Sending BTP packet raw: ${import_general.Bytes.toHex(packet)}`);
+      await this.writeBleCallback(packet);
+      if (!this.ackReceiveTimer.isRunning) {
+        this.ackReceiveTimer.start();
+      }
+      if (this.role === "central") {
+        if (this.idleTimeout.isRunning) {
+          this.idleTimeout.stop();
+        }
+        this.idleTimeout.start();
+      }
+      if (isEndingSegment) {
+        this.queuedOutgoingMatterMessages.shift();
+      }
+      if (this.exceedsWindowSize(this.prevIncomingAckNumber, this.sequenceNumber)) {
+        break;
+      }
+    }
+    this.sendInProgress = false;
+  }
+  /**
+   * Close the BTP session. This method is called when the BLE transport is disconnected and so the BTP session gets closed.
+   */
+  async close() {
+    this.sendAckTimer.stop();
+    this.ackReceiveTimer.stop();
+    this.idleTimeout.stop();
+    if (this.isActive) {
+      logger.debug(`Closing BTP session`);
+      this.isActive = false;
+      await this.disconnectBleCallback();
+    }
+  }
+  /**
+   * If this timer expires and the peer has a pending acknowledgement, the peer SHALL immediately send that
+   * acknowledgement
+   */
+  async btpSendAckTimeoutTriggered() {
+    if (this.prevIncomingSequenceNumber > this.prevAckedSequenceNumber) {
+      logger.debug(`Sending BTP ACK for sequence number ${this.prevIncomingSequenceNumber}`);
+      const btpPacket = {
+        header: {
+          isHandshakeRequest: false,
+          hasManagementOpcode: false,
+          hasAckNumber: true,
+          isBeginningSegment: false,
+          isContinuingSegment: false,
+          isEndingSegment: false
+        },
+        payload: {
+          ackNumber: this.prevIncomingSequenceNumber,
+          sequenceNumber: this.getNextSequenceNumber()
+        }
+      };
+      this.prevAckedSequenceNumber = this.prevIncomingSequenceNumber;
+      const packet = import_BtpCodec.BtpCodec.encodeBtpPacket(btpPacket);
+      await this.writeBleCallback(packet);
+      if (!this.ackReceiveTimer.isRunning) {
+        this.ackReceiveTimer.start();
+      }
+    }
+  }
+  /**
+   * If a peer’s acknowledgement-received timer expires, or if a peer receives an invalid acknowledgement,
+   * the peer SHALL close the BTP session and report an error to the application.
+   */
+  async btpAckTimeoutTriggered() {
+    if (this.prevIncomingAckNumber !== this.sequenceNumber) {
+      logger.warn("Acknowledgement for the sent sequence number was not received ... disconnect");
+      await this.close();
+    }
+  }
+  /**
+   * Increments sequence number for the packets and round it off to 0 when it reaches the maximum limit.
+   */
+  getNextSequenceNumber() {
+    this.sequenceNumber++;
+    if (this.sequenceNumber > MAXIMUM_SEQUENCE_NUMBER) {
+      this.sequenceNumber = 0;
+    }
+    return this.sequenceNumber;
+  }
+  /**
+   * Checks if incoming ackNumber and sent sequence number exceeds the client window size or not.
+   */
+  exceedsWindowSize(prevIncomingAckNumber, currentSequenceNumber) {
+    if (prevIncomingAckNumber > currentSequenceNumber) {
+      prevIncomingAckNumber = prevIncomingAckNumber % MAXIMUM_SEQUENCE_NUMBER - 1;
+    }
+    return currentSequenceNumber - prevIncomingAckNumber > this.clientWindowSize - 1;
+  }
+}
+//# sourceMappingURL=BtpSessionHandler.js.map

package/dist/cjs/ble/BtpSessionHandler.js.map

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

package/dist/cjs/ble/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Ble.js";
+export * from "./BleConsts.js";
+export * from "./BtpSessionHandler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/ble/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ble/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC"}