@originals/sdk 1.4.2 → 1.4.5

package/dist/lifecycle/ProvenanceQuery.js

@@ -0,0 +1,220 @@
+/**
+ * Base query class for provenance inspection
+ */
+export class ProvenanceQuery {
+    constructor(provenance) {
+        this.provenance = provenance;
+    }
+    /**
+     * Query migrations
+     */
+    migrations() {
+        return new MigrationQuery(this.provenance, this.afterDate, this.beforeDate);
+    }
+    /**
+     * Query transfers
+     */
+    transfers() {
+        return new TransferQuery(this.provenance, this.afterDate, this.beforeDate);
+    }
+    /**
+     * Filter by date range - after a specific date
+     */
+    after(date) {
+        this.afterDate = typeof date === 'string' ? new Date(date) : date;
+        return this;
+    }
+    /**
+     * Filter by date range - before a specific date
+     */
+    before(date) {
+        this.beforeDate = typeof date === 'string' ? new Date(date) : date;
+        return this;
+    }
+    /**
+     * Filter by date range - between two dates
+     */
+    between(start, end) {
+        this.afterDate = typeof start === 'string' ? new Date(start) : start;
+        this.beforeDate = typeof end === 'string' ? new Date(end) : end;
+        return this;
+    }
+    /**
+     * Get count of results
+     */
+    count() {
+        return this.all().length;
+    }
+    /**
+     * Get first result
+     */
+    first() {
+        const results = this.all();
+        return results.length > 0 ? results[0] : null;
+    }
+    /**
+     * Get last result
+     */
+    last() {
+        const results = this.all();
+        return results.length > 0 ? results[results.length - 1] : null;
+    }
+    /**
+     * Get all results
+     */
+    all() {
+        const merged = [...this.provenance.migrations, ...this.provenance.transfers];
+        const filtered = this.applyDateFilters(merged);
+        return filtered.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    }
+    /**
+     * Apply date filters to items
+     */
+    applyDateFilters(items) {
+        let filtered = items;
+        if (this.afterDate) {
+            filtered = filtered.filter(item => new Date(item.timestamp) > this.afterDate);
+        }
+        if (this.beforeDate) {
+            filtered = filtered.filter(item => new Date(item.timestamp) < this.beforeDate);
+        }
+        return filtered;
+    }
+}
+/**
+ * Query class for migrations
+ */
+export class MigrationQuery extends ProvenanceQuery {
+    constructor(provenance, afterDate, beforeDate) {
+        super(provenance);
+        this.afterDate = afterDate;
+        this.beforeDate = beforeDate;
+    }
+    /**
+     * Filter by source layer
+     */
+    fromLayer(layer) {
+        this.fromLayerFilter = layer;
+        return this;
+    }
+    /**
+     * Filter by destination layer
+     */
+    toLayer(layer) {
+        this.toLayerFilter = layer;
+        return this;
+    }
+    /**
+     * Filter by transaction ID
+     */
+    withTransaction(txId) {
+        this.transactionIdFilter = txId;
+        return this;
+    }
+    /**
+     * Filter by inscription ID
+     */
+    withInscription(inscriptionId) {
+        this.inscriptionIdFilter = inscriptionId;
+        return this;
+    }
+    /**
+     * Get all filtered migrations
+     */
+    all() {
+        let results = [...this.provenance.migrations];
+        // Apply date filters
+        results = this.applyDateFilters(results);
+        // Apply layer filters
+        if (this.fromLayerFilter) {
+            results = results.filter(m => m.from === this.fromLayerFilter);
+        }
+        if (this.toLayerFilter) {
+            results = results.filter(m => m.to === this.toLayerFilter);
+        }
+        // Apply transaction ID filter
+        if (this.transactionIdFilter) {
+            results = results.filter(m => m.transactionId === this.transactionIdFilter);
+        }
+        // Apply inscription ID filter
+        if (this.inscriptionIdFilter) {
+            results = results.filter(m => m.inscriptionId === this.inscriptionIdFilter);
+        }
+        return results;
+    }
+    /**
+     * Override migrations to return this (method chaining)
+     */
+    migrations() {
+        return this;
+    }
+    /**
+     * Override transfers to create new TransferQuery with date filters
+     */
+    transfers() {
+        return new TransferQuery(this.provenance, this.afterDate, this.beforeDate);
+    }
+}
+/**
+ * Query class for transfers
+ */
+export class TransferQuery extends ProvenanceQuery {
+    constructor(provenance, afterDate, beforeDate) {
+        super(provenance);
+        this.afterDate = afterDate;
+        this.beforeDate = beforeDate;
+    }
+    /**
+     * Filter by source address
+     */
+    from(address) {
+        this.fromAddressFilter = address;
+        return this;
+    }
+    /**
+     * Filter by destination address
+     */
+    to(address) {
+        this.toAddressFilter = address;
+        return this;
+    }
+    /**
+     * Filter by transaction ID
+     */
+    withTransaction(txId) {
+        this.transactionIdFilter = txId;
+        return this;
+    }
+    /**
+     * Get all filtered transfers
+     */
+    all() {
+        let results = [...this.provenance.transfers];
+        // Apply date filters
+        results = this.applyDateFilters(results);
+        // Apply address filters
+        if (this.fromAddressFilter) {
+            results = results.filter(t => t.from === this.fromAddressFilter);
+        }
+        if (this.toAddressFilter) {
+            results = results.filter(t => t.to === this.toAddressFilter);
+        }
+        // Apply transaction ID filter
+        if (this.transactionIdFilter) {
+            results = results.filter(t => t.transactionId === this.transactionIdFilter);
+        }
+        return results;
+    }
+    /**
+     * Override transfers to return this (method chaining)
+     */
+    transfers() {
+        return this;
+    }
+    /**
+     * Override migrations to create new MigrationQuery with date filters
+     */
+    migrations() {
+        return new MigrationQuery(this.provenance, this.afterDate, this.beforeDate);
+    }
+}

package/dist/lifecycle/ResourceVersioning.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ResourceVersioning module for immutable resource versioning with verifiable provenance.
+ *
+ * Resources in the Originals SDK are immutable and content-addressed. "Versioning" means
+ * creating a new immutable resource instance with a new hash and linking it to the prior
+ * version via previousVersionHash. Old versions remain accessible.
+ */
+export interface ResourceVersion {
+    version: number;
+    hash: string;
+    timestamp: string;
+    contentType: string;
+    changes?: string;
+    previousVersionHash?: string;
+}
+export interface ResourceHistory {
+    resourceId: string;
+    versions: ResourceVersion[];
+    currentVersion: ResourceVersion;
+}
+/**
+ * ResourceVersionManager manages the versioning of immutable resources.
+ * Each version is a separate resource with a unique content hash, linked to
+ * its predecessor via previousVersionHash.
+ */
+export declare class ResourceVersionManager {
+    private versionMap;
+    constructor();
+    /**
+     * Add a new version for a resource
+     * @param resourceId - Logical resource ID (stable across versions)
+     * @param hash - Content hash of the new version
+     * @param contentType - Content type of the resource
+     * @param previousVersionHash - Hash of the previous version (optional for v1)
+     * @param changes - Optional description of changes
+     */
+    addVersion(resourceId: string, hash: string, contentType: string, previousVersionHash?: string, changes?: string): void;
+    /**
+     * Get the complete version history for a resource
+     * @param resourceId - Logical resource ID
+     * @returns ResourceHistory or null if resource doesn't exist
+     */
+    getHistory(resourceId: string): ResourceHistory | null;
+    /**
+     * Get a specific version of a resource
+     * @param resourceId - Logical resource ID
+     * @param version - Version number (1-indexed)
+     * @returns ResourceVersion or null if not found
+     */
+    getVersion(resourceId: string, version: number): ResourceVersion | null;
+    /**
+     * Get the current (latest) version of a resource
+     * @param resourceId - Logical resource ID
+     * @returns ResourceVersion or null if not found
+     */
+    getCurrentVersion(resourceId: string): ResourceVersion | null;
+    /**
+     * Verify the integrity of the version chain for a resource.
+     * Ensures that:
+     * - Version numbers are sequential starting at 1
+     * - Each version (except v1) has a previousVersionHash
+     * - Each previousVersionHash matches the actual previous version's hash
+     *
+     * @param resourceId - Logical resource ID
+     * @returns true if the chain is valid, false otherwise
+     */
+    verifyChain(resourceId: string): boolean;
+    /**
+     * Serialize the version manager state to JSON
+     * @returns Object representation of all version data
+     */
+    toJSON(): object;
+}

package/dist/lifecycle/ResourceVersioning.js

@@ -0,0 +1,127 @@
+/**
+ * ResourceVersioning module for immutable resource versioning with verifiable provenance.
+ *
+ * Resources in the Originals SDK are immutable and content-addressed. "Versioning" means
+ * creating a new immutable resource instance with a new hash and linking it to the prior
+ * version via previousVersionHash. Old versions remain accessible.
+ */
+/**
+ * ResourceVersionManager manages the versioning of immutable resources.
+ * Each version is a separate resource with a unique content hash, linked to
+ * its predecessor via previousVersionHash.
+ */
+export class ResourceVersionManager {
+    constructor() {
+        this.versionMap = new Map();
+    }
+    /**
+     * Add a new version for a resource
+     * @param resourceId - Logical resource ID (stable across versions)
+     * @param hash - Content hash of the new version
+     * @param contentType - Content type of the resource
+     * @param previousVersionHash - Hash of the previous version (optional for v1)
+     * @param changes - Optional description of changes
+     */
+    addVersion(resourceId, hash, contentType, previousVersionHash, changes) {
+        const versions = this.versionMap.get(resourceId) || [];
+        const version = {
+            version: versions.length + 1,
+            hash,
+            timestamp: new Date().toISOString(),
+            contentType,
+            changes,
+            previousVersionHash
+        };
+        versions.push(version);
+        this.versionMap.set(resourceId, versions);
+    }
+    /**
+     * Get the complete version history for a resource
+     * @param resourceId - Logical resource ID
+     * @returns ResourceHistory or null if resource doesn't exist
+     */
+    getHistory(resourceId) {
+        const versions = this.versionMap.get(resourceId);
+        if (!versions || versions.length === 0) {
+            return null;
+        }
+        return {
+            resourceId,
+            versions: [...versions],
+            currentVersion: versions[versions.length - 1]
+        };
+    }
+    /**
+     * Get a specific version of a resource
+     * @param resourceId - Logical resource ID
+     * @param version - Version number (1-indexed)
+     * @returns ResourceVersion or null if not found
+     */
+    getVersion(resourceId, version) {
+        const versions = this.versionMap.get(resourceId);
+        if (!versions || version < 1 || version > versions.length) {
+            return null;
+        }
+        return versions[version - 1];
+    }
+    /**
+     * Get the current (latest) version of a resource
+     * @param resourceId - Logical resource ID
+     * @returns ResourceVersion or null if not found
+     */
+    getCurrentVersion(resourceId) {
+        const versions = this.versionMap.get(resourceId);
+        if (!versions || versions.length === 0) {
+            return null;
+        }
+        return versions[versions.length - 1];
+    }
+    /**
+     * Verify the integrity of the version chain for a resource.
+     * Ensures that:
+     * - Version numbers are sequential starting at 1
+     * - Each version (except v1) has a previousVersionHash
+     * - Each previousVersionHash matches the actual previous version's hash
+     *
+     * @param resourceId - Logical resource ID
+     * @returns true if the chain is valid, false otherwise
+     */
+    verifyChain(resourceId) {
+        const versions = this.versionMap.get(resourceId);
+        if (!versions || versions.length === 0) {
+            return false;
+        }
+        for (let i = 0; i < versions.length; i++) {
+            const version = versions[i];
+            // Check version number is sequential
+            if (version.version !== i + 1) {
+                return false;
+            }
+            // First version should not have previousVersionHash
+            if (i === 0) {
+                if (version.previousVersionHash !== undefined) {
+                    return false;
+                }
+            }
+            else {
+                // Subsequent versions must have previousVersionHash matching the prior version
+                const prevVersion = versions[i - 1];
+                if (version.previousVersionHash !== prevVersion.hash) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Serialize the version manager state to JSON
+     * @returns Object representation of all version data
+     */
+    toJSON() {
+        const result = {};
+        for (const [resourceId, versions] of this.versionMap.entries()) {
+            result[resourceId] = versions;
+        }
+        return result;
+    }
+}

package/dist/migration/MigrationManager.d.ts

@@ -0,0 +1,86 @@
+/**
+ * MigrationManager - Main orchestrator for DID layer migrations
+ * Coordinates validation, checkpoints, rollbacks, state tracking, and audit logging
+ */
+import { MigrationOptions, MigrationResult, BatchMigrationOptions, BatchMigrationResult, CostEstimate } from './types';
+import { OriginalsConfig } from '../types';
+import { DIDManager } from '../did/DIDManager';
+import { CredentialManager } from '../vc/CredentialManager';
+import { BitcoinManager } from '../bitcoin/BitcoinManager';
+export declare class MigrationManager {
+    private config;
+    private didManager;
+    private credentialManager;
+    private bitcoinManager?;
+    private static instance;
+    private validationPipeline;
+    private checkpointManager;
+    private rollbackManager;
+    private stateTracker;
+    private eventEmitter;
+    private inMemoryAuditRecords;
+    private peerToWebvh;
+    private webvhToBtco;
+    private peerToBtco;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(config?: OriginalsConfig, didManager?: DIDManager, credentialManager?: CredentialManager, bitcoinManager?: BitcoinManager): MigrationManager;
+    /**
+     * Reset singleton instance (primarily for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Main migration method
+     */
+    migrate(options: MigrationOptions): Promise<MigrationResult>;
+    /**
+     * Estimate migration cost without executing
+     */
+    estimateMigrationCost(sourceDid: string, targetLayer: string, feeRate?: number): Promise<CostEstimate>;
+    /**
+     * Get migration status
+     */
+    getMigrationStatus(migrationId: string): Promise<any>;
+    /**
+     * Rollback a migration
+     */
+    rollback(migrationId: string): Promise<any>;
+    /**
+     * Get migration history for a DID
+     * TODO: AuditLogger temporarily disabled for v1.0 release
+     * Returns in-memory audit records (unsigned) - will use proper AuditLogger in v1.1
+     */
+    getMigrationHistory(did: string): Promise<any[]>;
+    /**
+     * Batch migration
+     */
+    migrateBatch(dids: string[], targetLayer: string, options?: BatchMigrationOptions): Promise<BatchMigrationResult>;
+    /**
+     * Handle migration failure with automatic rollback
+     */
+    private handleMigrationFailure;
+    /**
+     * Get appropriate migration operation handler
+     */
+    private getMigrationOperation;
+    /**
+     * Store audit record in memory for v1.0
+     * Stores by both source and target DID for easy lookup
+     * TODO: Remove in v1.1 when AuditLogger is re-enabled with signatures
+     */
+    private storeAuditRecordInMemory;
+    /**
+     * Extract layer from DID
+     */
+    private extractLayer;
+    /**
+     * Create migration error
+     */
+    private createMigrationError;
+    /**
+     * Emit event
+     */
+    private emitEvent;
+}