@enbox/dwn-sdk-js 0.3.9 → 0.4.0

package/src/core/protocol-authorization-validation.ts

@@ -74,8 +74,8 @@ export async function verifyProtocolPathAndContextId(
     }
 
     throw new DwnError(
-      DwnErrorCode.ProtocolAuthorizationIncorrectProtocolPath,
-      `Could not find matching parent record to verify declared protocol path '${declaredProtocolPath}'.`
+      DwnErrorCode.ProtocolAuthorizationParentRecordNotFound,
+      `Could not find parent record '${parentId}' to verify declared protocol path '${declaredProtocolPath}'.`
     );
   }
 

package/src/core/replication-apply.ts

@@ -0,0 +1,272 @@
+import type { GenericMessage } from '../types/message-types.js';
+import type { ProtocolDefinition } from '../types/protocols-types.js';
+
+import { DwnErrorCode } from './dwn-error.js';
+import { Encoder } from '../utils/encoder.js';
+import { Message } from './message.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+import { isCrossProtocolRef, parseCrossProtocolRef } from '../utils/protocols.js';
+
+export type ReplicationApplyOptions = {
+  dataStream?: ReadableStream<Uint8Array>;
+};
+
+export type ReplicationApplyResult =
+  | { kind: 'Applied' }
+  | { kind: 'Duplicate' }
+  | { kind: 'Superseded' }
+  | { kind: 'Incomplete'; missing: DependencyRef[] }
+  | { kind: 'Invalid'; reason: string }
+  | { kind: 'Deferred'; reason: 'tenant-inactive' | 'resolver-unavailable' | 'storage' };
+
+export type ReplicationApplyResultContext = {
+  protocolDefinition?: ProtocolDefinition;
+};
+
+export type DependencyRef =
+  | { type: 'Protocol'; protocol: string; messageCid?: string; terminal?: boolean }
+  | { type: 'InitialWrite'; recordId: string; protocol?: string; messageCid?: string; terminal?: boolean }
+  | { type: 'Parent'; recordId: string; protocol: string; messageCid?: string; terminal?: boolean }
+  | { type: 'Ancestor'; recordId: string; protocol?: string; messageCid?: string; terminal?: boolean }
+  | { type: 'Role'; protocol: string; protocolPath: string; recipient: string; contextPrefix?: string; messageCid?: string; terminal?: boolean }
+  | { type: 'Grant'; permissionGrantId: string; messageCid?: string; terminal?: boolean }
+  | { type: 'KeyDelivery'; protocol: string; contextId: string; messageCid?: string; terminal?: boolean }
+  | { type: 'CrossProtocolRef'; protocol: string; recordId: string; messageCid?: string; terminal?: boolean }
+  | { type: 'RecordData'; recordId: string; dataCid: string; protocol?: string; messageCid?: string; terminal?: boolean };
+
+/**
+ * Converts a regular handler reply into the structured result consumed by
+ * replication sync. The DWN handler remains the dependency authority; this
+ * adapter only gives the sync transport a typed way to distinguish missing
+ * dependencies from terminal invalid messages.
+ */
+export function replicationApplyResultFromReply(
+  message: GenericMessage,
+  reply: { status: { code: number; detail?: string } },
+  context: ReplicationApplyResultContext = {},
+): ReplicationApplyResult {
+  const { code, detail = '' } = reply.status;
+
+  if (code === 202 || code === 204) {
+    return { kind: 'Applied' };
+  }
+
+  if (code === 409) {
+    return { kind: 'Superseded' };
+  }
+
+  if (getDwnErrorCode(detail) === DwnErrorCode.RecordsWriteNotAllowedAfterDelete) {
+    return { kind: 'Superseded' };
+  }
+
+  if (isResolverFailure(detail)) {
+    return { kind: 'Deferred', reason: 'resolver-unavailable' };
+  }
+
+  const missing = dependencyRefFromStatus(message, code, detail, context);
+  if (missing !== undefined) {
+    return { kind: 'Incomplete', missing: [missing] };
+  }
+
+  if (code >= 500) {
+    return { kind: 'Deferred', reason: 'storage' };
+  }
+
+  return { kind: 'Invalid', reason: detail || `replicated message rejected with status ${code}` };
+}
+
+function dependencyRefFromStatus(
+  message: GenericMessage,
+  code: number,
+  detail: string,
+  context: ReplicationApplyResultContext,
+): DependencyRef | undefined {
+  const errorCode = getDwnErrorCode(detail);
+  switch (errorCode) {
+  case DwnErrorCode.ProtocolAuthorizationProtocolNotFound:
+  case DwnErrorCode.ProtocolsConfigureComposedProtocolNotInstalled:
+    return protocolDependencyFromMessage(message, detail);
+  case DwnErrorCode.ProtocolAuthorizationParentRecordNotFound:
+  case DwnErrorCode.ProtocolAuthorizationCrossProtocolParentNotFound:
+    return parentDependencyFromMessage(message, detail);
+  case DwnErrorCode.ProtocolAuthorizationParentNotFoundConstructingRecordChain:
+    return ancestorDependencyFromMessage(message, detail);
+  case DwnErrorCode.RecordsWriteGetInitialWriteNotFound:
+    return initialWriteDependencyFromMessage(message);
+  case DwnErrorCode.GrantAuthorizationGrantMissing:
+    return grantDependencyFromMessage(message);
+  case DwnErrorCode.ProtocolAuthorizationMatchingRoleRecordNotFound:
+    return roleDependencyFromMessage(message, context);
+  case DwnErrorCode.RecordsWriteMissingDataInPrevious:
+  case DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious:
+    return recordDataDependencyFromMessage(message);
+  default:
+    break;
+  }
+
+  if (code === 404 && isRecordsDelete(message)) {
+    return { type: 'InitialWrite', recordId: getRecordsDeleteRecordId(message) };
+  }
+
+  return undefined;
+}
+
+function getDwnErrorCode(detail: string): string | undefined {
+  const delimiter = detail.indexOf(':');
+  return delimiter === -1 ? undefined : detail.slice(0, delimiter);
+}
+
+function isResolverFailure(detail: string): boolean {
+  return getDwnErrorCode(detail) === DwnErrorCode.GeneralJwsVerifierGetPublicKeyNotFound;
+}
+
+function protocolDependencyFromMessage(message: GenericMessage, detail: string): DependencyRef | undefined {
+  const composedProtocol = /composed protocol '([^']+)'/.exec(detail)?.[1];
+  if (composedProtocol !== undefined) {
+    return { type: 'Protocol', protocol: composedProtocol };
+  }
+
+  const protocol = (message.descriptor as Record<string, unknown>).protocol;
+  return typeof protocol === 'string' ? { type: 'Protocol', protocol } : undefined;
+}
+
+function parentDependencyFromMessage(message: GenericMessage, detail: string): DependencyRef | undefined {
+  const descriptor = message.descriptor as Record<string, unknown>;
+  const parentId = typeof descriptor.parentId === 'string'
+    ? descriptor.parentId
+    : /parent record '([^']+)'/.exec(detail)?.[1];
+  const protocol = /in protocol '([^']+)'/.exec(detail)?.[1] ?? descriptor.protocol;
+
+  if (typeof parentId !== 'string' || typeof protocol !== 'string') {
+    return undefined;
+  }
+
+  return { type: 'Parent', recordId: parentId, protocol };
+}
+
+function ancestorDependencyFromMessage(message: GenericMessage, detail: string): DependencyRef | undefined {
+  const recordId = /ID ([^ ]+)/.exec(detail)?.[1];
+  if (recordId === undefined) {
+    return undefined;
+  }
+
+  const protocol = (message.descriptor as Record<string, unknown>).protocol;
+  return {
+    type: 'Ancestor',
+    recordId,
+    ...(typeof protocol === 'string' ? { protocol } : {}),
+  };
+}
+
+function initialWriteDependencyFromMessage(message: GenericMessage): DependencyRef | undefined {
+  if (!isRecordsWrite(message)) {
+    return undefined;
+  }
+
+  const protocol = (message.descriptor as Record<string, unknown>).protocol;
+  return {
+    type     : 'InitialWrite',
+    recordId : message.recordId,
+    ...(typeof protocol === 'string' ? { protocol } : {}),
+  };
+}
+
+function grantDependencyFromMessage(message: GenericMessage): DependencyRef | undefined {
+  const descriptorGrantId = (message.descriptor as Record<string, unknown>).permissionGrantId;
+  if (typeof descriptorGrantId === 'string') {
+    return { type: 'Grant', permissionGrantId: descriptorGrantId };
+  }
+
+  const payloadGrantId = getSignaturePayload(message)?.permissionGrantId;
+  return typeof payloadGrantId === 'string'
+    ? { type: 'Grant', permissionGrantId: payloadGrantId }
+    : undefined;
+}
+
+function recordDataDependencyFromMessage(message: GenericMessage): DependencyRef | undefined {
+  if (!isRecordsWrite(message)) {
+    return undefined;
+  }
+
+  const descriptor = message.descriptor as Record<string, unknown>;
+  const dataCid = descriptor.dataCid;
+  const protocol = descriptor.protocol;
+  return typeof dataCid === 'string'
+    ? {
+      type     : 'RecordData',
+      recordId : message.recordId,
+      dataCid,
+      ...(typeof protocol === 'string' ? { protocol } : {}),
+    }
+    : undefined;
+}
+
+function roleDependencyFromMessage(message: GenericMessage, context: ReplicationApplyResultContext): DependencyRef | undefined {
+  const descriptor = message.descriptor as Record<string, unknown>;
+  const filter = descriptor.filter as Record<string, unknown> | undefined;
+  const protocol = descriptor.protocol ?? filter?.protocol;
+  const protocolRole = getSignaturePayload(message)?.protocolRole;
+  const recipient = Message.getAuthor(message);
+
+  if (typeof protocol !== 'string' || typeof protocolRole !== 'string' || recipient === undefined) {
+    return undefined;
+  }
+
+  let roleProtocol = protocol;
+  let roleProtocolPath = protocolRole;
+  if (isCrossProtocolRef(protocolRole)) {
+    const parsed = parseCrossProtocolRef(protocolRole);
+    const referencedProtocol = parsed === undefined ? undefined : context.protocolDefinition?.uses?.[parsed.alias];
+    if (parsed !== undefined && referencedProtocol !== undefined) {
+      roleProtocol = referencedProtocol;
+      roleProtocolPath = parsed.protocolPath;
+    }
+  }
+
+  let contextId: string | undefined;
+  if (typeof descriptor.contextId === 'string') {
+    contextId = descriptor.contextId;
+  } else if (typeof filter?.contextId === 'string') {
+    contextId = filter.contextId;
+  }
+  const roleSegments = roleProtocolPath.split('/').length - 1;
+  const contextPrefix = roleSegments > 0 && contextId !== undefined
+    ? contextId.split('/').slice(0, roleSegments).join('/')
+    : undefined;
+
+  return {
+    type         : 'Role',
+    protocol     : roleProtocol,
+    protocolPath : roleProtocolPath,
+    recipient,
+    ...(contextPrefix === undefined ? {} : { contextPrefix }),
+  };
+}
+
+function isRecordsWrite(message: GenericMessage): message is GenericMessage & { recordId: string } {
+  return message.descriptor.interface === DwnInterfaceName.Records &&
+    message.descriptor.method === DwnMethodName.Write &&
+    typeof (message as { recordId?: unknown }).recordId === 'string';
+}
+
+function isRecordsDelete(message: GenericMessage): boolean {
+  return message.descriptor.interface === DwnInterfaceName.Records &&
+    message.descriptor.method === DwnMethodName.Delete;
+}
+
+function getRecordsDeleteRecordId(message: GenericMessage): string {
+  return (message.descriptor as unknown as { recordId: string }).recordId;
+}
+
+function getSignaturePayload(message: GenericMessage): Record<string, unknown> | undefined {
+  const payload = message.authorization?.signature.payload;
+  if (payload === undefined) {
+    return undefined;
+  }
+
+  try {
+    return Encoder.base64UrlToObject(payload) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}

package/src/dwn.ts

@@ -1,33 +1,41 @@
 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, SubscriptionListener } from './types/subscriptions.js';
+import type { EventLog, MessageEvent, 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 { 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 { ReplicationApplyOptions, ReplicationApplyResult } from './core/replication-apply.js';
 
 import { AllowAllTenantGate } from './core/tenant-gate.js';
 import { CoreProtocolRegistry } from './core/core-protocol.js';
+import { DwnErrorCode } from './core/dwn-error.js';
 import { Message } from './core/message.js';
 import { messageReplyFromError } from './core/message-reply.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 { 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 { replicationApplyResultFromReply } from './core/replication-apply.js';
 import { ResumableTaskManager } from './core/resumable-task-manager.js';
 import { StorageController } from './store/storage-controller.js';
 import { DidDht, DidJwk, DidKey, DidResolverCacheMemory, DidWeb, UniversalResolver } from '@enbox/dids';
@@ -229,6 +237,292 @@ export class Dwn {
     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, options)) {
+      return { kind: 'Duplicate' };
+    }
+
+    const reply = await this.processMessage(tenant, rawMessage, options);
+    const protocolDefinition = await this.getReplicationApplyProtocolDefinition(tenant, rawMessage, reply);
+    return replicationApplyResultFromReply(rawMessage, reply, { protocolDefinition });
+  }
+
+  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 protocol = Dwn.getMessageProtocolForReplicationApply(message);
+    if (protocol === undefined) {
+      return undefined;
+    }
+
+    try {
+      return await ProtocolAuthorization.fetchProtocolDefinition(
+        tenant,
+        protocol,
+        this.messageStore,
+        message.descriptor.messageTimestamp,
+        this._coreProtocols,
+      );
+    } catch {
+      return undefined;
+    }
+  }
+
+  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 async replicatedMessageAlreadyStored(
+    tenant: string,
+    message: GenericMessage,
+    options: ReplicationApplyOptions,
+  ): 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;
+      }
+
+      if (options.dataStream !== undefined && Dwn.existingReplicatedWriteMayNeedDataCompletion(existing, message)) {
+        return false;
+      }
+
+      await this.repairReplicationIndexesForDuplicate(tenant, message, existingMessages, incomingCid);
+      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 [];
+  }
+
+  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.