@originals/sdk 1.5.0 → 1.6.1

package/dist/cel/hash.js

@@ -0,0 +1,66 @@
+/**
+ * CEL Hash Utilities
+ *
+ * Computes and verifies Multibase-encoded Multihash digests as specified
+ * in the CEL specification for external references.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+import { sha256 } from '@noble/hashes/sha2.js';
+import { multibase } from '../utils/encoding';
+/**
+ * Computes a CEL-compliant digestMultibase from content.
+ *
+ * Uses sha2-256 hash algorithm and encodes as Multibase base64url-nopad (prefix 'u').
+ *
+ * @param content - The raw bytes to hash
+ * @returns Multibase-encoded digest string (e.g., "uEiDm9F...")
+ *
+ * @example
+ * ```typescript
+ * const digest = computeDigestMultibase(new TextEncoder().encode("hello"));
+ * // Returns: "uLCA..."
+ * ```
+ */
+export function computeDigestMultibase(content) {
+    // Compute SHA-256 hash
+    const hash = sha256(content);
+    // Encode as Multibase base64url-nopad (prefix 'u')
+    return multibase.encode(hash, 'base64url');
+}
+/**
+ * Verifies that content matches a given digestMultibase.
+ *
+ * @param content - The raw bytes to verify
+ * @param digest - The expected digestMultibase string
+ * @returns True if the content hash matches the digest, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const content = new TextEncoder().encode("hello");
+ * const digest = computeDigestMultibase(content);
+ * const isValid = verifyDigestMultibase(content, digest); // true
+ * ```
+ */
+export function verifyDigestMultibase(content, digest) {
+    try {
+        // Compute hash of content
+        const computedDigest = computeDigestMultibase(content);
+        // Compare with expected digest
+        return computedDigest === digest;
+    }
+    catch {
+        // Invalid digest format or encoding error
+        return false;
+    }
+}
+/**
+ * Decodes a digestMultibase string back to raw hash bytes.
+ *
+ * @param digest - The Multibase-encoded digest string
+ * @returns The raw SHA-256 hash bytes
+ * @throws Error if the digest is not a valid Multibase base64url string
+ */
+export function decodeDigestMultibase(digest) {
+    return multibase.decode(digest);
+}

package/dist/cel/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CEL (Cryptographic Event Log) Module
+ *
+ * Implements W3C CCG CEL Specification for Originals Protocol
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+export * from './types';
+export * from './hash';
+export * from './algorithms';
+export * from './witnesses';
+export * from './serialization';
+export * from './ExternalReferenceManager';
+export * from './layers';
+export * from './OriginalsCel';
+export { main as celCli } from './cli/index';

package/dist/cel/index.js

@@ -0,0 +1,15 @@
+/**
+ * CEL (Cryptographic Event Log) Module
+ *
+ * Implements W3C CCG CEL Specification for Originals Protocol
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+export * from './types';
+export * from './hash';
+export * from './algorithms';
+export * from './witnesses';
+export * from './serialization';
+export * from './ExternalReferenceManager';
+export * from './layers';
+export * from './OriginalsCel';
+export { main as celCli } from './cli/index';

package/dist/cel/layers/BtcoCelManager.d.ts

@@ -0,0 +1,121 @@
+/**
+ * BtcoCelManager - CEL Manager for did:btco Layer
+ *
+ * Manages migration of Originals assets to the did:btco layer (Layer 2).
+ * This layer provides Bitcoin-based witnessing for maximum immutability.
+ *
+ * The did:btco method anchors asset provenance on the Bitcoin blockchain
+ * using ordinals inscriptions, providing the highest level of trust
+ * and permanence in the Originals Protocol.
+ *
+ * @see https://github.com/aviarytech/did-btco
+ */
+import type { EventLog, AssetState } from '../types';
+import type { BitcoinManager } from '../../bitcoin/BitcoinManager';
+import type { CelSigner } from './PeerCelManager';
+/**
+ * Configuration options for BtcoCelManager
+ */
+export interface BtcoCelConfig {
+    /** The DID URL of the verification method for signing */
+    verificationMethod?: string;
+    /** The purpose of proofs (defaults to 'assertionMethod') */
+    proofPurpose?: string;
+    /** Fee rate in sat/vB for Bitcoin transactions (optional - BitcoinManager will estimate if not provided) */
+    feeRate?: number;
+}
+/**
+ * Migration data stored in the update event when migrating to btco
+ */
+export interface BtcoMigrationData {
+    /** The source DID from the previous layer */
+    sourceDid: string;
+    /** The new did:btco DID */
+    targetDid: string;
+    /** The target layer */
+    layer: 'btco';
+    /** The Bitcoin transaction ID anchoring the migration */
+    txid?: string;
+    /** The inscription ID on Bitcoin */
+    inscriptionId?: string;
+    /** ISO 8601 timestamp of migration */
+    migratedAt: string;
+}
+/**
+ * BtcoCelManager - Manages CEL-based asset migration to did:btco layer
+ *
+ * The btco layer is the final publication layer for Originals assets.
+ * Assets at this layer:
+ * - Have a did:btco identifier anchored on Bitcoin
+ * - Have mandatory Bitcoin witness attestations via ordinals
+ * - Provide maximum immutability and timestamping
+ * - Cannot be migrated to any other layer
+ *
+ * @example
+ * ```typescript
+ * const bitcoinManager = new BitcoinManager(config);
+ * const manager = new BtcoCelManager(
+ *   async (data) => createEdDsaProof(data, privateKey),
+ *   bitcoinManager
+ * );
+ *
+ * const btcoLog = await manager.migrate(webvhLog);
+ * console.log(btcoLog.events[btcoLog.events.length - 1].data.txid);
+ * ```
+ */
+export declare class BtcoCelManager {
+    private signer;
+    private bitcoinManager;
+    private bitcoinWitness;
+    private config;
+    /**
+     * Creates a new BtcoCelManager instance
+     *
+     * @param signer - Function that signs data and returns a DataIntegrityProof
+     * @param bitcoinManager - BitcoinManager instance for ordinals inscriptions
+     * @param config - Optional configuration options
+     */
+    constructor(signer: CelSigner, bitcoinManager: BitcoinManager, config?: BtcoCelConfig);
+    /**
+     * Migrates a webvh layer event log to the did:btco layer
+     *
+     * This method:
+     * 1. Validates the input log (must have migrated to webvh layer)
+     * 2. Creates an update event with migration data
+     * 3. Adds mandatory Bitcoin witness proof via ordinals inscription
+     * 4. Generates a did:btco DID based on the inscription
+     * 5. Returns the updated EventLog
+     *
+     * Note: Bitcoin witness is REQUIRED at this layer - it cannot be skipped.
+     *
+     * @param webvhLog - The event log from the webvh layer to migrate
+     * @returns Promise resolving to an EventLog with the migration event appended
+     *
+     * @throws Error if the log is empty, deactivated, or not from webvh layer
+     * @throws Error if signer produces invalid proof
+     * @throws Error if Bitcoin inscription fails
+     */
+    migrate(webvhLog: EventLog): Promise<EventLog>;
+    /**
+     * Generates a did:btco DID fallback from source DID
+     *
+     * @param sourceDid - The source DID to derive from
+     * @returns A did:btco string
+     */
+    private generateBtcoDid;
+    /**
+     * Creates a URL-safe hash-based identifier from a string
+     */
+    private hashIdentifier;
+    /**
+     * Derives the current asset state by replaying all events in the log.
+     *
+     * @param log - The event log to derive state from
+     * @returns The current AssetState derived from replaying events
+     */
+    getCurrentState(log: EventLog): AssetState;
+    /**
+     * Gets the BitcoinManager instance used by this manager
+     */
+    get bitcoin(): BitcoinManager;
+}

package/dist/cel/layers/BtcoCelManager.js

@@ -0,0 +1,329 @@
+/**
+ * BtcoCelManager - CEL Manager for did:btco Layer
+ *
+ * Manages migration of Originals assets to the did:btco layer (Layer 2).
+ * This layer provides Bitcoin-based witnessing for maximum immutability.
+ *
+ * The did:btco method anchors asset provenance on the Bitcoin blockchain
+ * using ordinals inscriptions, providing the highest level of trust
+ * and permanence in the Originals Protocol.
+ *
+ * @see https://github.com/aviarytech/did-btco
+ */
+import { updateEventLog } from '../algorithms/updateEventLog';
+import { witnessEvent } from '../algorithms/witnessEvent';
+import { BitcoinWitness } from '../witnesses/BitcoinWitness';
+/**
+ * BtcoCelManager - Manages CEL-based asset migration to did:btco layer
+ *
+ * The btco layer is the final publication layer for Originals assets.
+ * Assets at this layer:
+ * - Have a did:btco identifier anchored on Bitcoin
+ * - Have mandatory Bitcoin witness attestations via ordinals
+ * - Provide maximum immutability and timestamping
+ * - Cannot be migrated to any other layer
+ *
+ * @example
+ * ```typescript
+ * const bitcoinManager = new BitcoinManager(config);
+ * const manager = new BtcoCelManager(
+ *   async (data) => createEdDsaProof(data, privateKey),
+ *   bitcoinManager
+ * );
+ *
+ * const btcoLog = await manager.migrate(webvhLog);
+ * console.log(btcoLog.events[btcoLog.events.length - 1].data.txid);
+ * ```
+ */
+export class BtcoCelManager {
+    /**
+     * Creates a new BtcoCelManager instance
+     *
+     * @param signer - Function that signs data and returns a DataIntegrityProof
+     * @param bitcoinManager - BitcoinManager instance for ordinals inscriptions
+     * @param config - Optional configuration options
+     */
+    constructor(signer, bitcoinManager, config = {}) {
+        if (typeof signer !== 'function') {
+            throw new Error('BtcoCelManager requires a signer function');
+        }
+        if (!bitcoinManager) {
+            throw new Error('BtcoCelManager requires a BitcoinManager instance');
+        }
+        this.signer = signer;
+        this.bitcoinManager = bitcoinManager;
+        this.config = {
+            proofPurpose: 'assertionMethod',
+            ...config,
+        };
+        // Create Bitcoin witness service with optional fee rate
+        this.bitcoinWitness = new BitcoinWitness(bitcoinManager, {
+            feeRate: config.feeRate,
+            verificationMethod: config.verificationMethod,
+        });
+    }
+    /**
+     * Migrates a webvh layer event log to the did:btco layer
+     *
+     * This method:
+     * 1. Validates the input log (must have migrated to webvh layer)
+     * 2. Creates an update event with migration data
+     * 3. Adds mandatory Bitcoin witness proof via ordinals inscription
+     * 4. Generates a did:btco DID based on the inscription
+     * 5. Returns the updated EventLog
+     *
+     * Note: Bitcoin witness is REQUIRED at this layer - it cannot be skipped.
+     *
+     * @param webvhLog - The event log from the webvh layer to migrate
+     * @returns Promise resolving to an EventLog with the migration event appended
+     *
+     * @throws Error if the log is empty, deactivated, or not from webvh layer
+     * @throws Error if signer produces invalid proof
+     * @throws Error if Bitcoin inscription fails
+     */
+    async migrate(webvhLog) {
+        // Validate input log
+        if (!webvhLog || !webvhLog.events || webvhLog.events.length === 0) {
+            throw new Error('Cannot migrate an empty event log');
+        }
+        // Get the create event to extract source DID
+        const createEvent = webvhLog.events[0];
+        if (createEvent.type !== 'create') {
+            throw new Error('First event must be a create event');
+        }
+        // Find the current layer and DID by checking for migration events
+        let currentDid;
+        let currentLayer;
+        // Look through events to find the latest migration
+        for (const event of webvhLog.events) {
+            const eventData = event.data;
+            if (event.type === 'create') {
+                currentDid = eventData.did;
+                currentLayer = eventData.layer || 'peer';
+            }
+            else if (event.type === 'update' && eventData.targetDid && eventData.layer) {
+                // This is a migration event
+                currentDid = eventData.targetDid;
+                currentLayer = eventData.layer;
+            }
+        }
+        if (!currentDid) {
+            throw new Error('Could not determine current DID from event log');
+        }
+        // Validate source is from webvh layer (only webvh can migrate to btco)
+        if (currentLayer !== 'webvh') {
+            throw new Error(`Cannot migrate from ${currentLayer} layer to btco layer. Must migrate to webvh first.`);
+        }
+        // Check if log is already deactivated
+        const lastEvent = webvhLog.events[webvhLog.events.length - 1];
+        if (lastEvent.type === 'deactivate') {
+            throw new Error('Cannot migrate a deactivated event log');
+        }
+        // Prepare initial migration data (will be updated with Bitcoin details after witnessing)
+        const migrationData = {
+            sourceDid: currentDid,
+            targetDid: '', // Will be set after inscription
+            layer: 'btco',
+            migratedAt: new Date().toISOString(),
+        };
+        // Build update options
+        const updateOptions = {
+            signer: this.signer,
+            verificationMethod: this.config.verificationMethod || `${currentDid}#key-0`,
+            proofPurpose: this.config.proofPurpose,
+        };
+        // Create the update event with migration data
+        let updatedLog = await updateEventLog(webvhLog, migrationData, updateOptions);
+        // Add Bitcoin witness proof (REQUIRED at btco layer)
+        const lastEventIndex = updatedLog.events.length - 1;
+        let witnessedEvent = updatedLog.events[lastEventIndex];
+        // Witness the event on Bitcoin
+        witnessedEvent = await witnessEvent(witnessedEvent, this.bitcoinWitness);
+        // Extract Bitcoin details from the witness proof
+        const bitcoinProof = witnessedEvent.proof.find(p => p.cryptosuite === 'bitcoin-ordinals-2024');
+        // Generate did:btco DID using inscription ID
+        let targetDid;
+        let txid;
+        let inscriptionId;
+        if (bitcoinProof) {
+            txid = bitcoinProof.txid;
+            inscriptionId = bitcoinProof.inscriptionId;
+            // did:btco format uses the inscription ID for identification
+            if (inscriptionId) {
+                // Sanitize inscription ID for DID (remove special chars)
+                const sanitizedId = inscriptionId.replace(/[^a-zA-Z0-9]/g, '');
+                targetDid = `did:btco:${sanitizedId}`;
+            }
+            else if (txid) {
+                targetDid = `did:btco:${txid}`;
+            }
+            else {
+                // Fallback: derive from source DID
+                targetDid = this.generateBtcoDid(currentDid);
+            }
+        }
+        else {
+            // Fallback: derive from source DID (shouldn't happen since witness is required)
+            targetDid = this.generateBtcoDid(currentDid);
+        }
+        // Update migration data with Bitcoin details
+        const updatedMigrationData = {
+            ...migrationData,
+            targetDid,
+            txid,
+            inscriptionId,
+        };
+        // Replace the event data with updated migration data
+        witnessedEvent = {
+            ...witnessedEvent,
+            data: updatedMigrationData,
+        };
+        // Replace the last event with the witnessed version
+        updatedLog = {
+            ...updatedLog,
+            events: [
+                ...updatedLog.events.slice(0, lastEventIndex),
+                witnessedEvent,
+            ],
+        };
+        return updatedLog;
+    }
+    /**
+     * Generates a did:btco DID fallback from source DID
+     *
+     * @param sourceDid - The source DID to derive from
+     * @returns A did:btco string
+     */
+    generateBtcoDid(sourceDid) {
+        // Extract identifier portion from source DID
+        let idPart;
+        if (sourceDid.startsWith('did:webvh:')) {
+            // For webvh DIDs, extract the identifier after domain
+            const parts = sourceDid.split(':');
+            idPart = parts.length > 3 ? parts.slice(3).join('') : this.hashIdentifier(sourceDid);
+        }
+        else {
+            // For other DIDs, create a hash-based identifier
+            idPart = this.hashIdentifier(sourceDid);
+        }
+        // Sanitize for DID (alphanumeric only)
+        idPart = idPart.replace(/[^a-zA-Z0-9]/g, '').substring(0, 64);
+        return `did:btco:${idPart}`;
+    }
+    /**
+     * Creates a URL-safe hash-based identifier from a string
+     */
+    hashIdentifier(input) {
+        // Simple hash for identifier generation (not cryptographic)
+        let hash = 0;
+        for (let i = 0; i < input.length; i++) {
+            const char = input.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * Derives the current asset state by replaying all events in the log.
+     *
+     * @param log - The event log to derive state from
+     * @returns The current AssetState derived from replaying events
+     */
+    getCurrentState(log) {
+        // Validate input log
+        if (!log || !log.events || log.events.length === 0) {
+            throw new Error('Cannot get state from an empty event log');
+        }
+        // First event must be a create event
+        const createEvent = log.events[0];
+        if (createEvent.type !== 'create') {
+            throw new Error('First event must be a create event');
+        }
+        // Extract initial state from create event
+        const createData = createEvent.data;
+        // Initialize state from create event
+        const state = {
+            did: createData.did,
+            name: createData.name,
+            layer: createData.layer || 'peer',
+            resources: createData.resources || [],
+            creator: createData.creator,
+            createdAt: createData.createdAt,
+            updatedAt: undefined,
+            deactivated: false,
+            metadata: {},
+        };
+        // Apply subsequent events
+        for (let i = 1; i < log.events.length; i++) {
+            const event = log.events[i];
+            if (event.type === 'update') {
+                const updateData = event.data;
+                // Check if this is a migration event
+                if (updateData.targetDid && updateData.layer) {
+                    // Migration event - update DID and layer
+                    state.did = updateData.targetDid;
+                    state.layer = updateData.layer;
+                    state.updatedAt = updateData.migratedAt;
+                    // Store migration info in metadata
+                    state.metadata = state.metadata || {};
+                    state.metadata.sourceDid = updateData.sourceDid;
+                    // Store Bitcoin-specific metadata for btco layer
+                    if (updateData.layer === 'btco') {
+                        if (updateData.txid) {
+                            state.metadata.txid = updateData.txid;
+                        }
+                        if (updateData.inscriptionId) {
+                            state.metadata.inscriptionId = updateData.inscriptionId;
+                        }
+                    }
+                    else if (updateData.domain) {
+                        state.metadata.domain = updateData.domain;
+                    }
+                }
+                else {
+                    // Regular update event
+                    if (updateData.name !== undefined) {
+                        state.name = updateData.name;
+                    }
+                    if (updateData.resources !== undefined) {
+                        state.resources = updateData.resources;
+                    }
+                    if (updateData.updatedAt !== undefined) {
+                        state.updatedAt = updateData.updatedAt;
+                    }
+                    if (updateData.did !== undefined) {
+                        state.did = updateData.did;
+                    }
+                    if (updateData.layer !== undefined) {
+                        state.layer = updateData.layer;
+                    }
+                }
+                // Store other fields in metadata
+                for (const [key, value] of Object.entries(updateData)) {
+                    if (!['name', 'resources', 'updatedAt', 'did', 'layer', 'creator', 'createdAt', 'sourceDid', 'targetDid', 'domain', 'migratedAt', 'txid', 'inscriptionId'].includes(key)) {
+                        state.metadata = state.metadata || {};
+                        state.metadata[key] = value;
+                    }
+                }
+            }
+            else if (event.type === 'deactivate') {
+                state.deactivated = true;
+                const deactivateData = event.data;
+                if (deactivateData.deactivatedAt !== undefined) {
+                    state.updatedAt = deactivateData.deactivatedAt;
+                }
+                if (deactivateData.reason !== undefined) {
+                    state.metadata = state.metadata || {};
+                    state.metadata.deactivationReason = deactivateData.reason;
+                }
+            }
+        }
+        return state;
+    }
+    /**
+     * Gets the BitcoinManager instance used by this manager
+     */
+    get bitcoin() {
+        return this.bitcoinManager;
+    }
+}