@interop/did-method-webvh 3.0.0

package/dist/utils/canonicalize.js

@@ -0,0 +1,80 @@
+import { canonicalizeEx } from 'json-canonicalize';
+const sanitizeForCanonicalization = (value, seen) => {
+    if (value === null)
+        return null;
+    const type = typeof value;
+    if (type === 'undefined') {
+        throw new Error('Canonicalization input contains undefined in array position');
+    }
+    if (type === 'function' || type === 'symbol' || type === 'bigint') {
+        throw new Error(`Canonicalization input contains unsupported type: ${type}`);
+    }
+    if (type === 'number' && !Number.isFinite(value)) {
+        throw new Error('Canonicalization input contains non-finite number');
+    }
+    if (type !== 'object')
+        return value;
+    const obj = value;
+    if (seen.has(obj)) {
+        throw new Error('Canonicalization input contains circular references');
+    }
+    if (Array.isArray(obj)) {
+        const sanitizedArray = [];
+        seen.set(obj, sanitizedArray);
+        for (const item of obj) {
+            sanitizedArray.push(sanitizeForCanonicalization(item, seen));
+        }
+        return sanitizedArray;
+    }
+    const sanitizedObject = {};
+    seen.set(obj, sanitizedObject);
+    for (const [key, entry] of Object.entries(obj)) {
+        if (typeof entry === 'undefined') {
+            continue;
+        }
+        sanitizedObject[key] = sanitizeForCanonicalization(entry, seen);
+    }
+    return sanitizedObject;
+};
+const assertJsonCompatible = (value, seen) => {
+    if (value === null)
+        return;
+    const type = typeof value;
+    if (type === 'undefined') {
+        throw new Error('Canonicalization input contains undefined');
+    }
+    if (type === 'function' || type === 'symbol' || type === 'bigint') {
+        throw new Error(`Canonicalization input contains unsupported type: ${type}`);
+    }
+    if (type === 'number' && !Number.isFinite(value)) {
+        throw new Error('Canonicalization input contains non-finite number');
+    }
+    if (type !== 'object')
+        return;
+    const obj = value;
+    if (seen.has(obj)) {
+        throw new Error('Canonicalization input contains circular references');
+    }
+    seen.add(obj);
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            assertJsonCompatible(item, seen);
+        }
+        return;
+    }
+    for (const entry of Object.values(obj)) {
+        assertJsonCompatible(entry, seen);
+    }
+};
+export function validateStrictJsonValue(value) {
+    assertJsonCompatible(value, new WeakSet());
+}
+export const canonicalizeStrict = (value) => {
+    const sanitized = sanitizeForCanonicalization(value, new WeakMap());
+    validateStrictJsonValue(sanitized);
+    return canonicalizeEx(sanitized, {
+        allowCircular: false,
+        filterUndefined: true,
+        undefinedInArrayToNull: false,
+    });
+};

package/dist/utils/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function createHash(data: string): Promise<Uint8Array>;
+export declare function createHashHex(data: string): Promise<string>;

package/dist/utils/crypto.js

@@ -0,0 +1,17 @@
+/// <reference lib="dom" />
+import { sha256 } from '@noble/hashes/sha2.js';
+const encoder = new TextEncoder();
+function arrayBufferToHex(buffer) {
+    const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    return Array.from(view)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+export async function createHash(data) {
+    return sha256(encoder.encode(data));
+}
+export async function createHashHex(data) {
+    const hash = await createHash(data);
+    const view = new Uint8Array(hash.buffer);
+    return arrayBufferToHex(view);
+}

package/dist/utils/multiformats.d.ts

@@ -0,0 +1,100 @@
+/**
+ * multiformats.ts
+ *
+ * This file provides utilities for working with Multibase and Multihash formats
+ * as specified in the DID:WebVH method specification.
+ */
+/**
+ * Supported Multibase encoding types
+ */
+export declare enum MultibaseEncoding {
+    BASE64URL_NO_PAD = "u",
+    BASE58_BTC = "z"
+}
+/**
+ * Encodes binary data using Base64URL (no padding)
+ * @param bytes - The binary data to encode
+ * @returns The base64url encoded string (without the multibase prefix)
+ */
+export declare function encodeBase64Url(bytes: Uint8Array): string;
+/**
+ * Encodes binary data using Base58BTC
+ * @param bytes - The binary data to encode
+ * @returns The base58btc encoded string (without the multibase prefix)
+ */
+export declare function encodeBase58Btc(bytes: Uint8Array): string;
+/**
+ * Decodes a Base58BTC string to binary data
+ * @param str - The base58btc encoded string
+ * @returns The decoded binary data
+ */
+export declare function decodeBase58Btc(str: string): Uint8Array;
+/**
+ * Encodes binary data using the specified multibase encoding
+ * @param bytes - The binary data to encode
+ * @param encoding - The multibase encoding to use
+ * @returns The multibase encoded string (including the prefix)
+ */
+export declare function multibaseEncode(bytes: Uint8Array, encoding?: MultibaseEncoding): string;
+/**
+ * Decodes a multibase encoded string to binary data
+ * @param str - The multibase encoded string
+ * @returns The decoded binary data and the encoding used
+ */
+export declare function multibaseDecode(str: string): {
+    bytes: Uint8Array;
+    encoding: MultibaseEncoding;
+};
+/**
+ * Supported Multihash algorithm identifiers
+ */
+export declare enum MultihashAlgorithm {
+    SHA2_256 = 18,
+    SHA2_384 = 32,
+    SHA3_256 = 22,
+    SHA3_384 = 21
+}
+/**
+ * Expected digest lengths for each algorithm (in bytes)
+ */
+export declare const DIGEST_LENGTHS: {
+    18: number;
+    32: number;
+    22: number;
+    21: number;
+};
+/**
+ * Creates a multihash from a digest and algorithm
+ * @param digest - The digest bytes
+ * @param algorithm - The hash algorithm used
+ * @returns The multihash as a Uint8Array
+ */
+export declare function createMultihash(digest: Uint8Array, algorithm: MultihashAlgorithm): Uint8Array;
+/**
+ * Decodes a multihash
+ * @param bytes - The multihash bytes
+ * @returns The decoded multihash components
+ */
+export declare function decodeMultihash(bytes: Uint8Array): {
+    algorithm: MultihashAlgorithm;
+    digestLength: number;
+    digest: Uint8Array;
+};
+/**
+ * Encodes a multihash using multibase encoding
+ * @param multihash - The multihash bytes
+ * @param encoding - The multibase encoding to use
+ * @returns The multibase encoded multihash
+ */
+export declare function encodeMultihashWithMultibase(multihash: Uint8Array, encoding?: MultibaseEncoding): string;
+/**
+ * Decodes a multibase encoded multihash
+ * @param str - The multibase encoded multihash
+ * @returns The decoded multihash components and the encoding used
+ */
+export declare function decodeMultihashFromMultibase(str: string): {
+    algorithm: MultihashAlgorithm;
+    digestLength: number;
+    digest: Uint8Array;
+    encoding: MultibaseEncoding;
+};

package/dist/utils/multiformats.js

@@ -0,0 +1,283 @@
+/**
+ * multiformats.ts
+ *
+ * This file provides utilities for working with Multibase and Multihash formats
+ * as specified in the DID:WebVH method specification.
+ */
+// ===== MULTIBASE IMPLEMENTATION =====
+/**
+ * Supported Multibase encoding types
+ */
+export var MultibaseEncoding;
+(function (MultibaseEncoding) {
+    MultibaseEncoding["BASE64URL_NO_PAD"] = "u";
+    MultibaseEncoding["BASE58_BTC"] = "z";
+})(MultibaseEncoding || (MultibaseEncoding = {}));
+/**
+ * Base encoding alphabets
+ */
+const BASE_ALPHABETS = {
+    [MultibaseEncoding.BASE64URL_NO_PAD]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+    [MultibaseEncoding.BASE58_BTC]: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+};
+/**
+ * Encodes binary data using Base64URL (no padding)
+ * @param bytes - The binary data to encode
+ * @returns The base64url encoded string (without the multibase prefix)
+ */
+export function encodeBase64Url(bytes) {
+    // Convert to base64
+    const base64 = Buffer.from(bytes).toString('base64');
+    // Convert to base64url by replacing + with - and / with _
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+/**
+ * Decodes a Base64URL (no padding) string to binary data
+ * @param str - The base64url encoded string
+ * @returns The decoded binary data
+ */
+function decodeBase64Url(str) {
+    // Add padding if necessary
+    const padding = str.length % 4 === 0 ? 0 : 4 - (str.length % 4);
+    const base64 = str.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat(padding);
+    // Decode base64 to binary
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Encodes binary data using Base58BTC
+ * @param bytes - The binary data to encode
+ * @returns The base58btc encoded string (without the multibase prefix)
+ */
+export function encodeBase58Btc(bytes) {
+    const ALPHABET = BASE_ALPHABETS[MultibaseEncoding.BASE58_BTC];
+    // Count leading zeros
+    let zeros = 0;
+    for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
+        zeros++;
+    }
+    // Convert to a big integer
+    let num = 0n;
+    for (let i = 0; i < bytes.length; i++) {
+        num = num * 256n + BigInt(bytes[i]);
+    }
+    // Convert to base58
+    let result = '';
+    while (num > 0n) {
+        const remainder = Number(num % 58n);
+        num = num / 58n;
+        result = ALPHABET[remainder] + result;
+    }
+    // Add leading '1's for each leading zero byte
+    return '1'.repeat(zeros) + result;
+}
+/**
+ * Decodes a Base58BTC string to binary data
+ * @param str - The base58btc encoded string
+ * @returns The decoded binary data
+ */
+export function decodeBase58Btc(str) {
+    const ALPHABET = BASE_ALPHABETS[MultibaseEncoding.BASE58_BTC];
+    // Count leading '1's (representing leading zero bytes)
+    let zeros = 0;
+    for (let i = 0; i < str.length && str[i] === '1'; i++) {
+        zeros++;
+    }
+    // Convert from base58 to a big integer
+    let num = 0n;
+    for (let i = zeros; i < str.length; i++) {
+        const char = str[i];
+        const value = ALPHABET.indexOf(char);
+        if (value === -1) {
+            throw new Error(`Invalid Base58 character: ${char}`);
+        }
+        num = num * 58n + BigInt(value);
+    }
+    // Convert to bytes
+    const bytes = [];
+    while (num > 0n) {
+        bytes.unshift(Number(num % 256n));
+        num = num / 256n;
+    }
+    // Add leading zeros
+    return new Uint8Array([...new Array(zeros).fill(0), ...bytes]);
+}
+/**
+ * Encodes binary data using the specified multibase encoding
+ * @param bytes - The binary data to encode
+ * @param encoding - The multibase encoding to use
+ * @returns The multibase encoded string (including the prefix)
+ */
+export function multibaseEncode(bytes, encoding = MultibaseEncoding.BASE64URL_NO_PAD) {
+    let encoded;
+    switch (encoding) {
+        case MultibaseEncoding.BASE64URL_NO_PAD:
+            encoded = encodeBase64Url(bytes);
+            break;
+        case MultibaseEncoding.BASE58_BTC:
+            encoded = encodeBase58Btc(bytes);
+            break;
+        default:
+            throw new Error(`Unsupported multibase encoding: ${encoding}`);
+    }
+    return `${encoding}${encoded}`;
+}
+/**
+ * Decodes a multibase encoded string to binary data
+ * @param str - The multibase encoded string
+ * @returns The decoded binary data and the encoding used
+ */
+export function multibaseDecode(str) {
+    if (!str || str.length < 2) {
+        throw new Error('Invalid multibase string: too short');
+    }
+    const prefix = str[0];
+    const encoded = str.slice(1);
+    let bytes;
+    switch (prefix) {
+        case MultibaseEncoding.BASE64URL_NO_PAD:
+            bytes = decodeBase64Url(encoded);
+            break;
+        case MultibaseEncoding.BASE58_BTC:
+            bytes = decodeBase58Btc(encoded);
+            break;
+        default:
+            throw new Error(`Unsupported multibase encoding prefix: ${prefix}`);
+    }
+    return { bytes, encoding: prefix };
+}
+// ===== MULTIHASH IMPLEMENTATION =====
+/**
+ * Supported Multihash algorithm identifiers
+ */
+export var MultihashAlgorithm;
+(function (MultihashAlgorithm) {
+    MultihashAlgorithm[MultihashAlgorithm["SHA2_256"] = 18] = "SHA2_256";
+    MultihashAlgorithm[MultihashAlgorithm["SHA2_384"] = 32] = "SHA2_384";
+    MultihashAlgorithm[MultihashAlgorithm["SHA3_256"] = 22] = "SHA3_256";
+    MultihashAlgorithm[MultihashAlgorithm["SHA3_384"] = 21] = "SHA3_384";
+})(MultihashAlgorithm || (MultihashAlgorithm = {}));
+/**
+ * Expected digest lengths for each algorithm (in bytes)
+ */
+export const DIGEST_LENGTHS = {
+    [MultihashAlgorithm.SHA2_256]: 32,
+    [MultihashAlgorithm.SHA2_384]: 48,
+    [MultihashAlgorithm.SHA3_256]: 32,
+    [MultihashAlgorithm.SHA3_384]: 48,
+};
+/**
+ * Encodes a varint (variable integer)
+ * @param value - The integer to encode
+ * @returns The encoded varint as a Uint8Array
+ */
+function encodeVarint(value) {
+    const bytes = [];
+    while (value >= 0x80) {
+        bytes.push((value & 0x7f) | 0x80);
+        value >>>= 7;
+    }
+    bytes.push(value & 0x7f);
+    return new Uint8Array(bytes);
+}
+/**
+ * Decodes a varint (variable integer)
+ * @param bytes - The bytes containing the varint
+ * @param offset - The starting offset in the bytes array
+ * @returns The decoded value and the number of bytes read
+ */
+function decodeVarint(bytes, offset = 0) {
+    let value = 0;
+    let shift = 0;
+    let bytesRead = 0;
+    let byte = 0;
+    do {
+        if (offset + bytesRead >= bytes.length) {
+            throw new Error('Invalid varint: buffer too short');
+        }
+        byte = bytes[offset + bytesRead];
+        value |= (byte & 0x7f) << shift;
+        shift += 7;
+        bytesRead++;
+    } while (byte & 0x80);
+    return { value, bytesRead };
+}
+/**
+ * Creates a multihash from a digest and algorithm
+ * @param digest - The digest bytes
+ * @param algorithm - The hash algorithm used
+ * @returns The multihash as a Uint8Array
+ */
+export function createMultihash(digest, algorithm) {
+    const expectedLength = DIGEST_LENGTHS[algorithm];
+    if (digest.length !== expectedLength) {
+        throw new Error(`Invalid digest length for algorithm ${algorithm.toString(16)}: expected ${expectedLength}, got ${digest.length}`);
+    }
+    const algorithmBytes = encodeVarint(algorithm);
+    const lengthBytes = encodeVarint(digest.length);
+    const result = new Uint8Array(algorithmBytes.length + lengthBytes.length + digest.length);
+    result.set(algorithmBytes, 0);
+    result.set(lengthBytes, algorithmBytes.length);
+    result.set(digest, algorithmBytes.length + lengthBytes.length);
+    return result;
+}
+/**
+ * Decodes a multihash
+ * @param bytes - The multihash bytes
+ * @returns The decoded multihash components
+ */
+export function decodeMultihash(bytes) {
+    if (bytes.length < 2) {
+        throw new Error('Invalid multihash: too short');
+    }
+    // Decode the algorithm identifier
+    const { value: algorithm, bytesRead: algorithmBytesRead } = decodeVarint(bytes, 0);
+    // Decode the digest length
+    const { value: digestLength, bytesRead: lengthBytesRead } = decodeVarint(bytes, algorithmBytesRead);
+    // Extract the digest
+    const offset = algorithmBytesRead + lengthBytesRead;
+    if (bytes.length - offset < digestLength) {
+        throw new Error(`Invalid multihash: digest too short, expected ${digestLength} bytes`);
+    }
+    const digest = bytes.slice(offset, offset + digestLength);
+    // Verify the algorithm is supported
+    if (!Object.values(MultihashAlgorithm).includes(algorithm)) {
+        throw new Error(`Unsupported multihash algorithm: 0x${algorithm.toString(16)}`);
+    }
+    // Verify the digest length matches the expected length for the algorithm
+    const expectedLength = DIGEST_LENGTHS[algorithm];
+    if (digestLength !== expectedLength) {
+        throw new Error(`Invalid digest length for algorithm 0x${algorithm.toString(16)}: expected ${expectedLength}, got ${digestLength}`);
+    }
+    return {
+        algorithm: algorithm,
+        digestLength,
+        digest,
+    };
+}
+/**
+ * Encodes a multihash using multibase encoding
+ * @param multihash - The multihash bytes
+ * @param encoding - The multibase encoding to use
+ * @returns The multibase encoded multihash
+ */
+export function encodeMultihashWithMultibase(multihash, encoding = MultibaseEncoding.BASE64URL_NO_PAD) {
+    return multibaseEncode(multihash, encoding);
+}
+/**
+ * Decodes a multibase encoded multihash
+ * @param str - The multibase encoded multihash
+ * @returns The decoded multihash components and the encoding used
+ */
+export function decodeMultihashFromMultibase(str) {
+    const { bytes, encoding } = multibaseDecode(str);
+    const multihash = decodeMultihash(bytes);
+    return {
+        ...multihash,
+        encoding,
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,49 @@
+import type { CreateDIDInterface, DIDDoc, DIDLog, ParsedDidKeyVerificationMethod, VerificationMethod, WitnessProofFileEntry } from './interfaces.js';
+export declare function parseDidKeyDid(input: string): {
+    did: string;
+    keyMultibase: string;
+};
+export declare function parseDidKeyVerificationMethod(input: string): ParsedDidKeyVerificationMethod;
+interface ParsedAddress {
+    canonicalHost: string;
+    canonicalPort?: number;
+    didDomainComponent: string;
+    paths?: string[];
+}
+export declare function parseCanonicalAddress(input: string): ParsedAddress;
+export declare const DID_PLACEHOLDER = "{DID}";
+export declare function validateCreateDidDocument(didDocument: DIDDoc): void;
+export declare function replaceCreateDidPlaceholders<T>(input: T, scid: string, did: string): T;
+export declare function convertWebvhIdToWebId(id: string): string;
+export declare function enrichAlsoKnownAs(doc: DIDDoc, did: string, opts: {
+    alsoKnownAsWeb?: boolean;
+}): DIDDoc;
+export declare function generateParallelDidWeb(didwebvhDid: string, didwebvhDoc: DIDDoc): DIDDoc;
+export declare const readLogFromDisk: (path: string) => Promise<DIDLog>;
+export declare const readLogFromString: (str: string) => DIDLog;
+export declare const writeLogToDisk: (path: string, log: DIDLog) => Promise<void>;
+export declare const maybeWriteTestLog: (did: string, log: DIDLog) => Promise<void>;
+export declare const writeVerificationMethodToEnv: (verificationMethod: VerificationMethod) => Promise<void>;
+export declare const clone: (input: any) => any;
+export declare function deepClone(obj: any): any;
+export declare const getBaseUrl: (id: string) => string;
+export declare const getFileUrl: (id: string) => string;
+export declare function fetchLogFromIdentifier(identifier: string): Promise<DIDLog>;
+export declare const createDate: (created?: Date | string) => string;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare const createSCID: (logEntryHash: string) => Promise<string>;
+export declare function deriveHash(input: any): Promise<string>;
+export declare const deriveNextKeyHash: (input: string) => Promise<string>;
+export declare const createDIDDoc: (options: CreateDIDInterface) => Promise<{
+    doc: DIDDoc;
+}>;
+export declare const generateRandomId: (length?: number) => string;
+export declare const createVMID: (vm: VerificationMethod, did: string | null) => string;
+export declare const normalizeVMs: (verificationMethod: VerificationMethod[] | undefined, did?: string | null) => any;
+export declare const resolveVM: (vm: string) => Promise<VerificationMethod | {
+    publicKeyMultibase: string;
+} | null>;
+export declare const findVerificationMethod: (doc: any, vmId: string) => VerificationMethod | null;
+export declare function fetchWitnessProofs(did: string): Promise<WitnessProofFileEntry[]>;
+export declare function replaceValueInObject(obj: any, searchValue: string, replaceValue: string): any;
+export {};