@interop/did-method-webvh 3.0.0

package/dist/method_versions/method.v1.0.js

@@ -0,0 +1,554 @@
+import { documentStateIsValid, hashChainValid, newKeysAreInNextKeys, scidIsFromHash } from '../assertions.js';
+import { METHOD, PLACEHOLDER } from '../constants.js';
+import { DidResolutionError } from '../interfaces.js';
+import { createDate, createDIDDoc, createSCID, deepClone, deriveHash, enrichAlsoKnownAs, findVerificationMethod, generateParallelDidWeb, getBaseUrl, parseCanonicalAddress, replaceCreateDidPlaceholders, replaceValueInObject, validateCreateDidDocument, } from '../utils.js';
+import { countVerifiedWitnessApprovals, fetchWitnessProofs, validateWitnessParameter } from '../witness.js';
+const VERSION = '1.0';
+const PROTOCOL = `did:${METHOD}:${VERSION}`;
+const requireDidId = (id) => {
+    if (!id) {
+        throw new Error('DID document id is missing');
+    }
+    return id;
+};
+export const createDID = async (options) => {
+    if (!options.updateKeys) {
+        throw new Error('Update keys not supplied');
+    }
+    if (options.witness?.witnesses && options.witness.witnesses.length > 0) {
+        validateWitnessParameter(options.witness);
+    }
+    // Parse address input with strict validation
+    const addressInput = options.address || options.domain;
+    if (!addressInput) {
+        throw new Error('Either address or domain must be provided');
+    }
+    const parsed = parseCanonicalAddress(addressInput);
+    const didDomainComponent = parsed.didDomainComponent;
+    const allPaths = [...(parsed.paths || []), ...(options.paths || [])];
+    const path = allPaths.length > 0 ? allPaths.join(':') : undefined;
+    const controller = `did:${METHOD}:${PLACEHOLDER}:${didDomainComponent}${path ? `:${path}` : ''}`;
+    const createdDate = createDate(options.created);
+    // Safety guard: Strip secret keys from verification methods before creating DID document
+    const safeVerificationMethods = options.verificationMethods?.map((vm) => {
+        if (vm.secretKeyMultibase) {
+            console.warn('Warning: Removing secretKeyMultibase from verification method - secret keys should not be stored in DID documents');
+            const { secretKeyMultibase, ...safeVm } = vm;
+            return safeVm;
+        }
+        return vm;
+    });
+    let doc;
+    if (options.didDocument) {
+        validateCreateDidDocument(options.didDocument);
+        doc = deepClone(options.didDocument);
+    }
+    else {
+        if (!safeVerificationMethods || safeVerificationMethods.length === 0) {
+            throw new Error('verificationMethods must be provided when didDocument is not supplied');
+        }
+        const didDocResult = await createDIDDoc({
+            ...options,
+            domain: addressInput,
+            paths: allPaths,
+            controller,
+            verificationMethods: safeVerificationMethods,
+        });
+        doc = didDocResult.doc;
+    }
+    doc = enrichAlsoKnownAs(doc, controller, {
+        alsoKnownAsWeb: options.alsoKnownAsWeb,
+    });
+    const params = {
+        scid: PLACEHOLDER,
+        updateKeys: options.updateKeys,
+        portable: options.portable ?? false,
+        nextKeyHashes: options.nextKeyHashes ?? [],
+        watchers: options.watchers ?? [],
+        witness: options.witness ?? {},
+        deactivated: false,
+    };
+    const initialLogEntry = {
+        versionId: PLACEHOLDER,
+        versionTime: createdDate,
+        parameters: {
+            method: PROTOCOL,
+            ...params,
+        },
+        state: doc,
+    };
+    const initialLogEntryHash = await deriveHash(initialLogEntry);
+    params.scid = await createSCID(initialLogEntryHash);
+    initialLogEntry.state = doc;
+    const didWithScid = controller.replaceAll(PLACEHOLDER, params.scid);
+    const prelimEntry = replaceCreateDidPlaceholders(initialLogEntry, params.scid, didWithScid);
+    prelimEntry.state = enrichAlsoKnownAs(prelimEntry.state, didWithScid, {
+        alsoKnownAsWeb: options.alsoKnownAsWeb,
+    });
+    const logEntryHash2 = await deriveHash(prelimEntry);
+    prelimEntry.versionId = `1-${logEntryHash2}`;
+    const proofTemplate = {
+        type: 'DataIntegrityProof',
+        cryptosuite: 'eddsa-jcs-2022',
+        verificationMethod: options.signer.getVerificationMethodId(),
+        created: createdDate,
+        proofPurpose: 'assertionMethod',
+    };
+    const signedProof = await options.signer.sign({ document: prelimEntry, proof: proofTemplate });
+    const allProofs = [{ ...proofTemplate, proofValue: signedProof.proofValue }];
+    prelimEntry.proof = allProofs;
+    const verified = await documentStateIsValid({ ...prelimEntry, versionId: `1-${logEntryHash2}` }, params.updateKeys, params.witness, true, // skipWitnessVerification
+    options.verifier);
+    if (!verified) {
+        throw new Error(`version ${prelimEntry.versionId} is invalid.`);
+    }
+    const didId = requireDidId(prelimEntry.state.id);
+    const webDoc = options.alsoKnownAsWeb ? generateParallelDidWeb(didId, prelimEntry.state) : undefined;
+    return {
+        did: didId,
+        doc: prelimEntry.state,
+        meta: {
+            versionId: prelimEntry.versionId,
+            created: prelimEntry.versionTime,
+            updated: prelimEntry.versionTime,
+            prerotation: (params.nextKeyHashes?.length ?? 0) > 0,
+            ...params,
+        },
+        log: [prelimEntry],
+        ...(webDoc ? { webDoc } : {}),
+    };
+};
+export const resolveDIDFromLog = async (log, options = {}) => {
+    if (options.verificationMethod && (options.versionNumber || options.versionId)) {
+        throw new Error('Cannot specify both verificationMethod and version number/id');
+    }
+    const resolutionLog = log.map((l) => deepClone(l));
+    const protocol = resolutionLog[0]?.parameters?.method;
+    if (protocol !== PROTOCOL) {
+        throw new Error(`'${protocol}' is not a supported method version.`);
+    }
+    let did = '';
+    let doc = null;
+    let resolvedDoc = null;
+    let lastValidDoc = null;
+    const meta = {
+        versionId: '',
+        created: '',
+        updated: '',
+        deactivated: false,
+        portable: false,
+        scid: '',
+        updateKeys: [],
+        nextKeyHashes: [],
+        prerotation: false,
+        witness: undefined,
+        watchers: null,
+    };
+    let resolvedMeta = null;
+    let lastValidMeta = null;
+    let i = 0;
+    let host = '';
+    const requiredWitnessChecks = [];
+    // Fast resolution is opt-in; full verification is the default conformant path.
+    const fastResolve = options.fastResolve ?? false;
+    const isFirstEntry = (idx) => idx === 0;
+    const isLastFewEntries = (idx) => idx >= resolutionLog.length - 10; // Verify last 10 entries
+    const shouldVerifyEntry = (idx) => !fastResolve || isFirstEntry(idx) || isLastFewEntries(idx);
+    try {
+        while (i < resolutionLog.length) {
+            const { versionId, versionTime, parameters, state, proof } = resolutionLog[i];
+            const [version, entryHash] = versionId.split('-');
+            const previousWitness = meta.witness ? deepClone(meta.witness) : undefined;
+            if (parseInt(version, 10) !== i + 1) {
+                throw new Error(`version '${version}' in log doesn't match expected '${i + 1}'.`);
+            }
+            meta.versionId = versionId;
+            if (versionTime) {
+                // TODO check timestamps make sense
+            }
+            meta.updated = versionTime;
+            let newDoc = state;
+            if (version === '1') {
+                meta.created = versionTime;
+                newDoc = state;
+                host = newDoc.id.split(':').at(-1);
+                meta.scid = parameters.scid;
+                if (options.scid && options.scid !== meta.scid) {
+                    throw new Error(`SCID in DID '${options.scid}' does not match SCID in log '${meta.scid}'`);
+                }
+                meta.portable = parameters.portable ?? meta.portable;
+                meta.updateKeys = parameters.updateKeys;
+                meta.nextKeyHashes = parameters.nextKeyHashes || [];
+                meta.prerotation = meta.nextKeyHashes.length > 0;
+                meta.witness = parameters.witness || meta.witness;
+                meta.watchers = parameters.watchers ?? null;
+                if (shouldVerifyEntry(i)) {
+                    // Optimized: Use efficient object manipulation instead of JSON stringify/parse
+                    const logEntry = {
+                        versionId: PLACEHOLDER,
+                        versionTime: meta.created,
+                        parameters: replaceValueInObject(parameters, meta.scid, PLACEHOLDER),
+                        state: replaceValueInObject(newDoc, meta.scid, PLACEHOLDER),
+                    };
+                    const logEntryHash = await deriveHash(logEntry);
+                    meta.previousLogEntryHash = logEntryHash;
+                    if (!(await scidIsFromHash(meta.scid, logEntryHash))) {
+                        throw new Error(`SCID '${meta.scid}' not derived from logEntryHash '${logEntryHash}'`);
+                    }
+                    // Optimized: Direct object manipulation instead of JSON stringify/parse
+                    const prelimEntry = replaceValueInObject(logEntry, PLACEHOLDER, meta.scid);
+                    const logEntryHash2 = await deriveHash(prelimEntry);
+                    const verified = await documentStateIsValid({ ...prelimEntry, versionId: `1-${logEntryHash2}`, proof }, meta.updateKeys, meta.witness, false, options.verifier);
+                    if (!verified) {
+                        throw new Error(`version ${meta.versionId} failed verification of the proof.`);
+                    }
+                }
+            }
+            else {
+                // version number > 1
+                const newHost = newDoc.id.split(':').at(-1);
+                if (!meta.portable && newHost !== host) {
+                    throw new Error('Cannot move DID: portability is disabled');
+                }
+                else if (newHost !== host) {
+                    host = newHost;
+                }
+                // Hash chain — ALWAYS runs (cheap), even in fast-resolve
+                const { proof: _proof, ...entryWithoutProof } = resolutionLog[i];
+                const recomputedHash = await deriveHash({ ...entryWithoutProof, versionId: resolutionLog[i - 1].versionId });
+                if (!hashChainValid(recomputedHash, entryHash)) {
+                    throw new Error(`Hash chain broken at '${meta.versionId}'`);
+                }
+                if (shouldVerifyEntry(i)) {
+                    // Signature verification — expensive, skipped for middle entries in fast-resolve
+                    const keys = meta.prerotation ? parameters.updateKeys : meta.updateKeys;
+                    const verified = await documentStateIsValid(resolutionLog[i], keys, meta.witness, false, options.verifier);
+                    if (!verified) {
+                        throw new Error(`version ${meta.versionId} failed verification of the proof.`);
+                    }
+                    if (meta.prerotation) {
+                        await newKeysAreInNextKeys(parameters.updateKeys ?? [], meta.nextKeyHashes ?? []);
+                    }
+                }
+                if (parameters.updateKeys) {
+                    meta.updateKeys = parameters.updateKeys;
+                }
+                if (parameters.deactivated === true) {
+                    meta.deactivated = true;
+                }
+                if (parameters.nextKeyHashes && parameters.nextKeyHashes.length > 0) {
+                    meta.nextKeyHashes = parameters.nextKeyHashes;
+                    meta.prerotation = true;
+                }
+                else {
+                    meta.nextKeyHashes = [];
+                    meta.prerotation = false;
+                }
+                if ('witness' in parameters) {
+                    meta.witness = parameters.witness;
+                }
+                else if (parameters.witnesses) {
+                    meta.witness = {
+                        witnesses: parameters.witnesses,
+                        threshold: parameters.witnessThreshold || parameters.witnesses.length,
+                    };
+                }
+                if (meta.witness?.witnesses?.length) {
+                    validateWitnessParameter(meta.witness);
+                }
+                if ('watchers' in parameters) {
+                    meta.watchers = parameters.watchers ?? null;
+                }
+            }
+            const requiredWitness = getRequiredWitnessForEntry(previousWitness, parameters, meta.witness);
+            if (requiredWitness) {
+                requiredWitnessChecks.push({
+                    targetVersionId: meta.versionId,
+                    targetVersionNumber: parseInt(version, 10),
+                    witness: requiredWitness,
+                });
+            }
+            // Optimized: Use efficient cloning instead of clone() function
+            doc = deepClone(newDoc);
+            did = doc.id;
+            // Only add default services for entries we need to process
+            if (shouldVerifyEntry(i) || i === resolutionLog.length - 1) {
+                // Add default services if they don't exist
+                doc.service = Array.isArray(doc.service) ? doc.service : [];
+                const baseUrl = getBaseUrl(did);
+                if (!doc.service.some((s) => s.id === '#files')) {
+                    doc.service.push({
+                        id: '#files',
+                        type: 'relativeRef',
+                        serviceEndpoint: baseUrl,
+                    });
+                }
+                if (!doc.service.some((s) => s.id === '#whois')) {
+                    doc.service.push({
+                        '@context': 'https://identity.foundation/linked-vp/contexts/v1',
+                        id: '#whois',
+                        type: 'LinkedVerifiablePresentation',
+                        serviceEndpoint: `${baseUrl}/whois.vp`,
+                    });
+                }
+            }
+            if (options.verificationMethod && findVerificationMethod(doc, options.verificationMethod)) {
+                if (!resolvedDoc) {
+                    resolvedDoc = deepClone(doc);
+                    resolvedMeta = { ...meta };
+                }
+            }
+            if (options.versionNumber === parseInt(version, 10) || options.versionId === meta.versionId) {
+                if (!resolvedDoc) {
+                    resolvedDoc = deepClone(doc);
+                    resolvedMeta = { ...meta };
+                }
+            }
+            if (options.versionTime && options.versionTime > new Date(meta.updated)) {
+                if (resolutionLog[i + 1] && options.versionTime < new Date(resolutionLog[i + 1].versionTime)) {
+                    if (!resolvedDoc) {
+                        resolvedDoc = deepClone(doc);
+                        resolvedMeta = { ...meta };
+                    }
+                }
+                else if (!resolutionLog[i + 1]) {
+                    if (!resolvedDoc) {
+                        resolvedDoc = deepClone(doc);
+                        resolvedMeta = { ...meta };
+                    }
+                }
+            }
+            lastValidDoc = deepClone(doc);
+            lastValidMeta = { ...meta };
+            i++;
+        }
+        if (requiredWitnessChecks.length > 0) {
+            if (!options.witnessProofs) {
+                options.witnessProofs = await fetchWitnessProofs(did);
+            }
+            const publishedVersionNumbers = new Map(resolutionLog.map((entry, index) => [entry.versionId, index + 1]));
+            for (const check of requiredWitnessChecks) {
+                const candidateProofs = (options.witnessProofs ?? []).filter((witnessProof) => {
+                    const proofVersionNumber = publishedVersionNumbers.get(witnessProof.versionId);
+                    return proofVersionNumber !== undefined && proofVersionNumber >= check.targetVersionNumber;
+                });
+                const approvals = await countVerifiedWitnessApprovals(resolutionLog[check.targetVersionNumber - 1], candidateProofs, check.witness, options.verifier);
+                const threshold = parseInt((check.witness.threshold ?? 0).toString(), 10);
+                if (approvals < threshold) {
+                    throw new Error(`Witness threshold not met for version ${check.targetVersionId}: got ${approvals}, need ${check.witness.threshold}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (!resolvedDoc) {
+            throw e;
+        }
+        if (resolvedMeta) {
+            const message = e instanceof Error ? e.message : String(e);
+            resolvedMeta.error = DidResolutionError.InvalidDid;
+            resolvedMeta.problemDetails = {
+                type: 'https://w3id.org/security#INVALID_CONTROLLED_IDENTIFIER_DOCUMENT_ID',
+                title: 'The resolved DID is invalid.',
+                detail: message,
+            };
+        }
+    }
+    if (!resolvedDoc) {
+        resolvedDoc = lastValidDoc;
+        resolvedMeta = lastValidMeta;
+    }
+    if (!resolvedMeta) {
+        throw new Error('DID resolution failed: No valid metadata found');
+    }
+    return {
+        did,
+        doc: resolvedDoc,
+        meta: resolvedMeta,
+    };
+};
+export const updateDID = async (options) => {
+    const log = options.log;
+    const lastEntry = log[log.length - 1];
+    const lastMeta = (await resolveDIDFromLog(log, { verifier: options.verifier, witnessProofs: options.witnessProofs }))
+        .meta;
+    if (lastMeta.deactivated) {
+        throw new Error('Cannot update deactivated DID');
+    }
+    const versionNumber = log.length + 1;
+    const createdDate = createDate(options.updated);
+    const watchersValue = options.watchers !== undefined ? options.watchers : lastMeta.watchers;
+    const witnessInput = options.witness;
+    const witness = witnessInput?.witnesses?.length
+        ? {
+            witnesses: witnessInput.witnesses,
+            threshold: witnessInput.threshold ?? 0,
+        }
+        : {};
+    const params = {
+        updateKeys: options.updateKeys ?? [],
+        nextKeyHashes: options.nextKeyHashes ?? [],
+        witness,
+        watchers: watchersValue ?? [],
+    };
+    if (params.witness?.witnesses?.length) {
+        validateWitnessParameter(params.witness);
+    }
+    // Safety guard: Strip secret keys from verification methods before creating DID document
+    const safeVerificationMethods = options.verificationMethods?.map((vm) => {
+        if (vm.secretKeyMultibase) {
+            console.warn('Warning: Removing secretKeyMultibase from verification method - secret keys should not be stored in DID documents');
+            const { secretKeyMultibase, ...safeVm } = vm;
+            return safeVm;
+        }
+        return vm;
+    });
+    const { doc } = await createDIDDoc({
+        ...options,
+        controller: options.controller || lastEntry.state.id || '',
+        context: options.context || lastEntry.state['@context'],
+        domain: options.domain ?? lastEntry.state.id?.split(':').at(-1) ?? '',
+        updateKeys: options.updateKeys ?? [],
+        verificationMethods: safeVerificationMethods ?? [],
+    });
+    // Add services if provided
+    if (options.services && options.services.length > 0) {
+        doc.service = options.services;
+    }
+    // Add assertionMethod if provided
+    if (options.assertionMethod) {
+        doc.assertionMethod = options.assertionMethod;
+    }
+    // Add keyAgreement if provided
+    if (options.keyAgreement) {
+        doc.keyAgreement = options.keyAgreement;
+    }
+    const logEntry = {
+        versionId: lastEntry.versionId,
+        versionTime: createdDate,
+        parameters: params,
+        state: doc,
+    };
+    const logEntryHash = await deriveHash(logEntry);
+    const versionId = `${versionNumber}-${logEntryHash}`;
+    const prelimEntry = { ...logEntry, versionId };
+    const proofTemplate = {
+        type: 'DataIntegrityProof',
+        cryptosuite: 'eddsa-jcs-2022',
+        verificationMethod: options.signer.getVerificationMethodId(),
+        created: createdDate,
+        proofPurpose: 'assertionMethod',
+    };
+    const signedProof = await options.signer.sign({ document: prelimEntry, proof: proofTemplate });
+    const allProofs = [{ ...proofTemplate, proofValue: signedProof.proofValue }];
+    prelimEntry.proof = allProofs;
+    const keysToVerify = lastMeta.prerotation ? params.updateKeys : lastMeta.updateKeys;
+    const verified = await documentStateIsValid(prelimEntry, keysToVerify, lastMeta.witness, true, options.verifier);
+    if (!verified) {
+        throw new Error(`version ${prelimEntry.versionId} is invalid.`);
+    }
+    const meta = {
+        ...lastMeta,
+        versionId: prelimEntry.versionId,
+        updated: prelimEntry.versionTime,
+        prerotation: (params.nextKeyHashes?.length ?? 0) > 0,
+        ...params,
+    };
+    const hasWebAlias = (prelimEntry.state.alsoKnownAs ?? []).some((alias) => alias.startsWith('did:web:'));
+    const didId = requireDidId(prelimEntry.state.id);
+    const webDoc = hasWebAlias ? generateParallelDidWeb(didId, prelimEntry.state) : undefined;
+    return {
+        did: didId,
+        doc: prelimEntry.state,
+        meta,
+        log: [...log, prelimEntry],
+        ...(webDoc ? { webDoc } : {}),
+    };
+};
+export const deactivateDID = async (options) => {
+    const log = options.log;
+    const lastEntry = log[log.length - 1];
+    const lastMeta = (await resolveDIDFromLog(log, { verifier: options.verifier })).meta;
+    if (lastMeta.deactivated) {
+        throw new Error('DID already deactivated');
+    }
+    const versionNumber = log.length + 1;
+    const createdDate = createDate();
+    const params = {
+        updateKeys: options.updateKeys ?? lastMeta.updateKeys,
+        deactivated: true,
+    };
+    const logEntry = {
+        versionId: lastEntry.versionId,
+        versionTime: createdDate,
+        parameters: params,
+        state: lastEntry.state,
+    };
+    const logEntryHash = await deriveHash(logEntry);
+    const versionId = `${versionNumber}-${logEntryHash}`;
+    const prelimEntry = { ...logEntry, versionId };
+    const proofTemplate = {
+        type: 'DataIntegrityProof',
+        cryptosuite: 'eddsa-jcs-2022',
+        verificationMethod: options.signer.getVerificationMethodId(),
+        created: createdDate,
+        proofPurpose: 'assertionMethod',
+    };
+    const signedProof = await options.signer.sign({ document: prelimEntry, proof: proofTemplate });
+    const allProofs = [{ ...proofTemplate, proofValue: signedProof.proofValue }];
+    prelimEntry.proof = allProofs;
+    const verified = await documentStateIsValid(prelimEntry, lastMeta.updateKeys, lastMeta.witness, true, // skipWitnessVerification
+    options.verifier);
+    if (!verified) {
+        throw new Error(`version ${prelimEntry.versionId} is invalid.`);
+    }
+    const meta = {
+        ...lastMeta,
+        versionId: prelimEntry.versionId,
+        updated: prelimEntry.versionTime,
+        deactivated: true,
+        updateKeys: params.updateKeys,
+    };
+    const didId = requireDidId(prelimEntry.state.id);
+    return {
+        did: didId,
+        doc: prelimEntry.state,
+        meta,
+        log: [...log, prelimEntry],
+    };
+};
+const getEntryWitnessParameter = (parameters) => {
+    if ('witness' in parameters) {
+        return parameters.witness ?? {};
+    }
+    if (parameters.witnesses) {
+        return {
+            witnesses: parameters.witnesses,
+            threshold: parameters.witnessThreshold || parameters.witnesses.length,
+        };
+    }
+    return undefined;
+};
+const isWitnessActive = (witness) => {
+    if (!witness?.witnesses || witness.witnesses.length === 0) {
+        return false;
+    }
+    const threshold = parseInt((witness.threshold ?? 0).toString(), 10);
+    return threshold > 0;
+};
+const getRequiredWitnessForEntry = (previousWitness, parameters, currentWitness) => {
+    const explicitWitness = getEntryWitnessParameter(parameters);
+    if (explicitWitness !== undefined) {
+        if (isWitnessActive(currentWitness)) {
+            return deepClone(currentWitness);
+        }
+        if (isWitnessActive(previousWitness)) {
+            return deepClone(previousWitness);
+        }
+        return undefined;
+    }
+    if (isWitnessActive(previousWitness)) {
+        return deepClone(previousWitness);
+    }
+    return undefined;
+};

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This file re-exports all types from interfaces.ts
+ * It's used to provide a clear entry point for type imports
+ */
+export * from './interfaces.js';

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * This file re-exports all types from interfaces.ts
+ * It's used to provide a clear entry point for type imports
+ */
+export * from './interfaces.js';

package/dist/utils/buffer.d.ts

@@ -0,0 +1,3 @@
+export declare const createBuffer: (input: string, encoding?: BufferEncoding) => Uint8Array;
+export declare const bufferToString: (buffer: Uint8Array, encoding?: BufferEncoding) => string;
+export declare const concatBuffers: (...buffers: Uint8Array[]) => Uint8Array;

package/dist/utils/buffer.js

@@ -0,0 +1,62 @@
+import { config } from '../config.js';
+// Helper to convert bytes to hex string
+const bytesToHex = (bytes) => {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+};
+// Helper to convert hex string to bytes
+const hexToBytes = (hex) => {
+    if (hex.length % 2 !== 0) {
+        throw new Error('Hex string must have an even number of characters');
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+    }
+    return bytes;
+};
+// Buffer polyfill for browser environments
+export const createBuffer = (input, encoding) => {
+    if (!config.isBrowser) {
+        return Buffer.from(input, encoding);
+    }
+    // Handle base64 encoding specifically
+    if (encoding === 'base64') {
+        const binaryString = atob(input);
+        return new Uint8Array(binaryString.length).map((_, i) => binaryString.charCodeAt(i));
+    }
+    // Default to UTF-8 encoding
+    return new TextEncoder().encode(input);
+};
+export const bufferToString = (buffer, encoding) => {
+    if (!config.isBrowser) {
+        return Buffer.from(buffer).toString(encoding);
+    }
+    // Handle hex encoding specifically
+    if (encoding === 'hex') {
+        return bytesToHex(buffer);
+    }
+    // Handle base64 encoding specifically
+    if (encoding === 'base64') {
+        const binary = String.fromCharCode(...buffer);
+        return btoa(binary);
+    }
+    // Default to UTF-8 encoding
+    return new TextDecoder().decode(buffer);
+};
+export const concatBuffers = (...buffers) => {
+    if (!config.isBrowser) {
+        return Buffer.concat(buffers);
+    }
+    // Calculate total length
+    const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+    // Create new array and copy all buffers into it
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buffer of buffers) {
+        result.set(buffer, offset);
+        offset += buffer.length;
+    }
+    return result;
+};

package/dist/utils/canonicalize.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from '../interfaces.js';
+export declare function validateStrictJsonValue(value: unknown): asserts value is JsonValue;
+export declare const canonicalizeStrict: (value: unknown) => string;