@originals/sdk 1.2.0 → 1.4.3

package/dist/did/BtcoDidResolver.js

@@ -1,166 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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 {};