@enbox/dwn-sdk-js 0.4.6 → 0.4.8

package/src/interfaces/records-write.ts

@@ -96,9 +96,9 @@ export type RecordsWriteOptions = {
 
 export type {
   EncryptionInput,
-  KeyEncryptionInput,
   ProtocolPathKeyEncryptionInput,
-  RoleAudienceKeyEncryptionInput,
+  SourceRoleAudienceKeyEncryptionInput,
+  X25519KeyEncryptionInput,
 } from '../utils/encryption.js';
 
 export type CreateFromOptions = {
@@ -301,45 +301,8 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
    *                                If not given, it means this write is for a root protocol record.
    */
   public static async create(options: RecordsWriteOptions): Promise<RecordsWrite> {
-    RecordsWrite.validateCreateOptions(options);
-
-    const dataCid = options.dataCid ?? await Cid.computeDagPbCidFromBytes(options.data!);
-    const dataSize = options.dataSize ?? options.data!.length;
-
-    const currentTime = Time.getCurrentTimestamp();
-    const permissionGrantInvocation = Message.normalizePermissionGrantInvocation({
-      permissionGrantId: options.permissionGrantId,
-    });
-
-    const descriptor: RecordsWriteDescriptor = {
-      interface        : DwnInterfaceName.Records,
-      method           : DwnMethodName.Write,
-      protocol         : normalizeProtocolUrl(options.protocol),
-      protocolPath     : options.protocolPath,
-      recipient        : options.recipient,
-      schema           : options.schema === undefined ? undefined : normalizeSchemaUrl(options.schema),
-      tags             : options.tags,
-      parentId         : RecordsWrite.getRecordIdFromContextId(options.parentContextId),
-      dataCid,
-      dataSize,
-      dateCreated      : options.dateCreated ?? currentTime,
-      messageTimestamp : options.messageTimestamp ?? currentTime,
-      published        : options.published,
-      datePublished    : options.datePublished,
-      dataFormat       : options.dataFormat,
-      squash           : options.squash,
-      ...permissionGrantInvocation,
-    };
-
-    // generate `datePublished` if the message is to be published but `datePublished` is not given
-    if (options.published === true &&
-      options.datePublished === undefined) {
-      descriptor.datePublished = currentTime;
-    }
-
-    // delete all descriptor properties that are `undefined` else the code will encounter the following IPLD issue when attempting to generate CID:
-    // Error: `undefined` is not supported by the IPLD Data Model and cannot be encoded
-    removeUndefinedProperties(descriptor);
+    RecordsWrite.validateCreateOptions(options, { requireSignerForDelegatedGrant: true });
+    const descriptor = await RecordsWrite.createDescriptor(options);
 
     // `recordId` computation
     const recordId = options.recordId;
@@ -350,6 +313,9 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
 
     // `encryption` generation
     const encryption = options.encryption ?? await createEncryptionProperty(options.encryptionInput);
+    const permissionGrantInvocation = Message.normalizePermissionGrantInvocation({
+      permissionGrantId: options.permissionGrantId,
+    });
 
     const message: InternalRecordsWriteMessage = {
       recordId,
@@ -374,7 +340,47 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
     return recordsWrite;
   }
 
-  private static validateCreateOptions(options: RecordsWriteOptions): void {
+  /**
+   * Creates the descriptor that determines a RecordsWrite entry id without signing the message.
+   */
+  public static async createDescriptor(options: RecordsWriteOptions): Promise<RecordsWriteDescriptor> {
+    RecordsWrite.validateCreateOptions(options, { requireSignerForDelegatedGrant: false });
+
+    const dataCid = options.dataCid ?? await Cid.computeDagPbCidFromBytes(options.data!);
+    const dataSize = options.dataSize ?? options.data!.length;
+    const currentTime = Time.getCurrentTimestamp();
+    const permissionGrantInvocation = Message.normalizePermissionGrantInvocation({
+      permissionGrantId: options.permissionGrantId,
+    });
+    const descriptor: RecordsWriteDescriptor = {
+      interface        : DwnInterfaceName.Records,
+      method           : DwnMethodName.Write,
+      protocol         : normalizeProtocolUrl(options.protocol),
+      protocolPath     : options.protocolPath,
+      recipient        : options.recipient,
+      schema           : options.schema === undefined ? undefined : normalizeSchemaUrl(options.schema),
+      tags             : options.tags,
+      parentId         : RecordsWrite.getRecordIdFromContextId(options.parentContextId),
+      dataCid,
+      dataSize,
+      dateCreated      : options.dateCreated ?? currentTime,
+      messageTimestamp : options.messageTimestamp ?? currentTime,
+      published        : options.published,
+      datePublished    : options.datePublished,
+      dataFormat       : options.dataFormat,
+      squash           : options.squash,
+      ...permissionGrantInvocation,
+    };
+
+    if (options.published === true && options.datePublished === undefined) {
+      descriptor.datePublished = currentTime;
+    }
+
+    removeUndefinedProperties(descriptor);
+    return descriptor;
+  }
+
+  private static validateCreateOptions(options: RecordsWriteOptions, optionsOverrides: { requireSignerForDelegatedGrant: boolean }): void {
     if (options.protocol === undefined || options.protocolPath === undefined) {
       throw new DwnError(DwnErrorCode.RecordsWriteCreateMissingProtocol, '`protocol` and `protocolPath` are required');
     }
@@ -389,7 +395,7 @@ export class RecordsWrite implements MessageInterface<RecordsWriteMessage> {
       throw new DwnError(DwnErrorCode.RecordsWriteCreateDataCidAndDataSizeMutuallyInclusive, '`dataCid` and `dataSize` must both be defined or undefined at the same time');
     }
 
-    if (options.signer === undefined && options.delegatedGrant !== undefined) {
+    if (optionsOverrides.requireSignerForDelegatedGrant && options.signer === undefined && options.delegatedGrant !== undefined) {
       throw new DwnError(DwnErrorCode.RecordsWriteCreateMissingSigner, '`signer` must be given when `delegatedGrant` is given');
     }
 

package/src/jose/algorithms/signing/ed25519.ts

@@ -1,7 +1,8 @@
-import * as Ed25519 from '@noble/ed25519';
 import type { JwkParamsOkpPrivate, JwkParamsOkpPublic } from '@enbox/crypto';
 import type { PrivateKeyJwk, PublicKeyJwk, SignatureAlgorithm } from '../../../types/jose-types.js';
 
+import { ed25519 as Ed25519 } from '@noble/curves/ed25519.js';
+
 import { Encoder } from '../../../utils/encoder.js';
 import { DwnError, DwnErrorCode } from '../../../core/dwn-error.js';
 
@@ -30,7 +31,7 @@ export const ed25519: SignatureAlgorithm = {
 
     const privateKeyBytes = Encoder.base64UrlToBytes((privateJwk as JwkParamsOkpPrivate).d);
 
-    return Ed25519.signAsync(content, privateKeyBytes);
+    return Ed25519.sign(content, privateKeyBytes);
   },
 
   verify: async (content: Uint8Array, signature: Uint8Array, publicJwk: PublicKeyJwk): Promise<boolean> => {
@@ -38,12 +39,12 @@ export const ed25519: SignatureAlgorithm = {
 
     const publicKeyBytes = Encoder.base64UrlToBytes((publicJwk as JwkParamsOkpPublic).x);
 
-    return Ed25519.verifyAsync(signature, content, publicKeyBytes);
+    return Ed25519.verify(signature, content, publicKeyBytes);
   },
 
   generateKeyPair: async (): Promise<{publicJwk: PublicKeyJwk, privateJwk: PrivateKeyJwk}> => {
-    const privateKeyBytes = Ed25519.utils.randomPrivateKey();
-    const publicKeyBytes = await Ed25519.getPublicKeyAsync(privateKeyBytes);
+    const privateKeyBytes = Ed25519.utils.randomSecretKey();
+    const publicKeyBytes = Ed25519.getPublicKey(privateKeyBytes);
 
     const d = Encoder.bytesToBase64Url(privateKeyBytes);
 
@@ -56,4 +57,4 @@ export const ed25519: SignatureAlgorithm = {
   publicKeyToJwk: async (publicKeyBytes: Uint8Array): Promise<PublicKeyJwk> => {
     return publicKeyToJwk(publicKeyBytes);
   }
-};
+};

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

@@ -64,7 +64,7 @@ export class GeneralJwsVerifier {
       }
 
       const cacheKey = `${signatureEntry.protected}.${jws.payload}.${signatureEntry.signature}`;
-      const cachedValue = await this.cache.get(cacheKey);
+      const cachedValue = await this.cache.get<boolean>(cacheKey);
 
       // explicit `undefined` check to differentiate `false`
       if (cachedValue === undefined) {
@@ -109,7 +109,7 @@ export class GeneralJwsVerifier {
     for (const method of verificationMethods) {
       // consider optimizing using a set for O(1) lookups if needed
       // key ID in DID Document may or may not be fully qualified. e.g.
-      // `did:ion:alice#key1` or `#key1`
+      // `did:example:alice#key1` or `#key1`
       if (kid.endsWith(method.id)) {
         verificationMethod = method;
         break;
@@ -160,4 +160,4 @@ export class GeneralJwsVerifier {
     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}])`;
   }
-}
+}