@enbox/dwn-sdk-js 0.4.0 → 0.4.2

package/src/dwn.ts

@@ -1,32 +1,55 @@
+import type { CoreProtocol } from './core/core-protocol.js';
 import type { DataStore } from './types/data-store.js';
 import type { DidResolver } from '@enbox/dids';
-import type { KeyValues } from './types/query-types.js';
 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 { EventLog, MessageEvent, SubscriptionListener } from './types/subscriptions.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 {
+  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, RecordsReadMessage, RecordsReadReply, RecordsSubscribeMessage, RecordsSubscribeMessageOptions, RecordsSubscribeReply, RecordsWriteMessage, RecordsWriteMessageOptions } from './types/records-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 { DwnErrorCode } from './core/dwn-error.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 { ProtocolAuthorization } from './core/protocol-authorization.js';
-import { ProtocolsConfigure } from './interfaces/protocols-configure.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';
@@ -35,11 +58,13 @@ 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 { replicationApplyResultFromReply } from './core/replication-apply.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
@@ -53,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;
@@ -76,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),
@@ -156,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();
@@ -167,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>;
@@ -187,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,
     };
   }
@@ -207,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>;
@@ -231,7 +269,7 @@ export class Dwn {
       tenant,
       message: rawMessage,
       dataStream,
-      subscriptionHandler
+      subscriptionHandler,
     });
 
     return methodHandlerReply;
@@ -259,13 +297,193 @@ export class Dwn {
       return { kind: 'Invalid', reason: integrityError.status.detail };
     }
 
-    if (await this.replicatedMessageAlreadyStored(tenant, rawMessage, options)) {
+    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);
-    return replicationApplyResultFromReply(rawMessage, reply, { protocolDefinition });
+    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(
@@ -278,24 +496,36 @@ export class Dwn {
       return undefined;
     }
 
-    const protocol = Dwn.getMessageProtocolForReplicationApply(message);
-    if (protocol === undefined) {
+    const lookup = Dwn.getReplicationApplyProtocolDefinitionLookup(message);
+    if (lookup === undefined) {
       return undefined;
     }
 
     try {
-      return await ProtocolAuthorization.fetchProtocolDefinition(
+      return await this.validationStateReader.fetchProtocolDefinition(
         tenant,
-        protocol,
-        this.messageStore,
-        message.descriptor.messageTimestamp,
-        this._coreProtocols,
+        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') {
@@ -306,10 +536,14 @@ export class Dwn {
     }
   }
 
+  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,
-    options: ReplicationApplyOptions,
   ): Promise<boolean> {
     const existingMessages = await this.getExistingMessagesForReplicationDedup(tenant, message);
     if (existingMessages.length === 0) {
@@ -322,11 +556,6 @@ export class Dwn {
         continue;
       }
 
-      if (options.dataStream !== undefined && Dwn.existingReplicatedWriteMayNeedDataCompletion(existing, message)) {
-        return false;
-      }
-
-      await this.repairReplicationIndexesForDuplicate(tenant, message, existingMessages, incomingCid);
       return true;
     }
 
@@ -381,148 +610,6 @@ export class Dwn {
     return [];
   }
 
-  private static existingReplicatedWriteMayNeedDataCompletion(existing: GenericMessage, incoming: GenericMessage): boolean {
-    if (
-      incoming.descriptor.interface !== DwnInterfaceName.Records ||
-      incoming.descriptor.method !== DwnMethodName.Write ||
-      existing.descriptor.interface !== DwnInterfaceName.Records ||
-      existing.descriptor.method !== DwnMethodName.Write
-    ) {
-      return false;
-    }
-
-    const existingWrite = existing as { encodedData?: string; descriptor: { dateCreated?: string; messageTimestamp?: string } };
-    const isInitialWrite = existingWrite.descriptor.dateCreated === existingWrite.descriptor.messageTimestamp;
-    return isInitialWrite && existingWrite.encodedData === undefined;
-  }
-
-  private async repairReplicationIndexesForDuplicate(
-    tenant: string,
-    message: GenericMessage,
-    existingMessages: GenericMessage[],
-    messageCid: string,
-  ): Promise<void> {
-    const leaves = await this.stateIndex.getLeaves(tenant, []);
-    const stateIndexHasMessage = leaves.includes(messageCid);
-    if (stateIndexHasMessage && this.eventLog === undefined) {
-      return;
-    }
-
-    const repair = await this.constructReplicationIndexRepair(tenant, message, existingMessages);
-    if (repair === undefined) {
-      return;
-    }
-
-    if (!stateIndexHasMessage) {
-      await this.stateIndex.insert(tenant, messageCid, repair.indexes);
-    }
-    if (repair.emitEvent && !await this.eventLogHasMessage(tenant, messageCid, repair.indexes)) {
-      await this.eventLog?.emit(tenant, repair.event, repair.indexes, messageCid);
-    }
-  }
-
-  private async eventLogHasMessage(tenant: string, messageCid: string, indexes: KeyValues): Promise<boolean> {
-    if (this.eventLog === undefined) {
-      return true;
-    }
-
-    const { events } = await this.eventLog.read(tenant, { filters: [indexes] });
-    for (const event of events) {
-      if (event.messageCid === messageCid || await Message.getCid(event.event.message) === messageCid) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  private async constructReplicationIndexRepair(
-    tenant: string,
-    message: GenericMessage,
-    existingMessages: GenericMessage[],
-  ): Promise<{ indexes: KeyValues; event: MessageEvent; emitEvent: boolean } | undefined> {
-    const { descriptor } = message;
-
-    if (descriptor.interface === DwnInterfaceName.Records && descriptor.method === DwnMethodName.Write) {
-      const isLatest = await Dwn.isNewestStoredMessage(message, existingMessages);
-      const eventMessage = await Dwn.getStoredMessageForCid(existingMessages, await Message.getCid(message)) ?? message;
-      const recordsWrite = await RecordsWrite.parse(eventMessage as RecordsWriteMessage);
-      const indexes = await recordsWrite.constructIndexes(isLatest);
-      const initialWrite = await this.getInitialWriteForReplicationEvent(tenant, eventMessage as RecordsWriteMessage);
-      return {
-        indexes,
-        event     : { message: eventMessage, initialWrite },
-        emitEvent : isLatest && Dwn.replicatedWriteHasQueryableData(eventMessage),
-      };
-    }
-
-    if (descriptor.interface === DwnInterfaceName.Records && descriptor.method === DwnMethodName.Delete) {
-      const initialWrite = await RecordsWrite.fetchInitialRecordsWriteMessage(
-        this.messageStore,
-        tenant,
-        (message as RecordsDeleteMessage).descriptor.recordId,
-      );
-      if (initialWrite === undefined) {
-        return undefined;
-      }
-
-      const recordsDelete = await RecordsDelete.parse(message as RecordsDeleteMessage);
-      const isLatest = await Dwn.isNewestStoredMessage(message, existingMessages);
-      return {
-        indexes   : recordsDelete.constructIndexes(initialWrite),
-        event     : { message, initialWrite },
-        emitEvent : isLatest,
-      };
-    }
-
-    if (descriptor.interface === DwnInterfaceName.Protocols && descriptor.method === DwnMethodName.Configure) {
-      const protocolsConfigure = await ProtocolsConfigure.parse(message as ProtocolsConfigureMessage);
-      const isLatest = await Dwn.isNewestStoredMessage(message, existingMessages);
-      return {
-        indexes   : ProtocolsConfigureHandler.constructIndexes(protocolsConfigure, isLatest),
-        event     : { message },
-        emitEvent : isLatest,
-      };
-    }
-
-    return undefined;
-  }
-
-  private static async isNewestStoredMessage(
-    message: GenericMessage,
-    existingMessages: GenericMessage[],
-  ): Promise<boolean> {
-    const newestMessage = await Message.getNewestMessage(existingMessages);
-    return newestMessage !== undefined && await Message.getCid(newestMessage) === await Message.getCid(message);
-  }
-
-  private static async getStoredMessageForCid(existingMessages: GenericMessage[], messageCid: string): Promise<GenericMessage | undefined> {
-    for (const existingMessage of existingMessages) {
-      if (await Message.getCid(existingMessage) === messageCid) {
-        return existingMessage;
-      }
-    }
-  }
-
-  private async getInitialWriteForReplicationEvent(
-    tenant: string,
-    message: RecordsWriteMessage,
-  ): Promise<RecordsWriteMessage | undefined> {
-    if (await RecordsWrite.isInitialWrite(message)) {
-      return message;
-    }
-
-    return RecordsWrite.fetchInitialRecordsWriteMessage(this.messageStore, tenant, message.recordId);
-  }
-
-  private static replicatedWriteHasQueryableData(message: GenericMessage): boolean {
-    if (message.descriptor.interface !== DwnInterfaceName.Records || message.descriptor.method !== DwnMethodName.Write) {
-      return false;
-    }
-
-    return (message as { encodedData?: unknown }).encodedData !== undefined ||
-      (message as RecordsWriteMessage).descriptor.dateCreated !== (message as RecordsWriteMessage).descriptor.messageTimestamp;
-  }
-
   /**
    * Checks tenant gate to see if tenant is allowed.
    * @param tenant The tenant DID to route the given message to.
@@ -598,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'
 }