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

package/src/cluster/server/ClusterDatasource.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Fabric } from "#fabric/Fabric.js";
+import { Storage, SupportedStorageTypes } from "#general";
+import { EventHandler } from "../../interaction/EventHandler.js";
+
+export interface ClusterDatasource<S extends Storage = any> {
+    readonly version: number;
+    readonly eventHandler?: EventHandler<S>;
+    readonly fabrics: Fabric[];
+    increaseVersion(): number;
+    changed(key: string, value: SupportedStorageTypes): void;
+}

package/src/cluster/server/ClusterServer.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ClusterId } from "#types";
+import { AnyAttributeServer } from "./AttributeServer.js";
+import { ClusterDatasource } from "./ClusterDatasource.js";
+import { CommandServer } from "./CommandServer.js";
+import { AnyEventServer } from "./EventServer.js";
+
+/**
+ * A collection of servers for a cluster's attributes, commands and events.
+ */
+export interface ClusterServer {
+    /**
+     * Cluster ID
+     */
+    id: ClusterId;
+
+    /**
+     * Cluster name
+     */
+    readonly name: string;
+
+    /**
+     * Cluster datasource
+     */
+    datasource?: ClusterDatasource;
+
+    /**
+     * Cluster attributes as named object that can be used to programmatically work with available attributes
+     */
+    readonly attributes: Record<string, AnyAttributeServer>;
+
+    /**
+     * Cluster commands as array
+     */
+    readonly commands: Record<string, CommandServer>;
+
+    /**
+     * Cluster events as named object
+     */
+    readonly events: Record<string, AnyEventServer>;
+}

package/src/cluster/server/CommandServer.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Logger } from "#general";
+import { AccessLevel, FabricIndex } from "#model";
+import { CommandId, StatusCode, TlvSchema, TlvStream } from "#types";
+import { Message } from "../../codec/MessageCodec.js";
+import { EndpointInterface } from "../../endpoint/EndpointInterface.js";
+import { SecureSession } from "../../session/SecureSession.js";
+import { Session } from "../../session/Session.js";
+
+const logger = Logger.get("CommandServer");
+
+export class CommandServer<RequestT = any, ResponseT = any> {
+    readonly #invokeAcl: AccessLevel;
+
+    constructor(
+        readonly invokeId: CommandId,
+        readonly responseId: CommandId,
+        readonly name: string,
+        readonly requestSchema: TlvSchema<RequestT>,
+        readonly responseSchema: TlvSchema<ResponseT>,
+        readonly requiresTimedInteraction: boolean,
+        invokeAcl: AccessLevel,
+        protected readonly handler: (
+            request: RequestT,
+            session: Session,
+            message: Message,
+            endpoint: EndpointInterface,
+        ) => Promise<ResponseT> | ResponseT,
+    ) {
+        this.#invokeAcl = invokeAcl;
+    }
+
+    async invoke(
+        session: Session,
+        args: TlvStream,
+        message: Message,
+        endpoint: EndpointInterface,
+    ): Promise<{
+        /** Primary StatusCode of the invoke request  as defined by Interaction proptocol. */
+        code: StatusCode;
+
+        /** Cluster specific StatusCode of the invoke request if required */
+        clusterCode?: number;
+
+        /** ID of the response */
+        responseId: CommandId;
+
+        /** Response data */
+        response: TlvStream;
+    }> {
+        let request = this.requestSchema.decodeTlv(args);
+
+        // Inject fabric index into structures in general if undefined, if set it will be used
+        if (session.isSecure) {
+            const fabric = (session as SecureSession).fabric;
+            if (fabric) {
+                request = this.requestSchema.injectField(
+                    request,
+                    <number>FabricIndex.id,
+                    session.associatedFabric.fabricIndex,
+                    () => true, // Noone should send any index and if we simply SHALL ignore it
+                );
+            }
+        }
+
+        this.requestSchema.validate(request);
+        this.debug(`Invoke ${this.name} with data ${Logger.toJSON(request)}`);
+        const response = await this.handler(request, session, message, endpoint);
+        this.debug(`Invoke ${this.name} response : ${Logger.toJSON(response)}`);
+        return {
+            code: StatusCode.Success,
+            responseId: this.responseId,
+            response: this.responseSchema.encodeTlv(response),
+        };
+    }
+
+    debug(message: string) {
+        logger.debug(message);
+    }
+
+    get invokeAcl() {
+        return this.#invokeAcl ?? AccessLevel.Operate; // or View?? Re "Read/Invoke" in Access table
+    }
+}

package/src/cluster/server/EventServer.ts

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    ImplementationError,
+    InternalError,
+    isObject,
+    MaybePromise,
+    Storage,
+    StorageOperationResult,
+    Time,
+} from "#general";
+import { AccessLevel, ClusterModel, EventModel, MatterModel } from "#model";
+import {
+    Attributes,
+    BitSchema,
+    Cluster,
+    ClusterId,
+    Commands,
+    Event,
+    EventId,
+    EventPriority,
+    Events,
+    FabricIndex,
+    TlvEventFilter,
+    TlvSchema,
+    TypeFromPartialBitSchema,
+    TypeFromSchema,
+} from "#types";
+import { Message } from "../../codec/MessageCodec.js";
+import { EndpointInterface } from "../../endpoint/EndpointInterface.js";
+import { EventData, EventHandler, EventStorageData } from "../../interaction/EventHandler.js";
+import { SecureSession } from "../../session/SecureSession.js";
+import { Session } from "../../session/Session.js";
+
+export type AnyEventServer<T = any, S extends Storage = any> = EventServer<T, S> | FabricSensitiveEventServer<T, S>;
+
+export function createEventServer<
+    T,
+    F extends BitSchema,
+    SF extends TypeFromPartialBitSchema<F>,
+    A extends Attributes,
+    C extends Commands,
+    E extends Events,
+    S extends Storage,
+>(
+    clusterDef: Cluster<F, SF, A, C, E>,
+    eventDef: Event<T, F>,
+    eventName: string,
+    schema: TlvSchema<T>,
+    priority: EventPriority,
+    readAcl: AccessLevel | undefined,
+): EventServer<T, S> {
+    let fabricSensitive = false;
+    const clusterFromModel = MatterModel.standard.get(ClusterModel, clusterDef.id);
+    if (clusterFromModel !== undefined) {
+        const eventModel = clusterFromModel.get(EventModel, eventDef.id);
+        if (eventModel !== undefined) {
+            fabricSensitive = eventModel.fabricSensitive;
+        }
+    }
+    if (fabricSensitive) {
+        return new FabricSensitiveEventServer(eventDef.id, clusterDef.id, eventName, schema, priority, readAcl);
+    }
+    return new EventServer(eventDef.id, clusterDef.id, eventName, schema, priority, readAcl);
+}
+
+export class EventServer<T = any, S extends Storage = any> {
+    private eventList = new Array<EventData<T>>();
+    private readonly listeners = new Array<(event: EventStorageData<T>) => void>();
+    protected endpoint?: EndpointInterface;
+    protected eventHandler?: EventHandler;
+    #readAcl: AccessLevel | undefined;
+    hasFabricSensitiveData = false;
+
+    constructor(
+        readonly id: EventId,
+        readonly clusterId: ClusterId,
+        readonly name: string,
+        readonly schema: TlvSchema<T>,
+        readonly priority: EventPriority,
+        readAcl: AccessLevel | undefined,
+    ) {
+        this.#readAcl = readAcl;
+    }
+
+    get readAcl() {
+        return this.#readAcl ?? AccessLevel.View; // ???
+    }
+
+    assignToEndpoint(endpoint: EndpointInterface) {
+        this.endpoint = endpoint;
+    }
+
+    // TODO Try to get rid of that late binding and simply things again
+    //      potentially with refactoring out MatterDevice and MatterController
+    bindToEventHandler(eventHandler: EventHandler<S>) {
+        this.eventHandler = eventHandler;
+        // Send all stored events to the new listener
+        const promises = new Array<PromiseLike<void>>();
+        for (const event of this.eventList) {
+            const finalEvent = this.eventHandler.pushEvent(event);
+            if (finalEvent !== undefined && MaybePromise.is(finalEvent)) {
+                promises.push(finalEvent.then(e => this.listeners.forEach(listener => listener(e))));
+            } else {
+                this.listeners.forEach(listener => listener(finalEvent));
+            }
+        }
+        this.eventList = [];
+        if (promises.length > 0) {
+            return Promise.all(promises).then(() => Promise.resolve()) as StorageOperationResult<S>;
+        }
+        return undefined as StorageOperationResult<S>;
+    }
+
+    triggerEvent(data: T) {
+        if (this.endpoint === undefined || this.endpoint.number === undefined) {
+            throw new InternalError("Endpoint not assigned");
+        }
+        const event: EventData<T> = {
+            eventId: this.id,
+            clusterId: this.clusterId,
+            endpointId: this.endpoint.number,
+            epochTimestamp: Time.nowMs(),
+            priority: this.priority,
+            data,
+        };
+        if (this.eventHandler === undefined) {
+            // As long as we have no eventManager, we store the events
+            this.eventList.push(event);
+        } else {
+            const finalEvent = this.eventHandler.pushEvent(event);
+            return MaybePromise.then(finalEvent, e => {
+                this.listeners.forEach(listener => listener(e));
+            }) as StorageOperationResult<S>;
+        }
+        return undefined as StorageOperationResult<S>;
+    }
+
+    addListener(listener: (event: EventStorageData<T>) => void) {
+        this.listeners.push(listener);
+    }
+
+    removeListener(listener: (event: EventStorageData<T>) => void) {
+        const entryIndex = this.listeners.indexOf(listener);
+        if (entryIndex !== -1) {
+            this.listeners.splice(entryIndex, 1);
+        }
+    }
+
+    get(
+        session: Session,
+        isFabricFiltered: boolean,
+        _message?: Message,
+        filters?: TypeFromSchema<typeof TlvEventFilter>[],
+    ) {
+        if (this.eventHandler === undefined) {
+            throw new InternalError("EventServer not bound to EventHandler");
+        }
+        if (this.endpoint === undefined) {
+            throw new InternalError("EventServer not bound to Endpoint");
+        }
+
+        return this.eventHandler.getEvents(
+            { endpointId: this.endpoint.number, clusterId: this.clusterId, eventId: this.id },
+            filters,
+            // When request is fabric filtered or the event is Fabric sensitive then filter the events for the fabrics
+            isFabricFiltered ? ((session as SecureSession).fabric?.fabricIndex ?? FabricIndex.NO_FABRIC) : undefined,
+        );
+    }
+}
+
+export class FabricSensitiveEventServer<T, S extends Storage> extends EventServer<T, S> {
+    override hasFabricSensitiveData = true;
+
+    override get(
+        session: Session,
+        _isFabricFiltered: boolean,
+        message?: Message,
+        filters?: TypeFromSchema<typeof TlvEventFilter>[],
+    ) {
+        // because the event is fabric sensitive it is always filtered out when another fabric tries to access it
+        return super.get(session, true, message, filters);
+    }
+
+    override triggerEvent(data: T) {
+        if (!isObject(data) || data === null) {
+            throw new ImplementationError("FabricSensitive events need to have an object as data.");
+        }
+        if (!("fabricIndex" in data)) {
+            throw new InternalError("FabricSensitive events requires fabricIndex in data.");
+        }
+        return super.triggerEvent(data);
+    }
+}

package/src/cluster/server/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from "./AttributeServer.js";
+export * from "./ClusterDatasource.js";
+export * from "./ClusterServer.js";
+export * from "./CommandServer.js";
+export * from "./EventServer.js";

package/src/codec/BtpCodec.ts

@@ -0,0 +1,333 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Bytes, DataReader, DataWriter, Endian } from "#general";
+import { BleError } from "../ble/Ble.js";
+import { BtpProtocolError } from "../ble/BtpSessionHandler.js";
+
+export interface BtpHandshakeRequest {
+    versions: number[];
+    attMtu: number;
+    clientWindowSize: number;
+}
+
+export interface BtpHandshakeResponse {
+    version: number;
+    attMtu: number;
+    windowSize: number;
+}
+
+export interface BtpPacketPayload {
+    ackNumber?: number;
+    sequenceNumber: number;
+    messageLength?: number;
+    segmentPayload?: Uint8Array;
+}
+
+export interface DecodedBtpPacketPayload extends BtpPacketPayload {
+    segmentPayload: Uint8Array;
+}
+
+export interface BtpHeader {
+    isHandshakeRequest: boolean;
+    hasManagementOpcode: boolean;
+    hasAckNumber: boolean;
+    isEndingSegment: boolean;
+    isContinuingSegment: boolean;
+    isBeginningSegment: boolean;
+}
+
+export interface BtpPacket {
+    header: BtpHeader;
+    payload: BtpPacketPayload;
+}
+
+export interface DecodedBtpPacket {
+    header: BtpHeader;
+    payload: DecodedBtpPacketPayload;
+}
+
+export enum BtpHeaderBits {
+    HandshakeBit = 0b01000000,
+    ManagementMsg = 0b00100000,
+    AckMsg = 0b00001000,
+    EndSegment = 0b00000100,
+    ContinuingSegment = 0b00000010,
+    BeginSegment = 0b00000001,
+}
+
+export enum BtpOpcode {
+    HandshakeManagementOpcode = 0x6c,
+}
+
+const HANDSHAKE_HEADER = 0b01100101;
+
+export class BtpCodec {
+    static decodeBtpHandshakeRequest(data: Uint8Array): BtpHandshakeRequest {
+        const reader = new DataReader(data, Endian.Little);
+        return this.decodeHandshakeRequestPayload(reader);
+    }
+
+    static decodeBtpPacket(data: Uint8Array): DecodedBtpPacket {
+        const reader = new DataReader(data, Endian.Little);
+
+        const header = this.decodeBtpPacketHeader(reader);
+
+        return {
+            header,
+            payload: this.decodeBtpPacketPayload(reader, header),
+        };
+    }
+
+    static encodeBtpPacket({ header, payload }: BtpPacket): Uint8Array {
+        return Bytes.concat(this.encodeBtpPacketHeader(header), this.encodeBtpPacketPayload(header, payload));
+    }
+
+    static encodeBtpHandshakeRequest({ versions, attMtu, clientWindowSize }: BtpHandshakeRequest): Uint8Array {
+        const writer = new DataWriter(Endian.Little);
+        writer.writeUInt8(HANDSHAKE_HEADER);
+        writer.writeUInt8(BtpOpcode.HandshakeManagementOpcode);
+        writer.writeUInt8((versions[1] << 4) | versions[0]);
+        writer.writeUInt8((versions[3] << 4) | versions[2]);
+        writer.writeUInt8((versions[5] << 4) | versions[4]);
+        writer.writeUInt8((versions[7] << 4) | versions[6]);
+        writer.writeUInt16(attMtu);
+        writer.writeUInt8(clientWindowSize);
+        return writer.toByteArray();
+    }
+
+    static encodeBtpHandshakeResponse({ version, attMtu, windowSize }: BtpHandshakeResponse): Uint8Array {
+        const writer = new DataWriter(Endian.Little);
+        writer.writeUInt8(HANDSHAKE_HEADER);
+        writer.writeUInt8(BtpOpcode.HandshakeManagementOpcode);
+        writer.writeUInt8(version & 0x0f); //reserved bit and final version
+        writer.writeUInt16(attMtu);
+        writer.writeUInt8(windowSize);
+        return writer.toByteArray();
+    }
+
+    private static decodeBtpPacketPayload(
+        reader: DataReader<Endian.Little>,
+        header: BtpHeader,
+    ): DecodedBtpPacketPayload {
+        const { hasAckNumber, isBeginningSegment } = header;
+        const ackNumber = hasAckNumber ? reader.readUInt8() : undefined;
+        const sequenceNumber = reader.readUInt8();
+        const messageLength = isBeginningSegment ? reader.readUInt16() : undefined;
+        const segmentPayload = reader.getRemainingBytes();
+
+        return { ackNumber, sequenceNumber, messageLength, segmentPayload };
+    }
+
+    private static encodeBtpPacketPayload(
+        { hasAckNumber, isBeginningSegment, isContinuingSegment, isEndingSegment }: BtpHeader,
+        { ackNumber, sequenceNumber, messageLength, segmentPayload }: BtpPacketPayload,
+    ): Uint8Array {
+        const writer = new DataWriter(Endian.Little);
+
+        // Validate Header against Payload fields to make sure they match together
+        if (!hasAckNumber && ackNumber !== undefined) {
+            throw new BtpProtocolError("Ack number shouldn't be set because header flag is not set.");
+        }
+        if (hasAckNumber && ackNumber === undefined) {
+            throw new BtpProtocolError("Ack number needs to be set because header flag is set.");
+        }
+        if (isBeginningSegment && isContinuingSegment) {
+            throw new BtpProtocolError("Beginning and continuing segment flags can't be set at the same time.");
+        }
+        if (isEndingSegment && !isContinuingSegment && !isBeginningSegment) {
+            throw new BtpProtocolError("Ending segment flag can't be set without continuing segment flag.");
+        }
+        if (
+            (isBeginningSegment || isContinuingSegment) &&
+            (segmentPayload === undefined || segmentPayload.length === 0)
+        ) {
+            throw new BtpProtocolError("Payload needs to be set because header flag indicates a message with payload.");
+        }
+        if (isBeginningSegment && messageLength === undefined) {
+            throw new BtpProtocolError("Message length needs to be set because packet is a beginning segment.");
+        }
+        if (!isBeginningSegment && messageLength !== undefined) {
+            throw new BtpProtocolError(
+                "Message length shouldn't be set because the package is not a beginning segment.",
+            );
+        }
+
+        if (ackNumber !== undefined) {
+            writer.writeUInt8(ackNumber);
+        }
+
+        writer.writeUInt8(sequenceNumber);
+
+        if (messageLength !== undefined) {
+            writer.writeUInt16(messageLength);
+        }
+
+        if (segmentPayload !== undefined) {
+            writer.writeByteArray(segmentPayload);
+        }
+        return writer.toByteArray();
+    }
+
+    private static decodeHandshakeRequestPayload(reader: DataReader<Endian.Little>): BtpHandshakeRequest {
+        const header = reader.readUInt8();
+        const opcode = reader.readUInt8();
+        let version = reader.readUInt8();
+
+        if (header !== HANDSHAKE_HEADER) {
+            throw new BtpProtocolError("Header for expected BTP Handshake Request is incorrect.");
+        }
+        if (opcode !== BtpOpcode.HandshakeManagementOpcode) {
+            throw new BtpProtocolError("Management Opcode for BTP Handshake Request is incorrect.");
+        }
+
+        const ver: number[] = [];
+        ver[0] = (version & 0xf0) >> 4;
+        ver[1] = version & 0x0f;
+
+        version = reader.readUInt8();
+        ver[2] = (version & 0xf0) >> 4;
+        ver[3] = version & 0x0f;
+
+        version = reader.readUInt8();
+        ver[4] = (version & 0xf0) >> 4;
+        ver[5] = version & 0x0f;
+
+        version = reader.readUInt8();
+        ver[6] = (version & 0xf0) >> 4;
+        ver[7] = version & 0x0f;
+
+        const versions = ver.filter(v => v !== 0);
+        if (versions.length === 0) {
+            throw new BtpProtocolError("No valid version provided.");
+        }
+
+        const attMtu = reader.readUInt16();
+        const clientWindowSize = reader.readUInt8();
+
+        return { versions, attMtu, clientWindowSize };
+    }
+
+    static decodeBtpHandshakeResponsePayload(data: Uint8Array): BtpHandshakeResponse {
+        const reader = new DataReader(data, Endian.Little);
+        const header = reader.readUInt8();
+        if (header !== HANDSHAKE_HEADER) {
+            throw new BtpProtocolError("Header for expected BTP Handshake Request is incorrect.");
+        }
+
+        const opcode = reader.readUInt8();
+        if (opcode !== BtpOpcode.HandshakeManagementOpcode) {
+            throw new BtpProtocolError("Management Opcode for BTP Handshake Request is incorrect.");
+        }
+
+        const version = reader.readUInt8() & 0x0f;
+        const attMtu = reader.readUInt16();
+        const windowSize = reader.readUInt8();
+        return { version, attMtu, windowSize };
+    }
+
+    private static decodeBtpPacketHeader(reader: DataReader<Endian.Little>): BtpHeader {
+        const headerBits = reader.readUInt8();
+        const isHandshakeRequest = (headerBits & BtpHeaderBits.HandshakeBit) !== 0;
+        const hasManagementOpcode = (headerBits & BtpHeaderBits.ManagementMsg) !== 0;
+        const hasAckNumber = (headerBits & BtpHeaderBits.AckMsg) !== 0;
+        const isEndingSegment = (headerBits & BtpHeaderBits.EndSegment) !== 0;
+        const isContinuingSegment = (headerBits & BtpHeaderBits.ContinuingSegment) !== 0;
+        const isBeginningSegment = (headerBits & BtpHeaderBits.BeginSegment) !== 0;
+
+        if (hasManagementOpcode) {
+            throw new BtpProtocolError("Management Opcode for BTPHandshake Request is not expected");
+        }
+
+        return {
+            isHandshakeRequest,
+            hasManagementOpcode,
+            hasAckNumber,
+            isEndingSegment,
+            isContinuingSegment,
+            isBeginningSegment,
+        };
+    }
+
+    private static encodeBtpPacketHeader({
+        isHandshakeRequest,
+        hasManagementOpcode,
+        hasAckNumber,
+        isEndingSegment,
+        isContinuingSegment,
+        isBeginningSegment,
+    }: BtpHeader): Uint8Array {
+        const writer = new DataWriter(Endian.Little);
+
+        if (isHandshakeRequest || hasManagementOpcode) {
+            throw new BtpProtocolError("Please use the specific methods to encode a Handshake packet");
+        }
+
+        const header =
+            // (isHandshakeRequest ? BtpHeaderBits.HandshakeBit : 0) | ... but always false here
+            // (hasManagementOpcode ? BtpHeaderBits.ManagementMsg : 0) | ... but alw<ys false here
+            (hasAckNumber ? BtpHeaderBits.AckMsg : 0) |
+            (isEndingSegment ? BtpHeaderBits.EndSegment : 0) |
+            (isContinuingSegment ? BtpHeaderBits.ContinuingSegment : 0) |
+            (isBeginningSegment ? BtpHeaderBits.BeginSegment : 0);
+
+        writer.writeUInt8(header);
+        return writer.toByteArray();
+    }
+
+    static encodeBleAdvertisementData(
+        discriminator: number,
+        vendorId: number,
+        productId: number,
+        hasAdditionalAdvertisementData = false,
+    ) {
+        const writer = new DataWriter(Endian.Little);
+        writer.writeUInt8(0x02);
+        writer.writeUInt8(0x01);
+        writer.writeUInt8(0x06);
+        writer.writeUInt8(0x0b);
+        writer.writeUInt8(0x16);
+        writer.writeUInt16(0xfff6);
+        writer.writeUInt8(0x00);
+        writer.writeUInt16(discriminator);
+        writer.writeUInt16(vendorId);
+        writer.writeUInt16(productId);
+        writer.writeUInt8(hasAdditionalAdvertisementData ? 0x01 : 0x00);
+        return writer.toByteArray();
+    }
+
+    static decodeBleAdvertisementData(data: Uint8Array) {
+        const reader = new DataReader(data, Endian.Little);
+        if (
+            reader.readUInt8() !== 0x02 ||
+            reader.readUInt8() !== 0x01 ||
+            reader.readUInt8() !== 0x06 ||
+            reader.readUInt8() !== 0x0b ||
+            reader.readUInt8() !== 0x16
+        ) {
+            throw new BleError("Invalid BLE advertisement data");
+        }
+        const serviceUuid = reader.readUInt16();
+        if (serviceUuid !== 0xfff6) {
+            throw new BleError("Invalid BLE advertisement data");
+        }
+        const { discriminator, vendorId, productId, hasAdditionalAdvertisementData } =
+            this.decodeBleAdvertisementServiceData(reader.getRemainingBytes());
+        return { discriminator, vendorId, productId, hasAdditionalAdvertisementData };
+    }
+
+    static decodeBleAdvertisementServiceData(data: Uint8Array) {
+        const reader = new DataReader(data, Endian.Little);
+        if (reader.readUInt8() !== 0x00) {
+            throw new BleError("Invalid BLE advertisement data");
+        }
+        const discriminator = reader.readUInt16();
+        const vendorId = reader.readUInt16();
+        const productId = reader.readUInt16();
+        const hasAdditionalAdvertisementData = !!reader.readUInt8();
+        return { discriminator, vendorId, productId, hasAdditionalAdvertisementData };
+    }
+}