@matter/protocol 0.12.4-alpha.0-20250224-e0964a795 → 0.12.4-alpha.0-20250224-46934b522

package/src/interaction/InteractionServer.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Crypto, Diagnostic, InternalError, Logger, MatterFlowError } from "#general";
+import { Crypto, Diagnostic, InternalError, Logger, MatterFlowError, Observable, ServerAddressIp } from "#general";
 import { AttributeModel, ClusterModel, CommandModel, GLOBAL_IDS, MatterModel, Specification } from "#model";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { SessionManager } from "#session/SessionManager.js";
@@ -67,6 +67,19 @@ import { ServerSubscriptionConfig } from "./SubscriptionOptions.js";
 
 const logger = Logger.get("InteractionServer");
 
+export interface PeerSubscription {
+    subscriptionId: number;
+    peerAddress: PeerAddress;
+    minIntervalFloorSeconds: number;
+    maxIntervalCeilingSeconds: number;
+    attributeRequests?: TypeFromSchema<typeof TlvAttributePath>[];
+    eventRequests?: TypeFromSchema<typeof TlvEventPath>[];
+    isFabricFiltered: boolean;
+    maxInterval: number;
+    sendInterval: number;
+    operationalAddress?: ServerAddressIp;
+}
+
 export interface CommandPath {
     nodeId?: NodeId;
     endpointId: EndpointNumber;
@@ -234,6 +247,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
     #clientHandler?: ProtocolHandler;
     readonly #subscriptionConfig: ServerSubscriptionConfig;
     readonly #maxPathsPerInvoke;
+    readonly #subscriptionEstablishmentStarted = Observable<[peerAddress: PeerAddress]>();
 
     constructor(context: InteractionContext) {
         this.#context = context;
@@ -254,6 +268,10 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         return this.#maxPathsPerInvoke;
     }
 
+    get subscriptionEstablishmentStarted() {
+        return this.#subscriptionEstablishmentStarted;
+    }
+
     async onNewExchange(exchange: MessageExchange, message: Message) {
         // Note - changes here must be copied to TransactionalInteractionServer as it does not call super() to avoid
         // the stack frame
@@ -975,7 +993,11 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
 
     async handleSubscribeRequest(
         exchange: MessageExchange,
-        {
+        request: SubscribeRequest,
+        messenger: InteractionServerMessenger,
+        message: Message,
+    ): Promise<void> {
+        const {
             minIntervalFloorSeconds,
             maxIntervalCeilingSeconds,
             attributeRequests,
@@ -985,10 +1007,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             keepSubscriptions,
             isFabricFiltered,
             interactionModelRevision,
-        }: SubscribeRequest,
-        messenger: InteractionServerMessenger,
-        message: Message,
-    ): Promise<void> {
+        } = request;
         logger.debug(
             `Received subscribe request from ${exchange.channel.name} (keepSubscriptions=${keepSubscriptions}, isFabricFiltered=${isFabricFiltered})`,
         );
@@ -1017,8 +1036,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
 
         if (!keepSubscriptions) {
             const clearedCount = await this.#context.sessions.clearSubscriptionsForNode(
-                fabric.fabricIndex,
-                session.peerNodeId,
+                fabric.addressOf(session.peerNodeId),
                 true,
             );
             if (clearedCount > 0) {
@@ -1084,6 +1102,71 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         if (this.#nextSubscriptionId === 0xffffffff) this.#nextSubscriptionId = 0;
         const subscriptionId = this.#nextSubscriptionId++;
 
+        this.#subscriptionEstablishmentStarted.emit(session.peerAddress);
+        let subscription: ServerSubscription;
+        try {
+            subscription = await this.#establishSubscription(
+                subscriptionId,
+                request,
+                messenger,
+                session,
+                exchange,
+                message,
+            );
+        } catch (error: any) {
+            logger.error(
+                `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports`,
+                error,
+            );
+            if (error instanceof StatusResponseError) {
+                logger.info(`Sending status response ${error.code} for interaction error: ${error.message}`);
+                await messenger.sendStatus(error.code, {
+                    logContext: {
+                        for: "I/SubscriptionSeed-Status",
+                    },
+                });
+            }
+            await messenger.close();
+            return; // Make sure to not bubble up the exception
+        }
+
+        const maxInterval = subscription.maxInterval;
+        // Then send the subscription response
+        await messenger.send(
+            MessageType.SubscribeResponse,
+            TlvSubscribeResponse.encode({
+                subscriptionId,
+                maxInterval,
+                interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+            }),
+            {
+                logContext: {
+                    subId: subscriptionId,
+                    maxInterval,
+                },
+            },
+        );
+
+        // When an error occurs while sending the response, the subscription is not yet active and will be cleaned up by GC
+        subscription.activate();
+    }
+
+    async #establishSubscription(
+        id: number,
+        {
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            attributeRequests,
+            dataVersionFilters,
+            eventRequests,
+            eventFilters,
+            isFabricFiltered,
+        }: SubscribeRequest,
+        messenger: InteractionServerMessenger,
+        session: SecureSession,
+        exchange: MessageExchange,
+        message: Message,
+    ) {
         const context: ServerSubscriptionContext = {
             session,
             structure: this.#endpointStructure,
@@ -1101,7 +1184,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         };
 
         const subscription = new ServerSubscription({
-            id: subscriptionId,
+            id,
             context,
             criteria: {
                 attributeRequests,
@@ -1110,56 +1193,86 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                 eventFilters,
                 isFabricFiltered,
             },
-            minIntervalFloor: minIntervalFloorSeconds,
-            maxIntervalCeiling: maxIntervalCeilingSeconds,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
             subscriptionOptions: this.#subscriptionConfig,
         });
 
         try {
             // Send initial data report to prime the subscription with initial data
             await subscription.sendInitialReport(messenger);
-        } catch (error: any) {
-            logger.error(
-                `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports`,
-                error,
-            );
+        } catch (error) {
             await subscription.close(); // Cleanup
-            if (error instanceof StatusResponseError) {
-                logger.info(`Sending status response ${error.code} for interaction error: ${error.message}`);
-                await messenger.sendStatus(error.code, {
-                    logContext: {
-                        for: "I/SubscriptionSeed-Status",
-                    },
-                });
-            }
-            await messenger.close();
-            return; // Make sure to not bubble up the exception
+            throw error;
         }
 
-        const maxInterval = subscription.maxInterval;
         logger.info(
-            `Successfully created subscription ${subscriptionId} for Session ${
+            `Successfully created subscription ${id} for Session ${
                 session.id
-            }. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${maxInterval} seconds (sendInterval = ${subscription.sendInterval} seconds)`,
+            }. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${subscription.maxInterval} seconds (sendInterval = ${subscription.sendInterval} seconds)`,
         );
-        // Then send the subscription response
-        await messenger.send(
-            MessageType.SubscribeResponse,
-            TlvSubscribeResponse.encode({
-                subscriptionId,
-                maxInterval,
-                interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
-            }),
-            {
-                logContext: {
-                    subId: subscriptionId,
-                    maxInterval,
-                },
-            },
+        return subscription;
+    }
+
+    async establishFormerSubscription(
+        {
+            subscriptionId,
+            attributeRequests,
+            eventRequests,
+            isFabricFiltered,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            maxInterval,
+            sendInterval,
+        }: PeerSubscription,
+        session: SecureSession,
+    ) {
+        const exchange = this.#context.initiateExchange(session.peerAddress, INTERACTION_PROTOCOL_ID);
+        const message = {} as Message;
+        logger.debug(
+            `Send DataReports to re-establish subscription ${subscriptionId} to `,
+            Diagnostic.dict({ isFabricFiltered, maxInterval, sendInterval }),
         );
+        const context: ServerSubscriptionContext = {
+            session,
+            structure: this.#endpointStructure,
 
-        // When an error occurs while sending the response, the subscription is not yet active and will be cleaned up by GC
-        subscription.activateSendingUpdates();
+            readAttribute: (path, attribute, offline) =>
+                this.readAttribute(path, attribute, exchange, isFabricFiltered, message, offline),
+
+            readEndpointAttributesForSubscription: attributes =>
+                this.readEndpointAttributesForSubscription(attributes, exchange, isFabricFiltered, message),
+
+            readEvent: (path, event, eventFilters) =>
+                this.readEvent(path, eventFilters, event, exchange, isFabricFiltered, message),
+
+            initiateExchange: (address: PeerAddress, protocolId) => this.#context.initiateExchange(address, protocolId),
+        };
+
+        const subscription = new ServerSubscription({
+            id: subscriptionId,
+            context,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            criteria: {
+                attributeRequests,
+                eventRequests,
+                isFabricFiltered,
+            },
+            subscriptionOptions: this.#subscriptionConfig,
+            useAsMaxInterval: maxInterval,
+            useAsSendInterval: sendInterval,
+        });
+
+        try {
+            // Send initial data report to prime the subscription with initial data
+            await subscription.sendInitialReport(new InteractionServerMessenger(exchange));
+            subscription.activate();
+        } catch (error) {
+            await subscription.close(); // Cleanup
+            throw error;
+        }
+        return subscription;
     }
 
     async handleInvokeRequest(

package/src/interaction/ServerSubscription.ts

@@ -175,41 +175,58 @@ export class ServerSubscription extends Subscription {
         }
     >();
     #sendUpdatesActivated = false;
-    readonly #maxIntervalMs: number;
     readonly #sendIntervalMs: number;
-    private readonly minIntervalFloorMs: number;
-    private readonly maxIntervalCeilingMs: number;
-    private readonly peerAddress: PeerAddress;
+    readonly #minIntervalFloorMs: number;
+    readonly #maxIntervalCeilingMs: number;
+    readonly #peerAddress: PeerAddress;
 
-    private sendNextUpdateImmediately = false;
-    private sendUpdateErrorCounter = 0;
-    private attributeUpdatePromises = new Set<PromiseLike<void>>();
-    private currentUpdatePromise?: Promise<void>;
+    #sendNextUpdateImmediately = false;
+    #sendUpdateErrorCounter = 0;
+    readonly #attributeUpdatePromises = new Set<PromiseLike<void>>();
+    #currentUpdatePromise?: Promise<void>;
 
     constructor(options: {
         id: number;
         context: ServerSubscriptionContext;
         criteria: SubscriptionCriteria;
-        minIntervalFloor: number;
-        maxIntervalCeiling: number;
+        minIntervalFloorSeconds: number;
+        maxIntervalCeilingSeconds: number;
         subscriptionOptions: ServerSubscriptionConfig;
+        useAsMaxInterval?: number;
+        useAsSendInterval?: number;
     }) {
-        const { id, context, criteria, minIntervalFloor, maxIntervalCeiling, subscriptionOptions } = options;
+        const {
+            id,
+            context,
+            criteria,
+            minIntervalFloorSeconds,
+            maxIntervalCeilingSeconds,
+            subscriptionOptions,
+            useAsMaxInterval,
+            useAsSendInterval,
+        } = options;
 
         super(context.session, id, criteria);
         this.#context = context;
         this.#structure = context.structure;
 
-        this.peerAddress = this.session.peerAddress;
-        this.minIntervalFloorMs = minIntervalFloor * 1000;
-        this.maxIntervalCeilingMs = maxIntervalCeiling * 1000;
-
-        const { maxInterval, sendInterval } = this.determineSendingIntervals(
-            subscriptionOptions.minIntervalSeconds * 1000,
-            subscriptionOptions.maxIntervalSeconds * 1000,
-            subscriptionOptions.randomizationWindowSeconds * 1000,
-        );
-        this.#maxIntervalMs = maxInterval;
+        this.#peerAddress = this.session.peerAddress;
+        this.#minIntervalFloorMs = minIntervalFloorSeconds * 1000;
+        this.#maxIntervalCeilingMs = maxIntervalCeilingSeconds * 1000;
+
+        let maxInterval: number;
+        let sendInterval: number;
+        if (useAsMaxInterval !== undefined && useAsSendInterval !== undefined) {
+            maxInterval = useAsMaxInterval * 1000;
+            sendInterval = useAsSendInterval * 1000;
+        } else {
+            ({ maxInterval, sendInterval } = this.#determineSendingIntervals(
+                subscriptionOptions.minIntervalSeconds * 1000,
+                subscriptionOptions.maxIntervalSeconds * 1000,
+                subscriptionOptions.randomizationWindowSeconds * 1000,
+            ));
+        }
+        this.maxIntervalMs = maxInterval;
         this.#sendIntervalMs = sendInterval;
 
         this.#updateTimer = Time.getTimer(`Subscription ${this.id} update`, this.#sendIntervalMs, () =>
@@ -217,7 +234,7 @@ export class ServerSubscription extends Subscription {
         ); // will be started later
     }
 
-    private determineSendingIntervals(
+    #determineSendingIntervals(
         subscriptionMinIntervalMs: number,
         subscriptionMaxIntervalMs: number,
         subscriptionRandomizationWindowMs: number,
@@ -230,7 +247,7 @@ export class ServerSubscription extends Subscription {
         const maxInterval = Math.min(
             Math.max(
                 subscriptionMinIntervalMs,
-                Math.max(this.minIntervalFloorMs, Math.min(subscriptionMaxIntervalMs, this.maxIntervalCeilingMs)),
+                Math.max(this.#minIntervalFloorMs, Math.min(subscriptionMaxIntervalMs, this.#maxIntervalCeilingMs)),
             ) + Math.floor(subscriptionRandomizationWindowMs * Math.random()),
             MAX_INTERVAL_PUBLISHER_LIMIT_S * 1000,
         );
@@ -239,7 +256,7 @@ export class ServerSubscription extends Subscription {
             // But if we have no chance of at least one full resubmission process we do like chip-tool.
             // One full resubmission process takes 33-45 seconds. So 60s means we reach at least first 2 retries of a
             // second subscription report after first failed.
-            sendInterval = Math.max(this.minIntervalFloorMs, Math.floor(maxInterval * 0.8));
+            sendInterval = Math.max(this.#minIntervalFloorMs, Math.floor(maxInterval * 0.8));
         }
         if (sendInterval < subscriptionMinIntervalMs) {
             // But not faster than once every 2s
@@ -251,7 +268,7 @@ export class ServerSubscription extends Subscription {
         return { maxInterval, sendInterval };
     }
 
-    private registerNewAttributes() {
+    #registerNewAttributes() {
         const newAttributes = new Array<AttributeWithPath>();
         const attributeErrors = new Array<TypeFromSchema<typeof TlvAttributeStatus>>();
         const formerAttributes = new Set<string>(this.#attributeListeners.keys());
@@ -426,7 +443,7 @@ export class ServerSubscription extends Subscription {
      * controller. The data of newly added events are not sent automatically.
      */
     async updateSubscription() {
-        const { newAttributes } = this.registerNewAttributes();
+        const { newAttributes } = this.#registerNewAttributes();
 
         for (const { path, attribute } of newAttributes) {
             const { version, value } = this.#context.readAttribute(path, attribute);
@@ -485,15 +502,21 @@ export class ServerSubscription extends Subscription {
         this.#prepareDataUpdate();
     }
 
-    get maxInterval(): number {
-        return Math.ceil(this.#maxIntervalMs / 1000);
-    }
-
     get sendInterval(): number {
         return Math.ceil(this.#sendIntervalMs / 1000);
     }
 
-    activateSendingUpdates() {
+    get minIntervalFloorSeconds(): number {
+        return Math.ceil(this.#minIntervalFloorMs / 1000);
+    }
+
+    get maxIntervalCeilingSeconds(): number {
+        return Math.ceil(this.#maxIntervalCeilingMs / 1000);
+    }
+
+    override activate() {
+        super.activate();
+
         // We do not need these data anymore, so we can free some memory
         if (this.criteria.eventFilters !== undefined) this.criteria.eventFilters.length = 0;
         if (this.criteria.dataVersionFilters !== undefined) this.criteria.dataVersionFilters.length = 0;
@@ -533,11 +556,11 @@ export class ServerSubscription extends Subscription {
         this.#updateTimer.stop();
         const now = Time.nowMs();
         const timeSinceLastUpdateMs = now - this.#lastUpdateTimeMs;
-        if (timeSinceLastUpdateMs < this.minIntervalFloorMs) {
+        if (timeSinceLastUpdateMs < this.#minIntervalFloorMs) {
             // Respect minimum delay time between updates
             this.#updateTimer = Time.getTimer(
                 "Subscription update",
-                this.minIntervalFloorMs - timeSinceLastUpdateMs,
+                this.#minIntervalFloorMs - timeSinceLastUpdateMs,
                 () => this.#prepareDataUpdate(),
             ).start();
             return;
@@ -550,14 +573,14 @@ export class ServerSubscription extends Subscription {
     }
 
     #triggerSendUpdate() {
-        if (this.currentUpdatePromise !== undefined) {
+        if (this.#currentUpdatePromise !== undefined) {
             logger.debug("Sending update already in progress, delaying update ...");
-            this.sendNextUpdateImmediately = true;
+            this.#sendNextUpdateImmediately = true;
             return;
         }
-        this.currentUpdatePromise = this.#sendUpdate()
+        this.#currentUpdatePromise = this.#sendUpdate()
             .catch(error => logger.warn("Sending subscription update failed:", error))
-            .finally(() => (this.currentUpdatePromise = undefined));
+            .finally(() => (this.#currentUpdatePromise = undefined));
     }
 
     /**
@@ -593,20 +616,20 @@ export class ServerSubscription extends Subscription {
         this.#lastUpdateTimeMs = Time.nowMs();
 
         try {
-            await this.sendUpdateMessage(attributeUpdatesToSend, eventUpdatesToSend);
-            this.sendUpdateErrorCounter = 0;
+            await this.#sendUpdateMessage(attributeUpdatesToSend, eventUpdatesToSend);
+            this.#sendUpdateErrorCounter = 0;
         } catch (error) {
             if (this.isClosed) {
                 // No need to care about resubmissions when the server is closing
                 return;
             }
 
-            this.sendUpdateErrorCounter++;
+            this.#sendUpdateErrorCounter++;
             logger.info(
-                `Error sending subscription update message (error count=${this.sendUpdateErrorCounter}):`,
+                `Error sending subscription update message (error count=${this.#sendUpdateErrorCounter}):`,
                 (error instanceof MatterError && error.message) || error,
             );
-            if (this.sendUpdateErrorCounter <= 2) {
+            if (this.#sendUpdateErrorCounter <= 2) {
                 // fill the data back in the queue to resend with next try
                 const newAttributeUpdatesToSend = Array.from(this.#outstandingAttributeUpdates.values());
                 this.#outstandingAttributeUpdates.clear();
@@ -622,13 +645,14 @@ export class ServerSubscription extends Subscription {
                 logger.info(
                     `Sending update failed 3 times in a row, canceling subscription ${this.id} and let controller subscribe again.`,
                 );
-                this.sendNextUpdateImmediately = false;
+                this.#sendNextUpdateImmediately = false;
                 if (
                     error instanceof NoResponseTimeoutError ||
                     error instanceof NetworkError ||
                     error instanceof NoChannelError
                 ) {
                     // Let's consider this subscription as dead and wait for a reconnect
+                    this.isCanceledByPeer = true; // We handle this case like  if the controller canceled the subscription
                     await this.destroy();
                     return;
                 } else {
@@ -637,9 +661,9 @@ export class ServerSubscription extends Subscription {
             }
         }
 
-        if (this.sendNextUpdateImmediately) {
+        if (this.#sendNextUpdateImmediately) {
             logger.debug("Sending delayed update immediately after last one was sent.");
-            this.sendNextUpdateImmediately = false;
+            this.#sendNextUpdateImmediately = false;
             await this.#sendUpdate(true); // Send but only if non-empty
         }
     }
@@ -799,7 +823,7 @@ export class ServerSubscription extends Subscription {
     async sendInitialReport(messenger: InteractionServerMessenger) {
         this.#updateTimer.stop();
 
-        const { newAttributes, attributeErrors } = this.registerNewAttributes();
+        const { newAttributes, attributeErrors } = this.#registerNewAttributes();
         const { newEvents, eventErrors } = this.#registerNewEvents();
         const { eventReportsPayload, eventsFiltered } = await this.#collectInitialEventReportPayloads(newEvents);
 
@@ -822,8 +846,8 @@ export class ServerSubscription extends Subscription {
         if (MaybePromise.is(changeResult)) {
             const resolver = Promise.resolve(changeResult)
                 .catch(error => logger.error(`Error handling attribute change:`, error))
-                .finally(() => this.attributeUpdatePromises.delete(resolver));
-            this.attributeUpdatePromises.add(resolver);
+                .finally(() => this.#attributeUpdatePromises.delete(resolver));
+            this.#attributeUpdatePromises.add(resolver);
         }
     }
 
@@ -877,15 +901,15 @@ export class ServerSubscription extends Subscription {
         }
     }
 
-    async flush() {
+    async #flush() {
         this.#sendDelayTimer.stop();
         if (this.#outstandingAttributeUpdates.size > 0 || this.#outstandingEventUpdates.size > 0) {
             logger.debug(
                 `Flushing subscription ${this.id} with ${this.#outstandingAttributeUpdates.size} attributes and ${this.#outstandingEventUpdates.size} events${this.isClosed ? " (for closing)" : ""}`,
             );
             this.#triggerSendUpdate();
-            if (this.currentUpdatePromise) {
-                await this.currentUpdatePromise;
+            if (this.#currentUpdatePromise) {
+                await this.#currentUpdatePromise;
             }
         }
     }
@@ -894,9 +918,9 @@ export class ServerSubscription extends Subscription {
         this.#sendUpdatesActivated = false;
         this.unregisterAttributeListeners(Array.from(this.#attributeListeners.keys()));
         this.unregisterEventListeners(Array.from(this.#eventListeners.keys()));
-        if (this.attributeUpdatePromises.size) {
-            const resolvers = [...this.attributeUpdatePromises.values()];
-            this.attributeUpdatePromises.clear();
+        if (this.#attributeUpdatePromises.size) {
+            const resolvers = [...this.#attributeUpdatePromises.values()];
+            this.#attributeUpdatePromises.clear();
             await MatterAggregateError.allSettled(resolvers, "Error receiving all outstanding attribute values").catch(
                 error => logger.error(error),
             );
@@ -909,16 +933,19 @@ export class ServerSubscription extends Subscription {
     /**
      * Closes the subscription and flushes all outstanding data updates if requested.
      */
-    override async close(graceful = false) {
+    override async close(graceful = false, cancelledByPeer = false) {
         if (this.isClosed) {
             return;
         }
+        if (cancelledByPeer) {
+            this.isCanceledByPeer = true;
+        }
         await this.destroy();
         if (graceful) {
-            await this.flush();
+            await this.#flush();
         }
-        if (this.currentUpdatePromise) {
-            await this.currentUpdatePromise;
+        if (this.#currentUpdatePromise) {
+            await this.#currentUpdatePromise;
         }
     }
 
@@ -954,11 +981,8 @@ export class ServerSubscription extends Subscription {
         }
     }
 
-    private async sendUpdateMessage(
-        attributes: AttributePathWithValueVersion<any>[],
-        events: EventPathWithEventData<any>[],
-    ) {
-        const exchange = this.#context.initiateExchange(this.peerAddress, INTERACTION_PROTOCOL_ID);
+    async #sendUpdateMessage(attributes: AttributePathWithValueVersion<any>[], events: EventPathWithEventData<any>[]) {
+        const exchange = this.#context.initiateExchange(this.#peerAddress, INTERACTION_PROTOCOL_ID);
         if (exchange === undefined) return;
         if (attributes.length) {
             logger.debug(