@originals/sdk 1.4.3 → 1.4.5

package/dist/did/BtcoDidResolver.js

@@ -0,0 +1,166 @@
+export class BtcoDidResolver {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    parseBtcoDid(did) {
+        const regex = /^did:btco(?::(reg|sig))?:([0-9]+)(?:\/(.+))?$/;
+        const match = did.match(regex);
+        if (!match)
+            return null;
+        const [, networkSuffix, satNumber, path] = match;
+        const network = networkSuffix || 'mainnet';
+        return { satNumber, path, network };
+    }
+    getDidPrefix(network) {
+        switch (network) {
+            case 'reg':
+            case 'regtest':
+                return 'did:btco:reg';
+            case 'sig':
+            case 'signet':
+                return 'did:btco:sig';
+            default:
+                return 'did:btco';
+        }
+    }
+    async resolve(did, options = {}) {
+        const parsed = this.parseBtcoDid(did);
+        if (!parsed) {
+            return this.createErrorResult('invalidDid', `Invalid BTCO DID format: ${did}`);
+        }
+        const { satNumber, network } = parsed;
+        const provider = options.provider || this.options.provider;
+        if (!provider) {
+            return this.createErrorResult('noProvider', 'No provider supplied');
+        }
+        let inscriptionIds = [];
+        try {
+            const satInfo = await provider.getSatInfo(satNumber);
+            inscriptionIds = satInfo?.inscription_ids || [];
+        }
+        catch (e) {
+            return this.createErrorResult('notFound', `Failed to retrieve inscriptions for satoshi ${satNumber}: ${e?.message || String(e)}`);
+        }
+        if (inscriptionIds.length === 0) {
+            return this.createErrorResult('notFound', `No inscriptions found on satoshi ${satNumber}`);
+        }
+        const expectedDid = `${this.getDidPrefix(network)}:${satNumber}`;
+        const didPattern = new RegExp(`^(?:BTCO DID: )?(${expectedDid.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'i');
+        const inscriptionDataList = [];
+        for (const inscriptionId of inscriptionIds) {
+            const inscriptionData = {
+                inscriptionId,
+                content: '',
+                metadata: null
+            };
+            try {
+                const inscription = await provider.resolveInscription(inscriptionId);
+                if (!inscription) {
+                    inscriptionData.error = `Inscription ${inscriptionId} not found`;
+                    inscriptionDataList.push(inscriptionData);
+                    continue;
+                }
+                inscriptionData.contentUrl = inscription.content_url;
+                inscriptionData.contentType = inscription.content_type;
+                try {
+                    // Use configurable fetch function or default to global fetch
+                    const fetchFn = options.fetchFn || this.options.fetchFn || fetch;
+                    const timeout = options.timeout || this.options.timeout || 10000; // 10 second default
+                    // Create abort controller for timeout
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), timeout);
+                    try {
+                        const response = await fetchFn(inscription.content_url);
+                        clearTimeout(timeoutId);
+                        if (!response.ok) {
+                            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                        }
+                        inscriptionData.content = await response.text();
+                    }
+                    finally {
+                        clearTimeout(timeoutId);
+                    }
+                }
+                catch (err) {
+                    inscriptionData.error = `Failed to fetch content: ${err?.message || String(err)}`;
+                    inscriptionDataList.push(inscriptionData);
+                    continue;
+                }
+                try {
+                    inscriptionData.metadata = await provider.getMetadata(inscriptionId);
+                }
+                catch (err) {
+                    inscriptionData.metadata = null;
+                }
+                inscriptionData.isValidDid = didPattern.test(inscriptionData.content);
+                if (inscriptionData.isValidDid && inscriptionData.metadata) {
+                    const didDocument = inscriptionData.metadata;
+                    if (this.isValidDidDocument(didDocument) && didDocument.id === expectedDid) {
+                        inscriptionData.didDocument = didDocument;
+                    }
+                    else {
+                        inscriptionData.error = 'Invalid DID document structure or mismatched ID';
+                    }
+                }
+                if (inscriptionData.content.includes('🔥')) {
+                    inscriptionData.didDocument = null;
+                    if (!inscriptionData.error) {
+                        inscriptionData.error = 'DID has been deactivated';
+                    }
+                }
+            }
+            catch (err) {
+                inscriptionData.error = `Failed to process inscription: ${err?.message || String(err)}`;
+            }
+            inscriptionDataList.push(inscriptionData);
+        }
+        let latestValidDidDocument = null;
+        let latestInscriptionId;
+        for (let i = inscriptionDataList.length - 1; i >= 0; i--) {
+            const data = inscriptionDataList[i];
+            if (data.didDocument && !data.error) {
+                latestValidDidDocument = data.didDocument;
+                latestInscriptionId = data.inscriptionId;
+                break;
+            }
+        }
+        return {
+            didDocument: latestValidDidDocument,
+            inscriptions: inscriptionDataList,
+            resolutionMetadata: {
+                inscriptionId: latestInscriptionId,
+                satNumber,
+                network,
+                totalInscriptions: inscriptionDataList.length
+            },
+            didDocumentMetadata: {
+                inscriptionId: latestInscriptionId,
+                network
+            }
+        };
+    }
+    isValidDidDocument(doc) {
+        if (!doc || typeof doc !== 'object')
+            return false;
+        if (!doc.id || typeof doc.id !== 'string')
+            return false;
+        if (!doc['@context'])
+            return false;
+        const contexts = Array.isArray(doc['@context']) ? doc['@context'] : [doc['@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))
+            return false;
+        if (doc.authentication && !Array.isArray(doc.authentication))
+            return false;
+        return true;
+    }
+    createErrorResult(error, message) {
+        return {
+            didDocument: null,
+            resolutionMetadata: { error, message },
+            didDocumentMetadata: {}
+        };
+    }
+}

package/dist/did/DIDManager.d.ts

@@ -0,0 +1,101 @@
+import { DIDDocument, OriginalsConfig, AssetResource, KeyPair, ExternalSigner, ExternalVerifier } from '../types';
+import { createBtcoDidDocument } from './createBtcoDidDocument';
+export declare class DIDManager {
+    private config;
+    constructor(config: OriginalsConfig);
+    createDIDPeer(resources: AssetResource[], returnKeyPair?: false): Promise<DIDDocument>;
+    createDIDPeer(resources: AssetResource[], returnKeyPair: true): Promise<{
+        didDocument: DIDDocument;
+        keyPair: {
+            privateKey: string;
+            publicKey: string;
+        };
+    }>;
+    migrateToDIDWebVH(didDoc: DIDDocument, domain?: string): Promise<DIDDocument>;
+    migrateToDIDBTCO(didDoc: DIDDocument, satoshi: string): Promise<DIDDocument>;
+    resolveDID(did: string): Promise<DIDDocument | null>;
+    validateDIDDocument(didDoc: DIDDocument): boolean;
+    private getLayerFromDID;
+    createBtcoDidDocument(satNumber: number | string, network: 'mainnet' | 'regtest' | 'signet', options: Parameters<typeof createBtcoDidDocument>[2]): DIDDocument;
+    /**
+     * Creates a new did:webvh DID with proper cryptographic signing
+     * @param options - Creation options including domain and optional key pair or external signer
+     * @returns The created DID, document, log, and key pair (if generated)
+     */
+    createDIDWebVH(options: CreateWebVHOptions): Promise<CreateWebVHResult>;
+    /**
+     * Updates a DID:WebVH document
+     * @param options - Update options
+     * @returns Updated DID document and log
+     */
+    updateDIDWebVH(options: {
+        did: string;
+        currentLog: DIDLog;
+        updates: Partial<DIDDocument>;
+        signer: ExternalSigner | {
+            privateKey: string;
+            publicKey: string;
+        };
+        verifier?: ExternalVerifier;
+        outputDir?: string;
+    }): Promise<{
+        didDocument: DIDDocument;
+        log: DIDLog;
+        logPath?: string;
+    }>;
+    /**
+     * Saves the DID log to the appropriate did.jsonl path
+     * @param did - The DID identifier
+     * @param log - The DID log to save
+     * @param baseDir - Base directory for saving (e.g., public/.well-known)
+     * @returns The full path where the log was saved
+     */
+    saveDIDLog(did: string, log: DIDLog, baseDir: string): Promise<string>;
+    /**
+     * Loads a DID log from a did.jsonl file
+     * @param logPath - Path to the did.jsonl file
+     * @returns The loaded DID log
+     */
+    loadDIDLog(logPath: string): Promise<DIDLog>;
+    /**
+     * Validates a path segment to prevent directory traversal attacks
+     * @param segment - Path segment to validate
+     * @returns true if valid, false otherwise
+     */
+    private isValidPathSegment;
+}
+interface WebVHVerificationMethod {
+    id?: string;
+    type: string;
+    controller?: string;
+    publicKeyMultibase: string;
+    secretKeyMultibase?: string;
+    purpose?: 'authentication' | 'assertionMethod' | 'keyAgreement' | 'capabilityInvocation' | 'capabilityDelegation';
+}
+interface DIDLogEntry {
+    versionId: string;
+    versionTime: string;
+    parameters: Record<string, unknown>;
+    state: Record<string, unknown>;
+    proof?: Record<string, unknown>[];
+}
+type DIDLog = DIDLogEntry[];
+export interface CreateWebVHOptions {
+    domain?: string;
+    keyPair?: KeyPair;
+    paths?: string[];
+    portable?: boolean;
+    outputDir?: string;
+    externalSigner?: ExternalSigner;
+    externalVerifier?: ExternalVerifier;
+    verificationMethods?: WebVHVerificationMethod[];
+    updateKeys?: string[];
+}
+export interface CreateWebVHResult {
+    did: string;
+    didDocument: DIDDocument;
+    log: DIDLog;
+    keyPair: KeyPair;
+    logPath?: string;
+}
+export {};