@matter/protocol 0.12.4-alpha.0-20250223-1e0341a1a → 0.12.4-alpha.0-20250224-46934b522

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(

package/src/interaction/Subscription.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger } from "#general";
+import { InternalError, Logger, Observable } from "#general";
 import { type SecureSession } from "#session/SecureSession.js";
 import { TlvAttributePath, TlvDataVersionFilter, TlvEventFilter, TlvEventPath, TypeFromSchema } from "#types";
 
@@ -29,15 +29,13 @@ export abstract class Subscription {
     #isClosed?: boolean;
     #isCanceledByPeer?: boolean;
     #criteria: SubscriptionCriteria;
+    #cancelled = Observable<[subscription: Subscription]>();
+    #maxIntervalMs?: number;
 
     constructor(session: SecureSession, id: SubscriptionId, criteria: SubscriptionCriteria) {
         this.#session = session;
         this.#id = id;
         this.#criteria = criteria;
-
-        // TODO Do not add to session but to node/peer
-        this.#session.subscriptions.add(this);
-        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 
     get id() {
@@ -60,6 +58,28 @@ export abstract class Subscription {
         return this.#session;
     }
 
+    get cancelled() {
+        return this.#cancelled;
+    }
+
+    get maxIntervalMs(): number {
+        if (this.#maxIntervalMs === undefined) {
+            throw new InternalError("Subscription MaxIntervalMs accessed before it was set");
+        }
+        return this.#maxIntervalMs;
+    }
+
+    set maxIntervalMs(value: number) {
+        if (this.#maxIntervalMs !== undefined) {
+            throw new InternalError("Subscription MaxIntervalMs set twice. This should never happen.");
+        }
+        this.#maxIntervalMs = value;
+    }
+
+    get maxInterval(): number {
+        return Math.ceil(this.maxIntervalMs / 1000);
+    }
+
     /**
      * Update session state.  This probably is meaningless except in a server context.
      */
@@ -77,7 +97,7 @@ export abstract class Subscription {
     }
 
     /** Close the subscription with the option to gracefully flush outstanding data. */
-    abstract close(graceful: boolean): Promise<void>;
+    abstract close(graceful: boolean, cancelledByPeer?: boolean): Promise<void>;
 
     /**
      * Destroy the subscription. Unsubscribe from all attributes and events and stop all timers.
@@ -86,5 +106,13 @@ export abstract class Subscription {
         this.#isClosed = true;
         this.#session.subscriptions.delete(this);
         logger.debug(`Removed subscription ${this.id} from ${this.#session.name}`);
+
+        this.#cancelled.emit(this);
+    }
+
+    protected activate() {
+        // TODO Do not add to session but to node/peer
+        this.#session.subscriptions.add(this);
+        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 }

package/src/interaction/SubscriptionClient.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MessageExchange } from "#protocol/MessageExchange.js";
+import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
+import { Environment, Environmental, Logger, MaybePromise, Time, Timer } from "@matter/general";
+import { INTERACTION_PROTOCOL_ID } from "@matter/types";
+import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+
+const logger = Logger.get("SubscriptionClient");
+
+export interface RegisteredSubscription {
+    id: number;
+    maximumPeerResponseTime: number;
+    maxIntervalS: number;
+    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onTimeout?: () => void;
+}
+
+/**
+ * A simple protocol handler that handles exchanges starting with data reports.
+ *
+ * Incoming data reports must match to a subscription registered with {@link add} or the exchange is invalid.
+ */
+export class SubscriptionClient implements ProtocolHandler {
+    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #timeouts = new Map<number, Timer>();
+
+    constructor() {}
+
+    static [Environmental.create](env: Environment) {
+        const client = new SubscriptionClient();
+        env.set(SubscriptionClient, client);
+        return client;
+    }
+
+    readonly id = INTERACTION_PROTOCOL_ID;
+
+    /**
+     * Register a subscription.
+     */
+    add(subscription: RegisteredSubscription) {
+        const { id, onData, onTimeout } = subscription;
+
+        this.#listeners.set(id, onData);
+        if (onTimeout) {
+            let timer = this.#timeouts.get(id);
+            if (timer !== undefined) {
+                timer.stop();
+                this.#timeouts.delete(id);
+            }
+
+            const maxIntervalMs = subscription.maxIntervalS * 1000 + subscription.maximumPeerResponseTime;
+
+            timer = Time.getTimer("Subscription timeout", maxIntervalMs, () => {
+                logger.info(`Subscription ${id} timed out after ${maxIntervalMs}ms`);
+                this.delete(id);
+                onTimeout();
+            }).start();
+
+            this.#timeouts.set(id, timer);
+        }
+    }
+
+    /**
+     * Unregister a subscription.
+     */
+    delete(id: number) {
+        this.#listeners.delete(id);
+        const timer = this.#timeouts.get(id);
+        if (timer !== undefined) {
+            timer.stop();
+            this.#timeouts.delete(id);
+        }
+    }
+
+    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.readAggregateDataReport([...this.#listeners.keys()]);
+        } finally {
+            messenger.close().catch(error => logger.info("Error closing client messenger", error));
+        }
+        const subscriptionId = dataReport.subscriptionId as number; // this is checked in the messenger already because we hand over allowed list
+
+        const listener = this.#listeners.get(subscriptionId);
+        const timer = this.#timeouts.get(subscriptionId);
+
+        if (timer !== undefined) {
+            timer.stop().start(); // Restart timer because we received data
+        }
+
+        await listener?.(dataReport);
+    }
+
+    async close() {
+        this.#listeners.clear();
+        this.#timeouts.forEach(timer => timer.stop());
+        this.#timeouts.clear();
+    }
+}

package/src/interaction/index.ts

@@ -14,3 +14,4 @@ export * from "./InteractionMessenger.js";
 export * from "./InteractionServer.js";
 export * from "./ServerSubscription.js";
 export * from "./Subscription.js";
+export * from "./SubscriptionClient.js";

package/src/peer/ControllerCommissioner.ts

@@ -27,11 +27,11 @@ import { ChannelStatusResponseError } from "#securechannel/index.js";
 import { PaseClient } from "#session/index.js";
 import { SessionManager } from "#session/SessionManager.js";
 import { DiscoveryCapabilitiesBitmap, NodeId, SECURE_CHANNEL_PROTOCOL_ID, TypeFromPartialBitSchema } from "#types";
-import { InteractionClient } from "../interaction/InteractionClient.js";
+import { InteractionClient, InteractionClientProvider } from "../interaction/InteractionClient.js";
 import { ExchangeManager, MessageChannel } from "../protocol/ExchangeManager.js";
 import { DedicatedChannelExchangeProvider } from "../protocol/ExchangeProvider.js";
 import { PeerAddress } from "./PeerAddress.js";
-import { NodeDiscoveryType, PeerSet } from "./PeerSet.js";
+import { NodeDiscoveryType } from "./PeerSet.js";
 
 const logger = Logger.get("PeerCommissioner");
 
@@ -108,7 +108,7 @@ export interface DiscoveryAndCommissioningOptions extends CommissioningOptions {
  * Interfaces {@link ControllerCommissioner} with other components.
  */
 export interface ControllerCommissionerContext {
-    peers: PeerSet;
+    clients: InteractionClientProvider;
     scanners: ScannerSet;
     netInterfaces: NetInterfaceSet;
     sessions: SessionManager;
@@ -130,7 +130,7 @@ export class ControllerCommissioner {
 
     static [Environmental.create](env: Environment) {
         const instance = new ControllerCommissioner({
-            peers: env.get(PeerSet),
+            clients: env.get(InteractionClientProvider),
             scanners: env.get(ScannerSet),
             netInterfaces: env.get(NetInterfaceSet),
             sessions: env.get(SessionManager),
@@ -385,6 +385,7 @@ export class ControllerCommissioner {
             // Use the created secure session to do the commissioning
             new InteractionClient(
                 new DedicatedChannelExchangeProvider(this.#context.exchanges, paseSecureMessageChannel),
+                this.#context.clients.peers.subscriptionClient,
                 address,
             ),
             this.#context.ca,
@@ -406,15 +407,14 @@ export class ControllerCommissioner {
                 }
 
                 // Look for the device broadcast over MDNS and do CASE pairing
-                return await this.#context.peers.connect(
-                    address,
-                    {
+                return await this.#context.clients.connect(address, {
+                    discoveryOptions: {
                         discoveryType: NodeDiscoveryType.TimedDiscovery,
                         timeoutSeconds: 120,
                         discoveryData,
                     },
-                    true,
-                ); // Wait maximum 120s to find the operational device for commissioning process
+                    allowUnknownPeer: true,
+                }); // Wait maximum 120s to find the operational device for commissioning process
             },
         );
 
@@ -422,7 +422,7 @@ export class ControllerCommissioner {
             await commissioningManager.executeCommissioning();
         } catch (error) {
             // We might have added data for an operational address that we need to cleanup
-            await this.#context.peers.delete(address);
+            await this.#context.clients.peers.delete(address);
             throw error;
         } finally {
             if (!paseSecureMessageChannel.closed) {

package/src/peer/InteractionQueue.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Environment, Environmental, PromiseQueue } from "@matter/general";
+
+const CONCURRENT_QUEUED_INTERACTIONS = 4;
+const INTERACTION_QUEUE_DELAY_MS = 100;
+
+export class InteractionQueue extends PromiseQueue {
+    constructor() {
+        super(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY_MS);
+    }
+
+    static [Environmental.create](env: Environment) {
+        const instance = new InteractionQueue();
+        env.set(InteractionQueue, instance);
+        return instance;
+    }
+}

package/src/peer/PeerAddress.ts

@@ -86,3 +86,17 @@ export class PeerAddressMap<T> extends Map<PeerAddress, T> {
         return super.get(PeerAddress(key));
     }
 }
+
+export class PeerAddressSet extends Set<PeerAddress> {
+    override add(value: PeerAddress) {
+        return super.add(PeerAddress(value));
+    }
+
+    override has(value: PeerAddress) {
+        return super.has(PeerAddress(value));
+    }
+
+    override delete(value: PeerAddress) {
+        return super.delete(PeerAddress(value));
+    }
+}

package/src/peer/PeerAddressStore.ts

@@ -18,7 +18,7 @@ export abstract class PeerAddressStore {
     abstract loadPeers(): MaybePromise<Iterable<OperationalPeer>>;
     abstract updatePeer(peer: OperationalPeer): MaybePromise<void>;
     abstract deletePeer(address: PeerAddress): MaybePromise<void>;
-    abstract createNodeStore(address: PeerAddress): Promise<PeerDataStore>;
+    abstract createNodeStore(address: PeerAddress): MaybePromise<PeerDataStore | undefined>;
 }
 
 export abstract class PeerDataStore {