@enbox/dwn-sdk-js 0.3.9 → 0.4.1

package/src/dwn.ts

@@ -1,37 +1,70 @@
+import type { CoreProtocol } from './core/core-protocol.js';
 import type { DataStore } from './types/data-store.js';
 import type { DidResolver } from '@enbox/dids';
 import type { MessageStore } from './types/message-store.js';
 import type { ResumableTaskStore } from './types/resumable-task-store.js';
-import type { StateIndex } from './types/state-index.js';
 import type { TenantGate } from './core/tenant-gate.js';
 import type { UnionMessageReply } from './core/message-reply.js';
+import type { ValidationStateReader } from './types/validation-state-reader.js';
 import type { EventLog, SubscriptionListener } from './types/subscriptions.js';
 import type { GenericMessage, GenericMessageReply } from './types/message-types.js';
 import type { HandlerDependencies, MethodHandler } from './types/method-handler.js';
-import type { MessagesReadMessage, MessagesReadReply, MessagesSubscribeMessage, MessagesSubscribeMessageOptions, MessagesSubscribeReply, MessagesSyncMessage, MessagesSyncReply } from './types/messages-types.js';
-import type { ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply } from './types/protocols-types.js';
-import type { RecordsCountMessage, RecordsCountReply, RecordsDeleteMessage, RecordsQueryMessage, RecordsQueryReply, RecordsReadMessage, RecordsReadReply, RecordsSubscribeMessage, RecordsSubscribeMessageOptions, RecordsSubscribeReply, RecordsWriteMessage, RecordsWriteMessageOptions } from './types/records-types.js';
+import type {
+  MessagesQueryMessage,
+  MessagesQueryReply,
+  MessagesReadMessage,
+  MessagesReadReply,
+  MessagesSubscribeMessage,
+  MessagesSubscribeMessageOptions,
+  MessagesSubscribeReply,
+} from './types/messages-types.js';
+import type { ProtocolDefinition, ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply } from './types/protocols-types.js';
+import type {
+  RecordsCountMessage,
+  RecordsCountReply,
+  RecordsDeleteMessage,
+  RecordsQueryMessage,
+  RecordsQueryReply,
+  RecordsQueryReplyEntry,
+  RecordsReadMessage,
+  RecordsReadReply,
+  RecordsSubscribeMessage,
+  RecordsSubscribeMessageOptions,
+  RecordsSubscribeReply,
+  RecordsWriteMessage,
+  RecordsWriteMessageOptions
+} from './types/records-types.js';
+import type { ReplicationApplyOptions, ReplicationApplyResult } from './core/replication-apply.js';
 
 import { AllowAllTenantGate } from './core/tenant-gate.js';
+import { Cid } from './utils/cid.js';
 import { CoreProtocolRegistry } from './core/core-protocol.js';
+import { DataStream } from './utils/data-stream.js';
+import { DwnConstant } from './core/dwn-constant.js';
 import { Message } from './core/message.js';
 import { messageReplyFromError } from './core/message-reply.js';
+import { MessagesQueryHandler } from './handlers/messages-query.js';
 import { MessagesReadHandler } from './handlers/messages-read.js';
 import { MessagesSubscribeHandler } from './handlers/messages-subscribe.js';
-import { MessagesSyncHandler } from './handlers/messages-sync.js';
 import { PermissionsProtocol } from './protocols/permissions.js';
 import { ProtocolsConfigureHandler } from './handlers/protocols-configure.js';
 import { ProtocolsQueryHandler } from './handlers/protocols-query.js';
+import { Records } from './utils/records.js';
 import { RecordsCountHandler } from './handlers/records-count.js';
+import { RecordsDelete } from './interfaces/records-delete.js';
 import { RecordsDeleteHandler } from './handlers/records-delete.js';
 import { RecordsQueryHandler } from './handlers/records-query.js';
 import { RecordsReadHandler } from './handlers/records-read.js';
 import { RecordsSubscribeHandler } from './handlers/records-subscribe.js';
+import { RecordsWrite } from './interfaces/records-write.js';
 import { RecordsWriteHandler } from './handlers/records-write.js';
 import { ResumableTaskManager } from './core/resumable-task-manager.js';
 import { StorageController } from './store/storage-controller.js';
+import { StoreValidationStateReader } from './core/validation-state-reader.js';
 import { DidDht, DidJwk, DidKey, DidResolverCacheMemory, DidWeb, UniversalResolver } from '@enbox/dids';
+import { DwnError, DwnErrorCode } from './core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from './enums/dwn-interface-method.js';
+import { missingAncestorRecordIdsFromReply, replicationApplyResultFromReply } from './core/replication-apply.js';
 
 /**
  * Structural shape for `DidResolver` implementations that expose
@@ -45,18 +78,29 @@ type LifecycleResolver = {
   close: () => Promise<void>;
 };
 
+type ReplicationApplyProtocolDefinitionLookup = {
+  protocol: string;
+  messageTimestamp?: string;
+};
+
+type DwnStorage = {
+  dataStore: DataStore;
+  messageStore: MessageStore;
+  eventLog: EventLog | undefined;
+};
+
 export class Dwn {
   private readonly methodHandlers: { [key:string]: MethodHandler };
   private readonly didResolver: DidResolver;
   private readonly messageStore: MessageStore;
   private readonly dataStore: DataStore;
   private readonly resumableTaskStore: ResumableTaskStore;
-  private readonly stateIndex: StateIndex;
   private readonly tenantGate: TenantGate;
   private readonly eventLog?: EventLog;
   private readonly storageController: StorageController;
   private readonly resumableTaskManager: ResumableTaskManager;
   private readonly _coreProtocols: CoreProtocolRegistry;
+  private readonly validationStateReader: ValidationStateReader;
 
   /** Whether the DWN owns the resolver's lifecycle (i.e., created it via defaults). */
   private readonly ownsResolver: boolean;
@@ -68,41 +112,46 @@ export class Dwn {
     this.messageStore = config.messageStore;
     this.dataStore = config.dataStore;
     this.resumableTaskStore = config.resumableTaskStore;
-    this.stateIndex = config.stateIndex;
+
+    // Initialize the core protocol registry with built-in system protocols.
+    this._coreProtocols = new CoreProtocolRegistry();
+    this._coreProtocols.register(new PermissionsProtocol());
+
+    // The single narrow surface through which validation logic reads state (replay-basis closure).
+    const validationStateReader = new StoreValidationStateReader({
+      messageStore  : this.messageStore,
+      dataStore     : this.dataStore,
+      coreProtocols : this._coreProtocols,
+    });
+    this.validationStateReader = config.instrumentValidationStateReader?.(validationStateReader) ?? validationStateReader;
 
     this.eventLog = config.eventLog;
 
     this.storageController = new StorageController({
       messageStore : this.messageStore,
       dataStore    : this.dataStore,
-      stateIndex   : this.stateIndex,
-      eventLog     : this.eventLog
     });
     this.resumableTaskManager = new ResumableTaskManager(
       config.resumableTaskStore,
       this.storageController
     );
 
-    // Initialize the core protocol registry with built-in system protocols.
-    this._coreProtocols = new CoreProtocolRegistry();
-    this._coreProtocols.register(new PermissionsProtocol());
-
     // Build the shared dependency bag once; every handler receives the same object
     // and accesses only the dependencies it needs.
     const deps: HandlerDependencies = {
-      didResolver          : this.didResolver,
-      messageStore         : this.messageStore,
-      dataStore            : this.dataStore,
-      stateIndex           : this.stateIndex,
-      resumableTaskManager : this.resumableTaskManager,
-      coreProtocols        : this._coreProtocols,
-      eventLog             : this.eventLog,
+      didResolver           : this.didResolver,
+      messageStore          : this.messageStore,
+      validationStateReader : this.validationStateReader,
+      dataStore             : this.dataStore,
+      resumableTaskManager  : this.resumableTaskManager,
+      coreProtocols         : this._coreProtocols,
+      eventLog              : this.eventLog,
     };
 
     this.methodHandlers = {
       [DwnInterfaceName.Messages + DwnMethodName.Read]       : new MessagesReadHandler(deps),
+      [DwnInterfaceName.Messages + DwnMethodName.Query]      : new MessagesQueryHandler(deps),
       [DwnInterfaceName.Messages + DwnMethodName.Subscribe]  : new MessagesSubscribeHandler(deps),
-      [DwnInterfaceName.Messages + DwnMethodName.Sync]       : new MessagesSyncHandler(deps),
       [DwnInterfaceName.Protocols + DwnMethodName.Configure] : new ProtocolsConfigureHandler(deps),
       [DwnInterfaceName.Protocols + DwnMethodName.Query]     : new ProtocolsQueryHandler(deps),
       [DwnInterfaceName.Records + DwnMethodName.Count]       : new RecordsCountHandler(deps),
@@ -148,7 +197,6 @@ export class Dwn {
     await this.messageStore.open();
     await this.dataStore.open();
     await this.resumableTaskStore.open();
-    await this.stateIndex.open();
     await this.eventLog?.open();
 
     await this.resumableTaskManager.resumeTasksAndWaitForCompletion();
@@ -159,7 +207,6 @@ export class Dwn {
     await this.messageStore.close();
     await this.dataStore.close();
     await this.resumableTaskStore.close();
-    await this.stateIndex.close();
 
     // Close the resolver's cache if the DWN owns it.
     const lifecycleResolver = this.didResolver as Partial<LifecycleResolver>;
@@ -179,15 +226,14 @@ export class Dwn {
 
   /**
    * Returns the internal storage components for advanced operations that
-   * cannot be expressed through the standard `processMessage()` pipeline
-   * (e.g., owner-upgrade of externally authored encrypted records).
+   * cannot be expressed through the standard `processMessage()` pipeline.
    *
    * Callers are responsible for maintaining consistency across stores.
    */
-  public get storage(): { messageStore: MessageStore; stateIndex: StateIndex; eventLog: EventLog | undefined } {
+  public get storage(): DwnStorage {
     return {
+      dataStore    : this.dataStore,
       messageStore : this.messageStore,
-      stateIndex   : this.stateIndex,
       eventLog     : this.eventLog,
     };
   }
@@ -199,7 +245,7 @@ export class Dwn {
   public async processMessage(
     tenant: string, rawMessage: MessagesSubscribeMessage, options?: MessagesSubscribeMessageOptions): Promise<MessagesSubscribeReply>;
   public async processMessage(tenant: string, rawMessage: MessagesReadMessage): Promise<MessagesReadReply>;
-  public async processMessage(tenant: string, rawMessage: MessagesSyncMessage): Promise<MessagesSyncReply>;
+  public async processMessage(tenant: string, rawMessage: MessagesQueryMessage): Promise<MessagesQueryReply>;
   public async processMessage(tenant: string, rawMessage: ProtocolsConfigureMessage): Promise<GenericMessageReply>;
   public async processMessage(tenant: string, rawMessage: ProtocolsQueryMessage): Promise<ProtocolsQueryReply>;
   public async processMessage(tenant: string, rawMessage: RecordsCountMessage): Promise<RecordsCountReply>;
@@ -223,12 +269,347 @@ export class Dwn {
       tenant,
       message: rawMessage,
       dataStream,
-      subscriptionHandler
+      subscriptionHandler,
     });
 
     return methodHandlerReply;
   }
 
+  /**
+   * Applies a message obtained through replication and returns a structured
+   * outcome instead of an HTTP-like handler status. Normal authoring still
+   * uses `processMessage`; sync uses this entry point so missing local
+   * dependencies can be fetched and retried without treating the replicated
+   * message as permanently invalid.
+   */
+  public async applyReplicatedMessage(
+    tenant: string,
+    rawMessage: GenericMessage,
+    options: ReplicationApplyOptions = {},
+  ): Promise<ReplicationApplyResult> {
+    const tenantError = await this.validateTenant(tenant);
+    if (tenantError !== undefined) {
+      return { kind: 'Deferred', reason: 'tenant-inactive' };
+    }
+
+    const integrityError = await this.validateMessageIntegrity(rawMessage);
+    if (integrityError !== undefined) {
+      return { kind: 'Invalid', reason: integrityError.status.detail };
+    }
+
+    if (await this.replicatedMessageAlreadyStored(tenant, rawMessage)) {
+      return { kind: 'Duplicate' };
+    }
+
+    const reply = await this.processMessage(tenant, rawMessage, options);
+    const replicatedWriteBeatenByDeleteResult = await this.storeReplicatedWriteBeatenByDelete(tenant, rawMessage, reply, options);
+    if (replicatedWriteBeatenByDeleteResult !== undefined) {
+      return replicatedWriteBeatenByDeleteResult;
+    }
+
+    const protocolDefinition = await this.getReplicationApplyProtocolDefinition(tenant, rawMessage, reply);
+    const missingAncestorRecordIds = await this.getReplicationApplyMissingAncestors(tenant, rawMessage, reply);
+    return replicationApplyResultFromReply(rawMessage, reply, { protocolDefinition, missingAncestorRecordIds });
+  }
+
+  /**
+   * Computes the layer-batched missing-ancestor set for a replicated message that failed on a
+   * missing ancestor (immediate parent or record-chain construction), so the resulting
+   * `Incomplete` names every locally-absent ancestor at once. Returns `undefined`
+   * (single-ancestor emission) when the set cannot be computed.
+   */
+  private async getReplicationApplyMissingAncestors(
+    tenant: string,
+    message: GenericMessage,
+    reply: { status: { detail?: string } },
+  ): Promise<string[] | undefined> {
+    try {
+      return await missingAncestorRecordIdsFromReply(tenant, message, reply, this.validationStateReader);
+    } catch {
+      return undefined;
+    }
+  }
+
+  private async storeReplicatedWriteBeatenByDelete(
+    tenant: string,
+    message: GenericMessage,
+    reply: { status: { detail?: string } },
+    options: ReplicationApplyOptions,
+  ): Promise<ReplicationApplyResult | undefined> {
+    const detail = reply.status.detail ?? '';
+    if (!detail.startsWith(`${DwnErrorCode.RecordsWriteNotAllowedAfterDelete}:`) || !Records.isRecordsWrite(message)) {
+      return undefined;
+    }
+
+    const query = {
+      interface : DwnInterfaceName.Records,
+      recordId  : message.recordId,
+    };
+    const { messages: existingMessages } = await this.messageStore.query(tenant, [query]);
+    const initialWrite = await RecordsWrite.getInitialWrite(existingMessages);
+    const existingDelete = await Records.getNewestRecordsDelete(existingMessages);
+    if (existingDelete === undefined) {
+      return undefined;
+    }
+
+    const validationReply = await this.validateReplicatedWriteBeatenByDelete(tenant, message, existingMessages, options);
+    if (validationReply !== undefined) {
+      return replicationApplyResultFromReply(message, validationReply);
+    }
+
+    const recordsWrite = await RecordsWrite.parse(message);
+    const storedWriteMessage: RecordsWriteMessage & { encodedData?: string } = { ...message };
+    delete storedWriteMessage.encodedData;
+    const recordsWriteIndexes = await recordsWrite.constructIndexes(false);
+    await this.messageStore.put(tenant, storedWriteMessage, recordsWriteIndexes);
+
+    const recordsDelete = await RecordsDelete.parse(existingDelete);
+    const visibilitySourceWrite = await Records.getNewestRecordsWrite([...existingMessages, storedWriteMessage]) ?? initialWrite;
+    const recordsDeleteIndexes = recordsDelete.constructIndexes(initialWrite, visibilitySourceWrite);
+    const recordsDeleteCid = await Message.getCid(existingDelete);
+    await this.messageStore.updateIndexes(tenant, recordsDeleteCid, recordsDeleteIndexes);
+
+    return { kind: 'Superseded' };
+  }
+
+  private async validateReplicatedWriteBeatenByDelete(
+    tenant: string,
+    message: RecordsWriteMessage,
+    existingMessages: GenericMessage[],
+    options: ReplicationApplyOptions,
+  ): Promise<GenericMessageReply | undefined> {
+    try {
+      await this.validateReplicatedWriteBeatenByDeleteOrThrow(tenant, message, existingMessages, options);
+      return undefined;
+    } catch (error) {
+      const statusCode = error instanceof DwnError
+        ? this._coreProtocols.mapErrorToStatusCode(error.code) ?? 400
+        : 400;
+      return messageReplyFromError(error, statusCode);
+    }
+  }
+
+  private async validateReplicatedWriteBeatenByDeleteOrThrow(
+    tenant: string,
+    message: RecordsWriteMessage,
+    existingMessages: GenericMessage[],
+    options: ReplicationApplyOptions,
+  ): Promise<void> {
+    const coreProtocol = message.descriptor.protocol === undefined
+      ? undefined
+      : this._coreProtocols.get(message.descriptor.protocol);
+
+    if (coreProtocol?.preProcessWrite !== undefined) {
+      await coreProtocol.preProcessWrite(tenant, message, this.validationStateReader);
+    }
+
+    if (options.dataStream !== undefined) {
+      await Dwn.validateReplicatedWriteBeatenByDeleteDataStream(message, options.dataStream, coreProtocol);
+      return;
+    }
+
+    if (await RecordsWrite.isInitialWrite(message)) {
+      return;
+    }
+
+    await this.validateReplicatedWriteBeatenByDeleteExistingData(tenant, message, existingMessages);
+  }
+
+  private static async validateReplicatedWriteBeatenByDeleteDataStream(
+    message: RecordsWriteMessage,
+    dataStream: ReadableStream<Uint8Array>,
+    coreProtocol: CoreProtocol | undefined,
+  ): Promise<void> {
+    if (message.descriptor.dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
+      const dataBytes = await DataStream.toBytes(dataStream);
+      const dataCid = await Cid.computeDagPbCidFromBytes(dataBytes);
+      RecordsWrite.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataBytes.length);
+
+      if (coreProtocol?.validateRecord !== undefined) {
+        coreProtocol.validateRecord(message, dataBytes);
+      }
+
+      return;
+    }
+
+    const [dataCidStream, dataSizeStream] = DataStream.duplicateDataStream(dataStream, 2);
+    const [dataCid, dataSize] = await Promise.all([
+      Cid.computeDagPbCidFromStream(dataCidStream),
+      Dwn.getDataStreamByteLength(dataSizeStream),
+    ]);
+    RecordsWrite.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataSize);
+  }
+
+  private async validateReplicatedWriteBeatenByDeleteExistingData(
+    tenant: string,
+    message: RecordsWriteMessage,
+    existingMessages: GenericMessage[],
+  ): Promise<void> {
+    const newestExistingWrite = await Records.getNewestRecordsWrite(existingMessages);
+    if (newestExistingWrite === undefined) {
+      throw new DwnError(
+        DwnErrorCode.RecordsWriteGetInitialWriteNotFound,
+        `initial write is missing for record ${message.recordId}`
+      );
+    }
+
+    const { dataCid, dataSize } = message.descriptor;
+    RecordsWrite.validateDataIntegrity(dataCid, dataSize, newestExistingWrite.descriptor.dataCid, newestExistingWrite.descriptor.dataSize);
+
+    if (dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
+      const newestExistingWriteWithData = newestExistingWrite as RecordsQueryReplyEntry;
+      if (newestExistingWriteWithData.encodedData === undefined) {
+        throw new DwnError(
+          DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious,
+          `No dataStream was provided and unable to get data from previous message`
+        );
+      }
+
+      return;
+    }
+
+    const priorDataExists = await this.validationStateReader.hasStoredData(tenant, newestExistingWrite.recordId, dataCid);
+    if (!priorDataExists) {
+      throw new DwnError(
+        DwnErrorCode.RecordsWriteMissingDataInPrevious,
+        `No dataStream was provided and unable to get data from previous message`
+      );
+    }
+  }
+
+  private static async getDataStreamByteLength(dataStream: ReadableStream<Uint8Array>): Promise<number> {
+    let byteLength = 0;
+    for await (const chunk of DataStream.asAsyncIterable(dataStream)) {
+      byteLength += chunk.length;
+    }
+
+    return byteLength;
+  }
+
+  private async getReplicationApplyProtocolDefinition(
+    tenant: string,
+    message: GenericMessage,
+    reply: { status: { detail?: string } },
+  ): Promise<ProtocolDefinition | undefined> {
+    const detail = reply.status.detail ?? '';
+    if (!detail.startsWith(`${DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound}:`)) {
+      return undefined;
+    }
+
+    const lookup = Dwn.getReplicationApplyProtocolDefinitionLookup(message);
+    if (lookup === undefined) {
+      return undefined;
+    }
+
+    try {
+      return await this.validationStateReader.fetchProtocolDefinition(
+        tenant,
+        lookup.protocol,
+        lookup.messageTimestamp,
+      );
+    } catch {
+      return undefined;
+    }
+  }
+
+  private static getReplicationApplyProtocolDefinitionLookup(
+    message: GenericMessage,
+  ): ReplicationApplyProtocolDefinitionLookup | undefined {
+    if (Dwn.isRecordsWriteMessage(message)) {
+      return {
+        protocol         : message.descriptor.protocol,
+        messageTimestamp : message.descriptor.messageTimestamp,
+      };
+    }
+
+    const protocol = Dwn.getMessageProtocolForReplicationApply(message);
+    return protocol === undefined ? undefined : { protocol };
+  }
+
+  private static getMessageProtocolForReplicationApply(message: GenericMessage): string | undefined {
+    const descriptor = message.descriptor as { protocol?: unknown; filter?: { protocol?: unknown } };
+    if (typeof descriptor.protocol === 'string') {
+      return descriptor.protocol;
+    }
+    if (typeof descriptor.filter?.protocol === 'string') {
+      return descriptor.filter.protocol;
+    }
+  }
+
+  private static isRecordsWriteMessage(message: GenericMessage): message is RecordsWriteMessage {
+    return message.descriptor.interface === DwnInterfaceName.Records &&
+      message.descriptor.method === DwnMethodName.Write;
+  }
+
+  private async replicatedMessageAlreadyStored(
+    tenant: string,
+    message: GenericMessage,
+  ): Promise<boolean> {
+    const existingMessages = await this.getExistingMessagesForReplicationDedup(tenant, message);
+    if (existingMessages.length === 0) {
+      return false;
+    }
+
+    const incomingCid = await Message.getCid(message);
+    for (const existing of existingMessages) {
+      if (await Message.getCid(existing) !== incomingCid) {
+        continue;
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  private async getExistingMessagesForReplicationDedup(
+    tenant: string,
+    message: GenericMessage,
+  ): Promise<GenericMessage[]> {
+    const { descriptor } = message;
+    if (descriptor.interface === DwnInterfaceName.Records && descriptor.method === DwnMethodName.Write) {
+      const recordId = (message as { recordId?: unknown }).recordId;
+      if (typeof recordId !== 'string') {
+        return [];
+      }
+
+      const { messages } = await this.messageStore.query(tenant, [{
+        interface: DwnInterfaceName.Records,
+        recordId,
+      }]);
+      return messages;
+    }
+
+    if (descriptor.interface === DwnInterfaceName.Records && descriptor.method === DwnMethodName.Delete) {
+      const recordId = (descriptor as { recordId?: unknown }).recordId;
+      if (typeof recordId !== 'string') {
+        return [];
+      }
+
+      const { messages } = await this.messageStore.query(tenant, [{
+        interface: DwnInterfaceName.Records,
+        recordId,
+      }]);
+      return messages;
+    }
+
+    if (descriptor.interface === DwnInterfaceName.Protocols && descriptor.method === DwnMethodName.Configure) {
+      const protocol = (descriptor as { definition?: { protocol?: unknown } }).definition?.protocol;
+      if (typeof protocol !== 'string') {
+        return [];
+      }
+
+      const { messages } = await this.messageStore.query(tenant, [{
+        interface : DwnInterfaceName.Protocols,
+        method    : DwnMethodName.Configure,
+        protocol,
+      }]);
+      return messages;
+    }
+
+    return [];
+  }
+
   /**
    * Checks tenant gate to see if tenant is allowed.
    * @param tenant The tenant DID to route the given message to.
@@ -304,8 +685,14 @@ export type DwnConfig = {
    */
   eventLog?: EventLog;
 
+  /**
+   * Instrumentation seam: wraps the internally constructed `ValidationStateReader` before it is
+   * handed to the handlers (e.g. with a `RecordingValidationStateReader`). Used by the
+   * replay-basis closure tests and harnesses to record every validation-time state read.
+   */
+  instrumentValidationStateReader?: (validationStateReader: ValidationStateReader) => ValidationStateReader;
+
   messageStore: MessageStore;
   dataStore: DataStore;
-  stateIndex: StateIndex;
   resumableTaskStore: ResumableTaskStore;
 };

package/src/enums/dwn-interface-method.ts

@@ -11,6 +11,5 @@ export enum DwnMethodName {
   Query = 'Query',
   Read = 'Read',
   Subscribe = 'Subscribe',
-  Sync = 'Sync',
   Write = 'Write'
 }