@originals/sdk 1.4.3 → 1.5.0

package/dist/did/providers/OrdinalsClientProviderAdapter.d.ts

@@ -0,0 +1,23 @@
+import type { ResourceProviderLike } from '../BtcoDidResolver';
+import { OrdinalsClient } from '../../bitcoin/OrdinalsClient';
+export interface OrdinalsClientProviderConfig {
+    baseUrl: string;
+    fetchFn?: (url: string, init?: RequestInit) => Promise<Response>;
+    timeout?: number;
+}
+export declare class OrdinalsClientProviderAdapter implements ResourceProviderLike {
+    private client;
+    private readonly config;
+    constructor(client: OrdinalsClient, configOrBaseUrl: string | OrdinalsClientProviderConfig);
+    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 default OrdinalsClientProviderAdapter;

package/dist/did/providers/OrdinalsClientProviderAdapter.js

@@ -0,0 +1,51 @@
+export class OrdinalsClientProviderAdapter {
+    constructor(client, configOrBaseUrl) {
+        this.client = client;
+        if (typeof configOrBaseUrl === 'string') {
+            this.config = { baseUrl: configOrBaseUrl };
+        }
+        else {
+            this.config = configOrBaseUrl;
+        }
+    }
+    async getSatInfo(satNumber) {
+        return this.client.getSatInfo(satNumber);
+    }
+    async resolveInscription(inscriptionId) {
+        const base = (this.config.baseUrl || '').replace(/\/$/, '');
+        if (!base) {
+            throw new Error('OrdinalsClientProviderAdapter requires a baseUrl');
+        }
+        try {
+            // Use configurable fetch function or default to global fetch
+            const fetchFn = this.config.fetchFn || fetch;
+            const timeout = this.config.timeout || 10000; // 10 second default timeout
+            const fetchOptions = {
+                headers: { 'Accept': 'application/json' },
+                signal: AbortSignal.timeout(timeout)
+            };
+            const res = await fetchFn(`${base}/inscription/${inscriptionId}`, fetchOptions);
+            if (!res.ok) {
+                // Log warning but don't throw - allow graceful degradation
+                console.warn(`Failed to resolve inscription ${inscriptionId}: HTTP ${res.status}`);
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            }
+            const info = await res.json();
+            return {
+                id: info.inscription_id || inscriptionId,
+                sat: typeof info.sat === 'number' ? info.sat : Number(info.sat || 0),
+                content_type: info.content_type || 'text/plain',
+                content_url: info.content_url || `${base}/content/${inscriptionId}`
+            };
+        }
+        catch (err) {
+            // Log error for debugging but re-throw for caller to handle
+            console.warn(`Failed to resolve inscription ${inscriptionId}:`, err.message || String(err));
+            throw new Error(`Failed to resolve inscription: ${inscriptionId}`);
+        }
+    }
+    async getMetadata(inscriptionId) {
+        return this.client.getMetadata(inscriptionId);
+    }
+}
+export default OrdinalsClientProviderAdapter;

package/dist/events/EventEmitter.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Type-safe EventEmitter for Originals SDK
+ *
+ * Features:
+ * - Type-safe event emission and subscription
+ * - Support for both sync and async handlers
+ * - Error isolation (one failing handler doesn't affect others)
+ * - Event namespacing
+ * - Performance optimized (<1ms overhead per event)
+ */
+import type { EventHandler, EventTypeMap } from './types';
+/**
+ * EventEmitter class for managing event subscriptions and emissions
+ */
+export declare class EventEmitter {
+    private handlers;
+    private onceHandlers;
+    /**
+     * Subscribe to an event
+     *
+     * @param eventType - The type of event to listen for
+     * @param handler - The handler function to call when the event is emitted
+     * @returns A function to unsubscribe the handler
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = emitter.on('asset:created', (event) => {
+     *   console.log('Asset created:', event.asset.id);
+     * });
+     *
+     * // Later, to unsubscribe:
+     * unsubscribe();
+     * ```
+     */
+    on<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): () => void;
+    /**
+     * Subscribe to an event for a single emission
+     *
+     * @param eventType - The type of event to listen for
+     * @param handler - The handler function to call when the event is emitted (only once)
+     * @returns A function to unsubscribe the handler
+     *
+     * @example
+     * ```typescript
+     * emitter.once('asset:migrated', (event) => {
+     *   console.log('Asset migrated once:', event.asset.id);
+     * });
+     * ```
+     */
+    once<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): () => void;
+    /**
+     * Unsubscribe from an event
+     *
+     * @param eventType - The type of event to stop listening for
+     * @param handler - The handler function to remove
+     *
+     * @example
+     * ```typescript
+     * const handler = (event) => console.log(event);
+     * emitter.on('asset:created', handler);
+     * emitter.off('asset:created', handler);
+     * ```
+     */
+    off<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): void;
+    /**
+     * Emit an event to all subscribed handlers
+     *
+     * @param event - The event to emit
+     *
+     * Features:
+     * - Handlers are called in subscription order
+     * - Async handlers are awaited
+     * - Errors in handlers are isolated (logged but don't affect other handlers)
+     * - Once handlers are automatically removed after execution
+     *
+     * @example
+     * ```typescript
+     * emitter.emit({
+     *   type: 'asset:created',
+     *   timestamp: new Date().toISOString(),
+     *   asset: { id: 'did:peer:123', layer: 'did:peer', resourceCount: 1 }
+     * });
+     * ```
+     */
+    emit<K extends keyof EventTypeMap>(event: EventTypeMap[K]): Promise<void>;
+    /**
+     * Remove all handlers for a specific event type, or all handlers if no type specified
+     *
+     * @param eventType - Optional event type to clear handlers for
+     *
+     * @example
+     * ```typescript
+     * // Remove all handlers for 'asset:created'
+     * emitter.removeAllListeners('asset:created');
+     *
+     * // Remove all handlers for all events
+     * emitter.removeAllListeners();
+     * ```
+     */
+    removeAllListeners<K extends keyof EventTypeMap>(eventType?: K): void;
+    /**
+     * Get the number of handlers for a specific event type
+     *
+     * @param eventType - The event type to check
+     * @returns The number of handlers subscribed to this event type
+     */
+    listenerCount<K extends keyof EventTypeMap>(eventType: K): number;
+    /**
+     * Check if there are any handlers for a specific event type
+     *
+     * @param eventType - The event type to check
+     * @returns True if there are any handlers subscribed
+     */
+    hasListeners<K extends keyof EventTypeMap>(eventType: K): boolean;
+}

package/dist/events/EventEmitter.js

@@ -0,0 +1,198 @@
+/**
+ * Type-safe EventEmitter for Originals SDK
+ *
+ * Features:
+ * - Type-safe event emission and subscription
+ * - Support for both sync and async handlers
+ * - Error isolation (one failing handler doesn't affect others)
+ * - Event namespacing
+ * - Performance optimized (<1ms overhead per event)
+ */
+/**
+ * EventEmitter class for managing event subscriptions and emissions
+ */
+export class EventEmitter {
+    constructor() {
+        this.handlers = new Map();
+        this.onceHandlers = new Map();
+    }
+    /**
+     * Subscribe to an event
+     *
+     * @param eventType - The type of event to listen for
+     * @param handler - The handler function to call when the event is emitted
+     * @returns A function to unsubscribe the handler
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = emitter.on('asset:created', (event) => {
+     *   console.log('Asset created:', event.asset.id);
+     * });
+     *
+     * // Later, to unsubscribe:
+     * unsubscribe();
+     * ```
+     */
+    on(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Set());
+        }
+        this.handlers.get(eventType).add(handler);
+        // Return unsubscribe function
+        return () => this.off(eventType, handler);
+    }
+    /**
+     * Subscribe to an event for a single emission
+     *
+     * @param eventType - The type of event to listen for
+     * @param handler - The handler function to call when the event is emitted (only once)
+     * @returns A function to unsubscribe the handler
+     *
+     * @example
+     * ```typescript
+     * emitter.once('asset:migrated', (event) => {
+     *   console.log('Asset migrated once:', event.asset.id);
+     * });
+     * ```
+     */
+    once(eventType, handler) {
+        if (!this.onceHandlers.has(eventType)) {
+            this.onceHandlers.set(eventType, new Set());
+        }
+        this.onceHandlers.get(eventType).add(handler);
+        // Return unsubscribe function
+        return () => {
+            const handlers = this.onceHandlers.get(eventType);
+            if (handlers) {
+                handlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Unsubscribe from an event
+     *
+     * @param eventType - The type of event to stop listening for
+     * @param handler - The handler function to remove
+     *
+     * @example
+     * ```typescript
+     * const handler = (event) => console.log(event);
+     * emitter.on('asset:created', handler);
+     * emitter.off('asset:created', handler);
+     * ```
+     */
+    off(eventType, handler) {
+        const handlers = this.handlers.get(eventType);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+        const onceHandlers = this.onceHandlers.get(eventType);
+        if (onceHandlers) {
+            onceHandlers.delete(handler);
+        }
+    }
+    /**
+     * Emit an event to all subscribed handlers
+     *
+     * @param event - The event to emit
+     *
+     * Features:
+     * - Handlers are called in subscription order
+     * - Async handlers are awaited
+     * - Errors in handlers are isolated (logged but don't affect other handlers)
+     * - Once handlers are automatically removed after execution
+     *
+     * @example
+     * ```typescript
+     * emitter.emit({
+     *   type: 'asset:created',
+     *   timestamp: new Date().toISOString(),
+     *   asset: { id: 'did:peer:123', layer: 'did:peer', resourceCount: 1 }
+     * });
+     * ```
+     */
+    async emit(event) {
+        const eventType = event.type;
+        // Get regular handlers
+        const handlers = this.handlers.get(eventType);
+        if (handlers && handlers.size > 0) {
+            // Create array to avoid modification during iteration
+            const handlerArray = Array.from(handlers);
+            for (const handler of handlerArray) {
+                try {
+                    await handler(event);
+                }
+                catch (error) {
+                    // Error isolation: log but don't throw
+                    // This ensures one failing handler doesn't affect others
+                    if (typeof console !== 'undefined' && console.error) {
+                        console.error(`Event handler error for ${eventType}:`, error);
+                    }
+                }
+            }
+        }
+        // Get and execute once handlers
+        const onceHandlers = this.onceHandlers.get(eventType);
+        if (onceHandlers && onceHandlers.size > 0) {
+            // Create array to avoid modification during iteration
+            const onceHandlerArray = Array.from(onceHandlers);
+            // Clear once handlers before execution
+            this.onceHandlers.delete(eventType);
+            for (const handler of onceHandlerArray) {
+                try {
+                    await handler(event);
+                }
+                catch (error) {
+                    // Error isolation: log but don't throw
+                    if (typeof console !== 'undefined' && console.error) {
+                        console.error(`Event handler error (once) for ${eventType}:`, error);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Remove all handlers for a specific event type, or all handlers if no type specified
+     *
+     * @param eventType - Optional event type to clear handlers for
+     *
+     * @example
+     * ```typescript
+     * // Remove all handlers for 'asset:created'
+     * emitter.removeAllListeners('asset:created');
+     *
+     * // Remove all handlers for all events
+     * emitter.removeAllListeners();
+     * ```
+     */
+    removeAllListeners(eventType) {
+        if (eventType) {
+            this.handlers.delete(eventType);
+            this.onceHandlers.delete(eventType);
+        }
+        else {
+            this.handlers.clear();
+            this.onceHandlers.clear();
+        }
+    }
+    /**
+     * Get the number of handlers for a specific event type
+     *
+     * @param eventType - The event type to check
+     * @returns The number of handlers subscribed to this event type
+     */
+    listenerCount(eventType) {
+        const handlers = this.handlers.get(eventType);
+        const onceHandlers = this.onceHandlers.get(eventType);
+        return (handlers?.size || 0) + (onceHandlers?.size || 0);
+    }
+    /**
+     * Check if there are any handlers for a specific event type
+     *
+     * @param eventType - The event type to check
+     * @returns True if there are any handlers subscribed
+     */
+    hasListeners(eventType) {
+        return this.listenerCount(eventType) > 0;
+    }
+}

package/dist/events/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Events module for the Originals SDK
+ *
+ * Provides a type-safe event system for tracking asset lifecycle operations
+ */
+export { EventEmitter } from './EventEmitter';
+export type { BaseEvent, AssetCreatedEvent, AssetMigratedEvent, AssetTransferredEvent, ResourcePublishedEvent, CredentialIssuedEvent, VerificationCompletedEvent, OriginalsEvent, EventHandler, EventTypeMap } from './types';

package/dist/events/index.js

@@ -0,0 +1,6 @@
+/**
+ * Events module for the Originals SDK
+ *
+ * Provides a type-safe event system for tracking asset lifecycle operations
+ */
+export { EventEmitter } from './EventEmitter';

package/dist/events/types.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Event types for the Originals SDK asset lifecycle operations
+ *
+ * All events follow a consistent structure:
+ * - type: Namespaced event name (e.g., 'asset:created')
+ * - timestamp: ISO 8601 timestamp of when the event occurred
+ * - Specific payload data relevant to the event
+ */
+import { LayerType } from '../types';
+/**
+ * Base event interface that all events extend
+ */
+export interface BaseEvent {
+    type: string;
+    timestamp: string;
+}
+/**
+ * Emitted when a new asset is created
+ */
+export interface AssetCreatedEvent extends BaseEvent {
+    type: 'asset:created';
+    asset: {
+        id: string;
+        layer: LayerType;
+        resourceCount: number;
+        createdAt: string;
+    };
+}
+/**
+ * Emitted when an asset migrates between layers
+ *
+ * Note: The `details` field is populated differently based on the target layer:
+ * - For did:webvh migrations: `details` is undefined (web publishing has no transaction details)
+ * - For did:btco migrations: `details` includes Bitcoin transaction information
+ *   (transactionId, inscriptionId, satoshi, commitTxId, revealTxId, feeRate)
+ */
+export interface AssetMigratedEvent extends BaseEvent {
+    type: 'asset:migrated';
+    asset: {
+        id: string;
+        fromLayer: LayerType;
+        toLayer: LayerType;
+    };
+    details?: {
+        transactionId?: string;
+        inscriptionId?: string;
+        satoshi?: string;
+        commitTxId?: string;
+        revealTxId?: string;
+        feeRate?: number;
+    };
+}
+/**
+ * Emitted when an asset's ownership is transferred
+ */
+export interface AssetTransferredEvent extends BaseEvent {
+    type: 'asset:transferred';
+    asset: {
+        id: string;
+        layer: LayerType;
+    };
+    from: string;
+    to: string;
+    transactionId: string;
+}
+/**
+ * Emitted when a resource is published to web storage
+ */
+export interface ResourcePublishedEvent extends BaseEvent {
+    type: 'resource:published';
+    asset: {
+        id: string;
+    };
+    resource: {
+        id: string;
+        url: string;
+        contentType: string;
+        hash: string;
+    };
+    publisherDid: string;
+}
+/**
+ * Emitted when a verifiable credential is issued for an asset
+ */
+export interface CredentialIssuedEvent extends BaseEvent {
+    type: 'credential:issued';
+    asset: {
+        id: string;
+    };
+    credential: {
+        type: string[];
+        issuer: string;
+    };
+}
+/**
+ * Emitted when a new resource version is created
+ */
+export interface ResourceVersionCreatedEvent extends BaseEvent {
+    type: 'resource:version:created';
+    asset: {
+        id: string;
+    };
+    resource: {
+        id: string;
+        fromVersion: number;
+        toVersion: number;
+        fromHash: string;
+        toHash: string;
+    };
+    changes?: string;
+}
+/**
+ * Emitted when asset verification is completed
+ */
+export interface VerificationCompletedEvent extends BaseEvent {
+    type: 'verification:completed';
+    asset: {
+        id: string;
+    };
+    result: boolean;
+    checks?: {
+        didDocument: boolean;
+        resources: boolean;
+        credentials: boolean;
+    };
+}
+/**
+ * Emitted when a batch operation starts
+ */
+export interface BatchStartedEvent extends BaseEvent {
+    type: 'batch:started';
+    operation: 'create' | 'publish' | 'inscribe' | 'transfer';
+    batchId: string;
+    itemCount: number;
+}
+/**
+ * Emitted when a batch operation completes successfully
+ */
+export interface BatchCompletedEvent extends BaseEvent {
+    type: 'batch:completed';
+    batchId: string;
+    operation: string;
+    results: {
+        successful: number;
+        failed: number;
+        totalDuration: number;
+        costSavings?: {
+            amount: number;
+            percentage: number;
+        };
+    };
+}
+/**
+ * Emitted when a batch operation fails
+ */
+export interface BatchFailedEvent extends BaseEvent {
+    type: 'batch:failed';
+    batchId: string;
+    operation: string;
+    error: string;
+    partialResults?: {
+        successful: number;
+        failed: number;
+    };
+}
+/**
+ * Emitted when a migration starts
+ */
+export interface MigrationStartedEvent extends BaseEvent {
+    type: 'migration:started';
+    migrationId: string;
+    sourceDid: string;
+    targetLayer: string;
+}
+/**
+ * Emitted when migration validation completes
+ */
+export interface MigrationValidatedEvent extends BaseEvent {
+    type: 'migration:validated';
+    migrationId: string;
+    valid: boolean;
+}
+/**
+ * Emitted when migration checkpoint is created
+ */
+export interface MigrationCheckpointedEvent extends BaseEvent {
+    type: 'migration:checkpointed';
+    migrationId: string;
+    checkpointId: string;
+}
+/**
+ * Emitted when migration enters in-progress state
+ */
+export interface MigrationInProgressEvent extends BaseEvent {
+    type: 'migration:in_progress';
+    migrationId: string;
+    currentOperation: string;
+    progress: number;
+}
+/**
+ * Emitted when migration enters anchoring state (Bitcoin)
+ */
+export interface MigrationAnchoringEvent extends BaseEvent {
+    type: 'migration:anchoring';
+    migrationId: string;
+    transactionId?: string;
+}
+/**
+ * Emitted when migration completes successfully
+ */
+export interface MigrationCompletedEvent extends BaseEvent {
+    type: 'migration:completed';
+    migrationId: string;
+    sourceDid: string;
+    targetDid: string;
+}
+/**
+ * Emitted when migration fails
+ */
+export interface MigrationFailedEvent extends BaseEvent {
+    type: 'migration:failed';
+    migrationId: string;
+    error: any;
+}
+/**
+ * Emitted when migration is rolled back
+ */
+export interface MigrationRolledbackEvent extends BaseEvent {
+    type: 'migration:rolledback';
+    migrationId: string;
+    checkpointId: string;
+}
+/**
+ * Emitted when migration enters quarantine state
+ */
+export interface MigrationQuarantineEvent extends BaseEvent {
+    type: 'migration:quarantine';
+    migrationId: string;
+    checkpointId: string;
+    reason: string;
+}
+/**
+ * Emitted during batch operations to report progress
+ */
+export interface BatchProgressEvent extends BaseEvent {
+    type: 'batch:progress';
+    batchId: string;
+    operation: string;
+    progress: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+/**
+ * Union type of all possible events
+ */
+export type OriginalsEvent = AssetCreatedEvent | AssetMigratedEvent | AssetTransferredEvent | ResourcePublishedEvent | CredentialIssuedEvent | VerificationCompletedEvent | BatchStartedEvent | BatchCompletedEvent | BatchFailedEvent | BatchProgressEvent | ResourceVersionCreatedEvent | MigrationStartedEvent | MigrationValidatedEvent | MigrationCheckpointedEvent | MigrationInProgressEvent | MigrationAnchoringEvent | MigrationCompletedEvent | MigrationFailedEvent | MigrationRolledbackEvent | MigrationQuarantineEvent;
+/**
+ * Event handler function type
+ */
+export type EventHandler<T extends OriginalsEvent = OriginalsEvent> = (event: T) => void | Promise<void>;
+/**
+ * Map of event types to their specific event interfaces
+ */
+export interface EventTypeMap {
+    'asset:created': AssetCreatedEvent;
+    'asset:migrated': AssetMigratedEvent;
+    'asset:transferred': AssetTransferredEvent;
+    'resource:published': ResourcePublishedEvent;
+    'credential:issued': CredentialIssuedEvent;
+    'verification:completed': VerificationCompletedEvent;
+    'batch:started': BatchStartedEvent;
+    'batch:completed': BatchCompletedEvent;
+    'batch:failed': BatchFailedEvent;
+    'batch:progress': BatchProgressEvent;
+    'resource:version:created': ResourceVersionCreatedEvent;
+    'migration:started': MigrationStartedEvent;
+    'migration:validated': MigrationValidatedEvent;
+    'migration:checkpointed': MigrationCheckpointedEvent;
+    'migration:in_progress': MigrationInProgressEvent;
+    'migration:anchoring': MigrationAnchoringEvent;
+    'migration:completed': MigrationCompletedEvent;
+    'migration:failed': MigrationFailedEvent;
+    'migration:rolledback': MigrationRolledbackEvent;
+    'migration:quarantine': MigrationQuarantineEvent;
+}

package/dist/events/types.js

@@ -0,0 +1,9 @@
+/**
+ * Event types for the Originals SDK asset lifecycle operations
+ *
+ * All events follow a consistent structure:
+ * - type: Namespaced event name (e.g., 'asset:created')
+ * - timestamp: ISO 8601 timestamp of when the event occurred
+ * - Specific payload data relevant to the event
+ */
+export {};