@enbox/dwn-sdk-js 0.4.0 → 0.4.2

package/src/handlers/records-write.ts

@@ -1,6 +1,5 @@
-import type { Filter } from '../types/query-types.js';
-import type { GenericMessageReply } from '../types/message-types.js';
-import type { MessageStore } from '../types/message-store.js';
+import type { ProgressToken } from '../types/subscriptions.js';
+import type { GenericMessage, GenericMessageReply } from '../types/message-types.js';
 import type { HandlerDependencies, MethodHandler } from '../types/method-handler.js';
 import type { RecordsQueryReplyEntry, RecordsWriteMessage } from '../types/records-types.js';
 
@@ -9,21 +8,18 @@ import { Cid } from '../utils/cid.js';
 import { DataStream } from '../utils/data-stream.js';
 import { DwnConstant } from '../core/dwn-constant.js';
 import { Encoder } from '../utils/encoder.js';
-import { FilterUtility } from '../utils/filter.js';
 import { Message } from '../core/message.js';
 import { messageReplyFromError } from '../core/message-reply.js';
-import { PermissionsProtocol } from '../protocols/permissions.js';
 import { ProtocolAuthorization } from '../core/protocol-authorization.js';
 import { Records } from '../utils/records.js';
 import { RecordsGrantAuthorization } from '../core/records-grant-authorization.js';
 import { RecordsWrite } from '../interfaces/records-write.js';
 import { ResumableTaskName } from '../core/resumable-task-manager.js';
-import { SortDirection } from '../types/query-types.js';
 import { StorageController } from '../store/storage-controller.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
 
-type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?: ReadableStream<Uint8Array>};
+type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?: ReadableStream<Uint8Array> };
 
 export class RecordsWriteHandler implements MethodHandler {
 
@@ -32,7 +28,7 @@ export class RecordsWriteHandler implements MethodHandler {
   public async handle({
     tenant,
     message,
-    dataStream
+    dataStream,
   }: HandlerArgs): Promise<GenericMessageReply> {
     let recordsWrite: RecordsWrite;
     try {
@@ -52,30 +48,26 @@ export class RecordsWriteHandler implements MethodHandler {
     // mutable validation. An already-stored message has already passed
     // admission; replay should not be reinterpreted against current protocol,
     // parent, role, grant, or record-limit state.
-    //
-    // Exception: an initial write may have been stored earlier without data
-    // (204). A later delivery of the same message with data must be allowed
-    // to complete the record.
     const incomingCid = await Message.getCid(message);
     for (const existingMessage of existingMessages) {
       if (await Message.getCid(existingMessage) !== incomingCid) {
         continue;
       }
 
-      const canCompleteMissingData = await this.existingInitialWriteLacksData(
-        tenant,
-        existingMessage as RecordsWriteMessage,
-        message,
-        dataStream !== undefined,
-      );
+      return { status: { code: 409, detail: 'Conflict' } };
+    }
 
-      if (!canCompleteMissingData) {
-        return { status: { code: 409, detail: 'Conflict' } };
-      }
+    const newMessageIsInitialWrite = await recordsWrite.isInitialWrite();
+
+    let initialWrite: RecordsWriteMessage | undefined;
+    try {
+      initialWrite = await this.getInitialWrite(existingMessages, newMessageIsInitialWrite);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
     }
 
     try {
-      await ProtocolAuthorization.validateReferentialIntegrity(tenant, recordsWrite, this.deps.messageStore, this.deps.coreProtocols);
+      await ProtocolAuthorization.validateReferentialIntegrity(tenant, recordsWrite, this.deps.validationStateReader);
     } catch (e) {
       return messageReplyFromError(e, 400);
     }
@@ -83,18 +75,14 @@ export class RecordsWriteHandler implements MethodHandler {
     // authentication & authorization
     try {
       await authenticate(message.authorization, this.deps.didResolver, message.attestation);
-      await this.authorizeRecordsWrite(tenant, recordsWrite, this.deps.messageStore);
+      await this.authorizeRecordsWrite(tenant, recordsWrite);
     } catch (e) {
       return messageReplyFromError(e, 401);
     }
 
-    // if the incoming write is not the initial write, then it must not modify any immutable properties defined by the initial write
-    const newMessageIsInitialWrite = await recordsWrite.isInitialWrite();
-    let initialWrite: RecordsWriteMessage | undefined;
-    if (!newMessageIsInitialWrite) {
+    if (initialWrite !== undefined) {
       try {
-        initialWrite = await RecordsWrite.getInitialWrite(existingMessages);
-        RecordsWrite.verifyEqualityOfImmutableProperties(initialWrite, message);
+        this.verifyImmutableProperties(initialWrite, message);
       } catch (e) {
         return messageReplyFromError(e, 400);
       }
@@ -121,30 +109,9 @@ export class RecordsWriteHandler implements MethodHandler {
     }
 
     if (!incomingMessageIsNewest) {
-      // Allow re-processing when the existing record was stored as an
-      // initial write without data (isLatestBaseState = false, status 204)
-      // and the incoming message now supplies data.  This happens during
-      // sync when a live pull initially stores the message without data
-      // and a subsequent poll or retry delivers the same message with data.
-      //
-      // We detect the incomplete state by checking whether the existing
-      // message is an initial write that lacks both inline encodedData and
-      // DataStore data — indicating it was stored without data.
-      let existingLacksData = false;
-      if (newestExistingMessage) {
-        existingLacksData = await this.existingInitialWriteLacksData(
-          tenant,
-          newestExistingMessage as RecordsWriteMessage,
-          message,
-          dataStream !== undefined,
-        );
-      }
-
-      if (!existingLacksData) {
-        return {
-          status: { code: 409, detail: 'Conflict' }
-        };
-      }
+      return {
+        status: { code: 409, detail: 'Conflict' }
+      };
     }
 
     // Look up the core protocol (if any) for the incoming message so that lifecycle hooks
@@ -152,6 +119,7 @@ export class RecordsWriteHandler implements MethodHandler {
     const coreProtocol = message.descriptor.protocol === undefined
       ? undefined
       : this.deps.coreProtocols?.get(message.descriptor.protocol);
+    let position: ProgressToken | undefined;
 
     try {
       if (newestExistingMessage?.descriptor.method === DwnMethodName.Delete) {
@@ -165,7 +133,7 @@ export class RecordsWriteHandler implements MethodHandler {
       // This allows core protocols to perform cross-record validation before storage
       // (e.g. ensuring revocation tag consistency with the parent grant's scoped protocol).
       if (coreProtocol?.preProcessWrite !== undefined) {
-        await coreProtocol.preProcessWrite(tenant, message, this.deps.messageStore);
+        await coreProtocol.preProcessWrite(tenant, message, this.deps.validationStateReader);
       }
 
       // NOTE: We allow isLatestBaseState to be true ONLY if the incoming message comes with data, or if the incoming message is NOT an initial write
@@ -192,21 +160,8 @@ export class RecordsWriteHandler implements MethodHandler {
       }
 
       const indexes = await recordsWrite.constructIndexes(isLatestBaseState);
-      await this.deps.messageStore.put(tenant, messageWithOptionalEncodedData, indexes);
-      const messageCid = await Message.getCid(message);
-      await this.deps.stateIndex!.insert(tenant, messageCid, indexes);
-
-      // NOTE: We only emit a `RecordsWrite` when the message is the latest base state.
-      // Because we allow a `RecordsWrite` which is not the latest state to be written, but not queried, we shouldn't emit it either.
-      // It will be emitted as a part of a subsequent next write, if it is the latest base state.
-      //
-      // We emit `messageWithOptionalEncodedData` (not the raw `message`) so
-      // that WebSocket subscribers receive inline `encodedData` for small
-      // records (<= 30 KB).  This allows live sync to store the record
-      // immediately without a separate MessagesRead round-trip.
-      if (this.deps.eventLog !== undefined && isLatestBaseState) {
-        await this.deps.eventLog.emit(tenant, { message: messageWithOptionalEncodedData, initialWrite }, indexes, messageCid);
-      }
+      const putResult = await this.deps.messageStore.put(tenant, messageWithOptionalEncodedData, indexes);
+      position = putResult.position;
     } catch (error) {
       if (error instanceof DwnError) {
         if (error.code === DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious ||
@@ -230,12 +185,13 @@ export class RecordsWriteHandler implements MethodHandler {
       // for more details.
       status: (newMessageIsInitialWrite && dataStream === undefined) ?
         { code: 204, detail: 'No Content' } :
-        { code: 202, detail: 'Accepted' }
+        { code: 202, detail: 'Accepted' },
+      position,
     };
 
-    // delete all existing messages of the same record that are not newest, except for the initial write
-    await StorageController.deleteAllOlderMessagesButKeepInitialWrite(
-      tenant, existingMessages, newestMessage, this.deps.messageStore, this.deps.dataStore!, this.deps.stateIndex!
+    // displace every other message for this record, retaining only the initial write as non-latest state
+    await StorageController.deleteDisplacedMessagesAndRetainWrites(
+      tenant, existingMessages, newestMessage, this.deps.messageStore, this.deps.dataStore!, []
     );
 
     // Squash processing: if the incoming write is a squash, delete all older sibling records
@@ -254,7 +210,6 @@ export class RecordsWriteHandler implements MethodHandler {
       await coreProtocol.postProcessWrite(tenant, recordsWrite, {
         messageStore : this.deps.messageStore,
         dataStore    : this.deps.dataStore!,
-        stateIndex   : this.deps.stateIndex!,
       });
     }
 
@@ -282,7 +237,7 @@ export class RecordsWriteHandler implements MethodHandler {
       // validate data integrity before setting.
       const dataBytes = await DataStream.toBytes(dataStream);
       const dataCid = await Cid.computeDagPbCidFromBytes(dataBytes);
-      RecordsWriteHandler.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataBytes.length);
+      RecordsWrite.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, dataBytes.length);
 
       // Dispatch schema validation to the core protocol, if applicable.
       const coreProtocol = message.descriptor.protocol === undefined
@@ -304,7 +259,7 @@ export class RecordsWriteHandler implements MethodHandler {
           this.deps.dataStore!.put(tenant, message.recordId, message.descriptor.dataCid, dataStreamCopy2)
         ]);
 
-        RecordsWriteHandler.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, DataStorePutResult.dataSize);
+        RecordsWrite.validateDataIntegrity(message.descriptor.dataCid, message.descriptor.dataSize, dataCid, DataStorePutResult.dataSize);
       } catch (error) {
         // unwind/delete data if we have issue with storage or the data failed integrity validation
         await this.deps.dataStore!.delete(tenant, message.recordId, message.descriptor.dataCid);
@@ -316,31 +271,33 @@ export class RecordsWriteHandler implements MethodHandler {
     return messageWithOptionalEncodedData;
   }
 
-  private async existingInitialWriteLacksData(
-    tenant: string,
-    existingMessage: RecordsWriteMessage,
-    incomingMessage: RecordsWriteMessage,
-    incomingHasData: boolean,
-  ): Promise<boolean> {
-    if (!incomingHasData) {
-      return false;
+  private async getInitialWrite(
+    existingMessages: GenericMessage[],
+    newMessageIsInitialWrite: boolean,
+  ): Promise<RecordsWriteMessage | undefined> {
+    if (newMessageIsInitialWrite) {
+      return undefined;
     }
 
-    const isInitial = await RecordsWrite.isInitialWrite(existingMessage);
-    if (!isInitial) {
-      return false;
-    }
+    return RecordsWrite.getInitialWrite(existingMessages);
+  }
 
-    const hasInlineData = !!(existingMessage as RecordsQueryReplyEntry).encodedData;
-    const hasStoredData = this.deps.dataStore
-      ? !!(await this.deps.dataStore.get(
-        tenant,
-        existingMessage.recordId,
-        incomingMessage.descriptor.dataCid,
-      ))
-      : false;
+  private verifyImmutableProperties(
+    initialWrite: RecordsWriteMessage,
+    message: RecordsWriteMessage,
+  ): void {
+    try {
+      RecordsWrite.verifyEqualityOfImmutableProperties(initialWrite, message);
+    } catch (error) {
+      if (error instanceof DwnError && error.code === DwnErrorCode.RecordsWriteImmutablePropertyChanged) {
+        throw new DwnError(
+          DwnErrorCode.RecordsWriteImmutablePropertyChanged,
+          'immutable RecordsWrite properties cannot be changed.'
+        );
+      }
 
-    return !hasInlineData && !hasStoredData;
+      throw error;
+    }
   }
 
   private async processMessageWithoutDataStream(
@@ -355,7 +312,7 @@ export class RecordsWriteHandler implements MethodHandler {
     // we preform the dataCid check in case a user attempts to gain access to data by referencing a different known dataCid,
     // so we insure that the data is already associated with the existing newest message
     // See: https://github.com/enboxorg/enbox/issues/359 for more info
-    RecordsWriteHandler.validateDataIntegrity(dataCid, dataSize, newestExistingWrite.descriptor.dataCid, newestExistingWrite.descriptor.dataSize);
+    RecordsWrite.validateDataIntegrity(dataCid, dataSize, newestExistingWrite.descriptor.dataCid, newestExistingWrite.descriptor.dataSize);
 
     if (dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
       // we encode the data from the original write if it is smaller than the data-store threshold
@@ -371,9 +328,9 @@ export class RecordsWriteHandler implements MethodHandler {
       // else just make sure the data is in the data store
 
       // attempt to retrieve the data from the previous message
-      const DataStoreGetResult = await this.deps.dataStore!.get(tenant, newestExistingWrite.recordId, message.descriptor.dataCid);
+      const priorDataExists = await this.deps.validationStateReader.hasStoredData(tenant, newestExistingWrite.recordId, message.descriptor.dataCid);
 
-      if (DataStoreGetResult === undefined) {
+      if (!priorDataExists) {
         throw new DwnError(
           DwnErrorCode.RecordsWriteMissingDataInPrevious,
           `No dataStream was provided and unable to get data from previous message`
@@ -384,35 +341,6 @@ export class RecordsWriteHandler implements MethodHandler {
     return messageWithOptionalEncodedData;
   }
 
-  /**
-   * Validates the expected `dataCid` and `dataSize` in the descriptor vs the received data.
-   *
-   * @throws {DwnError} with `DwnErrorCode.RecordsWriteDataCidMismatch`
-   *                    if the data stream resulted in a data CID that mismatches with `dataCid` in the given message
-   * @throws {DwnError} with `DwnErrorCode.RecordsWriteDataSizeMismatch`
-   *                    if `dataSize` in `descriptor` given mismatches the actual data size
-   */
-  private static validateDataIntegrity(
-    expectedDataCid: string,
-    expectedDataSize: number,
-    actualDataCid: string,
-    actualDataSize: number
-  ): void {
-    if (expectedDataCid !== actualDataCid) {
-      throw new DwnError(
-        DwnErrorCode.RecordsWriteDataCidMismatch,
-        `actual data CID ${actualDataCid} does not match dataCid in descriptor: ${expectedDataCid}`
-      );
-    }
-
-    if (expectedDataSize !== actualDataSize) {
-      throw new DwnError(
-        DwnErrorCode.RecordsWriteDataSizeMismatch,
-        `actual data size ${actualDataSize} bytes does not match dataSize in descriptor: ${expectedDataSize}`
-      );
-    }
-  }
-
   /**
    * Enforces the squash backstop: if the incoming message is at a protocol path with `$squash: true`,
    * and there exists a squash record at the same protocol path and parent context whose
@@ -426,16 +354,14 @@ export class RecordsWriteHandler implements MethodHandler {
       return;
     }
 
-    // Fetch the protocol definition to check if $squash is enabled at this path.
-    // Pass coreProtocols so that core protocols (e.g. permissions) are resolved from the registry.
+    // Fetch the protocol definition active at the incoming message timestamp to check if $squash is enabled at this path.
+    // The reader resolves core protocols (e.g. permissions) from the registry.
     let protocolDefinition;
     try {
-      protocolDefinition = await ProtocolAuthorization.fetchProtocolDefinition(
+      protocolDefinition = await this.deps.validationStateReader.fetchProtocolDefinition(
         tenant,
         message.descriptor.protocol,
-        this.deps.messageStore,
-        undefined,
-        this.deps.coreProtocols,
+        message.descriptor.messageTimestamp,
       );
     } catch (error) {
       // If the protocol definition can't be found, skip the backstop check.
@@ -455,36 +381,19 @@ export class RecordsWriteHandler implements MethodHandler {
       return;
     }
 
-    // Find the most recent squash record at the same protocol path and parent context
-    const filter: Filter = {
-      interface         : DwnInterfaceName.Records,
-      method            : DwnMethodName.Write,
-      isLatestBaseState : true,
-      protocol          : message.descriptor.protocol,
-      protocolPath      : message.descriptor.protocolPath,
-      squash            : true,
-    };
-
-    // Scope by parent context for nested records
     const parentContextId = Records.getParentContextFromOfContextId(message.contextId);
-    if (parentContextId !== undefined && parentContextId !== '') {
-      const prefixFilter = FilterUtility.constructPrefixFilterAsRangeFilter(parentContextId);
-      filter.contextId = prefixFilter;
-    }
-
-    const { messages: squashMessages } = await this.deps.messageStore.query(
+    const contextIdPrefix = parentContextId !== undefined && parentContextId !== '' ? parentContextId : undefined;
+    const newestSquash = await this.deps.validationStateReader.fetchLatestSquashRecordAtScope({
       tenant,
-      [filter],
-      { messageTimestamp: SortDirection.Descending },
-      { limit: 1 },
-    );
+      protocol     : message.descriptor.protocol,
+      protocolPath : message.descriptor.protocolPath,
+      contextIdPrefix,
+    });
 
-    if (squashMessages.length === 0) {
+    if (newestSquash === undefined) {
       return;
     }
 
-    const newestSquash = squashMessages[0] as RecordsWriteMessage;
-
     // Reject if the incoming message's timestamp is <= the squash record's timestamp
     if (message.descriptor.messageTimestamp <= newestSquash.descriptor.messageTimestamp) {
       throw new DwnError(
@@ -496,7 +405,7 @@ export class RecordsWriteHandler implements MethodHandler {
     }
   }
 
-  private async authorizeRecordsWrite(tenant: string, recordsWrite: RecordsWrite, messageStore: MessageStore): Promise<void> {
+  private async authorizeRecordsWrite(tenant: string, recordsWrite: RecordsWrite): Promise<void> {
     // if owner signature is given (`owner` is not `undefined`), it must be the same as the tenant DID
     if (recordsWrite.owner !== undefined && recordsWrite.owner !== tenant) {
       throw new DwnError(
@@ -506,11 +415,11 @@ export class RecordsWriteHandler implements MethodHandler {
     }
 
     if (recordsWrite.isSignedByAuthorDelegate) {
-      await recordsWrite.authorizeAuthorDelegate(messageStore);
+      await recordsWrite.authorizeAuthorDelegate(this.deps.validationStateReader);
     }
 
     if (recordsWrite.isSignedByOwnerDelegate) {
-      await recordsWrite.authorizeOwnerDelegate(messageStore);
+      await recordsWrite.authorizeOwnerDelegate(this.deps.validationStateReader);
     }
 
     if (recordsWrite.owner !== undefined) {
@@ -522,16 +431,16 @@ export class RecordsWriteHandler implements MethodHandler {
       return;
     } else if (recordsWrite.author !== undefined && Message.getPermissionGrantId(recordsWrite.signaturePayload!) !== undefined) {
       const permissionGrantId = Message.getPermissionGrantId(recordsWrite.signaturePayload!)!;
-      const permissionGrant = await PermissionsProtocol.fetchGrant(tenant, messageStore, permissionGrantId);
+      const permissionGrant = await this.deps.validationStateReader.fetchGrant(tenant, permissionGrantId);
       await RecordsGrantAuthorization.authorizeWrite({
-        recordsWriteMessage : recordsWrite.message,
-        expectedGrantor     : tenant,
-        expectedGrantee     : recordsWrite.author,
+        recordsWriteMessage   : recordsWrite.message,
+        expectedGrantor       : tenant,
+        expectedGrantee       : recordsWrite.author,
         permissionGrant,
-        messageStore
+        validationStateReader : this.deps.validationStateReader
       });
     } else {
-      await ProtocolAuthorization.authorizeWrite(tenant, recordsWrite, messageStore, this.deps.coreProtocols);
+      await ProtocolAuthorization.authorizeWrite(tenant, recordsWrite, this.deps.validationStateReader);
     }
   }
 }

package/src/index.ts

@@ -1,10 +1,14 @@
 // export everything that we want to be consumable
 export type { DwnConfig } from './dwn.js';
-export type { EventListener, EventLog, EventLogEntry, EventLogReadOptions, EventLogReadResult, EventLogSubscribeOptions, EventSubscription, MessageEvent, ProgressGapInfo, ProgressGapReason, ProgressToken, SubscriptionEose, SubscriptionError, SubscriptionEvent, SubscriptionListener, SubscriptionMessage, SubscriptionReply } from './types/subscriptions.js';
+export type { EventLog, EventLogEntry, EventLogReadOptions, EventLogReadResult, EventLogSubscribeOptions, EventSubscription, MessageEvent, ProgressGapInfo, ProgressGapReason, ProgressToken, ReplicationFeedReader, SubscriptionEose, SubscriptionError, SubscriptionEvent, SubscriptionListener, SubscriptionMessage, SubscriptionReply, Wake, WakePublisher, WakeSubscriber } from './types/subscriptions.js';
 export type { AuthorizationModel, Descriptor, DelegatedGrantRecordsWriteMessage, GenericMessage, GenericMessageReply, GenericSignaturePayload, MessageSort, MessageSubscription, Pagination, QueryResultEntry, Status } from './types/message-types.js';
 export type { DependencyRef, ReplicationApplyOptions, ReplicationApplyResult, ReplicationApplyResultContext } from './core/replication-apply.js';
 export { replicationApplyResultFromReply } from './core/replication-apply.js';
-export type { MessagesFilter, MessagesReadMessage, MessagesReadReply, MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncDiffEntry, MessagesSyncMessage, MessagesSyncReply } from './types/messages-types.js';
+export type { ValidationStateReader } from './types/validation-state-reader.js';
+export { StoreValidationStateReader } from './core/validation-state-reader.js';
+export type { RecordedValidationRead } from './core/recording-validation-state-reader.js';
+export { RecordingValidationStateReader } from './core/recording-validation-state-reader.js';
+export type { MessagesFilter, MessagesQueryDescriptor, MessagesQueryMessage, MessagesQueryReply, MessagesQueryReplyEntry, MessagesReadMessage, MessagesReadReply, MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions } from './types/messages-types.js';
 export type { GT, LT, Filter, FilterValue, KeyValues, EqualFilter, OneOfFilter, RangeFilter, RangeCriterion, PaginationCursor, QueryOptions, RangeValue, StartsWithFilter } from './types/query-types.js';
 export type { ProtocolsConfigureDescriptor, ProtocolDefinition, ProtocolTypes, ProtocolRuleSet, ProtocolsQueryFilter, ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply, ProtocolActionRule, ProtocolDeliveryStrategy, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolRecordLimitDefinition, ProtocolSizeDefinition, ProtocolTagsDefinition, ProtocolTagSchema, ProtocolType, ProtocolUses } from './types/protocols-types.js';
 export { ProtocolRecordLimitStrategy } from './types/protocols-types.js';
@@ -44,10 +48,11 @@ export type { KeyMaterial, PrivateKeyJwk, PublicKeyJwk, Jwk } from './types/jose
 export { Message } from './core/message.js';
 export { MessagesRead } from './interfaces/messages-read.js';
 export type { MessagesReadOptions } from './interfaces/messages-read.js';
-export { MessagesSync } from './interfaces/messages-sync.js';
-export type { MessagesSyncOptions } from './interfaces/messages-sync.js';
+export { MessagesQuery } from './interfaces/messages-query.js';
+export type { MessagesQueryOptions } from './interfaces/messages-query.js';
 export type { UnionMessageReply } from './core/message-reply.js';
-export type { MessageStore, MessageStoreOptions } from './types/message-store.js';
+export type { MessageStore, MessageStoreOptions, MessageStorePutResult } from './types/message-store.js';
+export { Replication } from './utils/replication.js';
 export type { MessageInterface } from './types/message-interface.js';
 export { PermissionGrant } from './protocols/permission-grant.js';
 export { PermissionRequest } from './protocols/permission-request.js';
@@ -93,19 +98,11 @@ export { MessageStoreLevel } from './store/message-store-level.js';
 export type { MessageStoreLevelConfig } from './store/message-store-level.js';
 export { ResumableTaskStoreLevel } from './store/resumable-task-store-level.js';
 export type { ResumableTaskStoreLevelConfig } from './store/resumable-task-store-level.js';
-export { EventEmitterEventLog } from './event-stream/event-emitter-event-log.js';
-export type { EventEmitterEventLogConfig } from './event-stream/event-emitter-event-log.js';
+export { EventEmitterWakePublisher } from './event-stream/event-emitter-wake-publisher.js';
+export { DurableEventLog } from './event-stream/durable-event-log.js';
+export type { DurableEventLogConfig, DurableEventLogStore } from './event-stream/durable-event-log.js';
 
-// Sparse Merkle Tree and StateIndex
-export type { StateIndex } from './types/state-index.js';
-export { StateIndexLevel } from './state-index/state-index-level.js';
-export type { StateIndexLevelConfig } from './state-index/state-index-level.js';
-export { SparseMerkleTree } from './smt/sparse-merkle-tree.js';
-export { SMTStoreLevel } from './smt/smt-store-level.js';
-export { SMTStoreMemory } from './smt/smt-store-memory.js';
-export type { Hash, SMTNode, SMTInternalNode, SMTLeafNode, SMTProof, SMTDiffResult, SMTNodeStore } from './types/smt-types.js';
-export { hashChildren, hashEquals, hashKey, hashLeaf, hashToHex, hexToHash, getBit, initDefaultHashes, getDefaultHashes, SMT_DEPTH, ZERO_HASH } from './smt/smt-utils.js';
 // test library exports
-export type { GenerateFromRecordsWriteInput, GenerateFromRecordsWriteOut, GenerateGrantCreateInput, GenerateGrantCreateOutput, GenerateMessagesReadInput, GenerateMessagesReadOutput, GenerateMessagesSubscribeInput, GenerateMessagesSubscribeOutput, GenerateProtocolsConfigureInput, GenerateProtocolsConfigureOutput, GenerateProtocolsQueryInput, GenerateProtocolsQueryOutput, GenerateRecordsCountInput, GenerateRecordsCountOutput, GenerateRecordsDeleteInput, GenerateRecordsDeleteOutput, GenerateRecordsQueryInput, GenerateRecordsQueryOutput, GenerateRecordsSubscribeInput, GenerateRecordsSubscribeOutput, GenerateRecordsWriteInput, GenerateRecordsWriteOutput, Persona } from '../tests/utils/test-data-generator.js';
+export type { GenerateFromRecordsWriteInput, GenerateFromRecordsWriteOut, GenerateGrantCreateInput, GenerateGrantCreateOutput, GenerateMessagesQueryInput, GenerateMessagesQueryOutput, GenerateMessagesReadInput, GenerateMessagesReadOutput, GenerateMessagesSubscribeInput, GenerateMessagesSubscribeOutput, GenerateProtocolsConfigureInput, GenerateProtocolsConfigureOutput, GenerateProtocolsQueryInput, GenerateProtocolsQueryOutput, GenerateRecordsCountInput, GenerateRecordsCountOutput, GenerateRecordsDeleteInput, GenerateRecordsDeleteOutput, GenerateRecordsQueryInput, GenerateRecordsQueryOutput, GenerateRecordsSubscribeInput, GenerateRecordsSubscribeOutput, GenerateRecordsWriteInput, GenerateRecordsWriteOutput, Persona } from '../tests/utils/test-data-generator.js';
 export { TestDataGenerator } from '../tests/utils/test-data-generator.js';
 export { Poller } from '../tests/utils/poller.js';

package/src/interfaces/messages-query.ts

@@ -0,0 +1,70 @@
+import type { MessageSigner } from '../types/signer.js';
+import type { ProgressToken } from '../types/subscriptions.js';
+import type { MessagesFilter, MessagesQueryDescriptor, MessagesQueryMessage } from '../types/messages-types.js';
+
+import { AbstractMessage } from '../core/abstract-message.js';
+import { Message } from '../core/message.js';
+import { removeUndefinedProperties } from '@enbox/common';
+import { Time } from '../utils/time.js';
+import { validateProtocolUrlNormalized } from '../utils/url.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export type MessagesQueryOptions = {
+  signer: MessageSigner;
+  messageTimestamp?: string;
+  filters?: MessagesFilter[];
+  permissionGrantIds?: string[];
+  cursor?: ProgressToken;
+  limit?: number;
+  cidsOnly?: boolean;
+};
+
+export class MessagesQuery extends AbstractMessage<MessagesQueryMessage> {
+  public static async parse(message: MessagesQueryMessage): Promise<MessagesQuery> {
+    Message.validateJsonSchema(message);
+    await Message.validateSignatureStructure(message.authorization.signature, message.descriptor);
+
+    for (const filter of message.descriptor.filters) {
+      if ('protocol' in filter && filter.protocol !== undefined) {
+        validateProtocolUrlNormalized(filter.protocol);
+      }
+    }
+
+    Time.validateTimestamp(message.descriptor.messageTimestamp);
+    return new MessagesQuery(message);
+  }
+
+  /**
+   * Creates a MessagesQuery message.
+   *
+   * @throws {DwnError} if json schema validation fails.
+   */
+  public static async create(options: MessagesQueryOptions): Promise<MessagesQuery> {
+    const permissionGrantInvocation = Message.normalizePermissionGrantInvocation({
+      permissionGrantIds: options.permissionGrantIds
+    });
+
+    const descriptor: MessagesQueryDescriptor = {
+      interface        : DwnInterfaceName.Messages,
+      method           : DwnMethodName.Query,
+      filters          : options.filters ?? [],
+      messageTimestamp : options.messageTimestamp ?? Time.getCurrentTimestamp(),
+      cursor           : options.cursor,
+      limit            : options.limit,
+      cidsOnly         : options.cidsOnly,
+      ...permissionGrantInvocation,
+    };
+
+    removeUndefinedProperties(descriptor);
+
+    const authorization = await Message.createAuthorization({
+      descriptor,
+      signer: options.signer,
+      ...permissionGrantInvocation,
+    });
+
+    const message: MessagesQueryMessage = { descriptor, authorization };
+    Message.validateJsonSchema(message);
+    return new MessagesQuery(message);
+  }
+}

package/src/interfaces/protocols-configure.ts

@@ -1,17 +1,18 @@
 import type { DataEncodedRecordsWriteMessage } from '../types/records-types.js';
 import type { MessageSigner } from '../types/signer.js';
-import type { MessageStore } from '../types/message-store.js';
+import type { ValidationStateReader } from '../types/validation-state-reader.js';
 import type {
   ProtocolActionRule, ProtocolDefinition, ProtocolRuleSet, ProtocolsConfigureDescriptor,
   ProtocolsConfigureMessage, ProtocolTypes, ProtocolUses
 } from '../types/protocols-types.js';
 
 import { AbstractMessage } from '../core/abstract-message.js';
-import Ajv from 'ajv/dist/2020.js';
+import { DwnConstant } from '../core/dwn-constant.js';
 import { Message } from '../core/message.js';
 import { PermissionGrant } from '../protocols/permission-grant.js';
 import { ProtocolsGrantAuthorization } from '../core/protocols-grant-authorization.js';
 import { Time } from '../utils/time.js';
+import { validateProtocolTagSchemaDefinition } from '../utils/protocol-tags.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
 import { isCrossProtocolRef, parseCrossProtocolRef } from '../utils/protocols.js';
@@ -69,16 +70,16 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
 
   /**
    * Authorizes the author-delegate who signed this message.
-   * @param messageStore Used to check if the grant has been revoked.
+   * @param validationStateReader Used to check if the grant has been revoked.
    */
-  public async authorizeAuthorDelegate(messageStore: MessageStore): Promise<void> {
+  public async authorizeAuthorDelegate(validationStateReader: ValidationStateReader): Promise<void> {
     const delegatedGrant = PermissionGrant.parse(this.message.authorization.authorDelegatedGrant!);
     await ProtocolsGrantAuthorization.authorizeConfigure({
       protocolsConfigureMessage : this.message,
       expectedGrantor           : this.author!,
       expectedGrantee           : this.signer!,
       permissionGrant           : delegatedGrant,
-      messageStore
+      validationStateReader
     });
   }
 
@@ -247,6 +248,13 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
         );
       }
 
+      if (max > DwnConstant.maxRecordLimit) {
+        throw new DwnError(
+          DwnErrorCode.ProtocolsConfigureInvalidRecordLimit,
+          `Invalid $recordLimit.max value ${max} at protocol path '${ruleSetProtocolPath}': must be <= ${DwnConstant.maxRecordLimit}.`
+        );
+      }
+
       const validStrategies = Object.values(ProtocolRecordLimitStrategy) as string[];
       if (!validStrategies.includes(strategy as string)) {
         throw new DwnError(
@@ -257,16 +265,18 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
       }
     }
 
-    if (ruleSet.$tags) {
-      const ajv = new Ajv.default();
+    if (ruleSet.$tags !== undefined) {
       const { $allowUndefinedTags, $requiredTags, ...tagProperties } = ruleSet.$tags;
 
-      // we validate each tag's expected schema to ensure it is a valid JSON schema
+      // validate each tag's schema against the DWN-supported tag schema subset
       for (const tag in tagProperties) {
         const tagSchemaDefinition = tagProperties[tag];
+        const schemaError = validateProtocolTagSchemaDefinition(
+          tagSchemaDefinition,
+          `${ruleSetProtocolPath}/$tags/${tag}`,
+        );
 
-        if (!ajv.validateSchema(tagSchemaDefinition as Record<string, unknown>)) {
-          const schemaError = ajv.errorsText(ajv.errors, { dataVar: `${ruleSetProtocolPath}/$tags/${tag}` });
+        if (schemaError !== undefined) {
           throw new DwnError(DwnErrorCode.ProtocolsConfigureInvalidTagSchema, `tags schema validation error: ${schemaError}`);
         }
       }