@originals/sdk 1.2.0 → 1.4.3

package/dist/migration/validation/LifecycleValidator.js

@@ -1,52 +0,0 @@
-/**
- * LifecycleValidator - Validates lifecycle state transitions
- */
-export class LifecycleValidator {
-    constructor(config) {
-        this.config = config;
-    }
-    async validate(options) {
-        const errors = [];
-        const warnings = [];
-        try {
-            // All lifecycle states are compatible with all layers
-            // This validator checks for pending operations that might interfere
-            // For now, lifecycle is always compatible
-            // Future enhancements could check for:
-            // - Pending operations on source DID
-            // - State machine compatibility
-            // - Event history preservation capability
-            return {
-                valid: errors.length === 0,
-                errors,
-                warnings,
-                estimatedCost: {
-                    storageCost: 0,
-                    networkFees: 0,
-                    totalCost: 0,
-                    currency: 'sats'
-                },
-                estimatedDuration: 30
-            };
-        }
-        catch (error) {
-            errors.push({
-                code: 'LIFECYCLE_VALIDATION_ERROR',
-                message: 'Error validating lifecycle compatibility',
-                details: { error: error instanceof Error ? error.message : String(error) }
-            });
-            return {
-                valid: false,
-                errors,
-                warnings,
-                estimatedCost: {
-                    storageCost: 0,
-                    networkFees: 0,
-                    totalCost: 0,
-                    currency: 'sats'
-                },
-                estimatedDuration: 0
-            };
-        }
-    }
-}

package/dist/migration/validation/StorageValidator.d.ts

@@ -1,10 +0,0 @@
-/**
- * StorageValidator - Validates storage adapter compatibility
- */
-import { MigrationOptions, MigrationValidationResult, IValidator } from '../types';
-import { OriginalsConfig } from '../../types';
-export declare class StorageValidator implements IValidator {
-    private config;
-    constructor(config: OriginalsConfig);
-    validate(options: MigrationOptions): Promise<MigrationValidationResult>;
-}

package/dist/migration/validation/StorageValidator.js

@@ -1,65 +0,0 @@
-/**
- * StorageValidator - Validates storage adapter compatibility
- */
-export class StorageValidator {
-    constructor(config) {
-        this.config = config;
-    }
-    async validate(options) {
-        const errors = [];
-        const warnings = [];
-        try {
-            const storageAdapter = this.config.storageAdapter;
-            // Check if storage adapter is available
-            if (!storageAdapter) {
-                warnings.push({
-                    code: 'NO_STORAGE_ADAPTER',
-                    message: 'No storage adapter configured; using memory storage (not persistent)'
-                });
-            }
-            // Check large file support for partial migrations
-            if (options.partialMode) {
-                // Verify storage adapter supports chunked uploads
-                if (storageAdapter && typeof storageAdapter.putChunk !== 'function') {
-                    warnings.push({
-                        code: 'NO_CHUNKED_UPLOAD_SUPPORT',
-                        message: 'Storage adapter does not support chunked uploads; partial mode may be inefficient'
-                    });
-                }
-            }
-            // Estimate storage costs (minimal for webvh, zero for peer/btco)
-            const storageCost = options.targetLayer === 'webvh' ? 0.001 : 0;
-            return {
-                valid: errors.length === 0,
-                errors,
-                warnings,
-                estimatedCost: {
-                    storageCost,
-                    networkFees: 0,
-                    totalCost: storageCost,
-                    currency: 'sats'
-                },
-                estimatedDuration: 50
-            };
-        }
-        catch (error) {
-            errors.push({
-                code: 'STORAGE_VALIDATION_ERROR',
-                message: 'Error validating storage compatibility',
-                details: { error: error instanceof Error ? error.message : String(error) }
-            });
-            return {
-                valid: false,
-                errors,
-                warnings,
-                estimatedCost: {
-                    storageCost: 0,
-                    networkFees: 0,
-                    totalCost: 0,
-                    currency: 'sats'
-                },
-                estimatedDuration: 0
-            };
-        }
-    }
-}

package/dist/migration/validation/ValidationPipeline.d.ts

@@ -1,29 +0,0 @@
-/**
- * ValidationPipeline - Orchestrates all validation checks before migration
- */
-import { MigrationOptions, MigrationValidationResult, ValidationError } from '../types';
-import { OriginalsConfig } from '../../types';
-import { DIDManager } from '../../did/DIDManager';
-import { CredentialManager } from '../../vc/CredentialManager';
-import { BitcoinManager } from '../../bitcoin/BitcoinManager';
-export declare class ValidationPipeline {
-    private config;
-    private didManager;
-    private credentialManager;
-    private bitcoinManager?;
-    private validators;
-    constructor(config: OriginalsConfig, didManager: DIDManager, credentialManager: CredentialManager, bitcoinManager?: BitcoinManager | undefined);
-    private initializeValidators;
-    /**
-     * Run all validation checks for a migration
-     */
-    validate(options: MigrationOptions): Promise<MigrationValidationResult>;
-    /**
-     * Validate basic input parameters
-     */
-    private validateInput;
-    /**
-     * Quick validation check (basic only, no async operations)
-     */
-    validateQuick(options: MigrationOptions): ValidationError[];
-}

package/dist/migration/validation/ValidationPipeline.js

@@ -1,180 +0,0 @@
-/**
- * ValidationPipeline - Orchestrates all validation checks before migration
- */
-import { DIDCompatibilityValidator } from './DIDCompatibilityValidator';
-import { CredentialValidator } from './CredentialValidator';
-import { StorageValidator } from './StorageValidator';
-import { LifecycleValidator } from './LifecycleValidator';
-import { BitcoinValidator } from './BitcoinValidator';
-export class ValidationPipeline {
-    constructor(config, didManager, credentialManager, bitcoinManager) {
-        this.config = config;
-        this.didManager = didManager;
-        this.credentialManager = credentialManager;
-        this.bitcoinManager = bitcoinManager;
-        this.validators = new Map();
-        this.initializeValidators();
-    }
-    initializeValidators() {
-        this.validators.set('did', new DIDCompatibilityValidator(this.config, this.didManager));
-        this.validators.set('credential', new CredentialValidator(this.config, this.credentialManager));
-        this.validators.set('storage', new StorageValidator(this.config));
-        this.validators.set('lifecycle', new LifecycleValidator(this.config));
-        if (this.bitcoinManager) {
-            this.validators.set('bitcoin', new BitcoinValidator(this.config, this.bitcoinManager));
-        }
-    }
-    /**
-     * Run all validation checks for a migration
-     */
-    async validate(options) {
-        const errors = [];
-        const warnings = [];
-        let estimatedCost = {
-            storageCost: 0,
-            networkFees: 0,
-            totalCost: 0,
-            currency: 'sats'
-        };
-        let estimatedDuration = 0;
-        try {
-            // Basic input validation
-            const inputErrors = this.validateInput(options);
-            if (inputErrors.length > 0) {
-                return {
-                    valid: false,
-                    errors: inputErrors,
-                    warnings: [],
-                    estimatedCost,
-                    estimatedDuration: 0
-                };
-            }
-            // Run DID compatibility validation
-            const didResult = await this.validators.get('did').validate(options);
-            errors.push(...didResult.errors);
-            warnings.push(...didResult.warnings);
-            estimatedDuration = Math.max(estimatedDuration, didResult.estimatedDuration);
-            // Run credential validation if enabled
-            if (options.credentialIssuance !== false) {
-                const credResult = await this.validators.get('credential').validate(options);
-                errors.push(...credResult.errors);
-                warnings.push(...credResult.warnings);
-            }
-            // Run storage validation
-            const storageResult = await this.validators.get('storage').validate(options);
-            errors.push(...storageResult.errors);
-            warnings.push(...storageResult.warnings);
-            estimatedCost.storageCost = storageResult.estimatedCost.storageCost;
-            // Run lifecycle validation
-            const lifecycleResult = await this.validators.get('lifecycle').validate(options);
-            errors.push(...lifecycleResult.errors);
-            warnings.push(...lifecycleResult.warnings);
-            // Run Bitcoin validation for btco migrations
-            if (options.targetLayer === 'btco') {
-                const bitcoinValidator = this.validators.get('bitcoin');
-                if (!bitcoinValidator) {
-                    errors.push({
-                        code: 'BITCOIN_VALIDATOR_MISSING',
-                        message: 'Bitcoin validator required for btco migrations but not configured',
-                        details: { targetLayer: options.targetLayer }
-                    });
-                }
-                else {
-                    const bitcoinResult = await bitcoinValidator.validate(options);
-                    errors.push(...bitcoinResult.errors);
-                    warnings.push(...bitcoinResult.warnings);
-                    estimatedCost.networkFees = bitcoinResult.estimatedCost.networkFees;
-                    estimatedDuration = Math.max(estimatedDuration, bitcoinResult.estimatedDuration);
-                }
-            }
-            // Calculate total cost
-            estimatedCost.totalCost = estimatedCost.storageCost + estimatedCost.networkFees;
-            return {
-                valid: errors.length === 0,
-                errors,
-                warnings,
-                estimatedCost,
-                estimatedDuration
-            };
-        }
-        catch (error) {
-            errors.push({
-                code: 'VALIDATION_PIPELINE_ERROR',
-                message: 'Unexpected error during validation',
-                details: { error: error instanceof Error ? error.message : String(error) }
-            });
-            return {
-                valid: false,
-                errors,
-                warnings,
-                estimatedCost,
-                estimatedDuration
-            };
-        }
-    }
-    /**
-     * Validate basic input parameters
-     */
-    validateInput(options) {
-        const errors = [];
-        // Validate source DID
-        if (!options.sourceDid || typeof options.sourceDid !== 'string') {
-            errors.push({
-                code: 'INVALID_SOURCE_DID',
-                message: 'Source DID is required and must be a string',
-                field: 'sourceDid'
-            });
-        }
-        // Validate target layer
-        if (!options.targetLayer) {
-            errors.push({
-                code: 'INVALID_TARGET_LAYER',
-                message: 'Target layer is required',
-                field: 'targetLayer'
-            });
-        }
-        else if (!['peer', 'webvh', 'btco'].includes(options.targetLayer)) {
-            errors.push({
-                code: 'INVALID_TARGET_LAYER',
-                message: 'Target layer must be one of: peer, webvh, btco',
-                field: 'targetLayer',
-                details: { received: options.targetLayer }
-            });
-        }
-        // Validate partial mode options
-        if (options.partialMode) {
-            if (typeof options.partialMode.chunkSize !== 'number' || options.partialMode.chunkSize <= 0) {
-                errors.push({
-                    code: 'INVALID_CHUNK_SIZE',
-                    message: 'Chunk size must be a positive number',
-                    field: 'partialMode.chunkSize'
-                });
-            }
-        }
-        // Validate webvh-specific options
-        if (options.targetLayer === 'webvh' && !options.domain) {
-            errors.push({
-                code: 'DOMAIN_REQUIRED',
-                message: 'Domain is required for webvh migrations',
-                field: 'domain'
-            });
-        }
-        // Validate btco-specific options
-        if (options.targetLayer === 'btco') {
-            if (options.feeRate !== undefined && (typeof options.feeRate !== 'number' || options.feeRate <= 0)) {
-                errors.push({
-                    code: 'INVALID_FEE_RATE',
-                    message: 'Fee rate must be a positive number',
-                    field: 'feeRate'
-                });
-            }
-        }
-        return errors;
-    }
-    /**
-     * Quick validation check (basic only, no async operations)
-     */
-    validateQuick(options) {
-        return this.validateInput(options);
-    }
-}

package/dist/storage/LocalStorageAdapter.d.ts

@@ -1,11 +0,0 @@
-import { GetObjectResult, LocalStorageAdapterOptions, StorageAdapter } from './StorageAdapter';
-export declare class LocalStorageAdapter implements StorageAdapter {
-    private baseDir;
-    private baseUrl?;
-    constructor(options: LocalStorageAdapterOptions);
-    private resolvePath;
-    private toUrl;
-    putObject(domain: string, objectPath: string, content: Uint8Array | string): Promise<string>;
-    getObject(domain: string, objectPath: string): Promise<GetObjectResult | null>;
-    exists(domain: string, objectPath: string): Promise<boolean>;
-}

package/dist/storage/LocalStorageAdapter.js

@@ -1,53 +0,0 @@
-// Local adapter is optional in this environment; keeping implementation but avoid Node typings
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import * as fs from 'fs/promises';
-import * as path from 'path';
-export class LocalStorageAdapter {
-    constructor(options) {
-        this.baseDir = options.baseDir;
-        this.baseUrl = options.baseUrl;
-    }
-    resolvePath(domain, objectPath) {
-        const safeDomain = domain.replace(/[^a-zA-Z0-9.-]/g, '_');
-        const cleanPath = objectPath.replace(/^\/+/, '');
-        return path.join(this.baseDir, safeDomain, cleanPath);
-    }
-    toUrl(domain, objectPath) {
-        const cleanPath = objectPath.replace(/^\/+/, '');
-        if (this.baseUrl) {
-            const trimmed = this.baseUrl.replace(/\/$/, '');
-            return `${trimmed}/${domain}/${cleanPath}`;
-        }
-        return `file://${this.resolvePath(domain, cleanPath)}`;
-    }
-    async putObject(domain, objectPath, content) {
-        const fullPath = this.resolvePath(domain, objectPath);
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        const data = typeof content === 'string' ? Buffer.from(content) : Buffer.from(content);
-        await fs.writeFile(fullPath, data);
-        return this.toUrl(domain, objectPath);
-    }
-    async getObject(domain, objectPath) {
-        const fullPath = this.resolvePath(domain, objectPath);
-        try {
-            const content = await fs.readFile(fullPath);
-            return { content: new Uint8Array(content) };
-        }
-        catch (e) {
-            if (e && e.code === 'ENOENT')
-                return null;
-            throw e;
-        }
-    }
-    async exists(domain, objectPath) {
-        const fullPath = this.resolvePath(domain, objectPath);
-        try {
-            await fs.access(fullPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/storage/MemoryStorageAdapter.d.ts

@@ -1,6 +0,0 @@
-import { GetObjectResult, StorageAdapter } from './StorageAdapter';
-export declare class MemoryStorageAdapter implements StorageAdapter {
-    putObject(domain: string, objectPath: string, content: Uint8Array | string): Promise<string>;
-    getObject(domain: string, objectPath: string): Promise<GetObjectResult | null>;
-    exists(domain: string, objectPath: string): Promise<boolean>;
-}

package/dist/storage/MemoryStorageAdapter.js

@@ -1,21 +0,0 @@
-const globalStore = new Map();
-function key(domain, objectPath) {
-    const cleanPath = objectPath.replace(/^\/+/, '');
-    return `${domain}::${cleanPath}`;
-}
-export class MemoryStorageAdapter {
-    async putObject(domain, objectPath, content) {
-        const data = typeof content === 'string' ? new TextEncoder().encode(content) : content;
-        globalStore.set(key(domain, objectPath), data);
-        return `mem://${domain}/${objectPath.replace(/^\/+/, '')}`;
-    }
-    async getObject(domain, objectPath) {
-        const stored = globalStore.get(key(domain, objectPath));
-        if (!stored)
-            return null;
-        return { content: stored };
-    }
-    async exists(domain, objectPath) {
-        return globalStore.has(key(domain, objectPath));
-    }
-}

package/dist/storage/StorageAdapter.d.ts

@@ -1,16 +0,0 @@
-export interface PutOptions {
-    contentType?: string;
-}
-export interface GetObjectResult {
-    content: Uint8Array;
-    contentType?: string;
-}
-export interface StorageAdapter {
-    putObject(domain: string, path: string, content: Uint8Array | string, options?: PutOptions): Promise<string>;
-    getObject(domain: string, path: string): Promise<GetObjectResult | null>;
-    exists(domain: string, path: string): Promise<boolean>;
-}
-export interface LocalStorageAdapterOptions {
-    baseDir: string;
-    baseUrl?: string;
-}

package/dist/storage/StorageAdapter.js

@@ -1 +0,0 @@
-export {};

package/dist/storage/index.d.ts

@@ -1,2 +0,0 @@
-export * from './StorageAdapter';
-export * from './MemoryStorageAdapter';

package/dist/storage/index.js

@@ -1,2 +0,0 @@
-export * from './StorageAdapter';
-export * from './MemoryStorageAdapter';

package/dist/types/bitcoin.d.ts

@@ -1,84 +0,0 @@
-export interface OrdinalsInscription {
-    satoshi: string;
-    inscriptionId: string;
-    content: Buffer;
-    contentType: string;
-    txid: string;
-    vout: number;
-    blockHeight?: number;
-}
-export interface BitcoinTransaction {
-    txid: string;
-    vin: TransactionInput[];
-    vout: TransactionOutput[];
-    fee: number;
-    blockHeight?: number;
-    confirmations?: number;
-}
-export interface TransactionInput {
-    txid: string;
-    vout: number;
-    scriptSig?: string;
-    witness?: string[];
-}
-export interface TransactionOutput {
-    value: number;
-    scriptPubKey: string;
-    address?: string;
-}
-export interface Utxo {
-    txid: string;
-    vout: number;
-    value: number;
-    scriptPubKey?: string;
-    address?: string;
-    inscriptions?: string[];
-    locked?: boolean;
-}
-/**
- * Extended UTXO interface that tracks whether it contains an Ordinals resource (inscription)
- */
-export interface ResourceUtxo extends Utxo {
-    /** True if this UTXO contains an inscription or other Ordinals resource */
-    hasResource?: boolean;
-}
-/**
- * Strategy for selecting UTXOs
- */
-export type UtxoSelectionStrategy = 'minimize_change' | 'minimize_inputs' | 'optimize_size';
-/**
- * Options for resource-aware UTXO selection
- */
-export interface ResourceUtxoSelectionOptions {
-    /** Required amount in satoshis */
-    requiredAmount: number;
-    /** Fee rate in satoshis per vbyte */
-    feeRate: number;
-    /** Allow using UTXOs that contain resources (default: false) */
-    allowResourceUtxos?: boolean;
-    /** Prefer older UTXOs (default: false) */
-    preferOlder?: boolean;
-    /** Prefer UTXOs with value closer to required amount (default: false) */
-    preferCloserAmount?: boolean;
-    /** List of UTXO IDs to avoid using (format: "txid:vout") */
-    avoidUtxoIds?: string[];
-}
-/**
- * Result of resource-aware UTXO selection
- */
-export interface ResourceUtxoSelectionResult {
-    /** Selected UTXOs for the transaction */
-    selectedUtxos: ResourceUtxo[];
-    /** Total value of selected UTXOs */
-    totalSelectedValue: number;
-    /** Estimated transaction fee in satoshis */
-    estimatedFee: number;
-    /** Change amount in satoshis (0 if less than dust) */
-    changeAmount: number;
-}
-export declare const DUST_LIMIT_SATS = 546;
-export interface KeyPair {
-    privateKey: string;
-    publicKey: string;
-}
-export type KeyType = 'ES256K' | 'Ed25519' | 'ES256';

package/dist/types/bitcoin.js

@@ -1 +0,0 @@
-export const DUST_LIMIT_SATS = 546;

package/dist/types/common.d.ts

@@ -1,82 +0,0 @@
-import { StorageAdapter, FeeOracleAdapter, OrdinalsProvider } from '../adapters';
-import { TelemetryHooks } from '../utils/telemetry';
-import type { LogLevel, LogOutput } from '../utils/Logger';
-import type { EventLoggingConfig } from '../utils/EventLogger';
-import type { WebVHNetworkName } from './network';
-export type LayerType = 'did:peer' | 'did:webvh' | 'did:btco';
-export interface OriginalsConfig {
-    network: 'mainnet' | 'regtest' | 'signet';
-    bitcoinRpcUrl?: string;
-    defaultKeyType: 'ES256K' | 'Ed25519' | 'ES256';
-    keyStore?: KeyStore;
-    enableLogging?: boolean;
-    webvhNetwork?: WebVHNetworkName;
-    storageAdapter?: StorageAdapter;
-    feeOracle?: FeeOracleAdapter;
-    ordinalsProvider?: OrdinalsProvider;
-    telemetry?: TelemetryHooks;
-    logging?: {
-        level?: LogLevel;
-        outputs?: LogOutput[];
-        includeTimestamps?: boolean;
-        includeContext?: boolean;
-        eventLogging?: EventLoggingConfig;
-        sanitizeLogs?: boolean;
-    };
-    metrics?: {
-        enabled?: boolean;
-        exportFormat?: 'json' | 'prometheus';
-        collectCache?: boolean;
-    };
-}
-export interface AssetResource {
-    id: string;
-    type: string;
-    url?: string;
-    content?: string;
-    contentType: string;
-    hash: string;
-    size?: number;
-    version?: number;
-    previousVersionHash?: string;
-    createdAt?: string;
-}
-export interface KeyStore {
-    getPrivateKey(verificationMethodId: string): Promise<string | null>;
-    setPrivateKey(verificationMethodId: string, privateKey: string): Promise<void>;
-}
-/**
- * External signer interface for DID operations (compatible with didwebvh-ts)
- * This allows integration with external key management systems like Privy
- */
-export interface ExternalSigner {
-    /**
-     * Sign data and return a proof value
-     * @param input - The signing input containing document and proof
-     * @returns The proof value (typically multibase-encoded signature)
-     */
-    sign(input: {
-        document: Record<string, unknown>;
-        proof: Record<string, unknown>;
-    }): Promise<{
-        proofValue: string;
-    }>;
-    /**
-     * Get the verification method ID for this signer
-     * @returns The verification method ID (e.g., "did:key:z6Mk...")
-     */
-    getVerificationMethodId(): string;
-}
-/**
- * External verifier interface for DID operations (compatible with didwebvh-ts)
- */
-export interface ExternalVerifier {
-    /**
-     * Verify a signature
-     * @param signature - The signature bytes
-     * @param message - The message bytes that were signed
-     * @param publicKey - The public key bytes
-     * @returns True if the signature is valid
-     */
-    verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
-}

package/dist/types/common.js

@@ -1 +0,0 @@
-export {};