@matter-server/ble-proxy 0.0.1

package/src/ProxyBle.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type Environment, ImplementationError, type Transport } from "@matter/main";
+import { Ble, type BlePeripheralInterface, type Scanner } from "@matter/main/protocol";
+import type { BleProxyHandler } from "./BleProxyHandler.js";
+import { ProxyBleCentralInterface } from "./ProxyBleChannel.js";
+import { ProxyBleClient } from "./ProxyBleClient.js";
+import { ProxyBleScanner } from "./ProxyBleScanner.js";
+
+/**
+ * BLE implementation that proxies all operations over a WebSocket connection.
+ * Replaces NodeJsBle for environments where BLE hardware is accessed through
+ * a remote proxy client (e.g. Home Assistant with ESPHome BLE proxies).
+ *
+ * Only central (client) mode is supported. Peripheral mode throws.
+ */
+export class ProxyBle extends Ble {
+    readonly #handler: BleProxyHandler;
+    #proxyBleClient?: ProxyBleClient;
+    #bleScanner?: ProxyBleScanner;
+    #bleCentralInterface?: ProxyBleCentralInterface;
+    #closed = false;
+
+    constructor(handler: BleProxyHandler, environment?: Environment) {
+        super();
+        this.#handler = handler;
+        // Register with the runtime so shutdown drives scanner.close() and clears pending
+        // discovery waiters. Mirrors @matter/nodejs-ble NobleBleClient's runtime registration.
+        environment?.runtime.add(this);
+    }
+
+    get peripheralInterface(): BlePeripheralInterface {
+        throw new ImplementationError("BLE Proxy only supports central mode, not peripheral");
+    }
+
+    get centralInterface(): Transport {
+        if (!this.#bleCentralInterface) {
+            this.#bleCentralInterface = new ProxyBleCentralInterface(this.scanner as ProxyBleScanner, this.#handler);
+        }
+        return this.#bleCentralInterface;
+    }
+
+    get scanner(): Scanner {
+        if (!this.#bleScanner) {
+            if (!this.#proxyBleClient) {
+                this.#proxyBleClient = new ProxyBleClient(this.#handler);
+            }
+            this.#bleScanner = new ProxyBleScanner(this.#proxyBleClient);
+        }
+        return this.#bleScanner;
+    }
+
+    async close(): Promise<void> {
+        if (this.#closed) return;
+        this.#closed = true;
+        await this.#bleCentralInterface?.close();
+        // scanner.close() also closes the underlying ProxyBleClient.
+        await this.#bleScanner?.close();
+    }
+}

package/src/ProxyBleChannel.ts

@@ -0,0 +1,407 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    type Bytes,
+    type Channel,
+    ChannelType,
+    createPromise,
+    InternalError,
+    Logger,
+    NetworkError,
+    ServerAddress,
+    Time,
+    type Transport,
+} from "@matter/main";
+import { BleChannel, BleError, BtpCodec, BtpFlowError, BtpSessionHandler, MatterBle } from "@matter/main/protocol";
+import type { BleProxyHandler } from "./BleProxyHandler.js";
+import { BinaryFrameOpcode, BleProxyCommand, BleProxyEvent } from "./BleProxyProtocol.js";
+import type { ProxyBleScanner } from "./ProxyBleScanner.js";
+
+const logger = Logger.get("ProxyBleChannel");
+
+/** BTP handshake response identification bytes (Matter spec 4.18.2.5.6) */
+const BTP_HANDSHAKE_RESPONSE_OPCODE_1 = 0x65;
+const BTP_HANDSHAKE_RESPONSE_OPCODE_2 = 0x6c;
+const BTP_HANDSHAKE_RESPONSE_LENGTH = 6;
+
+/**
+ * Normalize any UUID form sent by a proxy client to the canonical dashed-uppercase form used by
+ * Matter's MatterBle constants. Different BLE proxy clients deliver different formats:
+ *   - noble: 32 lowercase hex chars, no dashes ("18ee2ef5263d4559959f4f9c429f9d11")
+ *   - ESPHome / generic: dashed form, either case ("18EE2EF5-263D-4559-959F-4F9C429F9D11")
+ *   - 16-/32-bit short form ("fff6", "FFF6", "0000fff6") for standard service UUIDs
+ *
+ * All three round-trip to a comparable canonical string so command handlers stay format-agnostic.
+ */
+function toCanonicalUuid(uuid: string): string {
+    const upper = uuid.toUpperCase();
+    if (upper.length === 32) {
+        return [
+            upper.substring(0, 8),
+            upper.substring(8, 12),
+            upper.substring(12, 16),
+            upper.substring(16, 20),
+            upper.substring(20, 32),
+        ].join("-");
+    }
+    return upper;
+}
+
+/**
+ * ConnectionlessTransport implementation that opens BLE channels through the proxy WebSocket.
+ * Replaces NobleBleCentralInterface from @matter/nodejs-ble.
+ */
+export class ProxyBleCentralInterface implements Transport {
+    readonly #bleScanner: ProxyBleScanner;
+    readonly #handler: BleProxyHandler;
+    #onMatterMessageListener: ((socket: Channel<Bytes>, data: Bytes) => void) | undefined;
+    #closed = false;
+
+    constructor(bleScanner: ProxyBleScanner, handler: BleProxyHandler) {
+        this.#bleScanner = bleScanner;
+        this.#handler = handler;
+    }
+
+    async openChannel(address: ServerAddress): Promise<Channel<Bytes>> {
+        if (this.#closed) {
+            throw new NetworkError("Network interface is closed");
+        }
+        if (!ServerAddress.isBle(address)) {
+            throw new InternalError(`Unsupported address type for BLE channel.`);
+        }
+        if (this.#onMatterMessageListener === undefined) {
+            throw new InternalError("Network Interface was not added to the system yet.");
+        }
+
+        const { peripheralAddress } = address;
+        const { hasAdditionalAdvertisementData } = this.#bleScanner.getDiscoveredDevice(peripheralAddress);
+
+        if (!this.#handler.connected) {
+            throw new BleError("BLE proxy client not connected");
+        }
+
+        logger.debug(`Connecting to peripheral ${peripheralAddress} via proxy`);
+
+        // 1. Connect
+        const { connection_handle, mtu: peripheralMtu } = await this.#handler.sendCommand(BleProxyCommand.Connect, {
+            address: peripheralAddress,
+        });
+
+        let mtu = peripheralMtu ?? 0;
+        if (mtu > MatterBle.MAXIMUM_BTP_MTU) {
+            mtu = MatterBle.MAXIMUM_BTP_MTU;
+        }
+        logger.debug(`Connected to ${peripheralAddress}, handle=${connection_handle}, mtu=${mtu}`);
+
+        try {
+            // 2. Discover services
+            const { services } = await this.#handler.sendCommand(BleProxyCommand.DiscoverServices, {
+                connection_handle,
+            });
+
+            const matterService = services.find(s => MatterBle.isServiceUuid(s.uuid));
+            if (!matterService) {
+                throw new BleError(`Peripheral ${peripheralAddress} does not have Matter BLE service`);
+            }
+
+            // 3. Discover characteristics
+            const { characteristics } = await this.#handler.sendCommand(BleProxyCommand.DiscoverCharacteristics, {
+                connection_handle,
+                service_uuid: matterService.uuid,
+            });
+
+            let c1Uuid: string | undefined;
+            let c2Uuid: string | undefined;
+            let c3Uuid: string | undefined;
+
+            for (const char of characteristics) {
+                const canonical = toCanonicalUuid(char.uuid);
+                if (canonical === MatterBle.C1_CHARACTERISTIC_UUID) {
+                    c1Uuid = char.uuid;
+                } else if (canonical === MatterBle.C2_CHARACTERISTIC_UUID) {
+                    c2Uuid = char.uuid;
+                } else if (canonical === MatterBle.C3_CHARACTERISTIC_UUID) {
+                    c3Uuid = char.uuid;
+                }
+            }
+
+            if (!c1Uuid || !c2Uuid) {
+                throw new BleError(`Peripheral ${peripheralAddress} missing required Matter characteristics (C1/C2)`);
+            }
+
+            // 4. Read C3 if present and has additional data
+            if (c3Uuid && hasAdditionalAdvertisementData) {
+                logger.debug(`Reading additional commissioning data from C3`);
+                await this.#handler.sendCommand(BleProxyCommand.ReadCharacteristic, {
+                    connection_handle,
+                    characteristic_uuid: c3Uuid,
+                });
+                // Additional commissioning data read but not used directly by the proxy -
+                // it's handled by matter.js commissioning flow internally
+            }
+
+            // 5. Send BTP handshake request on C1.
+            // Matter BTP spec: writes to C1 use ATT Write Request (with response). C1 typically
+            // does not advertise writeWithoutResponse, so a writeWithoutResponse is silently
+            // dropped or rejected by the peripheral and the BTP handshake response never comes.
+            const btpHandshakeRequest = BtpCodec.encodeBtpHandshakeRequest({
+                versions: MatterBle.BTP_SUPPORTED_VERSIONS,
+                attMtu: mtu,
+                clientWindowSize: MatterBle.BTP_MAXIMUM_WINDOW_SIZE,
+            });
+            logger.debug(`Sending BTP handshake request on C1`);
+            await this.#handler.sendCommand(BleProxyCommand.WriteCharacteristic, {
+                connection_handle,
+                characteristic_uuid: c1Uuid,
+                value: Buffer.from(btpHandshakeRequest as ArrayBuffer).toString("base64"),
+                response: true,
+            });
+
+            // 6. Subscribe to C2 for notifications
+            await this.#handler.sendCommand(BleProxyCommand.SubscribeCharacteristic, {
+                connection_handle,
+                characteristic_uuid: c2Uuid,
+            });
+
+            // 7. Wait for BTP handshake response via binary frame
+            const {
+                promise: handshakePromise,
+                resolver: handshakeResolver,
+                rejecter: handshakeRejecter,
+            } = createPromise<Uint8Array>();
+
+            const btpHandshakeTimeout = Time.getTimer(
+                "BLE proxy handshake timeout",
+                MatterBle.BTP_CONN_RSP_TIMEOUT,
+                () => {
+                    handshakeRejecter(new BleError(`BTP handshake response not received from ${peripheralAddress}`));
+                },
+            ).start();
+
+            const handshakeObserver = (frame: { connectionHandle: number; opcode: number; payload: Uint8Array }) => {
+                if (frame.connectionHandle === connection_handle && frame.opcode === BinaryFrameOpcode.Notification) {
+                    const data = new Uint8Array(frame.payload);
+                    if (
+                        data[0] === BTP_HANDSHAKE_RESPONSE_OPCODE_1 &&
+                        data[1] === BTP_HANDSHAKE_RESPONSE_OPCODE_2 &&
+                        data.length === BTP_HANDSHAKE_RESPONSE_LENGTH
+                    ) {
+                        btpHandshakeTimeout.stop();
+                        handshakeResolver(data);
+                    }
+                }
+            };
+            this.#handler.binaryFrameReceived.on(handshakeObserver);
+
+            let handshakeResponse: Uint8Array;
+            try {
+                handshakeResponse = await handshakePromise;
+            } finally {
+                this.#handler.binaryFrameReceived.off(handshakeObserver);
+                btpHandshakeTimeout.stop();
+            }
+
+            // 8. Create BTP session
+            // Use a ref object so closures can access the channel after it's created
+            const onMatterMessageListener = this.#onMatterMessageListener;
+            const channelRef: { channel?: ProxyBleChannel } = {};
+
+            const btpSession = await BtpSessionHandler.createAsCentral(
+                handshakeResponse,
+                // Write callback: send binary frame to proxy client
+                async (data: Bytes) => {
+                    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as ArrayBuffer);
+                    this.#handler.sendBinaryFrame(BinaryFrameOpcode.WriteData, connection_handle, bytes);
+                },
+                // Disconnect callback
+                async () => {
+                    if (!channelRef.channel?.connected) return;
+                    logger.debug(`Disconnecting from ${peripheralAddress} via proxy`);
+                    try {
+                        await this.#handler.sendCommand(BleProxyCommand.Disconnect, { connection_handle });
+                    } catch (error) {
+                        logger.debug(
+                            `Peripheral ${peripheralAddress}: Error sending Disconnect to proxy client`,
+                            error,
+                        );
+                    }
+                },
+                // Matter message callback
+                async (data: Bytes) => {
+                    if (channelRef.channel) {
+                        channelRef.channel.pushMessage(data);
+                        onMatterMessageListener(channelRef.channel, data);
+                    }
+                },
+            );
+
+            // 9. Wire up binary frame notifications to BTP session
+            const binaryObserver = (frame: { connectionHandle: number; opcode: number; payload: Uint8Array }) => {
+                if (frame.connectionHandle === connection_handle && frame.opcode === BinaryFrameOpcode.Notification) {
+                    btpSession
+                        .handleIncomingBleData(new Uint8Array(frame.payload))
+                        .catch(error =>
+                            logger.warn(`Peripheral ${peripheralAddress}: Error handling incoming BLE data`, error),
+                        );
+                }
+            };
+            this.#handler.binaryFrameReceived.on(binaryObserver);
+
+            // 10. Handle unexpected disconnects from proxy client
+            const eventObserver = (event: string, data: Record<string, unknown>) => {
+                if (
+                    event === BleProxyEvent.Disconnected &&
+                    typeof data.connection_handle === "number" &&
+                    data.connection_handle === connection_handle
+                ) {
+                    logger.info(`Peripheral ${peripheralAddress} disconnected unexpectedly`);
+                    channelRef.channel?.markDisconnected();
+                    channelRef.channel
+                        ?.close()
+                        .catch(error => logger.debug(`Peripheral ${peripheralAddress}: Error closing channel`, error));
+                }
+            };
+            this.#handler.eventReceived.on(eventObserver);
+
+            // Cleanup function to remove observers when channel closes
+            const cleanupObservers = () => {
+                this.#handler.binaryFrameReceived.off(binaryObserver);
+                this.#handler.eventReceived.off(eventObserver);
+            };
+
+            const proxyChannel = new ProxyBleChannel(peripheralAddress, btpSession, cleanupObservers);
+            channelRef.channel = proxyChannel;
+            return proxyChannel;
+        } catch (error) {
+            // Clean up on failure — best-effort tear-down of the peripheral on the proxy side
+            try {
+                await this.#handler.sendCommand(BleProxyCommand.Disconnect, { connection_handle });
+            } catch (cleanupError) {
+                logger.debug(`Peripheral ${peripheralAddress}: Error during connect-failure cleanup`, cleanupError);
+            }
+            throw error;
+        }
+    }
+
+    onData(listener: (socket: Channel<Bytes>, data: Bytes) => void): Transport.Listener {
+        this.#onMatterMessageListener = listener;
+        return {
+            close: async () => await this.close(),
+        };
+    }
+
+    async close() {
+        this.#closed = true;
+    }
+
+    supports(type: ChannelType, _address?: string) {
+        return type === ChannelType.BLE;
+    }
+}
+
+/**
+ * BLE channel that communicates through the proxy WebSocket.
+ * Replaces NobleBleChannel from @matter/nodejs-ble.
+ */
+export class ProxyBleChannel extends BleChannel<Bytes> {
+    #connected = true;
+    readonly #peripheralAddress: string;
+    readonly #btpSession: BtpSessionHandler;
+    readonly #cleanupObservers: () => void;
+    readonly #onBtpSessionClosed: () => void;
+    readonly #closeListeners = new Set<() => void>();
+    #iteratorQueue = new Array<Bytes>();
+    #iteratorWaiter?: (value: IteratorResult<Bytes>) => void;
+    #iteratorDone = false;
+
+    constructor(peripheralAddress: string, btpSession: BtpSessionHandler, cleanupObservers: () => void) {
+        super();
+        this.#peripheralAddress = peripheralAddress;
+        this.#btpSession = btpSession;
+        this.#cleanupObservers = cleanupObservers;
+        this.#onBtpSessionClosed = () => this.emitClosed();
+        btpSession.closed.on(this.#onBtpSessionClosed);
+    }
+
+    get connected() {
+        return this.#connected;
+    }
+
+    markDisconnected() {
+        this.#connected = false;
+    }
+
+    pushMessage(data: Bytes): void {
+        if (this.#iteratorWaiter) {
+            const resolve = this.#iteratorWaiter;
+            this.#iteratorWaiter = undefined;
+            resolve({ value: data, done: false });
+        } else if (!this.#iteratorDone) {
+            this.#iteratorQueue.push(data);
+        }
+    }
+
+    onClose(listener: () => void): Transport.Listener {
+        this.#closeListeners.add(listener);
+        return {
+            close: async () => {
+                this.#closeListeners.delete(listener);
+            },
+        };
+    }
+
+    [Symbol.asyncIterator](): AsyncIterator<Bytes> {
+        return {
+            next: () => {
+                if (this.#iteratorQueue.length > 0) {
+                    return Promise.resolve({ value: this.#iteratorQueue.shift()!, done: false });
+                }
+                if (this.#iteratorDone || !this.#connected) {
+                    return Promise.resolve({ value: undefined as unknown as Bytes, done: true });
+                }
+                return new Promise<IteratorResult<Bytes>>(resolve => {
+                    this.#iteratorWaiter = resolve;
+                });
+            },
+        };
+    }
+
+    #terminateIterator(): void {
+        if (!this.#iteratorDone) {
+            this.#iteratorDone = true;
+            this.#iteratorWaiter?.({ value: undefined as unknown as Bytes, done: true });
+            this.#iteratorWaiter = undefined;
+        }
+    }
+
+    async send(data: Bytes) {
+        if (!this.#connected) {
+            logger.debug(`Cannot send data - not connected to ${this.#peripheralAddress}`);
+            return;
+        }
+        if (this.#btpSession === undefined) {
+            throw new BtpFlowError(`Cannot send data, no BTP session initialized`);
+        }
+        await this.#btpSession.sendMatterMessage(data);
+    }
+
+    get name() {
+        return `ble-proxy://${this.#peripheralAddress}`;
+    }
+
+    async close() {
+        this.#connected = false;
+        this.#cleanupObservers();
+        this.#terminateIterator();
+        for (const listener of this.#closeListeners) {
+            listener();
+        }
+        this.#btpSession.closed.off(this.#onBtpSessionClosed);
+        await this.#btpSession.close();
+        this.emitClosed();
+    }
+}

package/src/ProxyBleClient.ts

@@ -0,0 +1,136 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Logger } from "@matter/main";
+import { MatterBle } from "@matter/main/protocol";
+import type { BleProxyHandler } from "./BleProxyHandler.js";
+import { BleProxyCommand, BleProxyEvent, type DeviceDiscoveredData } from "./BleProxyProtocol.js";
+
+const logger = Logger.get("ProxyBleClient");
+
+/**
+ * Represents a BLE peripheral discovered through the proxy.
+ * Replaces Noble's Peripheral type - stores the data received from the proxy client.
+ */
+export interface ProxyPeripheral {
+    address: string;
+    name?: string;
+    rssi?: number;
+    connectable: boolean;
+    serviceData: Map<string, Uint8Array>;
+    mtu?: number;
+}
+
+/**
+ * BLE client that communicates over the BLE proxy WebSocket protocol.
+ * Replaces NobleBleClient - instead of using Noble directly, sends scan commands
+ * to the proxy client and receives device_discovered events.
+ */
+export class ProxyBleClient {
+    readonly #handler: BleProxyHandler;
+    readonly #discoveredPeripherals = new Map<string, { peripheral: ProxyPeripheral; matterServiceData: Uint8Array }>();
+    #deviceDiscoveredCallback: ((peripheral: ProxyPeripheral, matterServiceData: Uint8Array) => void) | undefined;
+    #isScanning = false;
+
+    readonly #eventObserver = (event: string, data: Record<string, unknown>) => {
+        if (event === BleProxyEvent.DeviceDiscovered) {
+            this.#handleDeviceDiscovered(data as unknown as DeviceDiscoveredData);
+        } else if (event === BleProxyEvent.ScanStopped) {
+            logger.info(`Scan stopped by proxy client: ${(data as { reason?: string }).reason ?? "unknown"}`);
+            this.#isScanning = false;
+        }
+    };
+
+    constructor(handler: BleProxyHandler) {
+        this.#handler = handler;
+        this.#handler.eventReceived.on(this.#eventObserver);
+    }
+
+    setDiscoveryCallback(callback: (peripheral: ProxyPeripheral, matterServiceData: Uint8Array) => void): void {
+        this.#deviceDiscoveredCallback = callback;
+        for (const { peripheral, matterServiceData } of this.#discoveredPeripherals.values()) {
+            this.#deviceDiscoveredCallback(peripheral, matterServiceData);
+        }
+    }
+
+    async startScanning(): Promise<void> {
+        if (this.#isScanning) {
+            return;
+        }
+
+        if (!this.#handler.connected) {
+            logger.info("BLE proxy not connected, deferring scan start");
+            return;
+        }
+
+        logger.debug("Start BLE scanning via proxy ...");
+        await this.#handler.sendCommand(BleProxyCommand.StartScan, {
+            service_uuids: ["fff6"],
+            allow_duplicates: true,
+        });
+        this.#isScanning = true;
+    }
+
+    async stopScanning(): Promise<void> {
+        if (!this.#isScanning) {
+            return;
+        }
+
+        if (!this.#handler.connected) {
+            this.#isScanning = false;
+            return;
+        }
+
+        logger.debug("Stop BLE scanning via proxy ...");
+        await this.#handler.sendCommand(BleProxyCommand.StopScan);
+        this.#isScanning = false;
+    }
+
+    close(): void {
+        this.#isScanning = false;
+        this.#handler.eventReceived.off(this.#eventObserver);
+    }
+
+    #handleDeviceDiscovered(data: DeviceDiscoveredData): void {
+        const { address, name, rssi, connectable, service_data } = data;
+
+        // service_data keys may arrive in any UUID form the proxy client chose: noble's compact
+        // 32-char form, ESPHome's dashed form, or the 16-bit short form "fff6"/"FFF6". Accept all.
+        const serviceData = new Map<string, Uint8Array>();
+        let matterServiceData: Uint8Array | undefined;
+        if (service_data) {
+            for (const [uuid, base64Value] of Object.entries(service_data)) {
+                const bytes = Buffer.from(base64Value, "base64");
+                serviceData.set(uuid, bytes);
+                if (MatterBle.isServiceUuid(uuid)) {
+                    matterServiceData = bytes;
+                }
+            }
+        }
+
+        const peripheral: ProxyPeripheral = {
+            address,
+            name,
+            rssi,
+            connectable,
+            serviceData,
+        };
+
+        if (!connectable) {
+            logger.debug(`Peripheral ${address} is not connectable, ignoring`);
+            return;
+        }
+
+        if (matterServiceData === undefined || matterServiceData.length !== 8) {
+            logger.debug(`Peripheral ${address} does not advertise valid Matter service data, ignoring`);
+            return;
+        }
+
+        logger.debug(`Discovered device ${address} (${name ?? "unnamed"}) via proxy`);
+        this.#discoveredPeripherals.set(address, { peripheral, matterServiceData });
+        this.#deviceDiscoveredCallback?.(peripheral, matterServiceData);
+    }
+}

package/src/ProxyBleScanner.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BleScanner as BaseBleScanner, type DiscoveredBleDevice } from "@matter/main/protocol";
+import type { ProxyBleClient, ProxyPeripheral } from "./ProxyBleClient.js";
+
+export type { DiscoveredBleDevice } from "@matter/main/protocol";
+
+export type DiscoveredProxyBleDevice = Omit<DiscoveredBleDevice, "peripheral"> & { peripheral: ProxyPeripheral };
+
+/**
+ * BLE scanner that discovers Matter devices through the BLE proxy.
+ *
+ * Extends matter.js's base `BleScanner`, which already handles the
+ * `findCommissionableDevicesContinuously` waiter loop, advertisement parsing,
+ * and cancellation semantics. We only narrow the `getDiscoveredDevice` return
+ * type to expose the proxy-side `ProxyPeripheral` and route `closeClient`
+ * through `ProxyBleClient.close()`.
+ */
+export class ProxyBleScanner extends BaseBleScanner {
+    readonly #proxyClient: ProxyBleClient;
+
+    constructor(proxyClient: ProxyBleClient) {
+        super(proxyClient);
+        this.#proxyClient = proxyClient;
+    }
+
+    override getDiscoveredDevice(address: string): DiscoveredProxyBleDevice {
+        return super.getDiscoveredDevice(address) as DiscoveredProxyBleDevice;
+    }
+
+    protected override closeClient(): void {
+        this.#proxyClient.close();
+    }
+}