@matter/nodejs-ble 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/BlenoBleServer.js

@@ -0,0 +1,327 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError, Logger, Time, createPromise } from "@matter/general";
+import { require as require2 } from "@matter/nodejs-ble/require";
+import {
+  BLE_MATTER_C1_CHARACTERISTIC_UUID,
+  BLE_MATTER_C2_CHARACTERISTIC_UUID,
+  BLE_MATTER_C3_CHARACTERISTIC_UUID,
+  BLE_MATTER_SERVICE_UUID,
+  BTP_CONN_RSP_TIMEOUT_MS,
+  BleChannel,
+  BleError,
+  BtpFlowError,
+  BtpSessionHandler
+} from "@project-chip/matter.js/ble";
+import { ChannelNotConnectedError } from "@project-chip/matter.js/protocol";
+const logger = Logger.get("BlenoBleServer");
+let Bleno;
+function initializeBleno(server, hciId) {
+  if (hciId !== void 0) {
+    process.env.BLENO_HCI_DEVICE_ID = hciId.toString();
+  }
+  Bleno = require2("@stoprocent/bleno");
+  class BtpWriteCharacteristicC1 extends Bleno.Characteristic {
+    constructor() {
+      super({
+        uuid: BLE_MATTER_C1_CHARACTERISTIC_UUID,
+        properties: ["write"]
+      });
+    }
+    onWriteRequest(data, offset, withoutResponse, callback) {
+      logger.debug(`C1 write request: ${data.toString("hex")} ${offset} ${withoutResponse}`);
+      try {
+        server.handleC1WriteRequest(data, offset, withoutResponse);
+        callback(this.RESULT_SUCCESS);
+      } catch (e) {
+        logger.error(`C1 write request failed: ${e}`);
+        callback(this.RESULT_UNLIKELY_ERROR);
+      }
+    }
+  }
+  class BtpIndicateCharacteristicC2 extends Bleno.Characteristic {
+    constructor() {
+      super({
+        uuid: BLE_MATTER_C2_CHARACTERISTIC_UUID,
+        properties: ["indicate"]
+      });
+    }
+    async onSubscribe(maxValueSize, updateValueCallback) {
+      logger.debug(`C2 subscribe ${maxValueSize}`);
+      await server.handleC2SubscribeRequest(maxValueSize, updateValueCallback);
+    }
+    async onUnsubscribe() {
+      logger.debug("C2 unsubscribe");
+      await server.close();
+    }
+    onIndicate() {
+      logger.debug("C2 indicate");
+      server.handleC2Indicate();
+    }
+  }
+  class BtpReadCharacteristicC3 extends Bleno.Characteristic {
+    constructor() {
+      super({
+        uuid: BLE_MATTER_C3_CHARACTERISTIC_UUID,
+        properties: ["read"]
+      });
+    }
+    onReadRequest(offset, callback) {
+      try {
+        const data = server.handleC3ReadRequest(offset);
+        logger.debug(`C3 read request: ${data.toString("hex")} ${offset}`);
+        callback(this.RESULT_SUCCESS, data);
+      } catch (e) {
+        logger.debug(`C3 read request failed : ${e} ${offset}`);
+        callback(this.RESULT_INVALID_OFFSET);
+      }
+    }
+  }
+  class BtpService extends Bleno.PrimaryService {
+    constructor() {
+      super({
+        uuid: BLE_MATTER_SERVICE_UUID,
+        characteristics: [
+          new BtpWriteCharacteristicC1(),
+          new BtpIndicateCharacteristicC2(),
+          new BtpReadCharacteristicC3()
+        ]
+      });
+    }
+  }
+  return new BtpService();
+}
+class BlenoBleServer extends BleChannel {
+  state = "unknown";
+  isAdvertising = false;
+  additionalAdvertisingData = Buffer.alloc(0);
+  advertisingData;
+  latestHandshakePayload;
+  btpSession;
+  onMatterMessageListener;
+  writeConformationResolver;
+  clientAddress;
+  btpHandshakeTimeout = Time.getTimer(
+    "BTP handshake timeout",
+    BTP_CONN_RSP_TIMEOUT_MS,
+    () => this.btpHandshakeTimeoutTriggered()
+  );
+  matterBleService;
+  constructor(options) {
+    super();
+    this.matterBleService = initializeBleno(this, options?.hciId);
+    Bleno.on("stateChange", (state) => {
+      if (state === this.state) return;
+      this.state = state;
+      logger.debug(`stateChange: ${state}, address = ${Bleno.address}`);
+      if (state !== "poweredOn") {
+        Bleno.stopAdvertising();
+      } else if (this.advertisingData) {
+        Bleno.startAdvertisingWithEIRData(this.advertisingData);
+        this.isAdvertising = true;
+      }
+    });
+    Bleno.on("accept", (clientAddress) => {
+      logger.debug(`accept new connection, client: ${clientAddress}`);
+      this.clientAddress = clientAddress;
+      Bleno.updateRssi();
+    });
+    Bleno.on("disconnect", (clientAddress) => {
+      logger.debug(`disconnect, client: ${clientAddress}`);
+      if (this.btpSession !== void 0) {
+        this.btpSession.close().then(() => {
+          this.btpSession = void 0;
+        }).catch(() => {
+          this.btpSession = void 0;
+        });
+      }
+    });
+    Bleno.on("rssiUpdate", (rssi) => {
+      logger.debug(`rssiUpdate: ${rssi}`);
+    });
+    Bleno.on("mtuChange", (mtu) => {
+      logger.debug(`mtuChange: ${mtu}`);
+    });
+    Bleno.on("advertisingStart", (error) => {
+      logger.debug(`advertisingStart: ${error ? `error ${error}` : "success"}`);
+      if (!error) {
+        Bleno.setServices([this.matterBleService]);
+      }
+    });
+    Bleno.on("advertisingStop", () => {
+      logger.debug("advertisingStop");
+    });
+    Bleno.on("servicesSet", (error) => {
+      logger.debug(`servicesSet: ${error ? `error ${error}` : "success"}`);
+    });
+  }
+  /**
+   * Process a Write request on characteristic C1 from the Matter service.
+   * The data are checked if it might be a handshake request and stored until the subscribe request comes in.
+   * Otherwise, the data are forwarded to the BTP session handler to be decoded and processed.
+   *
+   * @param data
+   * @param offset
+   * @param withoutResponse
+   */
+  handleC1WriteRequest(data, offset, withoutResponse) {
+    if (offset !== 0 || withoutResponse) {
+      throw new BleError(`Offset ${offset} or withoutResponse ${withoutResponse} not supported`);
+    }
+    if (data[0] === 101 && data[1] === 108 && data.length === 9) {
+      this.btpHandshakeTimeout.start();
+      logger.info(
+        `Received Matter handshake request: ${data.toString("hex")}, store until subscribe request comes in.`
+      );
+      this.latestHandshakePayload = data;
+    } else {
+      if (this.btpSession !== void 0) {
+        logger.debug(`Received Matter data for BTP Session: ${data.toString("hex")}`);
+        void this.btpSession.handleIncomingBleData(new Uint8Array(data));
+      } else {
+        throw new BtpFlowError(
+          `Received Matter data but no BTP session was initialized: ${data.toString("hex")}`
+        );
+      }
+    }
+  }
+  /**
+   * Process a Subscribe request on characteristic C2 from the Matter service.
+   * This is expected directly after a handshake request and initializes the BTP session handler with the stored
+   * handshake payload.
+   * The BtpSessionHandler instance is wired with the bleno instance for sending data and disconnecting.
+   *
+   * @param maxValueSize
+   * @param updateValueCallback
+   */
+  async handleC2SubscribeRequest(maxValueSize, updateValueCallback) {
+    if (this.latestHandshakePayload === void 0) {
+      throw new BtpFlowError(`Subscription request received before handshake Request`);
+    }
+    if (this.btpSession !== void 0) {
+      throw new BtpFlowError(
+        `Subscription request received but BTP session already initialized. Cannot handle two sessions!`
+      );
+    }
+    this.btpHandshakeTimeout.stop();
+    this.btpSession = await BtpSessionHandler.createFromHandshakeRequest(
+      Math.min(Bleno.mtu - 3, maxValueSize),
+      new Uint8Array(this.latestHandshakePayload),
+      // callback to write data to characteristic C2
+      async (data) => {
+        updateValueCallback(Buffer.from(data.buffer));
+        const { promise, resolver } = createPromise();
+        this.writeConformationResolver = resolver;
+        return promise;
+      },
+      // callback to disconnect the BLE connection
+      async () => this.close(),
+      // callback to forward decoded and de-assembled Matter messages to ExchangeManager
+      async (data) => {
+        if (this.onMatterMessageListener === void 0) {
+          throw new InternalError(`No listener registered for Matter messages`);
+        }
+        this.onMatterMessageListener(this, data);
+      }
+    );
+    this.latestHandshakePayload = void 0;
+  }
+  handleC2Indicate() {
+    if (this.writeConformationResolver !== void 0) {
+      this.writeConformationResolver();
+      this.writeConformationResolver = void 0;
+    } else {
+      logger.warn(`Received C2 indication but no former write expected a confirmation`);
+    }
+  }
+  /**
+   * Process a Read request on characteristic C3 from the Matter service.
+   * The relevant data needs optionally to be set before advertising, else empty data are used.
+   *
+   * @param offset
+   */
+  handleC3ReadRequest(offset) {
+    if (offset > this.additionalAdvertisingData.length) {
+      throw new BleError(`Offset ${offset} is larger than data ${this.additionalAdvertisingData.length}`);
+    } else {
+      return this.additionalAdvertisingData.subarray(offset);
+    }
+  }
+  async advertise(advertiseData, additionalAdvertisementData) {
+    this.advertisingData = Buffer.from(advertiseData.buffer);
+    if (additionalAdvertisementData) {
+      this.additionalAdvertisingData = Buffer.from(additionalAdvertisementData.buffer);
+    } else {
+      this.additionalAdvertisingData = Buffer.alloc(0);
+    }
+    if (this.isAdvertising) {
+      await this.stopAdvertising();
+      this.isAdvertising = false;
+    }
+    if (this.state === "poweredOn") {
+      Bleno.startAdvertisingWithEIRData(this.advertisingData);
+      this.isAdvertising = true;
+    } else {
+      logger.debug(`State is ${this.state}, advertise when powered on`);
+    }
+    return new Promise((resolve) => {
+      Bleno.once("advertisingStart", () => resolve());
+    });
+  }
+  async stopAdvertising() {
+    if (this.isAdvertising) {
+      return new Promise((resolve) => {
+        Bleno.stopAdvertising();
+        Bleno.once("advertisingStop", () => {
+          this.isAdvertising = false;
+          resolve();
+        });
+      });
+    }
+  }
+  setMatterMessageListener(listener) {
+    if (this.onMatterMessageListener !== void 0) {
+      throw new InternalError(`onData listener already set`);
+    }
+    this.onMatterMessageListener = listener;
+  }
+  async btpHandshakeTimeoutTriggered() {
+    await this.disconnect();
+    logger.error("Timeout for handshake subscribe request on C2 reached, disconnecting.");
+  }
+  async close() {
+    this.btpHandshakeTimeout.stop();
+    await this.disconnect();
+    if (this.btpSession !== void 0) {
+      await this.btpSession.close();
+      this.btpSession = void 0;
+    }
+    this.onMatterMessageListener = void 0;
+  }
+  async disconnect() {
+    Bleno.disconnect();
+  }
+  // Channel<Uint8Array>
+  /**
+   * Send a Matter message to the connected device - need to do BTP assembly first.
+   *
+   * @param data
+   */
+  async send(data) {
+    if (this.btpSession === void 0) {
+      throw new ChannelNotConnectedError(`Cannot send data, no BTP session initialized`);
+    }
+    await this.btpSession.sendMatterMessage(data);
+  }
+  // Channel<Uint8Array>
+  get name() {
+    return `${this.type}://${this.clientAddress}`;
+  }
+}
+export {
+  BlenoBleServer
+};
+//# sourceMappingURL=BlenoBleServer.js.map

package/dist/esm/BlenoBleServer.js.map

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

package/dist/esm/NobleBleChannel.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Channel, ChannelType, NetInterface, ServerAddress, TransportInterface } from "@matter/general";
+import { BleChannel, BtpSessionHandler } from "@project-chip/matter.js/ble";
+import type { Characteristic, Peripheral } from "@stoprocent/noble";
+export declare class NobleBleCentralInterface implements NetInterface {
+    private openChannels;
+    private onMatterMessageListener;
+    openChannel(address: ServerAddress, tryCount?: number): Promise<Channel<Uint8Array>>;
+    onData(listener: (socket: Channel<Uint8Array>, data: Uint8Array) => void): TransportInterface.Listener;
+    close(): Promise<void>;
+    supports(type: ChannelType, _address?: string): boolean;
+}
+export declare class NobleBleChannel extends BleChannel<Uint8Array> {
+    private readonly peripheral;
+    private readonly btpSession;
+    static create(peripheral: Peripheral, characteristicC1ForWrite: Characteristic, characteristicC2ForSubscribe: Characteristic, onMatterMessageListener: (socket: Channel<Uint8Array>, data: Uint8Array) => void, _additionalCommissioningRelatedData?: Uint8Array): Promise<NobleBleChannel>;
+    private connected;
+    constructor(peripheral: Peripheral, btpSession: BtpSessionHandler);
+    /**
+     * Send a Matter message to the connected device - need to do BTP assembly first.
+     *
+     * @param data
+     */
+    send(data: Uint8Array): Promise<void>;
+    get name(): string;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=NobleBleChannel.d.ts.map

package/dist/esm/NobleBleChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NobleBleChannel.d.ts","sourceRoot":"","sources":["../../src/NobleBleChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,OAAO,EACP,WAAW,EAGX,YAAY,EACZ,aAAa,EAEb,kBAAkB,EAErB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAUH,UAAU,EAGV,iBAAiB,EACpB,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA6BpE,qBAAa,wBAAyB,YAAW,YAAY;IACzD,OAAO,CAAC,YAAY,CAA6C;IACjE,OAAO,CAAC,uBAAuB,CAAwE;IAEvG,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,SAAI,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAwI/E,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,kBAAkB,CAAC,QAAQ;IAOhG,KAAK;IAMX,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM;CAMhD;AAED,qBAAa,eAAgB,SAAQ,UAAU,CAAC,UAAU,CAAC;IA6EnD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;WA7ElB,MAAM,CACf,UAAU,EAAE,UAAU,EACtB,wBAAwB,EAAE,cAAc,EACxC,4BAA4B,EAAE,cAAc,EAC5C,uBAAuB,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,EAChF,mCAAmC,CAAC,EAAE,UAAU,GACjD,OAAO,CAAC,eAAe,CAAC;IAmE3B,OAAO,CAAC,SAAS,CAAQ;gBAGJ,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,iBAAiB;IAUlD;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU;IAY3B,IAAI,IAAI,WAEP;IAEK,KAAK;CAId"}

package/dist/esm/NobleBleChannel.js

@@ -0,0 +1,266 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  ChannelType,
+  InternalError,
+  Logger,
+  Time,
+  createPromise
+} from "@matter/general";
+import {
+  BLE_MATTER_C1_CHARACTERISTIC_UUID,
+  BLE_MATTER_C2_CHARACTERISTIC_UUID,
+  BLE_MATTER_C3_CHARACTERISTIC_UUID,
+  BLE_MATTER_SERVICE_UUID,
+  BLE_MAXIMUM_BTP_MTU,
+  BTP_CONN_RSP_TIMEOUT_MS,
+  BTP_MAXIMUM_WINDOW_SIZE,
+  BTP_SUPPORTED_VERSIONS,
+  Ble,
+  BleChannel,
+  BleError,
+  BtpFlowError,
+  BtpSessionHandler
+} from "@project-chip/matter.js/ble";
+import { BtpCodec } from "@project-chip/matter.js/codec";
+const logger = Logger.get("BleChannel");
+function nobleUuidToUuid(uuid) {
+  uuid = uuid.toUpperCase();
+  if (uuid.length !== 32) {
+    return uuid;
+  }
+  const parts = [
+    uuid.substring(0, 8),
+    uuid.substring(8, 12),
+    uuid.substring(12, 16),
+    uuid.substring(16, 20),
+    uuid.substring(20, 32)
+  ];
+  return parts.join("-");
+}
+class NobleBleCentralInterface {
+  openChannels = /* @__PURE__ */ new Map();
+  onMatterMessageListener;
+  openChannel(address, tryCount = 1) {
+    return new Promise((resolve, reject) => {
+      if (this.onMatterMessageListener === void 0) {
+        reject(new InternalError(`Network Interface was not added to the system yet.`));
+        return;
+      }
+      if (address.type !== "ble") {
+        reject(new InternalError(`Unsupported address type ${address.type}.`));
+        return;
+      }
+      const { peripheral, hasAdditionalAdvertisementData } = Ble.get().getBleScanner().getDiscoveredDevice(address.peripheralAddress);
+      if (tryCount > 3) {
+        reject(new BleError(`Failed to connect to peripheral ${peripheral.address}`));
+        return;
+      }
+      logger.debug("BLE peripheral state", peripheral.state);
+      if (peripheral.state === "connected" || peripheral.state === "connecting") {
+        reject(
+          new BleError(
+            `Peripheral ${address.peripheralAddress} is already connected or connecting. Only one connection supported right now.`
+          )
+        );
+        return;
+      }
+      if (this.openChannels.has(address)) {
+        reject(
+          new BleError(
+            `Peripheral ${address.peripheralAddress} is already connected. Only one connection supported right now.`
+          )
+        );
+        return;
+      }
+      if (peripheral.state !== "disconnected") {
+        peripheral.disconnectAsync().then(() => this.openChannel(address, tryCount), reject);
+        return;
+      }
+      peripheral.once("connect", async () => {
+        if (this.onMatterMessageListener === void 0) {
+          reject(new InternalError(`Network Interface was not added to the system yet.`));
+          return;
+        }
+        const services = await peripheral.discoverServicesAsync([BLE_MATTER_SERVICE_UUID]);
+        logger.debug(`Found services: ${services.map((s) => s.uuid).join(", ")}`);
+        for (const service of services) {
+          logger.debug(`found service: ${service.uuid}`);
+          if (service.uuid !== BLE_MATTER_SERVICE_UUID) continue;
+          const characteristics = await service.discoverCharacteristicsAsync();
+          let characteristicC1ForWrite;
+          let characteristicC2ForSubscribe;
+          let additionalCommissioningRelatedData;
+          for (const characteristic of characteristics) {
+            logger.debug("found characteristic:", characteristic.uuid, characteristic.properties);
+            switch (nobleUuidToUuid(characteristic.uuid)) {
+              case BLE_MATTER_C1_CHARACTERISTIC_UUID:
+                logger.debug("found C1 characteristic");
+                characteristicC1ForWrite = characteristic;
+                break;
+              case BLE_MATTER_C2_CHARACTERISTIC_UUID:
+                logger.debug("found C2 characteristic");
+                characteristicC2ForSubscribe = characteristic;
+                break;
+              case BLE_MATTER_C3_CHARACTERISTIC_UUID:
+                logger.debug("found C3 characteristic");
+                if (hasAdditionalAdvertisementData) {
+                  logger.debug("reading additional commissioning related data");
+                  const data = await characteristic.readAsync();
+                  additionalCommissioningRelatedData = new Uint8Array(data);
+                  logger.debug("additional data", data);
+                }
+            }
+          }
+          if (!characteristicC1ForWrite || !characteristicC2ForSubscribe) {
+            logger.debug("missing characteristics");
+            continue;
+          }
+          peripheral.removeAllListeners("disconnect");
+          this.openChannels.set(address, peripheral);
+          resolve(
+            await NobleBleChannel.create(
+              peripheral,
+              characteristicC1ForWrite,
+              characteristicC2ForSubscribe,
+              this.onMatterMessageListener,
+              additionalCommissioningRelatedData
+            )
+          );
+          return;
+        }
+        peripheral.removeAllListeners("disconnect");
+        reject(new BleError(`Peripheral ${peripheral.address} does not have the required characteristics`));
+      });
+      const reTryHandler = async (error) => {
+        if (error) {
+          logger.error(
+            `Peripheral ${peripheral.address} disconnected while trying to connect, try again`,
+            error
+          );
+        } else {
+          logger.info(`Peripheral ${peripheral.address} disconnected while trying to connect, try gain`);
+        }
+        peripheral.removeAllListeners("disconnect");
+        peripheral.removeAllListeners("connect");
+        this.openChannel(address, tryCount + 1).then(resolve).catch(reject);
+      };
+      peripheral.once("disconnect", reTryHandler);
+      logger.debug(`Connect to Peripheral now (try ${tryCount})`);
+      peripheral.connectAsync().catch(reTryHandler);
+    });
+  }
+  onData(listener) {
+    this.onMatterMessageListener = listener;
+    return {
+      close: async () => await this.close()
+    };
+  }
+  async close() {
+    for (const peripheral of this.openChannels.values()) {
+      await peripheral.disconnectAsync();
+    }
+  }
+  supports(type, _address) {
+    if (type !== ChannelType.BLE) {
+      return false;
+    }
+    return true;
+  }
+}
+class NobleBleChannel extends BleChannel {
+  constructor(peripheral, btpSession) {
+    super();
+    this.peripheral = peripheral;
+    this.btpSession = btpSession;
+    peripheral.once("disconnect", () => {
+      logger.debug(`Disconnected from peripheral ${peripheral.address}`);
+      this.connected = false;
+      void this.btpSession.close();
+    });
+  }
+  static async create(peripheral, characteristicC1ForWrite, characteristicC2ForSubscribe, onMatterMessageListener, _additionalCommissioningRelatedData) {
+    let mtu = peripheral.mtu ?? 0;
+    if (mtu > BLE_MAXIMUM_BTP_MTU) {
+      mtu = BLE_MAXIMUM_BTP_MTU;
+    }
+    logger.debug(`Using MTU=${mtu} (Peripheral MTU=${peripheral.mtu})`);
+    const btpHandshakeRequest = BtpCodec.encodeBtpHandshakeRequest({
+      versions: BTP_SUPPORTED_VERSIONS,
+      attMtu: mtu,
+      clientWindowSize: BTP_MAXIMUM_WINDOW_SIZE
+    });
+    logger.debug(`sending BTP handshake request: ${Logger.toJSON(btpHandshakeRequest)}`);
+    await characteristicC1ForWrite.writeAsync(Buffer.from(btpHandshakeRequest.buffer), false);
+    const btpHandshakeTimeout = Time.getTimer("BLE handshake timeout", BTP_CONN_RSP_TIMEOUT_MS, async () => {
+      await peripheral.disconnectAsync();
+      logger.debug("Handshake Response not received. Disconnected from peripheral");
+    }).start();
+    logger.debug("subscribing to C2 characteristic");
+    await characteristicC2ForSubscribe.subscribeAsync();
+    const { promise: handshakeResponseReceivedPromise, resolver } = createPromise();
+    characteristicC2ForSubscribe.once("data", (data, isNotification) => {
+      logger.debug(`received first data on C2: ${data.toString("hex")} (isNotification: ${isNotification})`);
+      if (data[0] === 101 && data[1] === 108 && data.length === 6) {
+        logger.info(`Received Matter handshake response: ${data.toString("hex")}.`);
+        btpHandshakeTimeout.stop();
+        resolver(data);
+      }
+    });
+    const handshakeResponse = await handshakeResponseReceivedPromise;
+    const btpSession = await BtpSessionHandler.createAsCentral(
+      new Uint8Array(handshakeResponse),
+      // callback to write data to characteristic C1
+      async (data) => {
+        return await characteristicC1ForWrite.writeAsync(Buffer.from(data.buffer), false);
+      },
+      // callback to disconnect the BLE connection
+      async () => void characteristicC2ForSubscribe.unsubscribeAsync().then(() => peripheral.disconnectAsync().then(() => logger.debug("disconnected from peripheral"))),
+      // callback to forward decoded and de-assembled Matter messages to ExchangeManager
+      async (data) => {
+        if (onMatterMessageListener === void 0) {
+          throw new InternalError(`No listener registered for Matter messages`);
+        }
+        onMatterMessageListener(nobleChannel, data);
+      }
+    );
+    characteristicC2ForSubscribe.on("data", (data, isNotification) => {
+      logger.debug(`received data on C2: ${data.toString("hex")} (isNotification: ${isNotification})`);
+      void btpSession.handleIncomingBleData(new Uint8Array(data));
+    });
+    const nobleChannel = new NobleBleChannel(peripheral, btpSession);
+    return nobleChannel;
+  }
+  connected = true;
+  /**
+   * Send a Matter message to the connected device - need to do BTP assembly first.
+   *
+   * @param data
+   */
+  async send(data) {
+    if (!this.connected) {
+      logger.debug("Cannot send data because not connected to peripheral.");
+      return;
+    }
+    if (this.btpSession === void 0) {
+      throw new BtpFlowError(`Cannot send data, no BTP session initialized`);
+    }
+    await this.btpSession.sendMatterMessage(data);
+  }
+  // Channel<Uint8Array>
+  get name() {
+    return `${this.type}://${this.peripheral.address}`;
+  }
+  async close() {
+    await this.btpSession.close();
+    await this.peripheral.disconnectAsync();
+  }
+}
+export {
+  NobleBleCentralInterface,
+  NobleBleChannel
+};
+//# sourceMappingURL=NobleBleChannel.js.map

package/dist/esm/NobleBleChannel.js.map

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

package/dist/esm/NobleBleClient.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Peripheral } from "@stoprocent/noble";
+import { BleOptions } from "./NodeJsBle.js";
+export declare class NobleBleClient {
+    private readonly discoveredPeripherals;
+    private shouldScan;
+    private isScanning;
+    private nobleState;
+    private deviceDiscoveredCallback;
+    constructor(options?: BleOptions);
+    setDiscoveryCallback(callback: (peripheral: Peripheral, manufacturerData: Uint8Array) => void): void;
+    startScanning(): Promise<void>;
+    stopScanning(): Promise<void>;
+    private handleDiscoveredDevice;
+}
+//# sourceMappingURL=NobleBleClient.d.ts.map