@project-chip/matter.js 0.9.2 → 0.9.4

package/src/protocol/interaction/SubscriptionHandler.ts

@@ -6,7 +6,7 @@
 
 import { MatterDevice } from "../../MatterDevice.js";
 import { AnyAttributeServer, FabricScopedAttributeServer } from "../../cluster/server/AttributeServer.js";
-import { EventServer } from "../../cluster/server/EventServer.js";
+import { AnyEventServer, FabricSensitiveEventServer } from "../../cluster/server/EventServer.js";
 import { InternalError } from "../../common/MatterError.js";
 import { tryCatch, tryCatchAsync } from "../../common/TryCatchHandler.js";
 import { EventNumber } from "../../datatype/EventNumber.js";
@@ -17,9 +17,11 @@ import { NetworkError } from "../../net/Network.js";
 import { SecureSession } from "../../session/SecureSession.js";
 import { Time, Timer } from "../../time/Time.js";
 import { TlvSchema, TypeFromSchema } from "../../tlv/TlvSchema.js";
+import { MaybePromise } from "../../util/Promises.js";
+import { isObject } from "../../util/Type.js";
 import { RetransmissionLimitReachedError } from "../MessageExchange.js";
 import { AttributeReportPayload, EventReportPayload } from "./AttributeDataEncoder.js";
-import { EventHandler, EventStorageData } from "./EventHandler.js";
+import { EventStorageData } from "./EventHandler.js";
 import { InteractionEndpointStructure } from "./InteractionEndpointStructure.js";
 import { InteractionServerMessenger } from "./InteractionMessenger.js";
 import {
@@ -48,6 +50,7 @@ const logger = Logger.get("SubscriptionHandler");
 
 interface AttributePathWithValueVersion<T> {
     path: TypeFromSchema<typeof TlvAttributePath>;
+    attribute: AnyAttributeServer<T>;
     schema: TlvSchema<T>;
     value: T;
     version: number;
@@ -55,11 +58,28 @@ interface AttributePathWithValueVersion<T> {
 
 interface EventPathWithEventData<T> {
     path: TypeFromSchema<typeof TlvEventPath>;
+    event: AnyEventServer<any, any>;
     schema: TlvSchema<T>;
-    event: EventStorageData<T>;
+    data: EventStorageData<T>;
 }
 
 export class SubscriptionHandler {
+    readonly subscriptionId: number;
+    private readonly session: SecureSession<any>;
+    private readonly endpointStructure: InteractionEndpointStructure;
+    private readonly attributeRequests?: TypeFromSchema<typeof TlvAttributePath>[];
+    private readonly dataVersionFilters?: TypeFromSchema<typeof TlvDataVersionFilter>[];
+    private readonly eventRequests?: TypeFromSchema<typeof TlvEventPath>[];
+    private readonly eventFilters?: TypeFromSchema<typeof TlvEventFilter>[];
+    private readonly isFabricFiltered: boolean;
+    private readonly cancelCallback: () => void;
+    private readonly readAttribute: (path: AttributePath, attribute: AnyAttributeServer<any>) => Promise<any>;
+    private readonly readEvent: (
+        path: EventPath,
+        event: AnyEventServer<any, any>,
+        eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
+    ) => Promise<EventStorageData<any>[]>;
+
     private lastUpdateTimeMs = 0;
     private updateTimer: Timer;
     private readonly sendDelayTimer: Timer;
@@ -75,7 +95,7 @@ export class SubscriptionHandler {
     private readonly eventListeners = new Map<
         string,
         {
-            event: EventServer<any, any>;
+            event: AnyEventServer<any, any>;
             listener?: (newEvent: EventStorageData<any>) => void;
         }
     >();
@@ -91,22 +111,54 @@ export class SubscriptionHandler {
     private sendingUpdateInProgress = false;
     private sendNextUpdateImmediately = false;
     private sendUpdateErrorCounter = 0;
+    private attributeUpdatePromises = new Set<PromiseLike<void>>();
+
+    constructor(options: {
+        subscriptionId: number;
+        session: SecureSession<any>;
+        endpointStructure: InteractionEndpointStructure;
+        attributeRequests?: TypeFromSchema<typeof TlvAttributePath>[];
+        dataVersionFilters?: TypeFromSchema<typeof TlvDataVersionFilter>[];
+        eventRequests?: TypeFromSchema<typeof TlvEventPath>[];
+        eventFilters?: TypeFromSchema<typeof TlvEventFilter>[];
+        isFabricFiltered: boolean;
+        minIntervalFloor: number;
+        maxIntervalCeiling: number;
+        cancelCallback: () => void;
+        subscriptionOptions: SubscriptionOptions.Configuration;
+        readAttribute: (path: AttributePath, attribute: AnyAttributeServer<any>) => Promise<any>;
+        readEvent: (
+            path: EventPath,
+            event: AnyEventServer<any, any>,
+            eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
+        ) => Promise<EventStorageData<any>[]>;
+    }) {
+        const {
+            subscriptionId,
+            session,
+            endpointStructure,
+            attributeRequests,
+            dataVersionFilters,
+            eventRequests,
+            eventFilters,
+            isFabricFiltered,
+            minIntervalFloor,
+            maxIntervalCeiling,
+            cancelCallback,
+            subscriptionOptions,
+        } = options;
+        this.subscriptionId = subscriptionId;
+        this.session = session;
+        this.endpointStructure = endpointStructure;
+        this.attributeRequests = attributeRequests;
+        this.dataVersionFilters = dataVersionFilters;
+        this.eventRequests = eventRequests;
+        this.eventFilters = eventFilters;
+        this.isFabricFiltered = isFabricFiltered;
+        this.cancelCallback = cancelCallback;
+        this.readAttribute = options.readAttribute;
+        this.readEvent = options.readEvent;
 
-    constructor(
-        readonly subscriptionId: number,
-        private readonly session: SecureSession<any>,
-        private readonly endpointStructure: InteractionEndpointStructure,
-        private readonly attributeRequests: TypeFromSchema<typeof TlvAttributePath>[] | undefined,
-        private readonly dataVersionFilters: TypeFromSchema<typeof TlvDataVersionFilter>[] | undefined,
-        private readonly eventRequests: TypeFromSchema<typeof TlvEventPath>[] | undefined,
-        private readonly eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
-        private readonly eventHandler: EventHandler,
-        private readonly isFabricFiltered: boolean,
-        minIntervalFloor: number,
-        maxIntervalCeiling: number,
-        private readonly cancelCallback: () => void,
-        subscriptionOptions: SubscriptionOptions.Configuration,
-    ) {
         this.server = this.session.context;
         this.fabric = this.session.associatedFabric;
         this.peerNodeId = this.session.peerNodeId;
@@ -229,6 +281,7 @@ export class SubscriptionHandler {
                     }
                     if (attribute.isSubscribable) {
                         // If subscribable register listener
+                        // TODO: Move to state change listeners from behaviors to remove the dangling promise here
                         const listener = (value: any, version: number) =>
                             this.attributeChangeListener(path, attribute.schema, version, value);
                         attribute.addValueChangeListener(listener);
@@ -349,16 +402,17 @@ export class SubscriptionHandler {
      * Newly added attributes are then treated ad "changed values" and will be sent as subscription data update to the
      * controller. The data of newly added events are not sent automatically.
      */
-    updateSubscription() {
+    async updateSubscription() {
         const { newAttributes } = this.registerNewAttributes();
 
         for (const { path, attribute } of newAttributes) {
-            const { version, value } = attribute.getWithVersion(this.session, true);
+            const { version, value } = await this.readAttribute(path, attribute);
 
             // We do not do any version filtering for attributes that are newly added to make sure controller gets
             // most current state
 
             this.outstandingAttributeUpdates.set(attributePathToId(path), {
+                attribute,
                 path,
                 schema: attribute.schema,
                 version,
@@ -368,18 +422,20 @@ export class SubscriptionHandler {
 
         const { newEvents } = this.registerNewEvents();
         newEvents
-            .flatMap(({ path, event: { schema } }): EventPathWithEventData<any>[] => {
+            .flatMap(({ path, event }): EventPathWithEventData<any>[] => {
                 // But we use eventFilters because we do not want to send all events to the controller
-                const matchingEvents = this.eventHandler.getEvents(path, this.eventFilters) ?? [];
-                return matchingEvents.map(event => ({
+                const { schema } = event;
+                const matchingEvents = event.get(this.session, this.isFabricFiltered, undefined, this.eventFilters);
+                return matchingEvents.map(data => ({
+                    event,
                     schema,
                     path,
-                    event,
+                    data,
                 }));
             })
             .sort((a, b) => {
-                const eventNumberA = a.event?.eventNumber ?? EventNumber(0);
-                const eventNumberB = b.event?.eventNumber ?? EventNumber(0);
+                const eventNumberA = a.data?.eventNumber ?? EventNumber(0);
+                const eventNumberB = b.data?.eventNumber ?? EventNumber(0);
                 if (eventNumberA > eventNumberB) {
                     return 1;
                 } else if (eventNumberA < eventNumberB) {
@@ -457,8 +513,25 @@ export class SubscriptionHandler {
             this.sendNextUpdateImmediately = true;
             return;
         }
-        const attributeUpdatesToSend = Array.from(this.outstandingAttributeUpdates.values());
+
+        // Get all outstanding updates, make sure the order is correct per endpoint and cluster
+        const attributeUpdatesToSend = new Array<AttributePathWithValueVersion<any>>();
+        const attributeUpdates: Record<string, AttributePathWithValueVersion<any>[]> = {};
+        Array.from(this.outstandingAttributeUpdates.values()).forEach(entry => {
+            const {
+                path: { nodeId, endpointId, clusterId },
+            } = entry;
+            const pathId = `${nodeId}-${endpointId}-${clusterId}`;
+            attributeUpdates[pathId] = attributeUpdates[pathId] ?? [];
+            attributeUpdates[pathId].push(entry);
+        });
         this.outstandingAttributeUpdates.clear();
+        Object.values(attributeUpdates).forEach(data =>
+            attributeUpdatesToSend.push(
+                ...data.sort(({ version: versionA }, { version: versionB }) => versionA - versionB),
+            ),
+        );
+
         const eventUpdatesToSend = Array.from(this.outstandingEventUpdates.values());
         this.outstandingEventUpdates.clear();
         this.lastUpdateTimeMs = Time.nowMs();
@@ -500,15 +573,7 @@ export class SubscriptionHandler {
         }
     }
 
-    async sendInitialReport(
-        messenger: InteractionServerMessenger,
-        readAttribute: (path: AttributePath, attribute: AnyAttributeServer<any>) => Promise<any>,
-        readEvent: (
-            path: EventPath,
-            event: EventServer<any, any>,
-            eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
-        ) => Promise<EventStorageData<any>[]>,
-    ) {
+    async sendInitialReport(messenger: InteractionServerMessenger) {
         this.updateTimer.stop();
 
         const { newAttributes, attributeErrors } = this.registerNewAttributes();
@@ -523,10 +588,11 @@ export class SubscriptionHandler {
             value: any;
             version: number;
             schema: TlvSchema<any>;
+            attribute: AnyAttributeServer<any>;
         }>();
         for (const { path, attribute } of newAttributes) {
             try {
-                const { value, version } = await readAttribute(path, attribute);
+                const { value, version } = await this.readAttribute(path, attribute);
                 if (value === undefined) continue;
 
                 const { nodeId, endpointId, clusterId } = path;
@@ -540,13 +606,14 @@ export class SubscriptionHandler {
                     continue;
                 }
 
-                attributes.push({ path, value, version, schema: attribute.schema });
+                attributes.push({ path, value, version, schema: attribute.schema, attribute });
             } catch (error) {
                 logger.error(`Error reading attribute ${this.endpointStructure.resolveAttributeName(path)}:`, error);
             }
         }
         const attributeReportsPayload: AttributeReportPayload[] = attributes.map(
-            ({ path, schema, value, version }) => ({
+            ({ path, schema, value, version, attribute }) => ({
+                hasFabricSensitiveData: attribute.hasFabricSensitiveData,
                 attributeData: {
                     path,
                     dataVersion: version,
@@ -555,7 +622,12 @@ export class SubscriptionHandler {
                 },
             }),
         );
-        attributeErrors.forEach(attributeStatus => attributeReportsPayload.push({ attributeStatus }));
+        attributeErrors.forEach(attributeStatus =>
+            attributeReportsPayload.push({
+                hasFabricSensitiveData: false,
+                attributeStatus,
+            }),
+        );
 
         const { newEvents, eventErrors } = this.registerNewEvents();
 
@@ -564,12 +636,13 @@ export class SubscriptionHandler {
         for (const { path, event } of newEvents) {
             const { schema } = event;
             try {
-                const matchingEvents = await readEvent(path, event, this.eventFilters);
+                const matchingEvents = await this.readEvent(path, event, this.eventFilters);
                 if (matchingEvents.length === 0) {
                     eventsFiltered = true;
                 } else {
                     matchingEvents.forEach(({ eventNumber, priority, epochTimestamp, data }) => {
                         eventReportsPayload.push({
+                            hasFabricSensitiveData: event.hasFabricSensitiveData,
                             eventData: {
                                 path,
                                 eventNumber,
@@ -609,48 +682,82 @@ export class SubscriptionHandler {
             );
         }
 
-        eventErrors.forEach(eventStatus => eventReportsPayload.push({ eventStatus }));
+        eventErrors.forEach(eventStatus =>
+            eventReportsPayload.push({
+                hasFabricSensitiveData: false,
+                eventStatus,
+            }),
+        );
 
         logger.debug(
             `Initialize Subscription with ${attributes.length} attributes and ${eventReportsPayload.length} events.`,
         );
         this.lastUpdateTimeMs = Time.nowMs();
 
-        await messenger.sendDataReport({
-            suppressResponse: false,
-            subscriptionId: this.subscriptionId,
-            interactionModelRevision: INTERACTION_MODEL_REVISION,
-            attributeReportsPayload, // TODO Return compressed response once https://github.com/project-chip/connectedhomeip/issues/29359 is solved
-            eventReportsPayload,
-        });
+        await messenger.sendDataReport(
+            {
+                suppressResponse: false,
+                subscriptionId: this.subscriptionId,
+                interactionModelRevision: INTERACTION_MODEL_REVISION,
+                attributeReportsPayload, // TODO Return compressed response once https://github.com/project-chip/connectedhomeip/issues/29359 is solved
+                eventReportsPayload,
+            },
+            this.isFabricFiltered,
+        );
     }
 
-    attributeChangeListener<T>(
-        path: TypeFromSchema<typeof TlvAttributePath>,
+    attributeChangeListener<T>(path: AttributePath, schema: TlvSchema<T>, version: number, value: T) {
+        const changeResult = this.attributeChangeHandler(path, schema, version, value);
+        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);
+        }
+    }
+
+    attributeChangeHandler<T>(
+        path: AttributePath,
         schema: TlvSchema<T>,
         version: number,
         value: T,
-    ) {
+    ): MaybePromise<void> {
         const attributeListenerData = this.attributeListeners.get(attributePathToId(path));
         if (attributeListenerData === undefined) return; // Ignore changes to attributes that are not subscribed to
 
         const { attribute } = attributeListenerData;
         if (attribute instanceof FabricScopedAttributeServer) {
             // We can not be sure what value we got for fabric filtered attributes (and from which fabric),
-            // so get it again for this relevant fabric
+            // so get it again for this relevant fabric. This also makes sure that fabric sensitive fields are filtered
             // TODO: Maybe add try/catch when we add ACL handling and ignore the update if we can not get the value?
-            value = attribute.get(this.session, this.isFabricFiltered);
+            return this.readAttribute(path, attribute).then(({ value }) => {
+                this.outstandingAttributeUpdates.set(attributePathToId(path), {
+                    attribute,
+                    path,
+                    schema,
+                    version,
+                    value,
+                });
+                this.prepareDataUpdate();
+            });
         }
-        this.outstandingAttributeUpdates.set(attributePathToId(path), { path, schema, version, value });
+        this.outstandingAttributeUpdates.set(attributePathToId(path), { attribute, path, schema, version, value });
         this.prepareDataUpdate();
     }
 
-    eventChangeListener<T>(
-        path: TypeFromSchema<typeof TlvEventPath>,
-        schema: TlvSchema<T>,
-        newEvent: EventStorageData<T>,
-    ) {
-        this.outstandingEventUpdates.add({ path, schema, event: newEvent });
+    eventChangeListener<T>(path: EventPath, schema: TlvSchema<T>, newEvent: EventStorageData<T>) {
+        const eventListenerData = this.eventListeners.get(eventPathToId(path));
+        if (eventListenerData === undefined) return; // Ignore changes to attributes that are not subscribed to
+
+        const { event } = eventListenerData;
+        if (event instanceof FabricSensitiveEventServer) {
+            const { data } = newEvent;
+            if (isObject(data) && "fabricIndex" in data && data.fabricIndex !== this.session.fabric?.fabricIndex) {
+                // Ignore events from different fabrics because events are kind of always fabric filtered
+                return;
+            }
+        }
+        this.outstandingEventUpdates.add({ event, path, schema, data: newEvent });
         if (path.isUrgent) {
             this.prepareDataUpdate();
         }
@@ -668,6 +775,11 @@ export class SubscriptionHandler {
 
     async cancel(flush = false, cancelledByPeer = false) {
         this.sendUpdatesActivated = false;
+        if (this.attributeUpdatePromises.size) {
+            const resolvers = [...this.attributeUpdatePromises.values()];
+            this.attributeUpdatePromises.clear();
+            await Promise.all(resolvers);
+        }
         this.updateTimer.stop();
         this.sendDelayTimer.stop();
         this.unregisterAttributeListeners(Array.from(this.attributeListeners.keys()));
@@ -705,38 +817,49 @@ export class SubscriptionHandler {
             await tryCatchAsync(
                 async () => {
                     if (attributes.length === 0 && events.length === 0) {
-                        await messenger.sendDataReport({
-                            suppressResponse: true, // suppressResponse ok for empty DataReports
-                            subscriptionId: this.subscriptionId,
-                            interactionModelRevision: INTERACTION_MODEL_REVISION,
-                        });
+                        await messenger.sendDataReport(
+                            {
+                                suppressResponse: true, // suppressResponse ok for empty DataReports
+                                subscriptionId: this.subscriptionId,
+                                interactionModelRevision: INTERACTION_MODEL_REVISION,
+                            },
+                            this.isFabricFiltered,
+                        );
                     } else {
-                        await messenger.sendDataReport({
-                            suppressResponse: false,
-                            subscriptionId: this.subscriptionId,
-                            interactionModelRevision: INTERACTION_MODEL_REVISION,
-                            // TODO Return compressed response once https://github.com/project-chip/connectedhomeip/issues/29359 is solved
-                            attributeReportsPayload: attributes.map(({ path, schema, value, version }) => ({
-                                attributeData: {
-                                    path,
-                                    dataVersion: version,
-                                    schema,
-                                    payload: value,
-                                },
-                            })),
-                            eventReportsPayload: events.map(
-                                ({ path, schema, event: { eventNumber, priority, epochTimestamp, data } }) => ({
-                                    eventData: {
-                                        path,
-                                        eventNumber,
-                                        priority,
-                                        epochTimestamp,
-                                        schema,
-                                        payload: data,
-                                    },
+                        await messenger.sendDataReport(
+                            {
+                                suppressResponse: false,
+                                subscriptionId: this.subscriptionId,
+                                interactionModelRevision: INTERACTION_MODEL_REVISION,
+                                // TODO Return compressed response once https://github.com/project-chip/connectedhomeip/issues/29359 is solved
+                                attributeReportsPayload: attributes.map(
+                                    ({ path, schema, value, version, attribute }) => ({
+                                        hasFabricSensitiveData: attribute.hasFabricSensitiveData,
+                                        attributeData: {
+                                            path,
+                                            dataVersion: version,
+                                            schema,
+                                            payload: value,
+                                        },
+                                    }),
+                                ),
+                                eventReportsPayload: events.map(({ path, schema, event, data }) => {
+                                    const { eventNumber, priority, epochTimestamp, data: payload } = data;
+                                    return {
+                                        hasFabricSensitiveData: event.hasFabricSensitiveData,
+                                        eventData: {
+                                            path,
+                                            eventNumber,
+                                            priority,
+                                            epochTimestamp,
+                                            schema,
+                                            payload,
+                                        },
+                                    };
                                 }),
-                            ),
-                        });
+                            },
+                            this.isFabricFiltered,
+                        );
                     }
                 },
                 StatusResponseError,

package/src/session/SecureSession.ts

@@ -290,7 +290,8 @@ export class SecureSession<T> extends Session<T> {
     }
 
     async clearSubscriptions(flushSubscriptions = false) {
-        for (const subscription of this.#subscriptions) {
+        const subscriptions = [...this.#subscriptions]; // get all values because subscriptions will remove themselves when cancelled
+        for (const subscription of subscriptions) {
             await subscription.cancel(flushSubscriptions);
         }
         this.#subscriptions.length = 0;

package/src/session/SessionManager.ts

@@ -8,6 +8,7 @@ import { MatterFlowError } from "../common/MatterError.js";
 import { Crypto } from "../crypto/Crypto.js";
 import { CaseAuthenticatedTag } from "../datatype/CaseAuthenticatedTag.js";
 import { FabricId } from "../datatype/FabricId.js";
+import { FabricIndex } from "../datatype/FabricIndex.js";
 import { NodeId } from "../datatype/NodeId.js";
 import { Fabric } from "../fabric/Fabric.js";
 import { Logger } from "../log/Logger.js";
@@ -343,6 +344,14 @@ export class SessionManager<ContextT> {
             }));
     }
 
+    async clearSubscriptionsForNode(fabricIndex: FabricIndex, nodeId: NodeId, flushSubscriptions?: boolean) {
+        for (const session of this.#sessions) {
+            if (session.fabric?.fabricIndex === fabricIndex && session.peerNodeId === nodeId) {
+                await session.clearSubscriptions(flushSubscriptions);
+            }
+        }
+    }
+
     async close() {
         await this.storeResumptionRecords();
         for (const session of this.#sessions) {

package/src/tlv/TlvArray.ts

@@ -10,7 +10,7 @@ import { ValidationError } from "../common/ValidationError.js";
 import { deepCopy } from "../util/DeepCopy.js";
 import { serialize } from "../util/String.js";
 import { TlvTag, TlvType, TlvTypeLength } from "./TlvCodec.js";
-import { TlvReader, TlvSchema, TlvStream, TlvWriter } from "./TlvSchema.js";
+import { TlvEncodingOptions, TlvReader, TlvSchema, TlvStream, TlvWriter } from "./TlvSchema.js";
 
 export type LengthConstraints = {
     minLength?: number;
@@ -38,9 +38,9 @@ export class ArraySchema<T> extends TlvSchema<T[]> {
         super();
     }
 
-    override encodeTlvInternal(writer: TlvWriter, value: T[], tag?: TlvTag, forWriteInteraction?: boolean): void {
+    override encodeTlvInternal(writer: TlvWriter, value: T[], tag?: TlvTag, options?: TlvEncodingOptions): void {
         writer.writeTag({ type: TlvType.Array }, tag);
-        value.forEach(element => this.elementSchema.encodeTlvInternal(writer, element, undefined, forWriteInteraction));
+        value.forEach(element => this.elementSchema.encodeTlvInternal(writer, element, undefined, options));
         writer.writeTag({ type: TlvType.EndOfContainer });
     }
 

package/src/tlv/TlvNullable.ts

@@ -6,7 +6,7 @@
 
 import { ArraySchema } from "./TlvArray.js";
 import { TlvTag, TlvType, TlvTypeLength } from "./TlvCodec.js";
-import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+import { TlvEncodingOptions, TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
 import { StringSchema } from "./TlvString.js";
 
 /**
@@ -19,11 +19,11 @@ export class NullableSchema<T> extends TlvSchema<T | null> {
         super();
     }
 
-    override encodeTlvInternal(writer: TlvWriter, value: T | null, tag?: TlvTag, forWriteInteraction?: boolean): void {
+    override encodeTlvInternal(writer: TlvWriter, value: T | null, tag?: TlvTag, options?: TlvEncodingOptions): void {
         if (value === null) {
             writer.writeTag({ type: TlvType.Null }, tag);
         } else {
-            this.schema.encodeTlvInternal(writer, value, tag, forWriteInteraction);
+            this.schema.encodeTlvInternal(writer, value, tag, options);
         }
     }