@enbox/dwn-sdk-js 0.3.3 → 0.3.5

package/src/handlers/messages-sync.ts

@@ -25,7 +25,7 @@ const DEFAULT_MAX_INLINE_DATA_SIZE = DwnConstant.maxDataSizeAllowedToBeEncoded;
 
 export class MessagesSyncHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -51,9 +51,9 @@ export class MessagesSyncHandler implements MethodHandler {
     try {
       switch (action) {
       case 'root': {
-        const rootHash = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolRoot(tenant, protocol)
-          : await this.deps.stateIndex!.getRoot(tenant);
+        const rootHash = protocol === undefined
+          ? await this.deps.stateIndex!.getRoot(tenant)
+          : await this.deps.stateIndex!.getProtocolRoot(tenant, protocol);
         return {
           status : { code: 200, detail: 'OK' },
           root   : hashToHex(rootHash),
@@ -62,9 +62,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
       case 'subtree': {
         const bitPath = MessagesSyncHandler.parseBitPrefix(prefix!);
-        const hash = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolSubtreeHash(tenant, protocol, bitPath)
-          : await this.deps.stateIndex!.getSubtreeHash(tenant, bitPath);
+        const hash = protocol === undefined
+          ? await this.deps.stateIndex!.getSubtreeHash(tenant, bitPath)
+          : await this.deps.stateIndex!.getProtocolSubtreeHash(tenant, protocol, bitPath);
         return {
           status : { code: 200, detail: 'OK' },
           hash   : hashToHex(hash),
@@ -73,9 +73,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
       case 'leaves': {
         const bitPath = MessagesSyncHandler.parseBitPrefix(prefix!);
-        const leaves = protocol !== undefined
-          ? await this.deps.stateIndex!.getProtocolLeaves(tenant, protocol, bitPath)
-          : await this.deps.stateIndex!.getLeaves(tenant, bitPath);
+        const leaves = protocol === undefined
+          ? await this.deps.stateIndex!.getLeaves(tenant, bitPath)
+          : await this.deps.stateIndex!.getProtocolLeaves(tenant, protocol, bitPath);
         return {
           status  : { code: 200, detail: 'OK' },
           entries : leaves,
@@ -165,18 +165,18 @@ export class MessagesSyncHandler implements MethodHandler {
       if (clientHash === undefined) {
         // Server has entries the client doesn't — enumerate server leaves.
         const bitPath = MessagesSyncHandler.parseBitPrefix(pfx);
-        const leaves = protocol !== undefined
-          ? await stateIndex.getProtocolLeaves(tenant, protocol, bitPath)
-          : await stateIndex.getLeaves(tenant, bitPath);
+        const leaves = protocol === undefined
+          ? await stateIndex.getLeaves(tenant, bitPath)
+          : await stateIndex.getProtocolLeaves(tenant, protocol, bitPath);
         onlyRemoteCids.push(...leaves);
         continue;
       }
 
       // Both sides have entries but they differ — enumerate both and set-diff.
       const bitPath = MessagesSyncHandler.parseBitPrefix(pfx);
-      const serverLeaves = protocol !== undefined
-        ? await stateIndex.getProtocolLeaves(tenant, protocol, bitPath)
-        : await stateIndex.getLeaves(tenant, bitPath);
+      const serverLeaves = protocol === undefined
+        ? await stateIndex.getLeaves(tenant, bitPath)
+        : await stateIndex.getProtocolLeaves(tenant, protocol, bitPath);
 
       // We don't have the client's leaves, so we report all server leaves
       // as onlyRemote (the client will de-duplicate locally). We also
@@ -210,9 +210,9 @@ export class MessagesSyncHandler implements MethodHandler {
 
     const walk = async (prefix: string, currentDepth: number): Promise<void> => {
       const bitPath = MessagesSyncHandler.parseBitPrefix(prefix);
-      const hash = protocol !== undefined
-        ? await stateIndex.getProtocolSubtreeHash(tenant, protocol, bitPath)
-        : await stateIndex.getSubtreeHash(tenant, bitPath);
+      const hash = protocol === undefined
+        ? await stateIndex.getSubtreeHash(tenant, bitPath)
+        : await stateIndex.getProtocolSubtreeHash(tenant, protocol, bitPath);
       const hexHash = hashToHex(hash);
 
       if (hexHash === defaultHashHex) {

package/src/handlers/protocols-configure.ts

@@ -15,7 +15,7 @@ import { getRuleSetAtPath, parseCrossProtocolRef } from '../utils/protocols.js';
 
 export class ProtocolsConfigureHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -298,7 +298,7 @@ export class ProtocolsConfigureHandler implements MethodHandler {
 
             // Check that the role path exists and is marked $role: true in the referenced protocol
             const roleRuleSet = getRuleSetAtPath(parsed.protocolPath, refDefinition.structure);
-            if (roleRuleSet === undefined || !roleRuleSet.$role) {
+            if (!roleRuleSet?.$role) {
               throw new DwnError(
                 DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole,
                 `cross-protocol role '${actionRule.role}' at protocol path '${childProtocolPath}' ` +

package/src/handlers/protocols-query.ts

@@ -11,7 +11,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class ProtocolsQueryHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-count.ts

@@ -14,7 +14,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsCountHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-delete.ts

@@ -18,7 +18,7 @@ import { ResumableTaskName } from '../core/resumable-task-manager.js';
 
 export class RecordsDeleteHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-query.ts

@@ -18,7 +18,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsQueryHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,

package/src/handlers/records-read.ts

@@ -20,7 +20,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsReadHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -115,11 +115,7 @@ export class RecordsReadHandler implements MethodHandler {
     }
 
     let data;
-    if (matchedRecordsWrite.encodedData !== undefined) {
-      const dataBytes = Encoder.base64UrlToBytes(matchedRecordsWrite.encodedData);
-      data = DataStream.fromBytes(dataBytes);
-      delete matchedRecordsWrite.encodedData;
-    } else {
+    if (matchedRecordsWrite.encodedData === undefined) {
       const result = await this.deps.dataStore!.get(tenant, matchedRecordsWrite.recordId, matchedRecordsWrite.descriptor.dataCid);
       if (result?.dataStream === undefined) {
         // The message envelope exists but the record data is unavailable (e.g., evicted
@@ -131,6 +127,10 @@ export class RecordsReadHandler implements MethodHandler {
         };
       }
       data = result.dataStream;
+    } else {
+      const dataBytes = Encoder.base64UrlToBytes(matchedRecordsWrite.encodedData);
+      data = DataStream.fromBytes(dataBytes);
+      delete matchedRecordsWrite.encodedData;
     }
 
     const recordsReadReply: RecordsReadReply = {

package/src/handlers/records-subscribe.ts

@@ -20,7 +20,7 @@ import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.j
 
 export class RecordsSubscribeHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -97,7 +97,7 @@ export class RecordsSubscribeHandler implements MethodHandler {
           const gapInfo = (error as any).gapInfo as ProgressGapInfo | undefined;
           return {
             status : { code: 410, detail: 'Progress token gap' },
-            error  : gapInfo !== undefined ? { code: 'ProgressGap' as const, ...gapInfo } : undefined,
+            error  : gapInfo === undefined ? undefined : { code: 'ProgressGap' as const, ...gapInfo },
           };
         }
         return messageReplyFromError(error, 500);

package/src/handlers/records-write.ts

@@ -27,7 +27,7 @@ type HandlerArgs = { tenant: string, message: RecordsWriteMessage, dataStream?:
 
 export class RecordsWriteHandler implements MethodHandler {
 
-  constructor(private deps: HandlerDependencies) { }
+  constructor(private readonly deps: HandlerDependencies) { }
 
   public async handle({
     tenant,
@@ -106,7 +106,7 @@ export class RecordsWriteHandler implements MethodHandler {
         if (isInitial) {
           const hasInlineData = !!(newestExistingMessage as any).encodedData;
           const hasStoredData = this.deps.dataStore
-            ? !!(await this.deps.dataStore.get(tenant, recordsWrite.message.recordId, message.descriptor.dataCid!))
+            ? !!(await this.deps.dataStore.get(tenant, recordsWrite.message.recordId, message.descriptor.dataCid))
             : false;
           existingLacksData = !hasInlineData && !hasStoredData;
         }
@@ -121,9 +121,9 @@ export class RecordsWriteHandler implements MethodHandler {
 
     // Look up the core protocol (if any) for the incoming message so that lifecycle hooks
     // can be dispatched generically rather than checking for specific protocol URIs.
-    const coreProtocol = message.descriptor.protocol !== undefined
-      ? this.deps.coreProtocols?.get(message.descriptor.protocol)
-      : undefined;
+    const coreProtocol = message.descriptor.protocol === undefined
+      ? undefined
+      : this.deps.coreProtocols?.get(message.descriptor.protocol);
 
     try {
       if (newestExistingMessage?.descriptor.method === DwnMethodName.Delete) {
@@ -148,11 +148,8 @@ export class RecordsWriteHandler implements MethodHandler {
       let isLatestBaseState = false;
       let messageWithOptionalEncodedData = message as RecordsQueryReplyEntry;
 
-      if (dataStream !== undefined) {
-        messageWithOptionalEncodedData = await this.processMessageWithDataStream(tenant, message, dataStream);
-        isLatestBaseState = true;
-      } else {
-        // else data stream is NOT provided
+      if (dataStream === undefined) {
+        // data stream is NOT provided
 
         // if the incoming message is not an initial write, and no dataStream is provided, we would allow it provided it passes validation
         // processMessageWithoutDataStream() abstracts that logic
@@ -161,6 +158,9 @@ export class RecordsWriteHandler implements MethodHandler {
           messageWithOptionalEncodedData = await this.processMessageWithoutDataStream(tenant, message, newestExistingWrite );
           isLatestBaseState = true;
         }
+      } else {
+        messageWithOptionalEncodedData = await this.processMessageWithDataStream(tenant, message, dataStream);
+        isLatestBaseState = true;
       }
 
       const indexes = await recordsWrite.constructIndexes(isLatestBaseState);
@@ -252,14 +252,14 @@ export class RecordsWriteHandler implements MethodHandler {
     // if data is below the threshold, we store it within MessageStore
     if (message.descriptor.dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
       // validate data integrity before setting.
-      const dataBytes = await DataStream.toBytes(dataStream!);
+      const dataBytes = await DataStream.toBytes(dataStream);
       const dataCid = await Cid.computeDagPbCidFromBytes(dataBytes);
       RecordsWriteHandler.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
-        ? this.deps.coreProtocols?.get(message.descriptor.protocol)
-        : undefined;
+      const coreProtocol = message.descriptor.protocol === undefined
+        ? undefined
+        : this.deps.coreProtocols?.get(message.descriptor.protocol);
       if (coreProtocol?.validateRecord !== undefined) {
         coreProtocol.validateRecord(message, dataBytes);
       }
@@ -304,13 +304,13 @@ export class RecordsWriteHandler implements MethodHandler {
 
     if (dataSize <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
       // we encode the data from the original write if it is smaller than the data-store threshold
-      if (newestExistingWrite.encodedData !== undefined) {
-        messageWithOptionalEncodedData.encodedData = newestExistingWrite.encodedData;
-      } else {
+      if (newestExistingWrite.encodedData === undefined) {
         throw new DwnError(
           DwnErrorCode.RecordsWriteMissingEncodedDataInPrevious,
           `No dataStream was provided and unable to get data from previous message`
         );
+      } else {
+        messageWithOptionalEncodedData.encodedData = newestExistingWrite.encodedData;
       }
     } else {
       // else just make sure the data is in the data store
@@ -396,7 +396,7 @@ export class RecordsWriteHandler implements MethodHandler {
       ruleSet = ruleSet[pathSegments[i]] as typeof ruleSet;
     }
 
-    if (ruleSet === undefined || ruleSet.$squash !== true) {
+    if (ruleSet?.$squash !== true) {
       return;
     }
 

package/src/index.ts

@@ -2,7 +2,7 @@
 export type { DwnConfig } from './dwn.js';
 export type { EventListener, EventLog, EventLogEntry, EventLogReadOptions, EventLogReadResult, EventLogSubscribeOptions, EventSubscription, MessageEvent, ProgressGapInfo, ProgressGapReason, ProgressToken, SubscriptionEose, SubscriptionEvent, SubscriptionListener, SubscriptionMessage, 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, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncDiffEntry, MessagesSyncMessage, MessagesSyncReply } from './types/messages-types.js';
+export type { MessagesFilter, MessagesReadMessage, MessagesReadReply, MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions, MessagesSyncAction, MessagesSyncDescriptor, MessagesSyncDiffEntry, 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, ProtocolDeliveryStrategy, ProtocolPathEncryption, ProtocolsQueryDescriptor, ProtocolRecordLimitDefinition, ProtocolSizeDefinition, ProtocolTagsDefinition, ProtocolTagSchema, ProtocolType, ProtocolUses } from './types/protocols-types.js';
 export { ProtocolRecordLimitStrategy } from './types/protocols-types.js';
@@ -30,8 +30,8 @@ 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 } from './interfaces/messages-subscribe.js';
-export type { MessagesSubscribeOptions as MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
+export { MessagesSubscribe } from './interfaces/messages-subscribe.js';
+export type { MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
 export { Encryption, ContentEncryptionAlgorithm, KeyAgreementAlgorithm } from './utils/encryption.js';
 export type { JweEncryption, JweRecipient, JweRecipientHeader, JweProtectedHeader, JweKeyUnwrapPayload } from './utils/encryption.js';
 export { RecordsWrite } from './interfaces/records-write.js';
@@ -40,8 +40,8 @@ export { executeUnlessAborted } from './utils/abort.js';
 export { Jws } from './utils/jws.js';
 export type { KeyMaterial, PrivateKeyJwk, PublicKeyJwk, Jwk } from './types/jose-types.js';
 export { Message } from './core/message.js';
-export { MessagesRead as MessagesRead } from './interfaces/messages-read.js';
-export type { MessagesReadOptions as MessagesReadOptions } from './interfaces/messages-read.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 type { UnionMessageReply } from './core/message-reply.js';

package/src/interfaces/protocols-configure.ts

@@ -377,16 +377,8 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
       for (let j = i + 1; j < actionRules.length; j++) {
         const otherActionRule = actionRules[j];
 
-        if (actionRule.who !== undefined) {
-          if (actionRule.who === otherActionRule.who && actionRule.of === otherActionRule.of) {
-            throw new DwnError(
-              DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet,
-              `More than one action rule per actor ${actionRule.who} of ${actionRule.of} ` +
-              `not allowed within a rule set: ${JSON.stringify(actionRule)}`
-            );
-          }
-        } else {
-          // else implicitly a role-based action rule
+        if (actionRule.who === undefined) {
+          // implicitly a role-based action rule
 
           if (actionRule.role === otherActionRule.role) {
             throw new DwnError(
@@ -394,6 +386,14 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
               `More than one action rule per role ${actionRule.role} not allowed within a rule set: ${JSON.stringify(actionRule)}`
             );
           }
+        } else {
+          if (actionRule.who === otherActionRule.who && actionRule.of === otherActionRule.of) {
+            throw new DwnError(
+              DwnErrorCode.ProtocolsConfigureDuplicateActorInRuleSet,
+              `More than one action rule per actor ${actionRule.who} of ${actionRule.of} ` +
+              `not allowed within a rule set: ${JSON.stringify(actionRule)}`
+            );
+          }
         }
       }
     }
@@ -497,7 +497,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
     }
 
     // validate alias exists in `uses`
-    if (uses === undefined || uses[parsed.alias] === undefined) {
+    if (uses?.[parsed.alias] === undefined) {
       throw new DwnError(
         DwnErrorCode.ProtocolsConfigureInvalidRefAlias,
         `'$ref' alias '${parsed.alias}' at protocol path '${ruleSetProtocolPath}' does not exist in the 'uses' map.`
@@ -543,7 +543,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
       );
     }
 
-    if (uses === undefined || uses[parsed.alias] === undefined) {
+    if (uses?.[parsed.alias] === undefined) {
       const errorCode = fieldName === 'role'
         ? DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolRole
         : DwnErrorCode.ProtocolsConfigureInvalidCrossProtocolOf;

package/src/interfaces/records-delete.ts

@@ -110,7 +110,7 @@ export class RecordsDelete extends AbstractMessage<RecordsDeleteMessage> {
    * @param messageStore Used to check if the grant has been revoked.
    */
   public async authorizeDelegate(recordsWriteToDelete: RecordsWriteMessage, messageStore: MessageStore): Promise<void> {
-    const delegatedGrant = PermissionGrant.parse(this.message.authorization!.authorDelegatedGrant!);
+    const delegatedGrant = PermissionGrant.parse(this.message.authorization.authorDelegatedGrant!);
     await RecordsGrantAuthorization.authorizeDelete({
       recordsDeleteMessage : this.message,
       recordsWriteToDelete,

package/src/interfaces/records-write.ts

@@ -135,9 +135,9 @@ export type CreateFromOptions = {
  * NOTE: Unable to extend `AbstractMessage` directly because the incompatible `_message` type, which is not just a generic `<M>` type.
  */
 export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
-  private parentContextId: string | undefined;
+  private readonly parentContextId: string | undefined;
 
-  private _message: InternalRecordsWriteMessage;
+  private readonly _message: InternalRecordsWriteMessage;
   /**
    * Valid JSON message representing this RecordsWrite.
    * @throws `DwnErrorCode.RecordsWriteMissingSigner` if the message is not signed yet.
@@ -232,10 +232,10 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
       if (message.authorization.ownerSignature !== undefined) {
         // if the message authorization contains owner delegated grant, the owner would be the grantor of the grant
         // else the owner would be the signer of the owner signature
-        if (message.authorization.ownerDelegatedGrant !== undefined) {
-          this._owner = Message.getSigner(message.authorization.ownerDelegatedGrant);
-        } else {
+        if (message.authorization.ownerDelegatedGrant === undefined) {
           this._owner = Jws.getSignerDid(message.authorization.ownerSignature.signatures[0]);
+        } else {
+          this._owner = Message.getSigner(message.authorization.ownerDelegatedGrant);
         }
 
         this._ownerSignaturePayload = Jws.decodePlainObjectPayload(message.authorization.ownerSignature);
@@ -321,7 +321,7 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
       protocol          : normalizeProtocolUrl(options.protocol),
       protocolPath      : options.protocolPath,
       recipient         : options.recipient,
-      schema            : options.schema !== undefined ? normalizeSchemaUrl(options.schema) : undefined,
+      schema            : options.schema === undefined ? undefined : normalizeSchemaUrl(options.schema),
       tags              : options.tags,
       parentId          : RecordsWrite.getRecordIdFromContextId(options.parentContextId),
       dataCid,
@@ -524,11 +524,11 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
     // compute delegated grant ID and author if delegated grant is given
     let delegatedGrantId;
     let authorDid;
-    if (delegatedGrant !== undefined) {
+    if (delegatedGrant === undefined) {
+      authorDid = Jws.extractDid(signer.keyId);
+    } else {
       delegatedGrantId = await Message.getCid(delegatedGrant);
       authorDid = Jws.getSignerDid(delegatedGrant.authorization.signature.signatures[0]);
-    } else {
-      authorDid = Jws.extractDid(signer.keyId);
     }
 
     const descriptor = this._message.descriptor;
@@ -549,7 +549,7 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
     // `signature` generation
     const signature = await createSignerSignature({
       recordId    : this._message.recordId,
-      contextId   : this._message.contextId!, // contextId is computed just above, always defined here
+      contextId   : this._message.contextId, // contextId is computed just above, always defined here
       descriptorCid,
       attestation : this._message.attestation,
       encryption  : this._message.encryption,
@@ -872,7 +872,7 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
   public static async fetchInitialRecordsWrite(
     messageStore: MessageStore, tenant: string, recordId: string
   ): Promise<RecordsWrite | undefined> {
-    return fetchInitialRecordsWrite(messageStore, tenant, recordId) as Promise<RecordsWrite | undefined>;
+    return fetchInitialRecordsWrite(messageStore, tenant, recordId);
   }
 
   /** Delegate to `fetchInitialRecordsWriteMessage` in `records-write-query.ts`. */

package/src/jose/jws/general/builder.ts

@@ -4,7 +4,7 @@ import type { MessageSigner } from '../../../types/signer.js';
 import { Encoder } from '../../../utils/encoder.js';
 
 export class GeneralJwsBuilder {
-  private jws: GeneralJws;
+  private readonly jws: GeneralJws;
 
   private constructor(jws: GeneralJws) {
     this.jws = jws;

package/src/jose/jws/general/verifier.ts

@@ -1,7 +1,7 @@
 import type { Cache } from '../../../types/cache.js';
 import type { GeneralJws } from '../../../types/jws-types.js';
 import type { PublicKeyJwk } from '../../../types/jose-types.js';
-import type { DidResolver, DidVerificationMethod } from '@enbox/dids';
+import type { DidResolutionResult, DidResolver, DidVerificationMethod } from '@enbox/dids';
 
 import { Encoder } from '../../../utils/encoder.js';
 import { Jws } from '../../../utils/jws.js';
@@ -89,12 +89,19 @@ export class GeneralJwsVerifier {
 
   /**
    * Gets the public key given a fully qualified key ID (`kid`) by resolving the DID to its DID Document.
+   *
+   * Throws `GeneralJwsVerifierGetPublicKeyNotFound` when the public key cannot be located.
+   * The error message distinguishes between two failure modes so callers can tell them apart:
+   *   1. DID resolution failed (network error, DID not published, method not supported, etc.).
+   *      The resolution metadata error code and message are included.
+   *   2. DID resolved successfully but the requested `kid` does not match any verification
+   *      method in the DID Document. The list of available verification method IDs is included.
    */
   private static async getPublicKey(kid: string, didResolver: DidResolver): Promise<PublicKeyJwk> {
     // `resolve` throws exception if DID is invalid, DID method is not supported,
     // or resolving DID fails
     const did = Jws.extractDid(kid);
-    const { didDocument } = await didResolver.resolve(did);
+    const { didDocument, didResolutionMetadata } = await didResolver.resolve(did);
     const { verificationMethod: verificationMethods = [] } = didDocument || {};
 
     let verificationMethod: DidVerificationMethod | undefined;
@@ -110,7 +117,10 @@ export class GeneralJwsVerifier {
     }
 
     if (!verificationMethod) {
-      throw new DwnError(DwnErrorCode.GeneralJwsVerifierGetPublicKeyNotFound, 'public key needed to verify signature not found in DID Document');
+      throw new DwnError(
+        DwnErrorCode.GeneralJwsVerifierGetPublicKeyNotFound,
+        GeneralJwsVerifier.buildPublicKeyNotFoundMessage(kid, did, didDocument, didResolutionMetadata, verificationMethods),
+      );
     }
 
     validateJsonSchema('JwkVerificationMethod', verificationMethod);
@@ -119,4 +129,35 @@ export class GeneralJwsVerifier {
 
     return publicJwk as PublicKeyJwk;
   }
+
+  /**
+   * Builds a diagnostic error message for `GeneralJwsVerifierGetPublicKeyNotFound`.
+   * Surfaces resolution metadata or available verification methods so operators can
+   * distinguish between an unreachable DID and a `kid` mismatch.
+   */
+  private static buildPublicKeyNotFoundMessage(
+    kid: string,
+    did: string,
+    didDocument: DidResolutionResult['didDocument'],
+    didResolutionMetadata: DidResolutionResult['didResolutionMetadata'] | undefined,
+    verificationMethods: DidVerificationMethod[],
+  ): string {
+    const resolutionError = didResolutionMetadata?.error;
+    if (resolutionError !== undefined) {
+      const resolutionErrorMessage = didResolutionMetadata?.errorMessage;
+      const detail = resolutionErrorMessage ? `${resolutionError} — ${resolutionErrorMessage}` : resolutionError;
+      return `unable to resolve DID '${did}' to verify signature with kid '${kid}': ${detail}`;
+    }
+
+    if (didDocument === undefined || didDocument === null) {
+      return `DID Document not found for '${did}' when verifying signature with kid '${kid}'`;
+    }
+
+    if (verificationMethods.length === 0) {
+      return `DID Document for '${did}' has no verification methods to verify signature with kid '${kid}'`;
+    }
+
+    const availableIds = verificationMethods.map((method) => method.id).join(', ');
+    return `public key for kid '${kid}' not found in DID Document for '${did}' (available verification methods: [${availableIds}])`;
+  }
 }

package/src/protocols/permissions.ts

@@ -605,7 +605,7 @@ export class PermissionsProtocol implements CoreProtocol {
    */
   private static validateTags(requestOrGrant: RecordsWriteMessage, scopedProtocol: string): void {
     // the protocol tag must be included with the record.
-    if (requestOrGrant.descriptor.tags === undefined || requestOrGrant.descriptor.tags.protocol === undefined) {
+    if (requestOrGrant.descriptor.tags?.protocol === undefined) {
       throw new DwnError(
         DwnErrorCode.PermissionsProtocolValidateScopeMissingProtocolTag,
         'Permission grants must have a `tags` property that contains a protocol tag'

package/src/smt/smt-store-level.ts

@@ -31,7 +31,7 @@ type SerializedLeafNode = {
 type SerializedNode = SerializedInternalNode | SerializedLeafNode;
 
 export class SMTStoreLevel implements SMTNodeStore {
-  private db: LevelWrapper<string>;
+  private readonly db: LevelWrapper<string>;
   private nodesPartition!: LevelWrapper<string>;
   private metaPartition!: LevelWrapper<string>;
   private initialized = false;

package/src/smt/smt-store-memory.ts

@@ -8,7 +8,7 @@ import type { Hash, SMTNode, SMTNodeStore } from '../types/smt-types.js';
 import { hashToHex } from './smt-utils.js';
 
 export class SMTStoreMemory implements SMTNodeStore {
-  private nodes: Map<string, SMTNode> = new Map();
+  private readonly nodes: Map<string, SMTNode> = new Map();
   private root: Hash | undefined;
 
   async open(): Promise<void> {