@interop/did-method-webvh 3.0.0

package/dist/cryptography.js

@@ -0,0 +1,95 @@
+import { concatBuffers } from './utils/buffer.js';
+import { canonicalizeStrict } from './utils/canonicalize.js';
+import { createHash } from './utils/crypto.js';
+import { createDate } from './utils.js';
+/**
+ * Creates a proof object for a document
+ * @param verificationMethodId - The verification method ID to use in the proof
+ * @returns A proof object with type, cryptosuite, verificationMethod, created, and proofPurpose
+ */
+export const createProof = (verificationMethodId) => {
+    return {
+        type: 'DataIntegrityProof',
+        cryptosuite: 'eddsa-jcs-2022',
+        verificationMethod: verificationMethodId,
+        created: createDate(),
+        proofPurpose: 'assertionMethod',
+    };
+};
+/**
+ * Prepares data for signing by hashing and concatenating the document and proof
+ * @param document - The document to sign
+ * @param proof - The proof object
+ * @returns The prepared data for signing as a Uint8Array
+ */
+export const prepareDataForSigning = async (document, proof) => {
+    const dataHash = await createHash(canonicalizeStrict(document));
+    const proofHash = await createHash(canonicalizeStrict(proof));
+    return concatBuffers(proofHash, dataHash);
+};
+/**
+ * Abstract base class for signers
+ * Users should extend this class to implement their own signing logic
+ */
+export class AbstractCrypto {
+    verificationMethod;
+    useStaticId;
+    constructor(options) {
+        if (options.verificationMethod) {
+            this.verificationMethod = options.verificationMethod;
+        }
+        this.useStaticId = options.useStaticId !== undefined ? options.useStaticId : true;
+    }
+    /**
+     * Get the verification method ID
+     * @returns The verification method ID
+     */
+    getVerificationMethodId() {
+        if (!this.verificationMethod) {
+            throw new Error('Verification method not set');
+        }
+        return this.useStaticId
+            ? `did:key:${this.verificationMethod.publicKeyMultibase}#${this.verificationMethod.publicKeyMultibase}`
+            : this.verificationMethod.id || '';
+    }
+}
+/**
+ * Creates a document signer from any Signer implementation
+ * @param signer - The signer to use
+ * @param verificationMethodId - The verification method ID to use in proofs
+ * @returns A function that signs a document and returns the document with proof
+ */
+export const createDocumentSigner = (signer, verificationMethodId) => {
+    return async (doc) => {
+        try {
+            const proof = createProof(verificationMethodId);
+            const result = await signer.sign({ document: doc, proof });
+            return { ...doc, proof: { ...proof, proofValue: result.proofValue } };
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error(`Document signing failure: ${e.message || e}`);
+        }
+    };
+};
+/**
+ * @deprecated Use createDocumentSigner with your own Signer implementation instead
+ */
+export const createSigner = (vm, useStatic = true) => {
+    console.warn('createSigner is deprecated. Use createDocumentSigner with your own Signer implementation instead.');
+    return async (doc) => {
+        try {
+            const verificationMethodId = useStatic
+                ? `did:key:${vm.publicKeyMultibase}#${vm.publicKeyMultibase}`
+                : vm.id || '';
+            const proof = createProof(verificationMethodId);
+            // This is a placeholder for backward compatibility
+            // Users should implement their own signing logic
+            throw new Error('createSigner is deprecated. Implement your own Signer and use createDocumentSigner instead.');
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error(`Document signing failure: ${e.message || e}`);
+        }
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { AbstractCrypto, createDocumentSigner, createProof, createSigner, prepareDataForSigning, } from './cryptography.js';
+export * from './interfaces.js';
+export { createDID, deactivateDID, resolveDID, resolveDIDFromLog, updateDID } from './method.js';
+export { MultibaseEncoding, multibaseDecode, multibaseEncode } from './utils/multiformats.js';
+export { generateParallelDidWeb, parseDidKeyDid, parseDidKeyVerificationMethod } from './utils.js';
+export { createWitnessProof, signWitnessProofEntries, signWitnessProofEntry, } from './witness.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { AbstractCrypto, createDocumentSigner, createProof, createSigner, prepareDataForSigning, } from './cryptography.js';
+export * from './interfaces.js';
+export { createDID, deactivateDID, resolveDID, resolveDIDFromLog, updateDID } from './method.js';
+export { MultibaseEncoding, multibaseDecode, multibaseEncode } from './utils/multiformats.js';
+export { generateParallelDidWeb, parseDidKeyDid, parseDidKeyVerificationMethod } from './utils.js';
+export { createWitnessProof, signWitnessProofEntries, signWitnessProofEntry, } from './witness.js';

package/dist/interfaces.d.ts

@@ -0,0 +1,231 @@
+export type DataIntegrityProofPurpose = 'authentication' | 'assertionMethod' | 'keyAgreement' | 'capabilityInvocation' | 'capabilityDelegation';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type DataIntegrityProofType = 'DataIntegrityProof';
+export type DataIntegrityCryptosuite = 'eddsa-jcs-2022';
+export interface DataIntegrityProofTemplate {
+    id?: string;
+    type: DataIntegrityProofType;
+    cryptosuite: DataIntegrityCryptosuite;
+    verificationMethod: string;
+    created: string;
+    proofPurpose: DataIntegrityProofPurpose;
+}
+export interface SigningInput {
+    document: unknown;
+    proof: DataIntegrityProofTemplate;
+}
+export interface SigningOutput {
+    proofValue: string;
+}
+export interface Signer {
+    sign(input: SigningInput): Promise<SigningOutput>;
+    getVerificationMethodId(): string;
+}
+export interface Verifier {
+    verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
+}
+export interface SignerOptions {
+    verificationMethod?: VerificationMethod | null;
+    useStaticId?: boolean;
+}
+export interface ProblemDetails {
+    type: string;
+    title: string;
+    detail: string;
+}
+export declare enum DidResolutionError {
+    NotFound = "notFound",
+    InvalidDid = "invalidDid",
+    LegacyNotFound = "NOT_FOUND",
+    LegacyInvalidDid = "INVALID_DID",
+    InvalidDidUrl = "INVALID_DID_URL",
+    InvalidOptions = "INVALID_OPTIONS",
+    RepresentationNotSupported = "REPRESENTATION_NOT_SUPPORTED",
+    MethodNotSupported = "METHOD_NOT_SUPPORTED",
+    UnsupportedPublicKeyType = "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    LegacyInvalidDidDocument = "INVALID_DID_DOCUMENT",
+    InvalidPublicKey = "INVALID_PUBLIC_KEY",
+    InvalidPublicKeyLength = "INVALID_PUBLIC_KEY_LENGTH",
+    InvalidPublicKeyType = "INVALID_PUBLIC_KEY_TYPE",
+    InternalError = "INTERNAL_ERROR"
+}
+export interface DIDResolutionMeta {
+    versionId: string;
+    created: string;
+    updated: string;
+    previousLogEntryHash?: string;
+    updateKeys: string[];
+    scid: string;
+    prerotation: boolean;
+    portable: boolean;
+    nextKeyHashes: string[];
+    deactivated: boolean;
+    witness?: WitnessParameterResolution;
+    watchers?: string[] | null;
+    error?: DidResolutionError;
+    problemDetails?: ProblemDetails;
+    latestVersionId?: string;
+}
+export interface DIDDoc {
+    '@context'?: string | string[] | object | object[];
+    id?: string;
+    controller?: string | string[];
+    alsoKnownAs?: string[];
+    authentication?: string[];
+    assertionMethod?: string[];
+    keyAgreement?: string[];
+    capabilityInvocation?: string[];
+    capabilityDelegation?: string[];
+    verificationMethod?: VerificationMethod[];
+    service?: ServiceEndpoint[];
+}
+export interface VerificationMethod {
+    id?: string;
+    type: string;
+    controller?: string;
+    publicKeyMultibase?: string;
+    secretKeyMultibase?: string;
+    purpose?: DataIntegrityProofPurpose;
+    publicKeyJwk?: any;
+    use?: string;
+}
+export interface WitnessEntry {
+    id: string;
+}
+export interface ParsedDidKeyVerificationMethod {
+    did: string;
+    fragment?: string;
+    keyMultibase: string;
+}
+export interface WitnessSigningOptions {
+    versionId: string;
+    witnesses: WitnessEntry[];
+    witnessSignersByDid: Record<string, Signer>;
+    created?: string;
+}
+export interface WitnessSigningResult {
+    versionId: string;
+    proof: DataIntegrityProof[];
+}
+export interface WitnessParameter {
+    threshold?: number;
+    witnesses?: WitnessEntry[];
+}
+export interface WitnessParameterResolution {
+    threshold?: string | number;
+    witnesses?: WitnessEntry[];
+}
+export interface DataIntegrityProof {
+    id?: string;
+    type: DataIntegrityProofType;
+    cryptosuite: DataIntegrityCryptosuite;
+    verificationMethod: string;
+    created: string;
+    proofValue: string;
+    proofPurpose: DataIntegrityProofPurpose;
+}
+export interface DIDLogEntry {
+    versionId: string;
+    versionTime: string;
+    parameters: {
+        method?: string;
+        scid?: string;
+        updateKeys?: string[];
+        nextKeyHashes?: string[];
+        portable?: boolean;
+        witness?: WitnessParameter;
+        watchers?: string[] | null;
+        deactivated?: boolean;
+    };
+    state: DIDDoc;
+    proof?: DataIntegrityProof[];
+}
+export type DIDLog = DIDLogEntry[];
+export interface ServiceEndpoint {
+    id?: string;
+    type: string | string[];
+    serviceEndpoint?: string | string[] | any;
+    [key: string]: unknown;
+}
+export interface CreateDIDResult {
+    did: string;
+    doc: DIDDoc;
+    meta: DIDResolutionMeta;
+    log: DIDLog;
+    webDoc?: DIDDoc;
+}
+export interface UpdateDIDResult {
+    did: string;
+    doc: DIDDoc;
+    meta: DIDResolutionMeta;
+    log: DIDLog;
+    webDoc?: DIDDoc;
+}
+export interface CreateDIDInterface {
+    domain?: string;
+    address?: string;
+    signer: Signer;
+    updateKeys: string[];
+    verificationMethods?: VerificationMethod[];
+    didDocument?: DIDDoc;
+    services?: ServiceEndpoint[];
+    paths?: string[];
+    controller?: string;
+    context?: string | string[] | object | object[];
+    alsoKnownAs?: string[];
+    alsoKnownAsWeb?: boolean;
+    portable?: boolean;
+    nextKeyHashes?: string[];
+    witness?: WitnessParameter | null;
+    watchers?: string[] | null;
+    created?: string;
+    verifier?: Verifier;
+    authentication?: string[];
+    assertionMethod?: string[];
+    keyAgreement?: string[];
+}
+export interface SignDIDDocInterface {
+    document: unknown;
+    proof: DataIntegrityProofTemplate;
+    verificationMethod: VerificationMethod;
+}
+export interface UpdateDIDInterface {
+    log: DIDLog;
+    signer: Signer;
+    updateKeys?: string[];
+    verificationMethods?: VerificationMethod[];
+    controller?: string;
+    context?: string | string[] | object | object[];
+    alsoKnownAs?: string[];
+    portable?: boolean;
+    nextKeyHashes?: string[];
+    witness?: WitnessParameter | null;
+    watchers?: string[] | null;
+    verifier?: Verifier;
+    authentication?: string[];
+    assertionMethod?: string[];
+    keyAgreement?: string[];
+    witnessProofs?: WitnessProofFileEntry[];
+}
+export interface DeactivateDIDInterface {
+    log: DIDLog;
+    signer: Signer;
+    verifier?: Verifier;
+}
+export interface ResolutionOptions {
+    versionNumber?: number;
+    versionId?: string;
+    versionTime?: Date;
+    verificationMethod?: string;
+    verifier?: Verifier;
+    scid?: string;
+    fastResolve?: boolean;
+}
+export interface WitnessProofFileEntry {
+    versionId: string;
+    proof: DataIntegrityProof[];
+}

package/dist/interfaces.js

@@ -0,0 +1,17 @@
+export var DidResolutionError;
+(function (DidResolutionError) {
+    DidResolutionError["NotFound"] = "notFound";
+    DidResolutionError["InvalidDid"] = "invalidDid";
+    DidResolutionError["LegacyNotFound"] = "NOT_FOUND";
+    DidResolutionError["LegacyInvalidDid"] = "INVALID_DID";
+    DidResolutionError["InvalidDidUrl"] = "INVALID_DID_URL";
+    DidResolutionError["InvalidOptions"] = "INVALID_OPTIONS";
+    DidResolutionError["RepresentationNotSupported"] = "REPRESENTATION_NOT_SUPPORTED";
+    DidResolutionError["MethodNotSupported"] = "METHOD_NOT_SUPPORTED";
+    DidResolutionError["UnsupportedPublicKeyType"] = "UNSUPPORTED_PUBLIC_KEY_TYPE";
+    DidResolutionError["LegacyInvalidDidDocument"] = "INVALID_DID_DOCUMENT";
+    DidResolutionError["InvalidPublicKey"] = "INVALID_PUBLIC_KEY";
+    DidResolutionError["InvalidPublicKeyLength"] = "INVALID_PUBLIC_KEY_LENGTH";
+    DidResolutionError["InvalidPublicKeyType"] = "INVALID_PUBLIC_KEY_TYPE";
+    DidResolutionError["InternalError"] = "INTERNAL_ERROR";
+})(DidResolutionError || (DidResolutionError = {}));

package/dist/method.d.ts

@@ -0,0 +1,73 @@
+import type { CreateDIDInterface, CreateDIDResult, DeactivateDIDInterface, DIDLog, ResolutionOptions, UpdateDIDInterface, UpdateDIDResult, WitnessProofFileEntry } from './interfaces.js';
+import { DidResolutionError } from './interfaces.js';
+/**
+ * Creates a new did:webvh DID and initial DID log.
+ *
+ * @param options DID creation options.
+ * @returns The created DID, resolved document, and DID log.
+ */
+export declare const createDID: (options: CreateDIDInterface) => Promise<CreateDIDResult>;
+/**
+ * Resolves a DID by fetching and validating its DID log.
+ *
+ * @param did The DID to resolve.
+ * @param options Optional resolver settings.
+ * @returns The resolved DID result with resolution metadata.
+ */
+export declare const resolveDID: (did: string, options?: ResolutionOptions & {
+    witnessProofs?: WitnessProofFileEntry[];
+}) => Promise<{
+    did: string;
+    doc: any;
+    meta: import("./interfaces.js").DIDResolutionMeta;
+} | {
+    did: string;
+    doc: null;
+    meta: {
+        error: DidResolutionError.NotFound | DidResolutionError.InvalidDid;
+        problemDetails: {
+            type: string;
+            title: string;
+            detail: string;
+        };
+    };
+}>;
+/**
+ * Resolves a DID from an in-memory DID log.
+ *
+ * @param log In-memory DID log entries.
+ * @param options Optional resolver settings.
+ * @returns The resolved DID result with resolution metadata.
+ */
+export declare const resolveDIDFromLog: (log: DIDLog, options?: ResolutionOptions & {
+    witnessProofs?: WitnessProofFileEntry[];
+}) => Promise<{
+    did: string;
+    doc: any;
+    meta: import("./interfaces.js").DIDResolutionMeta;
+}>;
+/**
+ * Updates an existing DID log with a new entry.
+ *
+ * @param options DID update options.
+ * @returns The updated DID, resolved document, and DID log.
+ */
+export declare const updateDID: (options: UpdateDIDInterface & {
+    services?: any[];
+    domain?: string;
+    updated?: string;
+}) => Promise<UpdateDIDResult>;
+/**
+ * Deactivates an existing DID by appending a deactivation entry.
+ *
+ * @param options DID deactivation options.
+ * @returns The deactivated DID result and updated DID log.
+ */
+export declare const deactivateDID: (options: DeactivateDIDInterface & {
+    updateKeys?: string[];
+}) => Promise<{
+    did: string;
+    doc: any;
+    meta: import("./interfaces.js").DIDResolutionMeta;
+    log: DIDLog;
+}>;

package/dist/method.js

@@ -0,0 +1,95 @@
+import { DidResolutionError } from './interfaces.js';
+import * as v1 from './method_versions/method.v1.0.js';
+import { fetchLogFromIdentifier, maybeWriteTestLog } from './utils.js';
+const SUPPORTED_METHOD = 'did:webvh:1.0';
+/**
+ * Creates a new did:webvh DID and initial DID log.
+ *
+ * @param options DID creation options.
+ * @returns The created DID, resolved document, and DID log.
+ */
+export const createDID = async (options) => {
+    const method = options.method;
+    if (method && method !== SUPPORTED_METHOD) {
+        throw new Error(`'${method}' is not a supported method version.`);
+    }
+    const result = await v1.createDID(options);
+    maybeWriteTestLog(result.did, result.log);
+    return result;
+};
+/**
+ * Resolves a DID by fetching and validating its DID log.
+ *
+ * @param did The DID to resolve.
+ * @param options Optional resolver settings.
+ * @returns The resolved DID result with resolution metadata.
+ */
+export const resolveDID = async (did, options = {}) => {
+    // Extract the expected SCID from the DID string so the resolver can
+    // verify the log's SCID matches what the DID claims.
+    const didParts = did.split(':');
+    const scid = didParts.length > 2 && didParts[0] === 'did' && didParts[1] === 'webvh' ? didParts[2] : undefined;
+    try {
+        const log = await fetchLogFromIdentifier(did);
+        const result = await v1.resolveDIDFromLog(log, { ...options, scid });
+        maybeWriteTestLog(result.did, log);
+        return result;
+    }
+    catch (e) {
+        let errorType = DidResolutionError.InvalidDid;
+        const message = e instanceof Error ? e.message : String(e);
+        if (/not found/i.test(message) || /404/.test(message)) {
+            errorType = DidResolutionError.NotFound;
+        }
+        return {
+            did,
+            doc: null,
+            meta: {
+                error: errorType,
+                problemDetails: {
+                    type: errorType === DidResolutionError.NotFound
+                        ? 'https://w3id.org/security#NOT_FOUND'
+                        : 'https://w3id.org/security#INVALID_CONTROLLED_IDENTIFIER_DOCUMENT_ID',
+                    title: errorType === DidResolutionError.NotFound
+                        ? 'The DID Log or resource was not found.'
+                        : 'The resolved DID is invalid.',
+                    detail: message,
+                },
+            },
+        };
+    }
+};
+/**
+ * Resolves a DID from an in-memory DID log.
+ *
+ * @param log In-memory DID log entries.
+ * @param options Optional resolver settings.
+ * @returns The resolved DID result with resolution metadata.
+ */
+export const resolveDIDFromLog = async (log, options = {}) => {
+    const result = await v1.resolveDIDFromLog(log, options);
+    maybeWriteTestLog(result.did, log);
+    return result;
+};
+/**
+ * Updates an existing DID log with a new entry.
+ *
+ * @param options DID update options.
+ * @returns The updated DID, resolved document, and DID log.
+ */
+export const updateDID = async (options) => {
+    const result = await v1.updateDID(options);
+    maybeWriteTestLog(result.did, result.log);
+    return result;
+};
+/**
+ * Deactivates an existing DID by appending a deactivation entry.
+ *
+ * @param options DID deactivation options.
+ * @returns The deactivated DID result and updated DID log.
+ */
+export const deactivateDID = async (options) => {
+    const result = await v1.deactivateDID(options);
+    maybeWriteTestLog(result.did, result.log);
+    return result;
+};

package/dist/method_versions/method.v1.0.d.ts

@@ -0,0 +1,23 @@
+import type { CreateDIDInterface, CreateDIDResult, DeactivateDIDInterface, DIDLog, DIDResolutionMeta, ResolutionOptions, UpdateDIDInterface, UpdateDIDResult, WitnessProofFileEntry } from '../interfaces.js';
+export declare const createDID: (options: CreateDIDInterface) => Promise<CreateDIDResult>;
+export declare const resolveDIDFromLog: (log: DIDLog, options?: ResolutionOptions & {
+    witnessProofs?: WitnessProofFileEntry[];
+    fastResolve?: boolean;
+}) => Promise<{
+    did: string;
+    doc: any;
+    meta: DIDResolutionMeta;
+}>;
+export declare const updateDID: (options: UpdateDIDInterface & {
+    services?: any[];
+    domain?: string;
+    updated?: string;
+}) => Promise<UpdateDIDResult>;
+export declare const deactivateDID: (options: DeactivateDIDInterface & {
+    updateKeys?: string[];
+}) => Promise<{
+    did: string;
+    doc: any;
+    meta: DIDResolutionMeta;
+    log: DIDLog;
+}>;