@enbox/dwn-sdk-js 0.0.1 → 0.0.3

package/src/handlers/records-count.ts

@@ -0,0 +1,184 @@
+import type { DidResolver } from '@enbox/dids';
+import type { Filter } from '../types/query-types.js';
+import type { MessageStore } from '../types//message-store.js';
+import type { MethodHandler } from '../types/method-handler.js';
+import type { RecordsCountMessage, RecordsCountReply } from '../types/records-types.js';
+
+import { authenticate } from '../core/auth.js';
+import { Message } from '../core/message.js';
+import { messageReplyFromError } from '../core/message-reply.js';
+import { ProtocolAuthorization } from '../core/protocol-authorization.js';
+import { Records } from '../utils/records.js';
+import { RecordsCount } from '../interfaces/records-count.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export class RecordsCountHandler implements MethodHandler {
+
+  constructor(private didResolver: DidResolver, private messageStore: MessageStore) { }
+
+  public async handle({
+    tenant,
+    message
+  }: {tenant: string, message: RecordsCountMessage}): Promise<RecordsCountReply> {
+    let recordsCount: RecordsCount;
+    try {
+      recordsCount = await RecordsCount.parse(message);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
+    }
+
+    let count: number;
+
+    // if this is an anonymous count and the filter supports published records, count only published records
+    if (Records.filterIncludesPublishedRecords(recordsCount.message.descriptor.filter) && recordsCount.author === undefined) {
+      count = await this.countPublishedRecords(tenant, recordsCount);
+    } else {
+      // authentication and authorization
+      try {
+        await authenticate(message.authorization!, this.didResolver);
+
+        await RecordsCountHandler.authorizeRecordsCount(tenant, recordsCount, this.messageStore);
+      } catch (e) {
+        return messageReplyFromError(e, 401);
+      }
+
+      if (recordsCount.author === tenant) {
+        count = await this.countRecordsAsOwner(tenant, recordsCount);
+      } else {
+        count = await this.countRecordsAsNonOwner(tenant, recordsCount);
+      }
+    }
+
+    return {
+      status: { code: 200, detail: 'OK' },
+      count,
+    };
+  }
+
+  /**
+   * Counts records as the owner of the DWN with no additional filtering.
+   */
+  private async countRecordsAsOwner(tenant: string, recordsCount: RecordsCount): Promise<number> {
+    const { filter } = recordsCount.message.descriptor;
+    const countFilter = {
+      ...Records.convertFilter(filter),
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      isLatestBaseState : true
+    };
+
+    return this.messageStore.count(tenant, [countFilter]);
+  }
+
+  /**
+   * Counts records as a non-owner, applying the same filter logic as RecordsQuery.
+   */
+  private async countRecordsAsNonOwner(tenant: string, recordsCount: RecordsCount): Promise<number> {
+    const { filter } = recordsCount.message.descriptor;
+    const filters: Filter[] = [];
+
+    if (Records.filterIncludesPublishedRecords(filter)) {
+      filters.push(RecordsCountHandler.buildPublishedRecordsFilter(recordsCount));
+    }
+
+    if (Records.filterIncludesUnpublishedRecords(filter)) {
+      if (Records.shouldBuildUnpublishedAuthorFilter(filter, recordsCount.author!)) {
+        filters.push(RecordsCountHandler.buildUnpublishedRecordsByCountAuthorFilter(recordsCount));
+      }
+
+      if (Records.shouldProtocolAuthorize(recordsCount.signaturePayload!)) {
+        filters.push(RecordsCountHandler.buildUnpublishedProtocolAuthorizedRecordsFilter(recordsCount));
+      }
+
+      if (Records.shouldBuildUnpublishedRecipientFilter(filter, recordsCount.author!)) {
+        filters.push(RecordsCountHandler.buildUnpublishedRecordsForCountAuthorFilter(recordsCount));
+      }
+    }
+
+    return this.messageStore.count(tenant, filters);
+  }
+
+  /**
+   * Counts only published records.
+   */
+  private async countPublishedRecords(tenant: string, recordsCount: RecordsCount): Promise<number> {
+    const filter = RecordsCountHandler.buildPublishedRecordsFilter(recordsCount);
+    return this.messageStore.count(tenant, [filter]);
+  }
+
+  private static buildPublishedRecordsFilter(recordsCount: RecordsCount): Filter {
+    const { filter } = recordsCount.message.descriptor;
+    return {
+      ...Records.convertFilter(filter),
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      published         : true,
+      isLatestBaseState : true
+    };
+  }
+
+  /**
+   * Creates a filter for unpublished records that are intended for the count author (where `recipient` is the author).
+   */
+  private static buildUnpublishedRecordsForCountAuthorFilter(recordsCount: RecordsCount): Filter {
+    const { filter } = recordsCount.message.descriptor;
+    return {
+      ...Records.convertFilter(filter),
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      recipient         : recordsCount.author!,
+      isLatestBaseState : true,
+      published         : false
+    };
+  }
+
+  /**
+   * Creates a filter for unpublished records that are within the specified protocol.
+   */
+  private static buildUnpublishedProtocolAuthorizedRecordsFilter(recordsCount: RecordsCount): Filter {
+    const { filter } = recordsCount.message.descriptor;
+    return {
+      ...Records.convertFilter(filter),
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      isLatestBaseState : true,
+      published         : false
+    };
+  }
+
+  /**
+   * Creates a filter for only unpublished records where the author is the same as the count author.
+   */
+  private static buildUnpublishedRecordsByCountAuthorFilter(recordsCount: RecordsCount): Filter {
+    const { filter } = recordsCount.message.descriptor;
+    return {
+      ...Records.convertFilter(filter),
+      author            : recordsCount.author!,
+      interface         : DwnInterfaceName.Records,
+      method            : DwnMethodName.Write,
+      isLatestBaseState : true,
+      published         : false
+    };
+  }
+
+  /**
+   * @param messageStore Used to check if the grant has been revoked.
+   */
+  private static async authorizeRecordsCount(
+    tenant: string,
+    recordsCount: RecordsCount,
+    messageStore: MessageStore
+  ): Promise<void> {
+
+    if (Message.isSignedByAuthorDelegate(recordsCount.message)) {
+      await recordsCount.authorizeDelegate(messageStore);
+    }
+
+    // NOTE: not all RecordsCount messages require protocol authorization even if the filter includes protocol-related fields,
+    // this is because we dynamically filter out records that the caller is not authorized to see.
+    // Currently only run protocol authorization if message deliberately invokes a protocol role.
+    if (Records.shouldProtocolAuthorize(recordsCount.signaturePayload!)) {
+      await ProtocolAuthorization.authorizeQueryOrSubscribe(tenant, recordsCount, messageStore);
+    }
+  }
+}

package/src/handlers/records-query.ts

@@ -97,6 +97,10 @@ export class RecordsQueryHandler implements MethodHandler {
       return { datePublished: SortDirection.Ascending };
     case DateSort.PublishedDescending:
       return { datePublished: SortDirection.Descending };
+    case DateSort.UpdatedAscending:
+      return { messageTimestamp: SortDirection.Ascending };
+    case DateSort.UpdatedDescending:
+      return { messageTimestamp: SortDirection.Descending };
     default:
       return { dateCreated: SortDirection.Ascending };
     }

package/src/handlers/records-read.ts

@@ -44,29 +44,25 @@ export class RecordsReadHandler implements MethodHandler {
       return messageReplyFromError(e, 401);
     }
 
-    // get the latest active messages matching the supplied filter
+    // get the latest active message matching the supplied filter, sorted and limited to 1 result
     const query: Filter = {
       // NOTE: we don't filter by `method` so that we get both RecordsWrite and RecordsDelete messages
       interface         : DwnInterfaceName.Records,
       isLatestBaseState : true,
       ...Records.convertFilter(message.descriptor.filter)
     };
-    const { messages: existingMessages } = await this.messageStore.query(tenant, [ query ]);
+    const messageSort = Records.convertDateSort(message.descriptor.dateSort);
+    const { messages: existingMessages } = await this.messageStore.query(tenant, [ query ], messageSort, { limit: 1 });
     if (existingMessages.length === 0) {
       return {
         status: { code: 404, detail: 'Not Found' }
       };
-    } else if (existingMessages.length > 1) {
-      return messageReplyFromError(new DwnError(
-        DwnErrorCode.RecordsReadReturnedMultiple,
-        'Multiple records exist for the RecordsRead filter'
-      ), 400);
     }
 
     const matchedMessage = existingMessages[0];
 
     // if the matched message is a RecordsDelete, we mark the record as not-found and return both the RecordsDelete and the initial RecordsWrite
-    // TODO: https://github.com/TBD54566975/dwn-sdk-js/issues/819:
+    // TODO: https://github.com/enboxorg/enbox/issues/819:
     // Consider performing authorization checks like when records exists before returning RecordsDelete and initial RecordsWrite of a deleted record
     if (matchedMessage.descriptor.method === DwnMethodName.Delete) {
       const recordsDeleteMessage = matchedMessage as RecordsDeleteMessage;

package/src/handlers/records-write.ts

@@ -1,10 +1,10 @@
 import type { DataStore } from '../types/data-store.js';
 import type { DidResolver } from '@enbox/dids';
-import type { EventLog } from '../types/event-log.js';
 import type { EventStream } from '../types/subscriptions.js';
 import type { GenericMessageReply } from '../types/message-types.js';
-import type { MessageStore } from '../types//message-store.js';
+import type { MessageStore } from '../types/message-store.js';
 import type { MethodHandler } from '../types/method-handler.js';
+import type { StateIndex } from '../types/state-index.js';
 import type { RecordsQueryReplyEntry, RecordsWriteMessage } from '../types/records-types.js';
 
 import { authenticate } from '../core/auth.js';
@@ -22,7 +22,7 @@ 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?: _Readable.Readable};
+type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?: ReadableStream<Uint8Array>};
 
 export class RecordsWriteHandler implements MethodHandler {
 
@@ -30,7 +30,7 @@ export class RecordsWriteHandler implements MethodHandler {
     private didResolver: DidResolver,
     private messageStore: MessageStore,
     private dataStore: DataStore,
-    private eventLog: EventLog,
+    private stateIndex: StateIndex,
     private eventStream?: EventStream
   ) { }
 
@@ -113,7 +113,7 @@ export class RecordsWriteHandler implements MethodHandler {
       // This would allow an initial write to be written to the DB without data, but having it not queryable,
       // because query implementation filters on `isLatestBaseState` being `true`
       // thus preventing a user's attempt to gain authorized access to data by referencing the dataCid of a private data in their initial writes,
-      // See: https://github.com/TBD54566975/dwn-sdk-js/issues/359 for more info
+      // See: https://github.com/enboxorg/enbox/issues/359 for more info
       let isLatestBaseState = false;
       let messageWithOptionalEncodedData = message as RecordsQueryReplyEntry;
 
@@ -134,7 +134,7 @@ export class RecordsWriteHandler implements MethodHandler {
 
       const indexes = await recordsWrite.constructIndexes(isLatestBaseState);
       await this.messageStore.put(tenant, messageWithOptionalEncodedData, indexes);
-      await this.eventLog.append(tenant, await Message.getCid(message), indexes);
+      await this.stateIndex.insert(tenant, await Message.getCid(message), 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.
@@ -143,15 +143,14 @@ export class RecordsWriteHandler implements MethodHandler {
         this.eventStream.emit(tenant, { message, initialWrite }, indexes);
       }
     } catch (error) {
-      const e = error as any;
-      if (e.code !== undefined) {
-        if (e.code === DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious ||
-          e.code === DwnErrorCode.RecordsWriteMissingDataInPrevious ||
-          e.code === DwnErrorCode.RecordsWriteNotAllowedAfterDelete ||
-          e.code === DwnErrorCode.RecordsWriteDataCidMismatch ||
-          e.code === DwnErrorCode.RecordsWriteDataSizeMismatch ||
-          e.code.startsWith('PermissionsProtocolValidate') ||
-          e.code.startsWith('SchemaValidator')) {
+      if (error instanceof DwnError) {
+        if (error.code === DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious ||
+          error.code === DwnErrorCode.RecordsWriteMissingDataInPrevious ||
+          error.code === DwnErrorCode.RecordsWriteNotAllowedAfterDelete ||
+          error.code === DwnErrorCode.RecordsWriteDataCidMismatch ||
+          error.code === DwnErrorCode.RecordsWriteDataSizeMismatch ||
+          error.code.startsWith('PermissionsProtocolValidate') ||
+          error.code.startsWith('SchemaValidator')) {
           return messageReplyFromError(error, 400);
         }
       }
@@ -162,7 +161,7 @@ export class RecordsWriteHandler implements MethodHandler {
 
     const messageReply = {
       // In order to discern between something that was accepted as a queryable write and something that was accepted
-      // as an initial state we use separate response codes. See https://github.com/TBD54566975/dwn-sdk-js/issues/695
+      // as an initial state we use separate response codes. See https://github.com/enboxorg/enbox/issues/695
       // for more details.
       status: (newMessageIsInitialWrite && dataStream === undefined) ?
         { code: 204, detail: 'No Content' } :
@@ -171,7 +170,7 @@ export class RecordsWriteHandler implements MethodHandler {
 
     // delete all existing messages of the same record that are not newest, except for the initial write
     await StorageController.deleteAllOlderMessagesButKeepInitialWrite(
-      tenant, existingMessages, newestMessage, this.messageStore, this.dataStore, this.eventLog
+      tenant, existingMessages, newestMessage, this.messageStore, this.dataStore, this.stateIndex
     );
 
     await this.postProcessingForCoreRecordsWrite(tenant, recordsWrite);
@@ -220,7 +219,7 @@ export class RecordsWriteHandler implements MethodHandler {
    */
   private async postProcessingForCoreRecordsWrite(tenant: string, recordsWrite: RecordsWrite): Promise<void> {
     // If this message is a Permission revocation, we need to delete all grant-authorized messages with timestamp after revocation
-    // TODO: https://github.com/TBD54566975/dwn-sdk-js/issues/716
+    // TODO: https://github.com/enboxorg/enbox/issues/716
     // This code is a direct copy and paste from the original PermissionsRevokeHandler (no longer exists),
     // but it appears that there was no test for it and it does not look like the code worked:
     // - not seeing `permissionGrantId` being an index
@@ -239,7 +238,7 @@ export class RecordsWriteHandler implements MethodHandler {
         const messageCid = await Message.getCid(grantAuthorizedMessage);
         await this.messageStore.delete(tenant, messageCid);
       }
-      this.eventLog.deleteEventsByCid(tenant, grantAuthorizedMessageCidsAfterRevoke);
+      this.stateIndex.delete(tenant, grantAuthorizedMessageCidsAfterRevoke);
     }
   }
 
@@ -255,7 +254,7 @@ export class RecordsWriteHandler implements MethodHandler {
   private async processMessageWithDataStream(
     tenant: string,
     message: RecordsWriteMessage,
-    dataStream: _Readable.Readable,
+    dataStream: ReadableStream<Uint8Array>,
   ):Promise<RecordsQueryReplyEntry> {
     let messageWithOptionalEncodedData: RecordsQueryReplyEntry = message;
 
@@ -303,7 +302,7 @@ export class RecordsWriteHandler implements MethodHandler {
     // Since incoming message is not an initial write, and no dataStream is provided, we first check integrity against newest existing write.
     // 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/TBD54566975/dwn-sdk-js/issues/359 for more info
+    // See: https://github.com/enboxorg/enbox/issues/359 for more info
     RecordsWriteHandler.validateDataIntegrity(dataCid, dataSize, newestExistingWrite.descriptor.dataCid, newestExistingWrite.descriptor.dataSize);
 
     if (dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {

package/src/index.ts

@@ -1,67 +1,104 @@
 // export everything that we want to be consumable
 export type { DwnConfig } from './dwn.js';
-export type { EventLog } from './types/event-log.js';
 export type { EventListener, EventStream, EventSubscription, MessageEvent, SubscriptionReply } from './types/subscriptions.js';
 export type { AuthorizationModel, Descriptor, DelegatedGrantRecordsWriteMessage, GenericMessage, GenericMessageReply, GenericSignaturePayload, MessageSort, MessageSubscription, Pagination, QueryResultEntry, Status } from './types/message-types.js';
-export type { MessagesFilter, MessagesReadMessage as MessagesReadMessage, MessagesReadReply as MessagesReadReply, MessagesReadReplyEntry as MessagesReadReplyEntry, MessagesReadDescriptor, MessagesQueryDescriptor, MessagesQueryMessage, MessagesQueryReply, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessageSubscriptionHandler, MessagesSubscribeMessageOptions } from './types/messages-types.js';
+export type { MessagesFilter, MessagesReadMessage as MessagesReadMessage, MessagesReadReply as MessagesReadReply, MessagesReadReplyEntry as MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessageSubscriptionHandler, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncMessage, MessagesSyncReply } 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, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolType } from './types/protocols-types.js';
-export type { DataEncodedRecordsWriteMessage, EncryptedKey, EncryptionProperty, RecordsDeleteMessage, RecordsFilter, RecordsQueryMessage, RecordsQueryReply, RecordsQueryReplyEntry, RecordsReadMessage, RecordsReadReply, RecordsSubscribeDescriptor, RecordsSubscribeMessage, RecordsSubscribeReply, RecordSubscriptionHandler, RecordsWriteDescriptor, RecordsWriteTags, RecordsWriteTagValue, RecordsWriteMessage, RecordsWriteSignaturePayload, RecordsDeleteDescriptor, RecordsQueryDescriptor, RecordsReadDescriptor, RecordsSubscribeMessageOptions, RecordsWriteMessageOptions, InternalRecordsWriteMessage, RecordEvent, RecordsWriteTagsFilter } from './types/records-types.js';
+export type { ProtocolsConfigureDescriptor, ProtocolDefinition, ProtocolTypes, ProtocolRuleSet, ProtocolsQueryFilter, ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply, ProtocolActionRule, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolType, ProtocolUses } from './types/protocols-types.js';
+export type { DataEncodedRecordsWriteMessage, EncryptedKey, EncryptionProperty, RecordsCountDescriptor, RecordsCountMessage, RecordsCountReply, RecordsDeleteMessage, RecordsFilter, RecordsQueryMessage, RecordsQueryReply, RecordsQueryReplyEntry, RecordsReadMessage, RecordsReadReply, RecordsSubscribeDescriptor, RecordsSubscribeMessage, RecordsSubscribeReply, RecordSubscriptionHandler, RecordsWriteDescriptor, RecordsWriteTags, RecordsWriteTagValue, RecordsWriteMessage, RecordsWriteSignaturePayload, RecordsDeleteDescriptor, RecordsQueryDescriptor, RecordsReadDescriptor, RecordsSubscribeMessageOptions, RecordsWriteMessageOptions, InternalRecordsWriteMessage, RecordEvent, RecordsWriteTagsFilter } from './types/records-types.js';
 export type { GeneralJws, SignatureEntry } from './types/jws-types.js';
 export { authenticate } from './core/auth.js';
-export { ActiveTenantCheckResult, AllowAllTenantGate, TenantGate } from './core/tenant-gate.js';
+export { AllowAllTenantGate } from './core/tenant-gate.js';
+export type { ActiveTenantCheckResult, TenantGate } from './core/tenant-gate.js';
 export { Cid } from './utils/cid.js';
-export { RecordsQuery, RecordsQueryOptions } from './interfaces/records-query.js';
-export { DataStore, DataStorePutResult, DataStoreGetResult } from './types/data-store.js';
-export { ResumableTaskStore, ManagedResumableTask } from './types/resumable-task-store.js';
+export { RecordsCount } from './interfaces/records-count.js';
+export type { RecordsCountOptions } from './interfaces/records-count.js';
+export { RecordsQuery } from './interfaces/records-query.js';
+export type { RecordsQueryOptions } from './interfaces/records-query.js';
+export type { DataStore, DataStorePutResult, DataStoreGetResult } from './types/data-store.js';
+export type { ResumableTaskStore, ManagedResumableTask } from './types/resumable-task-store.js';
 export { DataStream } from './utils/data-stream.js';
-export { DerivedPrivateJwk, HdKey, KeyDerivationScheme } from './utils/hd-key.js';
-export { Dwn, MessageOptions } from './dwn.js';
+export { HdKey, KeyDerivationScheme } from './utils/hd-key.js';
+export type { DerivedPrivateJwk } from './utils/hd-key.js';
+export { Dwn } from './dwn.js';
+export type { MessageOptions } from './dwn.js';
 export { DwnConstant } from './core/dwn-constant.js';
 export { DwnError, DwnErrorCode } from './core/dwn-error.js';
 export { DwnInterfaceName, DwnMethodName } from './enums/dwn-interface-method.js';
 export { Encoder } from './utils/encoder.js';
-export { MessagesSubscribe as MessagesSubscribe, MessagesSubscribeOptions as MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
-export { Encryption, EncryptionAlgorithm, EciesEncryptionOutput, EciesEncryptionInput } from './utils/encryption.js';
-export { EncryptionInput, KeyEncryptionInput, RecordsWrite, RecordsWriteOptions, CreateFromOptions } from './interfaces/records-write.js';
+export { MessagesSubscribe as MessagesSubscribe } from './interfaces/messages-subscribe.js';
+export type { MessagesSubscribeOptions as MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
+export { Encryption, EncryptionAlgorithm } from './utils/encryption.js';
+export type { EciesEncryptionOutput, EciesEncryptionInput } from './utils/encryption.js';
+export { RecordsWrite } from './interfaces/records-write.js';
+export type { EncryptionInput, KeyEncryptionInput, RecordsWriteOptions, CreateFromOptions } from './interfaces/records-write.js';
 export { executeUnlessAborted } from './utils/abort.js';
 export { Jws } from './utils/jws.js';
-export { KeyMaterial, PrivateJwk, PublicJwk, Jwk } from './types/jose-types.js';
+export type { KeyMaterial, PrivateKeyJwk, PublicKeyJwk, Jwk } from './types/jose-types.js';
 export { Message } from './core/message.js';
-export { MessagesRead as MessagesRead, MessagesReadOptions as MessagesReadOptions } from './interfaces/messages-read.js';
-export { MessagesQuery, MessagesQueryOptions } from './interfaces/messages-query.js';
-export { UnionMessageReply } from './core/message-reply.js';
-export { MessageStore, MessageStoreOptions } from './types/message-store.js';
-export { MessageInterface } from './types/message-interface.js';
+export { MessagesRead as MessagesRead } from './interfaces/messages-read.js';
+export type { MessagesReadOptions as MessagesReadOptions } from './interfaces/messages-read.js';
+export { MessagesSync } from './interfaces/messages-sync.js';
+export type { MessagesSyncOptions } from './interfaces/messages-sync.js';
+export type { UnionMessageReply } from './core/message-reply.js';
+export type { MessageStore, MessageStoreOptions } from './types/message-store.js';
+export type { MessageInterface } from './types/message-interface.js';
 export { PermissionGrant } from './protocols/permission-grant.js';
 export { PermissionRequest } from './protocols/permission-request.js';
-export { PermissionsProtocol, PermissionGrantCreateOptions, PermissionRequestCreateOptions, PermissionRevocationCreateOptions } from './protocols/permissions.js';
-export { PrivateKeySigner, PrivateKeySignerOptions } from './utils/private-key-signer.js';
-export { Protocols } from './utils/protocols.js';
-export { ProtocolsConfigure, ProtocolsConfigureOptions } from './interfaces/protocols-configure.js';
-export { ProtocolsQuery, ProtocolsQueryOptions } from './interfaces/protocols-query.js';
+export { PermissionsProtocol } from './protocols/permissions.js';
+export type { PermissionGrantCreateOptions, PermissionRequestCreateOptions, PermissionRevocationCreateOptions } from './protocols/permissions.js';
+export { PrivateKeySigner } from './utils/private-key-signer.js';
+export type { PrivateKeySignerOptions } from './utils/private-key-signer.js';
+export { Protocols, parseCrossProtocolRef, isCrossProtocolRef, getRuleSetAtPath } from './utils/protocols.js';
+export type { CrossProtocolRef } from './utils/protocols.js';
+export { ProtocolsConfigure } from './interfaces/protocols-configure.js';
+export type { ProtocolsConfigureOptions } from './interfaces/protocols-configure.js';
+export { ProtocolsQuery } from './interfaces/protocols-query.js';
+export type { ProtocolsQueryOptions } from './interfaces/protocols-query.js';
 export { Records } from './utils/records.js';
-export { RecordsDelete, RecordsDeleteOptions } from './interfaces/records-delete.js';
-export { RecordsRead, RecordsReadOptions } from './interfaces/records-read.js';
-export { RecordsSubscribe, RecordsSubscribeOptions } from './interfaces/records-subscribe.js';
+export { RecordsDelete } from './interfaces/records-delete.js';
+export type { RecordsDeleteOptions } from './interfaces/records-delete.js';
+export { RecordsRead } from './interfaces/records-read.js';
+export type { RecordsReadOptions } from './interfaces/records-read.js';
+export { RecordsSubscribe } from './interfaces/records-subscribe.js';
+export type { RecordsSubscribeOptions } from './interfaces/records-subscribe.js';
 export { Secp256k1 } from './utils/secp256k1.js';
 export { Secp256r1 } from './utils/secp256r1.js';
-export { Signer } from './types/signer.js';
+export type { SupportedCurve } from './jose/algorithms/signing/signature-algorithms.js';
+export type { MessageSigner } from './types/signer.js';
 export { SortDirection } from './types/query-types.js';
+export type { EncryptionKeyDeriver, KeyDecrypter } from './types/encryption-types.js';
 export { Time } from './utils/time.js';
 export * from './types/permission-types.js';
 export * from './types/records-types.js';
 
 // concrete implementations of stores and event stream
-export { BlockstoreLevel, BlockstoreLevelConfig } from './store/blockstore-level.js';
-export { DataStoreLevel, DataStoreLevelConfig } from './store/data-store-level.js';
-export { EventLogLevel, EventLogLevelConfig } from './event-log/event-log-level.js';
-export { IndexLevel, IndexLevelConfig, IndexedItem, IndexLevelOptions } from './store/index-level.js';
-export { createLevelDatabase, CreateLevelDatabaseOptions, LevelDatabase, LevelWrapper, LevelWrapperConfig, LevelWrapperBatchOperation, LevelWrapperOptions, LevelWrapperIteratorOptions } from './store/level-wrapper.js';
-export { MessageStoreLevel, MessageStoreLevelConfig } from './store/message-store-level.js';
-export { ResumableTaskStoreLevel, ResumableTaskStoreLevelConfig } from './store/resumable-task-store-level.js';
-export { EventEmitterStream, EventEmitterStreamConfig } from './event-log/event-emitter-stream.js';
+export { BlockstoreLevel } from './store/blockstore-level.js';
+export type { BlockstoreLevelConfig } from './store/blockstore-level.js';
+export { DataStoreLevel } from './store/data-store-level.js';
+export type { DataStoreLevelConfig } from './store/data-store-level.js';
+export { IndexLevel } from './store/index-level.js';
+export type { CompoundIndexDefinition, IndexLevelConfig, IndexedItem, IndexLevelOptions } from './store/index-level.js';
+export { createLevelDatabase, LevelWrapper } from './store/level-wrapper.js';
+export type { CreateLevelDatabaseOptions, LevelDatabase, LevelWrapperConfig, LevelWrapperBatchOperation, LevelWrapperOptions, LevelWrapperIteratorOptions } from './store/level-wrapper.js';
+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 { EventEmitterStream } from './event-stream/event-emitter-stream.js';
+export type { EventEmitterStreamConfig } from './event-stream/event-emitter-stream.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 { GenerateFromRecordsWriteOut, GenerateGrantCreateOutput, GenerateMessagesQueryOutput, GenerateMessagesReadOutput, GenerateMessagesSubscribeOutput, GenerateProtocolsConfigureOutput, GenerateProtocolsQueryOutput, GenerateRecordsDeleteOutput, GenerateRecordsQueryOutput, GenerateRecordsSubscribeOutput, GenerateRecordsWriteOutput, Persona, TestDataGenerator, GenerateFromRecordsWriteInput, GenerateGrantCreateInput, GenerateMessagesQueryInput, GenerateMessagesReadInput, GenerateMessagesSubscribeInput, GenerateProtocolsConfigureInput, GenerateProtocolsQueryInput, GenerateRecordsDeleteInput, GenerateRecordsQueryInput, GenerateRecordsSubscribeInput, GenerateRecordsWriteInput } from '../tests/utils/test-data-generator.js';
+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 { TestDataGenerator } from '../tests/utils/test-data-generator.js';
 export { Poller } from '../tests/utils/poller.js';

package/src/interfaces/messages-read.ts

@@ -1,4 +1,4 @@
-import type { Signer } from '../types/signer.js';
+import type { MessageSigner } from '../types/signer.js';
 import type { MessagesReadDescriptor, MessagesReadMessage } from '../types/messages-types.js';
 
 import { AbstractMessage } from '../core/abstract-message.js';
@@ -10,7 +10,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export type MessagesReadOptions = {
   messageCid: string;
-  signer: Signer;
+  signer: MessageSigner;
   messageTimestamp?: string;
   permissionGrantId?: string;
 };
@@ -27,14 +27,15 @@ export class MessagesRead extends AbstractMessage<MessagesReadMessage> {
   }
 
   public static async create(options: MessagesReadOptions): Promise<MessagesRead> {
+    const { signer, permissionGrantId } = options;
+
     const descriptor: MessagesReadDescriptor = {
       interface        : DwnInterfaceName.Messages,
       method           : DwnMethodName.Read,
       messageCid       : options.messageCid,
       messageTimestamp : options.messageTimestamp ?? Time.getCurrentTimestamp(),
+      ...(permissionGrantId !== undefined && { permissionGrantId }),
     };
-
-    const { signer, permissionGrantId } = options;
     const authorization = await Message.createAuthorization({
       descriptor,
       signer,
@@ -56,7 +57,7 @@ export class MessagesRead extends AbstractMessage<MessagesReadMessage> {
   private static validateMessageCid(messageCid: string): void {
     try {
       Cid.parseCid(messageCid);
-    } catch (_) {
+    } catch {
       throw new DwnError(DwnErrorCode.MessagesReadInvalidCid, `${messageCid} is not a valid CID`);
     }
   }

package/src/interfaces/messages-subscribe.ts

@@ -1,5 +1,5 @@
 import type { MessagesFilter } from '../types/messages-types.js';
-import type { Signer } from '../types/signer.js';
+import type { MessageSigner } from '../types/signer.js';
 import type { MessagesSubscribeDescriptor, MessagesSubscribeMessage } from '../types/messages-types.js';
 
 import { AbstractMessage } from '../core/abstract-message.js';
@@ -11,7 +11,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 
 export type MessagesSubscribeOptions = {
-  signer: Signer;
+  signer: MessageSigner;
   messageTimestamp?: string;
   filters?: MessagesFilter[]
   permissionGrantId?: string;
@@ -43,10 +43,11 @@ export class MessagesSubscribe extends AbstractMessage<MessagesSubscribeMessage>
     const currentTime = Time.getCurrentTimestamp();
 
     const descriptor: MessagesSubscribeDescriptor = {
-      interface        : DwnInterfaceName.Messages,
-      method           : DwnMethodName.Subscribe,
-      filters          : options.filters ?? [],
-      messageTimestamp : options.messageTimestamp ?? currentTime,
+      interface         : DwnInterfaceName.Messages,
+      method            : DwnMethodName.Subscribe,
+      filters           : options.filters ?? [],
+      messageTimestamp  : options.messageTimestamp ?? currentTime,
+      permissionGrantId : options.permissionGrantId,
     };
 
     removeUndefinedProperties(descriptor);

package/src/interfaces/messages-sync.ts

@@ -0,0 +1,59 @@
+import type { MessageSigner } from '../types/signer.js';
+import type { MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncMessage } from '../types/messages-types.js';
+
+import { AbstractMessage } from '../core/abstract-message.js';
+import { Message } from '../core/message.js';
+import { removeUndefinedProperties } from '../utils/object.js';
+import { Time } from '../utils/time.js';
+import { validateProtocolUrlNormalized } from '../utils/url.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export type MessagesSyncOptions = {
+  signer : MessageSigner;
+  action : MessagesSyncAction;
+  protocol? : string;
+  prefix? : string;
+  messageTimestamp? : string;
+  permissionGrantId? : string;
+};
+
+export class MessagesSync extends AbstractMessage<MessagesSyncMessage> {
+
+  public static async parse(message: MessagesSyncMessage): Promise<MessagesSync> {
+    Message.validateJsonSchema(message);
+    await Message.validateSignatureStructure(message.authorization.signature, message.descriptor);
+
+    if (message.descriptor.protocol !== undefined) {
+      validateProtocolUrlNormalized(message.descriptor.protocol);
+    }
+
+    return new MessagesSync(message);
+  }
+
+  public static async create(options: MessagesSyncOptions): Promise<MessagesSync> {
+    const descriptor: MessagesSyncDescriptor = {
+      interface         : DwnInterfaceName.Messages,
+      method            : DwnMethodName.Sync,
+      messageTimestamp  : options.messageTimestamp ?? Time.getCurrentTimestamp(),
+      action            : options.action,
+      protocol          : options.protocol,
+      prefix            : options.prefix,
+      permissionGrantId : options.permissionGrantId,
+    };
+
+    removeUndefinedProperties(descriptor);
+
+    const { permissionGrantId, signer } = options;
+    const authorization = await Message.createAuthorization({
+      descriptor,
+      signer,
+      permissionGrantId
+    });
+
+    const message = { descriptor, authorization };
+
+    Message.validateJsonSchema(message);
+
+    return new MessagesSync(message);
+  }
+}