@matter/protocol 0.12.4-alpha.0-20250217-b0bba5179 → 0.12.4-alpha.0-20250224-e0964a795

package/src/action/index.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+export * from "./client/index.js";
 export * from "./errors.js";
 export * from "./Interactable.js";
 export * from "./protocols.js";

package/src/interaction/DecodedDataReport.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { DataReport } from "#types";
+import { DecodedAttributeReportValue, normalizeAndDecodeReadAttributeReport } from "./AttributeDataDecoder.js";
+import { DecodedEventReportValue, normalizeAndDecodeReadEventReport } from "./EventDataDecoder.js";
+
+export interface DecodedDataReport extends DataReport {
+    isNormalized: true;
+    attributeReports: DecodedAttributeReportValue<any>[];
+    eventReports: DecodedEventReportValue<any>[];
+}
+
+export function DecodedDataReport(report: DataReport): DecodedDataReport {
+    if ((report as DecodedDataReport).isNormalized) {
+        return report as DecodedDataReport;
+    }
+
+    return {
+        ...report,
+        isNormalized: true,
+        attributeReports:
+            report.attributeReports === undefined ? [] : normalizeAndDecodeReadAttributeReport(report.attributeReports),
+        eventReports: report.eventReports === undefined ? [] : normalizeAndDecodeReadEventReport(report.eventReports),
+    };
+}

package/src/interaction/InteractionClient.ts

@@ -5,20 +5,20 @@
  */
 
 import {
+    Environment,
+    Environmental,
     ImplementationError,
-    InternalError,
     Logger,
     MatterFlowError,
-    MaybePromise,
     PromiseQueue,
-    Time,
     Timer,
     UnexpectedDataError,
     isDeepEqual,
 } from "#general";
 import { Specification } from "#model";
-import { PeerAddress } from "#peer/PeerAddress.js";
+import { PeerAddress, PeerAddressMap } from "#peer/PeerAddress.js";
 import { PeerDataStore } from "#peer/PeerAddressStore.js";
+import { DiscoveryOptions, PeerSet } from "#peer/PeerSet.js";
 import {
     ArraySchema,
     Attribute,
@@ -30,7 +30,6 @@ import {
     Event,
     EventId,
     EventNumber,
-    INTERACTION_PROTOCOL_ID,
     NodeId,
     RequestType,
     ResponseType,
@@ -47,16 +46,11 @@ import {
     resolveEventName,
 } from "#types";
 import { ExchangeProvider, ReconnectableExchangeProvider } from "../protocol/ExchangeProvider.js";
-import { MessageExchange } from "../protocol/MessageExchange.js";
-import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
-import { DecodedAttributeReportValue, normalizeAndDecodeReadAttributeReport } from "./AttributeDataDecoder.js";
-import { DecodedEventData, DecodedEventReportValue, normalizeAndDecodeReadEventReport } from "./EventDataDecoder.js";
-import {
-    DataReport,
-    IncomingInteractionClientMessenger,
-    InteractionClientMessenger,
-    ReadRequest,
-} from "./InteractionMessenger.js";
+import { DecodedAttributeReportValue } from "./AttributeDataDecoder.js";
+import { DecodedDataReport } from "./DecodedDataReport.js";
+import { DecodedEventData, DecodedEventReportValue } from "./EventDataDecoder.js";
+import { DataReport, InteractionClientMessenger, ReadRequest } from "./InteractionMessenger.js";
+import { RegisteredSubscription, SubscriptionClient } from "./SubscriptionClient.js";
 
 const logger = Logger.get("InteractionClient");
 
@@ -74,102 +68,98 @@ export interface AttributeStatus {
     status: StatusCode;
 }
 
-export class SubscriptionClient implements ProtocolHandler {
-    private readonly subscriptionListeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
-    private readonly subscriptionUpdateTimers = new Map<number, Timer>();
-
-    constructor() {}
+export class InteractionClientProvider {
+    readonly #peers: PeerSet;
+    readonly #clients = new PeerAddressMap<InteractionClient>();
 
-    getId() {
-        return INTERACTION_PROTOCOL_ID;
+    constructor(peers: PeerSet) {
+        this.#peers = peers;
+        this.#peers.deleted.on(peer => this.#onPeerLoss(peer.address));
+        this.#peers.disconnected.on(address => this.#onPeerLoss(address));
     }
 
-    registerSubscriptionListener(subscriptionId: number, listener: (dataReport: DataReport) => MaybePromise<void>) {
-        this.subscriptionListeners.set(subscriptionId, listener);
+    static [Environmental.create](env: Environment) {
+        const instance = new InteractionClientProvider(env.get(PeerSet));
+        env.set(InteractionClientProvider, instance);
+        return instance;
     }
 
-    removeSubscriptionListener(subscriptionId: number) {
-        this.subscriptionListeners.delete(subscriptionId);
+    get peers() {
+        return this.#peers;
     }
 
-    registerSubscriptionUpdateTimer(subscriptionId: number, timer: Timer) {
-        this.subscriptionUpdateTimers.set(subscriptionId, timer);
-    }
+    async connect(
+        address: PeerAddress,
+        discoveryOptions: DiscoveryOptions,
+        allowUnknownPeer = false,
+    ): Promise<InteractionClient> {
+        await this.#peers.ensureConnection(address, discoveryOptions, allowUnknownPeer);
 
-    removeSubscriptionUpdateTimer(subscriptionId: number) {
-        this.subscriptionUpdateTimers.get(subscriptionId)?.stop();
-        this.subscriptionUpdateTimers.delete(subscriptionId);
+        return this.getInteractionClient(address, discoveryOptions);
     }
 
-    async onNewExchange(exchange: MessageExchange) {
-        const messenger = new IncomingInteractionClientMessenger(exchange);
-
-        let dataReport: DataReport;
-        try {
-            // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
-            dataReport = await messenger.readDataReports([...this.subscriptionListeners.keys()]);
-        } finally {
-            messenger.close().catch(error => logger.info("Error closing client messenger", error));
+    async getInteractionClient(address: PeerAddress, discoveryOptions: DiscoveryOptions) {
+        let client = this.#clients.get(address);
+        if (client !== undefined) {
+            return client;
         }
-        const subscriptionId = dataReport.subscriptionId as number; // this is checked in the messenger already because we hand over allowed list
 
-        const listener = this.subscriptionListeners.get(subscriptionId);
-        const timer = this.subscriptionUpdateTimers.get(subscriptionId);
+        const nodeStore = this.#peers.get(address)?.dataStore;
+        await nodeStore?.construction; // Lazy initialize the data if not already done
 
-        if (timer !== undefined) {
-            timer.stop().start(); // Restart timer because we received data
-        }
+        const exchangeProvider = await this.#peers.exchangeProviderFor(address, discoveryOptions);
 
-        await listener?.(dataReport);
+        client = new InteractionClient(
+            exchangeProvider,
+            this.#peers.subscriptionClient,
+            address,
+            this.#peers.interactionQueue,
+            nodeStore,
+        );
+        this.#clients.set(address, client);
+
+        return client;
     }
 
-    async close() {
-        this.subscriptionListeners.clear();
-        this.subscriptionUpdateTimers.forEach(timer => timer.stop());
-        this.subscriptionUpdateTimers.clear();
+    #onPeerLoss(address: PeerAddress) {
+        const client = this.#clients.get(address);
+        if (client !== undefined) {
+            client.close();
+            this.#clients.delete(address);
+        }
     }
 }
 
 export class InteractionClient {
+    readonly #exchangeProvider: ExchangeProvider;
     readonly #nodeStore?: PeerDataStore;
     readonly #ownSubscriptionIds = new Set<number>();
     readonly #subscriptionClient: SubscriptionClient;
     readonly #queue?: PromiseQueue;
 
     constructor(
-        private readonly exchangeProvider: ExchangeProvider,
+        exchangeProvider: ExchangeProvider,
+        subscriptionClient: SubscriptionClient,
         readonly address: PeerAddress,
         queue?: PromiseQueue,
         nodeStore?: PeerDataStore,
     ) {
+        this.#exchangeProvider = exchangeProvider;
         this.#nodeStore = nodeStore;
+        this.#subscriptionClient = subscriptionClient;
         this.#queue = queue;
-
-        const client = this.exchangeProvider.getProtocolHandler(INTERACTION_PROTOCOL_ID);
-        if (client === undefined || !(client instanceof SubscriptionClient)) {
-            throw new InternalError(
-                `Subscription protocol handler ${INTERACTION_PROTOCOL_ID} missing or unexpected type.`,
-            );
-        }
-        this.#subscriptionClient = client;
     }
 
     get channelUpdated() {
-        if (this.exchangeProvider instanceof ReconnectableExchangeProvider) {
-            return this.exchangeProvider.channelUpdated;
+        if (this.#exchangeProvider instanceof ReconnectableExchangeProvider) {
+            return this.#exchangeProvider.channelUpdated;
         }
         throw new ImplementationError("ExchangeProvider does not support channelUpdated");
     }
 
-    registerSubscriptionListener(subscriptionId: number, listener: (dataReport: DataReport) => MaybePromise<void>) {
-        this.#ownSubscriptionIds.add(subscriptionId);
-        this.#subscriptionClient.registerSubscriptionListener(subscriptionId, listener);
-    }
-
     removeSubscription(subscriptionId: number) {
         this.#ownSubscriptionIds.delete(subscriptionId);
-        this.#subscriptionClient.removeSubscriptionListener(subscriptionId);
-        this.#subscriptionClient.removeSubscriptionUpdateTimer(subscriptionId);
+        this.#subscriptionClient.delete(subscriptionId);
     }
 
     async getAllAttributes(
@@ -259,10 +249,7 @@ export class InteractionClient {
             isFabricFiltered?: boolean;
             executeQueued?: boolean;
         } = {},
-    ): Promise<{
-        attributeReports: DecodedAttributeReportValue<any>[];
-        eventReports: DecodedEventReportValue<any>[];
-    }> {
+    ): Promise<DecodedDataReport> {
         const {
             attributes: attributeRequests,
             dataVersionFilters,
@@ -302,10 +289,7 @@ export class InteractionClient {
             );
         }
 
-        const result = await this.withMessenger<{
-            attributeReports: DecodedAttributeReportValue<any>[];
-            eventReports: DecodedEventReportValue<any>[];
-        }>(async messenger => {
+        const result = await this.withMessenger(async messenger => {
             const { isFabricFiltered = true } = options;
             return await this.processReadRequest(messenger, {
                 attributeRequests,
@@ -404,7 +388,7 @@ export class InteractionClient {
     private async processReadRequest(
         messenger: InteractionClientMessenger,
         request: ReadRequest,
-    ): Promise<{ attributeReports: DecodedAttributeReportValue<any>[]; eventReports: DecodedEventReportValue<any>[] }> {
+    ): Promise<DecodedDataReport> {
         const { attributeRequests, eventRequests } = request;
         logger.debug(
             `Sending read request to ${messenger.getExchangeChannelName()} for attributes ${attributeRequests
@@ -415,10 +399,7 @@ export class InteractionClient {
         const response = await messenger.sendReadRequest(request);
 
         // Normalize and decode the response
-        const normalizedResult = {
-            attributeReports: normalizeAndDecodeReadAttributeReport(response.attributeReports ?? []),
-            eventReports: normalizeAndDecodeReadEventReport(response.eventReports ?? []),
-        };
+        const normalizedResult = DecodedDataReport(response);
         logger.debug(
             `Received read response with attributes ${normalizedResult.attributeReports
                 .map(({ path, value }) => `${resolveAttributeName(path)} = ${Logger.toJSON(value)}`)
@@ -643,33 +624,39 @@ export class InteractionClient {
                 return;
             }
 
-            const data = normalizeAndDecodeReadAttributeReport(dataReport.attributeReports);
+            const { attributeReports } = DecodedDataReport(dataReport);
 
-            if (data.length === 0) {
+            if (attributeReports.length === 0) {
                 throw new MatterFlowError("Subscription result reporting undefined/no value not specified");
             }
-            if (data.length > 1) {
+            if (attributeReports.length > 1) {
                 throw new UnexpectedDataError("Unexpected response with more then one attribute");
             }
-            const { value, version } = data[0];
+            const { value, version } = attributeReports[0];
             if (value === undefined)
                 throw new MatterFlowError("Subscription result reporting undefined value not specified.");
 
-            await this.#nodeStore?.persistAttributes([data[0]]);
+            await this.#nodeStore?.persistAttributes([attributeReports[0]]);
 
             listener?.(value, version);
         };
 
-        this.registerSubscriptionListener(subscriptionId, subscriptionListener);
-        if (updateTimeoutHandler !== undefined) {
-            this.registerSubscriptionUpdateTimer(
+        await this.#registerSubscription(
+            {
+                id: subscriptionId,
                 maximumPeerResponseTime,
-                subscriptionId,
-                maxInterval,
-                updateTimeoutHandler,
-            );
-        }
-        await subscriptionListener(report);
+                maxIntervalS: maxInterval,
+                onData: subscriptionListener,
+                onTimeout: updateTimeoutHandler,
+            },
+            report,
+        );
+    }
+
+    async #registerSubscription(subscription: RegisteredSubscription, initialReport: DataReport) {
+        this.#ownSubscriptionIds.add(subscription.id);
+        this.#subscriptionClient.add(subscription);
+        await subscription.onData(initialReport);
     }
 
     async subscribeEvent<T, E extends Event<T, any>>(options: {
@@ -736,30 +723,30 @@ export class InteractionClient {
                 return;
             }
 
-            const data = normalizeAndDecodeReadEventReport(dataReport.eventReports);
+            const { eventReports } = DecodedDataReport(dataReport);
 
-            if (data.length === 0) {
+            if (eventReports.length === 0) {
                 throw new MatterFlowError("Received empty subscription result value.");
             }
-            if (data.length > 1) {
+            if (eventReports.length > 1) {
                 throw new UnexpectedDataError("Unexpected response with more then one attribute.");
             }
-            const { events } = data[0];
+            const { events } = eventReports[0];
             if (events === undefined)
                 throw new MatterFlowError("Subscription result reporting undefined value not specified.");
 
             events.forEach(event => listener?.(event));
         };
-        this.registerSubscriptionListener(subscriptionId, subscriptionListener);
-        if (updateTimeoutHandler !== undefined) {
-            this.registerSubscriptionUpdateTimer(
+        await this.#registerSubscription(
+            {
+                id: subscriptionId,
                 maximumPeerResponseTime,
-                subscriptionId,
-                maxInterval,
-                updateTimeoutHandler,
-            );
-        }
-        subscriptionListener(report);
+                maxIntervalS: maxInterval,
+                onData: subscriptionListener,
+                onTimeout: updateTimeoutHandler,
+            },
+            report,
+        );
     }
 
     async subscribeAllAttributesAndEvents(options: {
@@ -957,39 +944,21 @@ export class InteractionClient {
                 }
             }
         };
-        this.registerSubscriptionListener(subscriptionId, async dataReport => {
-            await subscriptionListener({
-                ...dataReport,
-                attributeReports:
-                    dataReport.attributeReports !== undefined
-                        ? normalizeAndDecodeReadAttributeReport(dataReport.attributeReports)
-                        : undefined,
-                eventReports:
-                    dataReport.eventReports !== undefined
-                        ? normalizeAndDecodeReadEventReport(dataReport.eventReports)
-                        : undefined,
-            });
-        });
 
-        if (updateTimeoutHandler !== undefined) {
-            this.registerSubscriptionUpdateTimer(
+        const seedReport = DecodedDataReport(report);
+
+        await this.#registerSubscription(
+            {
+                id: subscriptionId,
                 maximumPeerResponseTime,
-                subscriptionId,
-                maxInterval,
-                updateTimeoutHandler,
-            );
-        }
+                maxIntervalS: maxInterval,
 
-        const seedReport = {
-            attributeReports:
-                report.attributeReports !== undefined
-                    ? normalizeAndDecodeReadAttributeReport(report.attributeReports)
-                    : undefined,
-            eventReports:
-                report.eventReports !== undefined ? normalizeAndDecodeReadEventReport(report.eventReports) : undefined,
-            subscriptionId,
-        };
-        await subscriptionListener(seedReport);
+                onData: dataReport => subscriptionListener(DecodedDataReport(dataReport)),
+
+                onTimeout: updateTimeoutHandler,
+            },
+            seedReport,
+        );
 
         if (dataVersionFilters !== undefined && dataVersionFilters.length > 0 && enrichCachedAttributeData) {
             this.#enrichCachedAttributeData(seedReport.attributeReports ?? [], dataVersionFilters);
@@ -1164,7 +1133,7 @@ export class InteractionClient {
         invoke: (messenger: InteractionClientMessenger) => Promise<T>,
         executeQueued = false,
     ): Promise<T> {
-        const messenger = await InteractionClientMessenger.create(this.exchangeProvider);
+        const messenger = await InteractionClientMessenger.create(this.#exchangeProvider);
         let result: T;
         try {
             if (executeQueued) {
@@ -1181,27 +1150,6 @@ export class InteractionClient {
         return result;
     }
 
-    private registerSubscriptionUpdateTimer(
-        maximumPeerResponseTime: number,
-        subscriptionId: number,
-        maxIntervalS: number,
-        updateTimeoutHandler: Timer.Callback,
-    ) {
-        if (!this.#ownSubscriptionIds.has(subscriptionId)) {
-            throw new MatterFlowError(
-                `Cannot register update timer for subscription ${subscriptionId} because it is not owned by this client.`,
-            );
-        }
-        const maxIntervalMs = maxIntervalS * 1000 + maximumPeerResponseTime;
-
-        const timer = Time.getTimer("Subscription timeout", maxIntervalMs, () => {
-            logger.info(`Subscription ${subscriptionId} timed out after ${maxIntervalMs}ms ...`);
-            this.removeSubscription(subscriptionId);
-            updateTimeoutHandler();
-        }).start();
-        this.#subscriptionClient.registerSubscriptionUpdateTimer(subscriptionId, timer);
-    }
-
     removeAllSubscriptions() {
         for (const subscriptionId of this.#ownSubscriptionIds) {
             this.removeSubscription(subscriptionId);
@@ -1213,11 +1161,11 @@ export class InteractionClient {
     }
 
     get session() {
-        return this.exchangeProvider.session;
+        return this.#exchangeProvider.session;
     }
 
     get channelType() {
-        return this.exchangeProvider.channelType;
+        return this.#exchangeProvider.channelType;
     }
 
     /** Enrich cached data to get complete responses when data version filters were used. */

package/src/interaction/InteractionMessenger.ts

@@ -18,11 +18,9 @@ import {
     StatusCode,
     StatusResponseError,
     TlvAny,
-    TlvAttributeReport,
     TlvDataReport,
     TlvDataReportForSend,
     TlvDataVersionFilter,
-    TlvEventReport,
     TlvInvokeRequest,
     TlvInvokeResponse,
     TlvReadRequest,
@@ -693,15 +691,10 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         return message;
     }
 
-    // TODO: Adjust to use callbacks or events to push put received data to allow parallel processing
-    async readDataReports(expectedSubscriptionIds?: number[]): Promise<DataReport> {
-        let subscriptionId: number | undefined;
-        const attributeValues: TypeFromSchema<typeof TlvAttributeReport>[] = [];
-        const eventValues: TypeFromSchema<typeof TlvEventReport>[] = [];
+    async readAggregateDataReport(expectedSubscriptionIds?: number[]): Promise<DataReport> {
+        let result: DataReport | undefined;
 
-        while (true) {
-            const dataReportMessage = await this.waitFor("DataReport", MessageType.ReportData);
-            const report = TlvDataReport.decode(dataReportMessage.payload);
+        for await (const report of this.readDataReports()) {
             if (expectedSubscriptionIds !== undefined) {
                 if (report.subscriptionId === undefined || !expectedSubscriptionIds.includes(report.subscriptionId)) {
                     await this.sendStatus(StatusCode.InvalidSubscription, {
@@ -718,56 +711,82 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
                 }
             }
 
-            if (subscriptionId === undefined && report.subscriptionId !== undefined) {
-                subscriptionId = report.subscriptionId;
-            } else if (
-                (subscriptionId !== undefined || report.subscriptionId !== undefined) &&
-                report.subscriptionId !== subscriptionId
-            ) {
+            if (result?.subscriptionId !== undefined && report.subscriptionId !== result.subscriptionId) {
                 throw new UnexpectedDataError(`Invalid subscription ID ${report.subscriptionId} received`);
             }
 
-            const logContext = {
-                subId: report.subscriptionId,
-                dataReportFlags: Diagnostic.asFlags({
-                    empty: !report.attributeReports?.length && !report.eventReports?.length,
-                    suppressResponse: report.suppressResponse,
-                    moreChunkedMessages: report.moreChunkedMessages,
-                }),
-                attr: report.attributeReports?.length,
-                ev: report.eventReports?.length,
-            };
-
-            if (Array.isArray(report.attributeReports) && report.attributeReports.length > 0) {
-                attributeValues.push(...report.attributeReports);
-            }
-            if (Array.isArray(report.eventReports) && report.eventReports.length > 0) {
-                eventValues.push(...report.eventReports);
+            if (!result) {
+                result = report;
+            } else {
+                if (Array.isArray(report.attributeReports)) {
+                    if (!result.attributeReports) {
+                        result.attributeReports = report.attributeReports;
+                    } else {
+                        result.attributeReports.push(...report.attributeReports);
+                    }
+                }
+                if (Array.isArray(report.eventReports)) {
+                    if (!result.eventReports) {
+                        result.eventReports = report.eventReports;
+                    } else {
+                        result.eventReports.push(...report.eventReports);
+                    }
+                }
             }
+        }
+
+        if (result === undefined) {
+            // readDataReports should have thrown
+            throw new InternalError("No data reports loaded during read");
+        }
+
+        return result;
+    }
+
+    /**
+     * Read data reports as they come in on the wire.
+     *
+     * Data reports payloads are decoded but list attributes may be split across messages; these will require reassembly.
+     */
+    async *readDataReports() {
+        while (true) {
+            const dataReportMessage = await this.waitFor("DataReport", MessageType.ReportData);
+            const report = TlvDataReport.decode(dataReportMessage.payload);
+
+            yield report;
 
             if (report.moreChunkedMessages) {
                 await this.sendStatus(StatusCode.Success, {
                     multipleMessageInteraction: true,
-                    logContext,
+                    logContext: this.#logContextOf(report),
                 });
             } else if (!report.suppressResponse) {
-                // We received the last message and need to send a final Success, but we do not need to wait for it and
+                // We received the last message and need to send a final success, but we do not need to wait for it and
                 // also don't care if it fails
                 this.sendStatus(StatusCode.Success, {
                     multipleMessageInteraction: true,
-                    logContext,
-                }).catch(error =>
-                    logger.info("Error while sending final Success after receiving all DataReport chunks", error),
-                );
+                    logContext: this.#logContextOf(report),
+                }).catch(error => logger.info("Error sending success after final data report chunk", error));
             }
 
             if (!report.moreChunkedMessages) {
-                report.attributeReports = attributeValues;
-                report.eventReports = eventValues;
-                return report;
+                break;
             }
         }
     }
+
+    #logContextOf(report: DataReport) {
+        return {
+            subId: report.subscriptionId,
+            dataReportFlags: Diagnostic.asFlags({
+                empty: !report.attributeReports?.length && !report.eventReports?.length,
+                suppressResponse: report.suppressResponse,
+                moreChunkedMessages: report.moreChunkedMessages,
+            }),
+            attr: report.attributeReports?.length,
+            ev: report.eventReports?.length,
+        };
+    }
 }
 
 export class InteractionClientMessenger extends IncomingInteractionClientMessenger {
@@ -793,6 +812,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
             return await this.exchange.send(messageType, payload, options);
         } catch (error) {
             if (
+                this.exchangeProvider.supportsReconnect &&
                 (error instanceof RetransmissionLimitReachedError || error instanceof ChannelNotConnectedError) &&
                 !options?.multipleMessageInteraction
             ) {
@@ -815,7 +835,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
     async sendReadRequest(readRequest: ReadRequest) {
         await this.send(MessageType.ReadRequest, this.#encodeReadingRequest(TlvReadRequest, readRequest));
 
-        return this.readDataReports();
+        return this.readAggregateDataReport();
     }
 
     #encodeReadingRequest<T extends TlvSchema<any>>(schema: T, request: TypeFromSchema<T>) {
@@ -876,7 +896,7 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         const request = this.#encodeReadingRequest(TlvSubscribeRequest, subscribeRequest);
         await this.send(MessageType.SubscribeRequest, request);
 
-        const report = await this.readDataReports();
+        const report = await this.readAggregateDataReport();
         const { subscriptionId } = report;
 
         if (subscriptionId === undefined) {