@originals/sdk 1.2.0 → 1.4.2

package/dist/crypto/noble-init.d.ts

@@ -1,18 +0,0 @@
-/**
- * Noble Crypto Library Initialization
- *
- * @noble/ed25519 v2.x and @noble/secp256k1 require manual configuration of hash functions.
- * This is by design - they don't bundle hash implementations to allow flexibility.
- *
- * This module centralizes the initialization to ensure:
- * 1. Libraries are configured before any crypto operations
- * 2. Configuration is consistent across the SDK
- * 3. Readonly property issues (Bun) are handled gracefully
- *
- * This should be imported at the SDK entry point (index.ts) to ensure it runs first.
- */
-/**
- * Initialize all noble crypto libraries
- * This should be called once at SDK startup
- */
-export declare function initNobleCrypto(): void;

package/dist/crypto/noble-init.js

@@ -1,106 +0,0 @@
-/**
- * Noble Crypto Library Initialization
- *
- * @noble/ed25519 v2.x and @noble/secp256k1 require manual configuration of hash functions.
- * This is by design - they don't bundle hash implementations to allow flexibility.
- *
- * This module centralizes the initialization to ensure:
- * 1. Libraries are configured before any crypto operations
- * 2. Configuration is consistent across the SDK
- * 3. Readonly property issues (Bun) are handled gracefully
- *
- * This should be imported at the SDK entry point (index.ts) to ensure it runs first.
- */
-import * as secp256k1 from '@noble/secp256k1';
-import * as ed25519 from '@noble/ed25519';
-import { sha256, sha512 } from '@noble/hashes/sha2.js';
-import { hmac } from '@noble/hashes/hmac.js';
-import { concatBytes } from '@noble/hashes/utils.js';
-// Implementation functions
-const sha512Impl = (...msgs) => sha512(concatBytes(...msgs));
-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) {
-    try {
-        obj[prop] = value;
-        return true;
-    }
-    catch {
-        // Property might be readonly, try defineProperty
-        try {
-            Object.defineProperty(obj, prop, {
-                value,
-                writable: options?.writable ?? true,
-                configurable: options?.configurable ?? true,
-            });
-            return true;
-        }
-        catch {
-            // If both fail, property might already be set or truly readonly
-            return false;
-        }
-    }
-}
-/**
- * Initialize @noble/secp256k1 with hmacSha256Sync utility
- */
-function initSecp256k1() {
-    const sAny = secp256k1;
-    if (!sAny?.utils) {
-        // Try to create utils object if it doesn't exist
-        try {
-            sAny.utils = {};
-        }
-        catch {
-            // If we can't create it, try defineProperty
-            Object.defineProperty(sAny, 'utils', {
-                value: {},
-                writable: true,
-                configurable: true,
-            });
-        }
-    }
-    // Set hmacSha256Sync if not already set
-    if (typeof sAny.utils.hmacSha256Sync !== 'function') {
-        safeSetProperty(sAny.utils, 'hmacSha256Sync', hmacSha256Impl);
-    }
-}
-/**
- * Initialize @noble/ed25519 with sha512Sync utility
- * Handles both etc.sha512Sync (v2.x) and utils.sha512Sync (backward compat)
- */
-function initEd25519() {
-    const eAny = ed25519;
-    // Set etc.sha512Sync for @noble/ed25519 v2.x (required)
-    if (eAny?.etc && typeof eAny.etc.sha512Sync !== 'function') {
-        safeSetProperty(eAny.etc, 'sha512Sync', sha512Impl);
-    }
-    // Set utils.sha512Sync for backward compatibility
-    if (!eAny?.utils) {
-        try {
-            eAny.utils = {};
-        }
-        catch {
-            Object.defineProperty(eAny, 'utils', {
-                value: {},
-                writable: true,
-                configurable: true,
-            });
-        }
-    }
-    if (typeof eAny.utils.sha512Sync !== 'function') {
-        safeSetProperty(eAny.utils, 'sha512Sync', sha512Impl);
-    }
-}
-/**
- * Initialize all noble crypto libraries
- * This should be called once at SDK startup
- */
-export function initNobleCrypto() {
-    initSecp256k1();
-    initEd25519();
-}
-// Auto-initialize when this module is imported
-initNobleCrypto();

package/dist/did/BtcoDidResolver.d.ts

@@ -1,57 +0,0 @@
-import type { DIDDocument } from '../types/did';
-export interface BtcoInscriptionData {
-    inscriptionId: string;
-    content: string;
-    metadata: any;
-    contentUrl?: string;
-    contentType?: string;
-    isValidDid?: boolean;
-    didDocument?: DIDDocument | null;
-    error?: string;
-}
-export interface BtcoDidResolutionResult {
-    didDocument: DIDDocument | null;
-    inscriptions?: BtcoInscriptionData[];
-    resolutionMetadata: {
-        contentType?: string;
-        error?: string;
-        message?: string;
-        inscriptionId?: string;
-        satNumber?: string;
-        network?: string;
-        totalInscriptions?: number;
-    };
-    didDocumentMetadata: {
-        created?: string;
-        updated?: string;
-        deactivated?: boolean;
-        inscriptionId?: string;
-        network?: string;
-    };
-}
-export interface ResourceProviderLike {
-    getSatInfo(satNumber: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    resolveInscription(inscriptionId: string): Promise<{
-        id: string;
-        sat: number;
-        content_type: string;
-        content_url: string;
-    }>;
-    getMetadata(inscriptionId: string): Promise<any>;
-}
-export interface BtcoDidResolutionOptions {
-    provider?: ResourceProviderLike;
-    fetchFn?: (url: string) => Promise<Response>;
-    timeout?: number;
-}
-export declare class BtcoDidResolver {
-    private readonly options;
-    constructor(options?: BtcoDidResolutionOptions);
-    private parseBtcoDid;
-    private getDidPrefix;
-    resolve(did: string, options?: BtcoDidResolutionOptions): Promise<BtcoDidResolutionResult>;
-    private isValidDidDocument;
-    private createErrorResult;
-}

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 {};