@enbox/dwn-sdk-js 0.4.5 → 0.4.7

package/src/utils/secp256r1.ts

@@ -1,14 +1,12 @@
 import type { JwkParamsEcPrivate, JwkParamsEcPublic } from '@enbox/crypto';
 import type { PrivateKeyJwk, PublicKeyJwk } from '../types/jose-types.js';
 
-import { p256, secp256r1 } from '@noble/curves/p256';
+import { bytesToNumberBE } from '@noble/curves/utils.js';
+import { p256 } from '@noble/curves/nist.js';
 
 import { Encoder } from './encoder.js';
 import { sha256 } from 'multiformats/hashes/sha2';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
-import { fromString, toString } from 'uint8arrays';
-
-const u8a = { toString, fromString };
 
 /**
  * Class containing SECP256R1 related utility methods.
@@ -37,8 +35,8 @@ export class Secp256r1 {
     let uncompressedPublicKeyBytes;
     if (publicKeyBytes.byteLength === 33) {
       // this means given key is compressed
-      const curvePoints = p256.ProjectivePoint.fromHex(publicKeyBytes);
-      uncompressedPublicKeyBytes = curvePoints.toRawBytes(false); // isCompressed = false
+      const curvePoints = p256.Point.fromBytes(publicKeyBytes);
+      uncompressedPublicKeyBytes = curvePoints.toBytes(false); // isCompressed = false
     } else {
       uncompressedPublicKeyBytes = publicKeyBytes;
     }
@@ -87,9 +85,7 @@ export class Secp256r1 {
     const hashedContent = await sha256.encode(content);
     const privateKeyBytes = Secp256r1.privateJwkToBytes(privateJwk);
 
-    return Promise.resolve(
-      p256.sign(hashedContent, privateKeyBytes).toCompactRawBytes()
-    );
+    return Promise.resolve(p256.sign(hashedContent, privateKeyBytes, { prehash: false }));
   }
 
   /**
@@ -104,21 +100,15 @@ export class Secp256r1 {
   ): Promise<boolean> {
     Secp256r1.validateKey(publicJwk);
 
-    // handle DER vs compact signature formats
-    let sig;
-    if (signature.length === 64) {
-      sig = p256.Signature.fromCompact(signature);
-    } else {
-      sig = p256.Signature.fromDER(signature);
-    }
+    const signatureFormat = signature.length === 64 ? 'compact' : 'der';
     const hashedContent = await sha256.encode(content);
     const ecJwk = publicJwk as JwkParamsEcPublic;
-    const keyBytes = p256.ProjectivePoint.fromAffine({
+    const keyBytes = p256.Point.fromAffine({
       x : Secp256r1.bytesToBigInt(Encoder.base64UrlToBytes(ecJwk.x)),
       y : Secp256r1.bytesToBigInt(Encoder.base64UrlToBytes(ecJwk.y!)),
-    }).toRawBytes(false);
+    }).toBytes(false);
 
-    return p256.verify(sig, hashedContent, keyBytes);
+    return p256.verify(signature, hashedContent, keyBytes, { format: signatureFormat, lowS: false, prehash: false });
   }
 
   /**
@@ -128,8 +118,8 @@ export class Secp256r1 {
     publicJwk: PublicKeyJwk;
     privateJwk: PrivateKeyJwk;
   }> {
-    const privateKeyBytes = p256.utils.randomPrivateKey();
-    const publicKeyBytes = secp256r1.getPublicKey(privateKeyBytes, false); // `false` = uncompressed
+    const privateKeyBytes = p256.utils.randomSecretKey();
+    const publicKeyBytes = p256.getPublicKey(privateKeyBytes, false); // `false` = uncompressed
 
     const d = Encoder.bytesToBase64Url(privateKeyBytes);
     const publicJwk: PublicKeyJwk = await Secp256r1.publicKeyToJwk(publicKeyBytes);
@@ -139,6 +129,6 @@ export class Secp256r1 {
   }
 
   public static bytesToBigInt(b: Uint8Array): bigint {
-    return BigInt(`0x` + u8a.toString(b, 'base16'));
+    return bytesToNumberBE(b);
   }
 }

package/src/utils/time.ts

@@ -1,7 +1,24 @@
 import { sleep } from '@enbox/common';
-import { Temporal } from '@js-temporal/polyfill';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 
+type ParsedTimestamp = {
+  epochMilliseconds: number;
+  microsecond: number;
+};
+
+type TimestampOptions = {
+  year?: number;
+  month?: number;
+  day?: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+  millisecond?: number;
+  microsecond?: number;
+};
+
+const timestampRegex = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{6})Z$/;
+
 /**
  * Time related utilities.
  */
@@ -19,10 +36,9 @@ export class Time {
 
   /**
    * Returns an UTC ISO-8601 timestamp with microsecond precision accepted by DWN.
-   * using @js-temporal/polyfill
    */
   public static getCurrentTimestamp(): string {
-    return Temporal.Now.instant().toString({ smallestUnit: 'microseconds' });
+    return Time.formatUtcTimestamp(Date.now(), 0);
   }
 
   /**
@@ -30,21 +46,21 @@ export class Time {
    * @param options - Options for creating the timestamp.
    * @returns string
    */
-  public static createTimestamp(options: {
-    year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, microsecond?: number
-  }): string {
-    const { year, month, day, hour, minute, second, millisecond, microsecond } = options;
-    return Temporal.ZonedDateTime.from({
-      timeZone: 'UTC',
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      millisecond,
-      microsecond
-    }).toInstant().toString({ smallestUnit: 'microseconds' });
+  public static createTimestamp(options: TimestampOptions): string {
+    const year = Time.constrainInteger(Time.requireTimestampField(options.year, 'year'), 0, 9999);
+    const month = Time.constrainInteger(Time.requireTimestampField(options.month, 'month'), 1, 12);
+    const day = Time.constrainInteger(Time.requireTimestampField(options.day, 'day'), 1, Time.daysInUtcMonth(year, month));
+    const hour = Time.constrainInteger(options.hour ?? 0, 0, 23);
+    const minute = Time.constrainInteger(options.minute ?? 0, 0, 59);
+    const second = Time.constrainInteger(options.second ?? 0, 0, 59);
+    const millisecond = Time.constrainInteger(options.millisecond ?? 0, 0, 999);
+    const microsecond = Time.constrainInteger(options.microsecond ?? 0, 0, 999);
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, millisecond);
+
+    return Time.formatUtcTimestamp(date.getTime(), microsecond);
   }
 
   /**
@@ -52,22 +68,124 @@ export class Time {
    * @param offset Negative number means offset into the past.
    */
   public static createOffsetTimestamp(offset: { seconds: number }, timestamp?: string): string {
-    const timestampInstant = timestamp ? Temporal.Instant.from(timestamp) : Temporal.Now.instant();
-    const offsetDuration = Temporal.Duration.from(offset);
-    const offsetInstant = timestampInstant.add(offsetDuration);
-    return offsetInstant.toString({ smallestUnit: 'microseconds' });
+    const parsedTimestamp = timestamp === undefined ? { epochMilliseconds: Date.now(), microsecond: 0 } : Time.parseTimestamp(timestamp);
+    if (parsedTimestamp === undefined) {
+      throw new DwnError(DwnErrorCode.TimestampInvalid, `Invalid timestamp: ${timestamp}`);
+    }
+
+    const offsetSeconds = Time.requireWholeNumber(offset.seconds, 'seconds');
+    return Time.formatUtcTimestamp(parsedTimestamp.epochMilliseconds + (offsetSeconds * 1000), parsedTimestamp.microsecond);
   }
 
   /**
-   * Validates that the provided timestamp is a valid number
+   * Validates that the provided timestamp is a DWN-compatible UTC timestamp.
    * @param timestamp the timestamp to validate
-   * @throws DwnError if timestamp is not a valid number
+   * @throws DwnError if timestamp is invalid
    */
   public static validateTimestamp(timestamp: string): void {
-    try {
-      Temporal.Instant.from(timestamp);
-    } catch {
+    if (Time.parseTimestamp(timestamp) === undefined) {
       throw new DwnError(DwnErrorCode.TimestampInvalid, `Invalid timestamp: ${timestamp}`);
     }
   }
+
+  private static constrainInteger(value: number, min: number, max: number): number {
+    if (!Number.isFinite(value)) {
+      throw new RangeError('timestamp field must be finite');
+    }
+
+    const integer = Math.trunc(value);
+    return Math.min(Math.max(integer, min), max);
+  }
+
+  private static daysInUtcMonth(year: number, month: number): number {
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month, 0);
+
+    return date.getUTCDate();
+  }
+
+  private static formatUtcTimestamp(epochMilliseconds: number, microsecond: number): string {
+    if (!Number.isFinite(epochMilliseconds)) {
+      throw new RangeError('timestamp is outside the supported Date range');
+    }
+
+    const date = new Date(epochMilliseconds);
+    const year = date.getUTCFullYear();
+    if (year < 0 || year > 9999) {
+      throw new RangeError('timestamp year must be between 0000 and 9999');
+    }
+
+    const fraction = String((date.getUTCMilliseconds() * 1000) + microsecond).padStart(6, '0');
+    return `${Time.pad(year, 4)}-${Time.pad(date.getUTCMonth() + 1, 2)}-${Time.pad(date.getUTCDate(), 2)}` +
+      `T${Time.pad(date.getUTCHours(), 2)}:${Time.pad(date.getUTCMinutes(), 2)}:${Time.pad(date.getUTCSeconds(), 2)}.${fraction}Z`;
+  }
+
+  private static pad(value: number, length: number): string {
+    return String(value).padStart(length, '0');
+  }
+
+  private static parseTimestamp(timestamp: string): ParsedTimestamp | undefined {
+    const match = timestampRegex.exec(timestamp);
+    if (match === null) {
+      return undefined;
+    }
+
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const fraction = match[7];
+    const millisecond = Number(fraction.slice(0, 3));
+    const microsecond = Number(fraction.slice(3));
+    const isLeapSecond = hour === 23 && minute === 59 && second === 60;
+
+    if (
+      month < 1 ||
+      month > 12 ||
+      day < 1 ||
+      day > Time.daysInUtcMonth(year, month) ||
+      hour > 23 ||
+      minute > 59 ||
+      (second > 59 && !isLeapSecond)
+    ) {
+      return undefined;
+    }
+
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, isLeapSecond ? 59 : second, millisecond);
+
+    if (
+      date.getUTCFullYear() !== year ||
+      date.getUTCMonth() !== month - 1 ||
+      date.getUTCDate() !== day ||
+      date.getUTCHours() !== hour ||
+      date.getUTCMinutes() !== minute ||
+      date.getUTCSeconds() !== (isLeapSecond ? 59 : second)
+    ) {
+      return undefined;
+    }
+
+    return { epochMilliseconds: date.getTime(), microsecond };
+  }
+
+  private static requireTimestampField(value: number | undefined, fieldName: string): number {
+    if (value === undefined) {
+      throw new TypeError(`required property '${fieldName}' missing or undefined`);
+    }
+
+    return value;
+  }
+
+  private static requireWholeNumber(value: number, fieldName: string): number {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      throw new RangeError(`${fieldName} must be a finite integer`);
+    }
+
+    return value;
+  }
 }

package/src/types/mitt.d.ts

@@ -1,28 +0,0 @@
-// mitt v3 does not include `"type": "module"` in its package.json, so under
-// TypeScript's `NodeNext` module resolution the `export default function` in
-// mitt's own typings is treated as a CJS namespace rather than a callable.
-// This ambient module declaration re-exports the factory as a proper ESM
-// default so `import mitt from 'mitt'` type-checks correctly.
-declare module 'mitt' {
-  type EventType = string | symbol;
-  type Handler<T = unknown> = (event: T) => void;
-  type EventHandlerList<T = unknown> = Array<Handler<T>>;
-  type WildCardEventHandlerList<T = Record<string, unknown>> = Array<
-    (type: keyof T, event: T[keyof T]) => void
-  >;
-  type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
-    keyof Events | '*',
-    EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
-  >;
-
-  interface Emitter<Events extends Record<EventType, unknown>> {
-    all: EventHandlerMap<Events>;
-    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
-    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
-    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
-  }
-
-  export default function mitt<Events extends Record<EventType, unknown>>(
-    all?: EventHandlerMap<Events>
-  ): Emitter<Events>;
-}