@originals/sdk 1.4.5 → 1.6.0

package/dist/cel/witnesses/HttpWitness.js

@@ -0,0 +1,163 @@
+/**
+ * HttpWitness - HTTP-based witness service for CEL event logs
+ *
+ * Implements the WitnessService interface for HTTP-based witness endpoints.
+ * Used primarily for the did:webvh layer to obtain third-party attestations
+ * from remote witness services.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+/**
+ * Error thrown when the HTTP witness service is unavailable or returns an error
+ */
+export class HttpWitnessError extends Error {
+    constructor(message, witnessUrl, statusCode, responseBody) {
+        super(message);
+        this.name = 'HttpWitnessError';
+        this.witnessUrl = witnessUrl;
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+    }
+}
+/**
+ * HTTP-based witness service implementation
+ *
+ * Posts digestMultibase to a witness endpoint and parses the WitnessProof response.
+ *
+ * @example
+ * ```typescript
+ * const witness = new HttpWitness('https://witness.example.com/api/attest');
+ * const proof = await witness.witness('uEiD...');
+ * console.log(proof.witnessedAt); // ISO timestamp of attestation
+ * ```
+ */
+export class HttpWitness {
+    /**
+     * Creates a new HttpWitness instance
+     *
+     * @param witnessUrl - The URL of the witness endpoint to POST to
+     * @param options - Optional configuration options
+     */
+    constructor(witnessUrl, options = {}) {
+        if (!witnessUrl || typeof witnessUrl !== 'string') {
+            throw new Error('witnessUrl must be a non-empty string');
+        }
+        // Validate URL format
+        try {
+            new URL(witnessUrl);
+        }
+        catch {
+            throw new Error(`Invalid witness URL: ${witnessUrl}`);
+        }
+        this.witnessUrl = witnessUrl;
+        this.timeout = options.timeout ?? 30000;
+        this.headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...options.headers,
+        };
+        this.fetchFn = options.fetch ?? globalThis.fetch;
+    }
+    /**
+     * Witnesses a digest by posting to the HTTP endpoint
+     *
+     * @param digestMultibase - The Multibase-encoded digest to witness
+     * @returns A WitnessProof containing the attestation and witnessedAt timestamp
+     * @throws HttpWitnessError if the witness service is unavailable or returns an error
+     */
+    async witness(digestMultibase) {
+        if (!digestMultibase || typeof digestMultibase !== 'string') {
+            throw new Error('digestMultibase must be a non-empty string');
+        }
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchFn(this.witnessUrl, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify({ digest: digestMultibase }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Handle non-OK responses
+            if (!response.ok) {
+                let responseBody;
+                try {
+                    responseBody = await response.text();
+                }
+                catch {
+                    // Ignore body read errors
+                }
+                throw new HttpWitnessError(`Witness service returned ${response.status} ${response.statusText}`, this.witnessUrl, response.status, responseBody);
+            }
+            // Parse response
+            let data;
+            try {
+                data = await response.json();
+            }
+            catch {
+                throw new HttpWitnessError('Witness service returned invalid JSON response', this.witnessUrl, response.status);
+            }
+            // Validate WitnessProof structure
+            const proof = this.validateWitnessProof(data);
+            return proof;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Re-throw HttpWitnessError as-is
+            if (error instanceof HttpWitnessError) {
+                throw error;
+            }
+            // Handle abort/timeout
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new HttpWitnessError(`Witness service request timed out after ${this.timeout}ms`, this.witnessUrl);
+            }
+            // Handle network errors
+            if (error instanceof TypeError) {
+                throw new HttpWitnessError(`Witness service unavailable: ${error.message}`, this.witnessUrl);
+            }
+            // Re-throw other errors
+            throw new HttpWitnessError(`Witness request failed: ${error instanceof Error ? error.message : String(error)}`, this.witnessUrl);
+        }
+    }
+    /**
+     * Validates that the response data is a valid WitnessProof
+     *
+     * @param data - The parsed JSON response
+     * @returns A validated WitnessProof
+     * @throws HttpWitnessError if the response is not a valid WitnessProof
+     */
+    validateWitnessProof(data) {
+        if (!data || typeof data !== 'object') {
+            throw new HttpWitnessError('Witness service returned invalid proof: expected object', this.witnessUrl);
+        }
+        const proof = data;
+        // Check required DataIntegrityProof fields
+        const requiredFields = ['type', 'cryptosuite', 'created', 'verificationMethod', 'proofPurpose', 'proofValue'];
+        for (const field of requiredFields) {
+            if (typeof proof[field] !== 'string') {
+                throw new HttpWitnessError(`Witness service returned invalid proof: missing or invalid '${field}' field`, this.witnessUrl);
+            }
+        }
+        // Check WitnessProof-specific field
+        if (typeof proof.witnessedAt !== 'string') {
+            throw new HttpWitnessError("Witness service returned invalid proof: missing or invalid 'witnessedAt' field", this.witnessUrl);
+        }
+        return {
+            type: proof.type,
+            cryptosuite: proof.cryptosuite,
+            created: proof.created,
+            verificationMethod: proof.verificationMethod,
+            proofPurpose: proof.proofPurpose,
+            proofValue: proof.proofValue,
+            witnessedAt: proof.witnessedAt,
+        };
+    }
+    /**
+     * Gets the witness URL this instance is configured to use
+     */
+    get url() {
+        return this.witnessUrl;
+    }
+}

package/dist/cel/witnesses/WitnessService.d.ts

@@ -0,0 +1,49 @@
+/**
+ * WitnessService Interface
+ *
+ * Defines a pluggable interface for witness services that attest to the
+ * existence of events at a point in time. Witnesses add trust anchors
+ * to event logs by providing third-party attestations.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+import type { WitnessProof } from '../types';
+/**
+ * Interface for witness services that can attest to event digests.
+ *
+ * Implementations might include:
+ * - HTTP-based witness services (for did:webvh layer)
+ * - Bitcoin timestamping services (for did:btco layer)
+ * - Notary services
+ * - Blockchain-based attestation services
+ *
+ * @example
+ * ```typescript
+ * class MyHttpWitness implements WitnessService {
+ *   constructor(private witnessUrl: string) {}
+ *
+ *   async witness(digestMultibase: string): Promise<WitnessProof> {
+ *     const response = await fetch(this.witnessUrl, {
+ *       method: 'POST',
+ *       body: JSON.stringify({ digest: digestMultibase })
+ *     });
+ *     return response.json();
+ *   }
+ * }
+ * ```
+ */
+export interface WitnessService {
+    /**
+     * Witnesses a digest and returns a proof of attestation.
+     *
+     * The witness should:
+     * 1. Record the digest at the current point in time
+     * 2. Generate a cryptographic proof of the attestation
+     * 3. Include a witnessedAt timestamp in the proof
+     *
+     * @param digestMultibase - The Multibase-encoded digest to witness (from computeDigestMultibase)
+     * @returns A WitnessProof containing the attestation and witnessedAt timestamp
+     * @throws Error if the witness service is unavailable or fails
+     */
+    witness(digestMultibase: string): Promise<WitnessProof>;
+}

package/dist/cel/witnesses/WitnessService.js

@@ -0,0 +1,10 @@
+/**
+ * WitnessService Interface
+ *
+ * Defines a pluggable interface for witness services that attest to the
+ * existence of events at a point in time. Witnesses add trust anchors
+ * to event logs by providing third-party attestations.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+export {};

package/dist/cel/witnesses/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CEL Witness Services
+ *
+ * Pluggable witness interfaces and implementations for third-party attestations.
+ */
+export type { WitnessService } from './WitnessService';
+export { HttpWitness, HttpWitnessError } from './HttpWitness';
+export type { HttpWitnessOptions } from './HttpWitness';
+export { BitcoinWitness, BitcoinWitnessError } from './BitcoinWitness';
+export type { BitcoinWitnessOptions, BitcoinWitnessProof } from './BitcoinWitness';

package/dist/cel/witnesses/index.js

@@ -0,0 +1,7 @@
+/**
+ * CEL Witness Services
+ *
+ * Pluggable witness interfaces and implementations for third-party attestations.
+ */
+export { HttpWitness, HttpWitnessError } from './HttpWitness';
+export { BitcoinWitness, BitcoinWitnessError } from './BitcoinWitness';

package/dist/core/OriginalsSDK.js

@@ -49,6 +49,7 @@ export class OriginalsSDK {
             this.eventLogger.configureEventLogging(this.config.logging.eventLogging);
         }
         // Subscribe to lifecycle events
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
         this.eventLogger.subscribeToEvents(this.lifecycle.eventEmitter);
     }
     /**
@@ -179,6 +180,7 @@ export class OriginalsSDK {
         });
         return {
             did: result.did,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             doc: result.doc,
             log: result.log,
             meta: result.meta
@@ -197,10 +199,12 @@ export class OriginalsSDK {
         switch (options.type) {
             case 'did':
                 return OriginalsSDK.updateDIDOriginal(options);
-            default:
+            default: {
                 // TypeScript exhaustiveness check
                 const _exhaustive = options;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
                 throw new Error(`Unsupported Original type: ${_exhaustive.type}`);
+            }
         }
     }
     /**

package/dist/crypto/Signer.js

@@ -25,7 +25,9 @@ export class ES256KSigner extends Signer {
         }
         const privateKey = decoded.key;
         const hash = sha256(data);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         const sigAny = await secp256k1.signAsync(hash, privateKey);
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         const sigBytes = sigAny instanceof Uint8Array
             ? sigAny
             : typeof sigAny?.toCompactRawBytes === 'function'
@@ -33,6 +35,7 @@ export class ES256KSigner extends Signer {
                 : typeof sigAny?.toRawBytes === 'function'
                     ? sigAny.toRawBytes()
                     : new Uint8Array(sigAny);
+        /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         return Buffer.from(sigBytes);
     }
     async verify(data, signature, publicKeyMultibase) {
@@ -52,7 +55,7 @@ export class ES256KSigner extends Signer {
         const publicKey = decoded.key;
         const hash = sha256(data);
         try {
-            return secp256k1.verify(signature, hash, publicKey);
+            return await Promise.resolve(secp256k1.verify(signature, hash, publicKey));
         }
         catch {
             return false;
@@ -75,6 +78,7 @@ export class Ed25519Signer extends Signer {
             throw new Error('Invalid key type for Ed25519');
         }
         const privateKey = decoded.key;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         const signature = await ed25519.signAsync(data, privateKey);
         return Buffer.from(signature);
     }
@@ -94,6 +98,7 @@ export class Ed25519Signer extends Signer {
         }
         const publicKey = decoded.key;
         try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
             return await ed25519.verifyAsync(signature, data, publicKey);
         }
         catch {
@@ -118,7 +123,9 @@ export class ES256Signer extends Signer {
         }
         const privateKey = decoded.key;
         const hash = sha256(data);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
         const sigAny = p256.sign(hash, privateKey);
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
         const sigBytes = sigAny instanceof Uint8Array
             ? sigAny
             : typeof sigAny?.toCompactRawBytes === 'function'
@@ -126,7 +133,8 @@ export class ES256Signer extends Signer {
                 : typeof sigAny?.toRawBytes === 'function'
                     ? sigAny.toRawBytes()
                     : new Uint8Array(sigAny);
-        return Buffer.from(sigBytes);
+        /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
+        return await Promise.resolve(Buffer.from(sigBytes));
     }
     async verify(data, signature, publicKeyMultibase) {
         if (!publicKeyMultibase || publicKeyMultibase[0] !== 'z') {
@@ -145,7 +153,7 @@ export class ES256Signer extends Signer {
         const publicKey = decoded.key;
         const hash = sha256(data);
         try {
-            return p256.verify(signature, hash, publicKey);
+            return await Promise.resolve(p256.verify(signature, hash, publicKey));
         }
         catch {
             return false;
@@ -168,8 +176,8 @@ export class Bls12381G2Signer extends Signer {
             throw new Error('Invalid key type for Bls12381G2');
         }
         const sk = decoded.key;
-        const sig = await bls.sign(data, sk);
-        return Buffer.from(sig);
+        const sig = bls.sign(data, sk);
+        return await Promise.resolve(Buffer.from(sig));
     }
     async verify(data, signature, publicKeyMultibase) {
         if (!publicKeyMultibase || publicKeyMultibase[0] !== 'z') {
@@ -187,7 +195,7 @@ export class Bls12381G2Signer extends Signer {
         }
         const pk = decoded.key;
         try {
-            return await bls.verify(signature, data, pk);
+            return await Promise.resolve(bls.verify(signature, data, pk));
         }
         catch {
             return false;

package/dist/crypto/noble-init.js

@@ -22,8 +22,14 @@ const hmacSha256Impl = (key, ...msgs) => hmac(sha256, key, concatBytes(...msgs))
 /**
  * Safely set a property on an object, handling readonly properties
  */
-function safeSetProperty(obj, prop, value, options) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function safeSetProperty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+obj, prop, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value, options) {
     try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
         obj[prop] = value;
         return true;
     }
@@ -31,6 +37,7 @@ function safeSetProperty(obj, prop, value, options) {
         // Property might be readonly, try defineProperty
         try {
             Object.defineProperty(obj, prop, {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 value,
                 writable: options?.writable ?? true,
                 configurable: options?.configurable ?? true,
@@ -47,10 +54,13 @@ function safeSetProperty(obj, prop, value, options) {
  * Initialize @noble/secp256k1 with hmacSha256Sync utility
  */
 function initSecp256k1() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
     const sAny = secp256k1;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (!sAny?.utils) {
         // Try to create utils object if it doesn't exist
         try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             sAny.utils = {};
         }
         catch {
@@ -63,7 +73,9 @@ function initSecp256k1() {
         }
     }
     // Set hmacSha256Sync if not already set
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (typeof sAny.utils.hmacSha256Sync !== 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         safeSetProperty(sAny.utils, 'hmacSha256Sync', hmacSha256Impl);
     }
 }
@@ -72,14 +84,19 @@ function initSecp256k1() {
  * Handles both etc.sha512Sync (v2.x) and utils.sha512Sync (backward compat)
  */
 function initEd25519() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
     const eAny = ed25519;
     // Set etc.sha512Sync for @noble/ed25519 v2.x (required)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (eAny?.etc && typeof eAny.etc.sha512Sync !== 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         safeSetProperty(eAny.etc, 'sha512Sync', sha512Impl);
     }
     // Set utils.sha512Sync for backward compatibility
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (!eAny?.utils) {
         try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             eAny.utils = {};
         }
         catch {
@@ -90,7 +107,9 @@ function initEd25519() {
             });
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (typeof eAny.utils.sha512Sync !== 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         safeSetProperty(eAny.utils, 'sha512Sync', sha512Impl);
     }
 }

package/dist/did/BtcoDidResolver.d.ts

@@ -2,7 +2,7 @@ import type { DIDDocument } from '../types/did';
 export interface BtcoInscriptionData {
     inscriptionId: string;
     content: string;
-    metadata: any;
+    metadata: Record<string, unknown> | null;
     contentUrl?: string;
     contentType?: string;
     isValidDid?: boolean;
@@ -39,7 +39,7 @@ export interface ResourceProviderLike {
         content_type: string;
         content_url: string;
     }>;
-    getMetadata(inscriptionId: string): Promise<any>;
+    getMetadata(inscriptionId: string): Promise<Record<string, unknown> | null>;
 }
 export interface BtcoDidResolutionOptions {
     provider?: ResourceProviderLike;

package/dist/did/BtcoDidResolver.js

@@ -39,7 +39,8 @@ export class BtcoDidResolver {
             inscriptionIds = satInfo?.inscription_ids || [];
         }
         catch (e) {
-            return this.createErrorResult('notFound', `Failed to retrieve inscriptions for satoshi ${satNumber}: ${e?.message || String(e)}`);
+            const message = e instanceof Error ? e.message : String(e);
+            return this.createErrorResult('notFound', `Failed to retrieve inscriptions for satoshi ${satNumber}: ${message}`);
         }
         if (inscriptionIds.length === 0) {
             return this.createErrorResult('notFound', `No inscriptions found on satoshi ${satNumber}`);
@@ -82,7 +83,8 @@ export class BtcoDidResolver {
                     }
                 }
                 catch (err) {
-                    inscriptionData.error = `Failed to fetch content: ${err?.message || String(err)}`;
+                    const message = err instanceof Error ? err.message : String(err);
+                    inscriptionData.error = `Failed to fetch content: ${message}`;
                     inscriptionDataList.push(inscriptionData);
                     continue;
                 }
@@ -110,7 +112,8 @@ export class BtcoDidResolver {
                 }
             }
             catch (err) {
-                inscriptionData.error = `Failed to process inscription: ${err?.message || String(err)}`;
+                const message = err instanceof Error ? err.message : String(err);
+                inscriptionData.error = `Failed to process inscription: ${message}`;
             }
             inscriptionDataList.push(inscriptionData);
         }
@@ -142,17 +145,18 @@ export class BtcoDidResolver {
     isValidDidDocument(doc) {
         if (!doc || typeof doc !== 'object')
             return false;
-        if (!doc.id || typeof doc.id !== 'string')
+        const d = doc;
+        if (!d.id || typeof d.id !== 'string')
             return false;
-        if (!doc['@context'])
+        if (!d['@context'])
             return false;
-        const contexts = Array.isArray(doc['@context']) ? doc['@context'] : [doc['@context']];
+        const contexts = Array.isArray(d['@context']) ? d['@context'] : [d['@context']];
         if (!contexts.includes('https://www.w3.org/ns/did/v1') && !contexts.includes('https://w3id.org/did/v1')) {
             return false;
         }
-        if (doc.verificationMethod && !Array.isArray(doc.verificationMethod))
+        if (d.verificationMethod && !Array.isArray(d.verificationMethod))
             return false;
-        if (doc.authentication && !Array.isArray(doc.authentication))
+        if (d.authentication && !Array.isArray(d.authentication))
             return false;
         return true;
     }

package/dist/did/DIDManager.js

@@ -28,7 +28,9 @@ export class DIDManager {
             }
         ], undefined, undefined);
         // Resolve to DID Document using the same library
-        const resolved = await didPeerMod.resolve(did);
+        const rawResolved = await didPeerMod.resolve(did);
+        // Type the resolved document properly
+        const resolved = rawResolved;
         // Ensure controller is set on VM entries for compatibility
         if (resolved && Array.isArray(resolved.verificationMethod)) {
             resolved.verificationMethod = resolved.verificationMethod.map((vm) => ({
@@ -88,7 +90,7 @@ export class DIDManager {
             ...didDoc,
             id: `did:webvh:${normalized}:${slug}`
         };
-        return migrated;
+        return await Promise.resolve(migrated);
     }
     async migrateToDIDBTCO(didDoc, satoshi) {
         // Validate satoshi parameter
@@ -115,7 +117,7 @@ export class DIDManager {
             network = this.config.network || 'mainnet';
         }
         // Try to carry over the first multikey VM if present
-        const firstVm = (didDoc.verificationMethod && didDoc.verificationMethod[0]);
+        const firstVm = didDoc.verificationMethod?.[0];
         let publicKey;
         let keyType;
         try {
@@ -147,7 +149,7 @@ export class DIDManager {
         if (didDoc.service && didDoc.service.length > 0) {
             btcoDoc.service = didDoc.service;
         }
-        return btcoDoc;
+        return await Promise.resolve(btcoDoc);
     }
     async resolveDID(did) {
         try {

package/dist/did/KeyManager.d.ts

@@ -3,7 +3,7 @@ import { DIDDocument, KeyPair, KeyType, KeyRecoveryCredential } from '../types';
 export declare class KeyManager {
     constructor();
     generateKeyPair(type: KeyType): Promise<KeyPair>;
-    rotateKeys(didDoc: DIDDocument, newKeyPair: KeyPair): Promise<DIDDocument>;
+    rotateKeys(didDoc: DIDDocument, newKeyPair: KeyPair): DIDDocument;
     recoverFromCompromise(didDoc: DIDDocument): Promise<{
         didDocument: DIDDocument;
         recoveryCredential: KeyRecoveryCredential;

package/dist/did/KeyManager.js

@@ -11,7 +11,8 @@ function toMultikeyType(type) {
         return 'Ed25519';
     if (type === 'ES256')
         return 'P256';
-    throw new Error(`Unsupported key type: ${type}`);
+    const _exhaustiveCheck = type;
+    throw new Error(`Unsupported key type: ${String(_exhaustiveCheck)}`);
 }
 function fromMultikeyType(type) {
     if (type === 'Secp256k1')
@@ -38,7 +39,8 @@ export class KeyManager {
         }
         if (type === 'Ed25519') {
             const privateKeyBytes = ed25519.utils.randomPrivateKey();
-            const publicKeyBytes = await ed25519.getPublicKeyAsync(privateKeyBytes);
+            const ed25519Module = ed25519;
+            const publicKeyBytes = await ed25519Module.getPublicKeyAsync(privateKeyBytes);
             return {
                 privateKey: multikey.encodePrivateKey(privateKeyBytes, 'Ed25519'),
                 publicKey: multikey.encodePublicKey(publicKeyBytes, 'Ed25519')
@@ -52,9 +54,10 @@ export class KeyManager {
                 publicKey: multikey.encodePublicKey(publicKeyBytes, 'P256')
             };
         }
-        throw new Error(`Unsupported key type: ${type}`);
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported key type: ${String(_exhaustiveCheck)}`);
     }
-    async rotateKeys(didDoc, newKeyPair) {
+    rotateKeys(didDoc, newKeyPair) {
         const multikeyContext = 'https://w3id.org/security/multikey/v1';
         const securityContext = 'https://w3id.org/security/v1';
         // Ensure required contexts are present

package/dist/did/WebVHManager.js

@@ -292,7 +292,7 @@ export class WebVHManager {
             log: currentLog,
             doc: updatedDoc,
             signer,
-            verifier,
+            verifier: verifier || undefined,
         });
         // Validate the returned DID document
         if (!this.isDIDDocument(result.doc)) {

package/dist/did/createBtcoDidDocument.js

@@ -7,7 +7,8 @@ function getDidPrefix(network) {
         return 'did:btco:sig';
     if (network === 'regtest')
         return 'did:btco:reg';
-    throw new Error(`Unsupported Bitcoin network: ${network}`);
+    const _exhaustiveCheck = network;
+    throw new Error(`Unsupported Bitcoin network: ${String(_exhaustiveCheck)}`);
 }
 function buildVerificationMethod(did, params) {
     const fragment = '#0';

package/dist/events/types.d.ts

@@ -220,7 +220,10 @@ export interface MigrationCompletedEvent extends BaseEvent {
 export interface MigrationFailedEvent extends BaseEvent {
     type: 'migration:failed';
     migrationId: string;
-    error: any;
+    error: Error | {
+        message: string;
+        code?: string;
+    };
 }
 /**
  * Emitted when migration is rolled back

package/dist/examples/create-module-original.js

@@ -322,7 +322,7 @@ async function estimateModuleCosts() {
     }
     console.log('');
     // Validate migration before attempting
-    const validation = await sdk.lifecycle.validateMigration(moduleAsset, 'did:btco');
+    const validation = sdk.lifecycle.validateMigration(moduleAsset, 'did:btco');
     console.log('Migration validation:');
     console.log(`  Valid: ${validation.valid}`);
     console.log(`  Checks:`);

package/dist/examples/full-lifecycle-flow.js

@@ -139,11 +139,11 @@ async function validateAndEstimate(sdk, asset) {
     console.log('\n🔍 STEP 3: Validating Migration & Estimating Costs\n');
     // Validate migration to did:webvh
     console.log('Validating migration to did:webvh:');
-    const webvhValidation = await sdk.lifecycle.validateMigration(asset, 'did:webvh');
+    const webvhValidation = sdk.lifecycle.validateMigration(asset, 'did:webvh');
     printValidation(webvhValidation);
     // Validate migration to did:btco
     console.log('\nValidating migration to did:btco:');
-    const btcoValidation = await sdk.lifecycle.validateMigration(asset, 'did:btco');
+    const btcoValidation = sdk.lifecycle.validateMigration(asset, 'did:btco');
     printValidation(btcoValidation);
     // Estimate costs for Bitcoin inscription
     console.log('\nCost estimates for Bitcoin inscription:');