@serve.zone/interfaces 20.0.0 → 20.1.0

package/ts/private/canonicaljson.ts

@@ -0,0 +1,221 @@
+export const strictCanonicalJsonRules = Object.freeze({
+  version: 1 as const,
+  encoding: 'utf-8' as const,
+  objectKeyOrdering: 'utf-16-code-unit-ascending' as const,
+  arrayOrdering: 'preserved-dense' as const,
+  unicodeNormalization: 'preserved' as const,
+  numberEncoding: 'safe-integer-json-no-negative-zero' as const,
+  digest: 'sha256-lowercase-hex' as const,
+});
+
+export type TCanonicalJsonFailure = (reasonArg: string) => never;
+
+const assertUnicodeScalarString = (
+  valueArg: string,
+  fieldNameArg: string,
+  failArg: TCanonicalJsonFailure,
+): void => {
+  for (let index = 0; index < valueArg.length; index++) {
+    const codeUnit = valueArg.charCodeAt(index);
+    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const followingCodeUnit = valueArg.charCodeAt(index + 1);
+      if (
+        !Number.isInteger(followingCodeUnit) ||
+        followingCodeUnit < 0xdc00 ||
+        followingCodeUnit > 0xdfff
+      ) {
+        failArg(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+      }
+      index++;
+      continue;
+    }
+    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+      failArg(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+    }
+  }
+};
+
+const readStrictRecord = (
+  valueArg: object,
+  fieldNameArg: string,
+  failArg: TCanonicalJsonFailure,
+): Record<string, unknown> => {
+  const prototype = Object.getPrototypeOf(valueArg);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return failArg(`${fieldNameArg} must be a plain object`);
+  }
+  const record = valueArg as Record<string, unknown>;
+  const ownKeys = Reflect.ownKeys(record);
+  if (ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+    return failArg(`${fieldNameArg} must not contain symbol keys`);
+  }
+  for (const key of ownKeys as string[]) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (
+      !descriptor ||
+      !descriptor.enumerable ||
+      !Object.hasOwn(descriptor, 'value')
+    ) {
+      return failArg(
+        `${fieldNameArg} must contain enumerable data properties only`,
+      );
+    }
+  }
+  return record;
+};
+
+const readStrictArray = (
+  valueArg: unknown[],
+  fieldNameArg: string,
+  failArg: TCanonicalJsonFailure,
+): unknown[] => {
+  if (Object.getPrototypeOf(valueArg) !== Array.prototype) {
+    return failArg(`${fieldNameArg} must be a dense plain array`);
+  }
+  for (let index = 0; index < valueArg.length; index++) {
+    if (!Object.hasOwn(valueArg, index)) {
+      return failArg(`${fieldNameArg} must not contain sparse entries`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+    if (
+      !descriptor ||
+      !descriptor.enumerable ||
+      !Object.hasOwn(descriptor, 'value')
+    ) {
+      return failArg(`${fieldNameArg} must contain enumerable data entries only`);
+    }
+  }
+  for (const key of Reflect.ownKeys(valueArg)) {
+    if (key === 'length') {
+      continue;
+    }
+    if (
+      typeof key !== 'string' ||
+      !/^(?:0|[1-9][0-9]*)$/.test(key) ||
+      Number(key) >= valueArg.length
+    ) {
+      return failArg(`${fieldNameArg} must not contain extra properties`);
+    }
+  }
+  return valueArg;
+};
+
+export const canonicalizeStrictJson = (
+  valueArg: unknown,
+  failArg: TCanonicalJsonFailure,
+  fieldNameArg = 'canonical JSON input',
+): string => {
+  const ancestors = new Set<object>();
+
+  const visit = (currentValueArg: unknown, currentFieldNameArg: string): string => {
+    if (currentValueArg === null) {
+      return 'null';
+    }
+    if (typeof currentValueArg === 'boolean') {
+      return currentValueArg ? 'true' : 'false';
+    }
+    if (typeof currentValueArg === 'string') {
+      assertUnicodeScalarString(currentValueArg, currentFieldNameArg, failArg);
+      return JSON.stringify(currentValueArg);
+    }
+    if (typeof currentValueArg === 'number') {
+      if (
+        !Number.isSafeInteger(currentValueArg) ||
+        Object.is(currentValueArg, -0)
+      ) {
+        return failArg(`${currentFieldNameArg} must contain safe integers only`);
+      }
+      return String(currentValueArg);
+    }
+    if (!currentValueArg || typeof currentValueArg !== 'object') {
+      return failArg(`${currentFieldNameArg} contains a non-JSON value`);
+    }
+    if (ancestors.has(currentValueArg)) {
+      return failArg(`${currentFieldNameArg} contains a cycle`);
+    }
+
+    ancestors.add(currentValueArg);
+    try {
+      if (Array.isArray(currentValueArg)) {
+        const array = readStrictArray(
+          currentValueArg,
+          currentFieldNameArg,
+          failArg,
+        );
+        return `[${array
+          .map((entryArg, indexArg) =>
+            visit(entryArg, `${currentFieldNameArg}[${indexArg}]`),
+          )
+          .join(',')}]`;
+      }
+
+      const record = readStrictRecord(
+        currentValueArg,
+        currentFieldNameArg,
+        failArg,
+      );
+      const keys = Object.keys(record).sort((leftArg, rightArg) => {
+        return leftArg < rightArg ? -1 : leftArg > rightArg ? 1 : 0;
+      });
+      return `{${keys
+        .map((keyArg) => {
+          assertUnicodeScalarString(
+            keyArg,
+            `${currentFieldNameArg} key`,
+            failArg,
+          );
+          return `${JSON.stringify(keyArg)}:${visit(
+            record[keyArg],
+            `${currentFieldNameArg}.${keyArg}`,
+          )}`;
+        })
+        .join(',')}}`;
+    } finally {
+      ancestors.delete(currentValueArg);
+    }
+  };
+
+  return visit(valueArg, fieldNameArg);
+};
+
+export const createSha256Hex = async (
+  contentsArg: Uint8Array,
+  failArg: TCanonicalJsonFailure,
+): Promise<string> => {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    return failArg('Web Crypto SHA-256 is unavailable in this runtime');
+  }
+  const digest = await subtle.digest('SHA-256', new Uint8Array(contentsArg));
+  return Array.from(new Uint8Array(digest), (byteArg) =>
+    byteArg.toString(16).padStart(2, '0'),
+  ).join('');
+};
+
+export const createCanonicalJsonSha256Hex = async (
+  canonicalJsonArg: string,
+  failArg: TCanonicalJsonFailure,
+): Promise<string> => {
+  return createSha256Hex(new TextEncoder().encode(canonicalJsonArg), failArg);
+};
+
+export const deepFreezeValue = <T>(
+  valueArg: T,
+  seenArg = new WeakSet<object>(),
+): T => {
+  if (!valueArg || typeof valueArg !== 'object') {
+    return valueArg;
+  }
+  const object = valueArg as object;
+  if (ArrayBuffer.isView(object) || seenArg.has(object)) {
+    return valueArg;
+  }
+  seenArg.add(object);
+  for (const key of Reflect.ownKeys(object)) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (descriptor && Object.hasOwn(descriptor, 'value')) {
+      deepFreezeValue(descriptor.value, seenArg);
+    }
+  }
+  return Object.freeze(valueArg);
+};