@originals/sdk 1.5.0 → 1.6.0

package/dist/adapters/FeeOracleMock.js

@@ -2,7 +2,7 @@ export class FeeOracleMock {
     constructor(feeRate = 7) {
         this.feeRate = feeRate;
     }
-    async estimateFeeRate(targetBlocks = 1) {
-        return Math.max(1, this.feeRate - (targetBlocks - 1));
+    estimateFeeRate(targetBlocks = 1) {
+        return Promise.resolve(Math.max(1, this.feeRate - (targetBlocks - 1)));
     }
 }

package/dist/bitcoin/OrdinalsClient.d.ts

@@ -6,7 +6,7 @@ export declare class OrdinalsClient {
     getInscriptionById(id: string): Promise<OrdinalsInscription | null>;
     getInscriptionsBySatoshi(satoshi: string): Promise<OrdinalsInscription[]>;
     broadcastTransaction(tx: BitcoinTransaction): Promise<string>;
-    getTransactionStatus(txid: string): Promise<{
+    getTransactionStatus(_txid: string): Promise<{
         confirmed: boolean;
         blockHeight?: number;
         confirmations?: number;

package/dist/bitcoin/OrdinalsClient.js

@@ -17,14 +17,14 @@ export class OrdinalsClient {
         const inscriptions = await Promise.all(info.inscription_ids.map(id => this.resolveInscription(id)));
         return inscriptions.filter((x) => x !== null);
     }
-    async broadcastTransaction(tx) {
-        return tx.txid || 'txid';
+    broadcastTransaction(tx) {
+        return Promise.resolve(tx.txid || 'txid');
     }
-    async getTransactionStatus(txid) {
-        return { confirmed: false };
+    getTransactionStatus(_txid) {
+        return Promise.resolve({ confirmed: false });
     }
-    async estimateFee(blocks = 1) {
-        return Math.max(1, blocks) * 10;
+    estimateFee(blocks = 1) {
+        return Promise.resolve(Math.max(1, blocks) * 10);
     }
     // Added provider-like helper methods commonly expected by higher-level resolvers
     // Minimal placeholder implementations suitable for unit testing
@@ -44,7 +44,7 @@ export class OrdinalsClient {
             return null;
         // Fetch content bytes
         const contentUrl = info.content_url || `${this.rpcUrl}/content/${identifier}`;
-        const contentRes = await fetch(contentUrl);
+        const contentRes = await fetch(String(contentUrl));
         if (!contentRes.ok)
             throw new Error(`Failed to fetch inscription content: ${contentRes.status}`);
         const contentArrayBuf = await contentRes.arrayBuffer();
@@ -83,7 +83,9 @@ export class OrdinalsClient {
             try {
                 text = JSON.parse(text);
             }
-            catch (_) { }
+            catch (_) {
+                // Keep original text if parsing fails
+            }
         }
         try {
             const bytes = hexToBytes(text);

package/dist/bitcoin/PSBTBuilder.js

@@ -68,7 +68,7 @@ export class PSBTBuilder {
         const json = JSON.stringify(payload);
         let psbtBase64;
         try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             const B = global.Buffer;
             psbtBase64 = B ? B.from(json, 'utf8').toString('base64') : global.btoa(json);
         }

package/dist/bitcoin/utxo-selection.js

@@ -70,7 +70,7 @@ export function selectUtxos(utxos, options) {
         throw new Error(`Invalid target amount: ${targetAmount}`);
     }
     // Sort UTXOs based on selected strategy
-    let sortedUtxos = [...utxos];
+    const sortedUtxos = [...utxos];
     if (strategy === 'minimize_inputs') {
         // Sort by value descending to use fewest inputs
         sortedUtxos.sort((a, b) => b.value - a.value);
@@ -129,7 +129,7 @@ export function selectResourceUtxos(availableUtxos, options) {
     // Convert requiredAmount to bigint for compatibility with fee calculations
     const requiredAmountBigInt = BigInt(requiredAmount);
     // Filter out UTXOs to avoid and those with resources if not allowed
-    let eligibleUtxos = availableUtxos.filter(utxo => {
+    const eligibleUtxos = availableUtxos.filter(utxo => {
         const utxoId = `${utxo.txid}:${utxo.vout}`;
         const shouldAvoid = avoidUtxoIds.includes(utxoId);
         const containsResource = utxo.hasResource === true;

package/dist/cel/ExternalReferenceManager.d.ts

@@ -0,0 +1,57 @@
+/**
+ * External Reference Manager
+ *
+ * Creates and verifies external resource references as specified in the CEL specification.
+ * External references point to data outside the event log (e.g., large media files)
+ * and include a cryptographic hash for content verification.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+import type { ExternalReference } from './types';
+/**
+ * Creates an external reference for content.
+ *
+ * Computes a CEL-compliant digestMultibase hash from the content bytes
+ * and creates an ExternalReference with the provided metadata.
+ *
+ * @param content - The raw bytes of the content to reference
+ * @param mediaType - The MIME type of the content (e.g., "image/png")
+ * @param urls - Optional array of URLs where the content can be retrieved
+ * @returns An ExternalReference object with the computed digest
+ *
+ * @example
+ * ```typescript
+ * const imageBytes = await fs.readFile('./image.png');
+ * const ref = createExternalReference(
+ *   imageBytes,
+ *   'image/png',
+ *   ['https://example.com/image.png']
+ * );
+ * // Returns: { digestMultibase: "uLCA...", mediaType: "image/png", url: ["https://example.com/image.png"] }
+ * ```
+ */
+export declare function createExternalReference(content: Uint8Array, mediaType: string, urls?: string[]): ExternalReference;
+/**
+ * Verifies that content matches an external reference.
+ *
+ * Computes the hash of the provided content and compares it
+ * against the digestMultibase in the reference.
+ *
+ * @param ref - The external reference to verify against
+ * @param content - The raw bytes of the content to verify
+ * @returns True if the content hash matches the reference digest, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const imageBytes = await fs.readFile('./image.png');
+ * const ref = createExternalReference(imageBytes, 'image/png');
+ *
+ * // Verify the content
+ * const isValid = verifyExternalReference(ref, imageBytes); // true
+ *
+ * // Modified content will fail verification
+ * const modified = new Uint8Array([...imageBytes, 0]);
+ * const isValid2 = verifyExternalReference(ref, modified); // false
+ * ```
+ */
+export declare function verifyExternalReference(ref: ExternalReference, content: Uint8Array): boolean;

package/dist/cel/ExternalReferenceManager.js

@@ -0,0 +1,73 @@
+/**
+ * External Reference Manager
+ *
+ * Creates and verifies external resource references as specified in the CEL specification.
+ * External references point to data outside the event log (e.g., large media files)
+ * and include a cryptographic hash for content verification.
+ *
+ * @see https://w3c-ccg.github.io/cel-spec/
+ */
+import { computeDigestMultibase, verifyDigestMultibase } from './hash';
+/**
+ * Creates an external reference for content.
+ *
+ * Computes a CEL-compliant digestMultibase hash from the content bytes
+ * and creates an ExternalReference with the provided metadata.
+ *
+ * @param content - The raw bytes of the content to reference
+ * @param mediaType - The MIME type of the content (e.g., "image/png")
+ * @param urls - Optional array of URLs where the content can be retrieved
+ * @returns An ExternalReference object with the computed digest
+ *
+ * @example
+ * ```typescript
+ * const imageBytes = await fs.readFile('./image.png');
+ * const ref = createExternalReference(
+ *   imageBytes,
+ *   'image/png',
+ *   ['https://example.com/image.png']
+ * );
+ * // Returns: { digestMultibase: "uLCA...", mediaType: "image/png", url: ["https://example.com/image.png"] }
+ * ```
+ */
+export function createExternalReference(content, mediaType, urls) {
+    // Compute the CEL-compliant hash of the content
+    const digestMultibase = computeDigestMultibase(content);
+    // Build the reference object
+    const ref = {
+        digestMultibase,
+        mediaType,
+    };
+    // Only include urls if provided and non-empty
+    if (urls && urls.length > 0) {
+        ref.url = urls;
+    }
+    return ref;
+}
+/**
+ * Verifies that content matches an external reference.
+ *
+ * Computes the hash of the provided content and compares it
+ * against the digestMultibase in the reference.
+ *
+ * @param ref - The external reference to verify against
+ * @param content - The raw bytes of the content to verify
+ * @returns True if the content hash matches the reference digest, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const imageBytes = await fs.readFile('./image.png');
+ * const ref = createExternalReference(imageBytes, 'image/png');
+ *
+ * // Verify the content
+ * const isValid = verifyExternalReference(ref, imageBytes); // true
+ *
+ * // Modified content will fail verification
+ * const modified = new Uint8Array([...imageBytes, 0]);
+ * const isValid2 = verifyExternalReference(ref, modified); // false
+ * ```
+ */
+export function verifyExternalReference(ref, content) {
+    // Use the hash verification function to check content against digest
+    return verifyDigestMultibase(content, ref.digestMultibase);
+}

package/dist/cel/OriginalsCel.d.ts

@@ -0,0 +1,245 @@
+/**
+ * OriginalsCel - Unified SDK Entry Point for CEL Operations
+ *
+ * Provides a single, simplified interface for all Cryptographic Event Log
+ * operations across all layers (peer, webvh, btco).
+ *
+ * This class delegates to the appropriate layer manager based on
+ * the configured layer and the current state of the event log.
+ *
+ * @example
+ * ```typescript
+ * // Create a peer-layer asset
+ * const cel = new OriginalsCel({
+ *   layer: 'peer',
+ *   signer: async (data) => createEdDsaProof(data, privateKey),
+ * });
+ *
+ * const log = await cel.create('My Asset', [
+ *   { digestMultibase: 'uXYZ...', mediaType: 'image/png' }
+ * ]);
+ *
+ * // Update the asset
+ * const updated = await cel.update(log, { description: 'Updated' });
+ *
+ * // Verify the log
+ * const result = await cel.verify(updated);
+ *
+ * // Migrate to webvh layer
+ * const migrated = await cel.migrate(updated, 'webvh');
+ * ```
+ */
+import type { EventLog, ExternalReference, VerificationResult, VerifyOptions, AssetState } from './types';
+import { type PeerCelConfig, type CelSigner } from './layers/PeerCelManager';
+import { type WebVHCelConfig } from './layers/WebVHCelManager';
+import { type BtcoCelConfig } from './layers/BtcoCelManager';
+import type { WitnessService } from './witnesses/WitnessService';
+import type { BitcoinManager } from '../bitcoin/BitcoinManager';
+/**
+ * Supported layer types
+ */
+export type CelLayer = 'peer' | 'webvh' | 'btco';
+export type { CelSigner };
+/**
+ * Configuration options for OriginalsCel
+ */
+export interface OriginalsCelConfig {
+    /** Configuration for peer layer operations */
+    peer?: PeerCelConfig;
+    /** Configuration for webvh layer operations */
+    webvh?: {
+        /** The domain for the did:webvh DID (required for webvh operations) */
+        domain?: string;
+        /** Optional witness services for HTTP attestations */
+        witnesses?: WitnessService[];
+    } & WebVHCelConfig;
+    /** Configuration for btco layer operations */
+    btco?: {
+        /** BitcoinManager instance (required for btco operations) */
+        bitcoinManager?: BitcoinManager;
+    } & BtcoCelConfig;
+}
+/**
+ * Options for creating an OriginalsCel instance
+ */
+export interface OriginalsCelOptions {
+    /** The target layer for operations */
+    layer: CelLayer;
+    /** Signer function that produces DataIntegrityProofs */
+    signer: CelSigner;
+    /** Optional layer-specific configuration */
+    config?: OriginalsCelConfig;
+}
+/**
+ * OriginalsCel - Unified SDK for Cryptographic Event Log operations
+ *
+ * Provides a consistent API for creating, updating, verifying, and migrating
+ * assets across all supported layers (peer, webvh, btco).
+ */
+export declare class OriginalsCel {
+    private layer;
+    private signer;
+    private config;
+    private _peerManager?;
+    private _webvhManager?;
+    private _btcoManager?;
+    /**
+     * Creates a new OriginalsCel instance
+     *
+     * @param options - Configuration options
+     * @param options.layer - The target layer for operations (peer, webvh, btco)
+     * @param options.signer - Function that signs data and returns a DataIntegrityProof
+     * @param options.config - Optional layer-specific configuration
+     *
+     * @throws Error if signer is not a function
+     * @throws Error if layer is invalid
+     */
+    constructor(options: OriginalsCelOptions);
+    /**
+     * Gets or creates the PeerCelManager instance
+     */
+    private get peerManager();
+    /**
+     * Gets or creates the WebVHCelManager instance
+     *
+     * @throws Error if domain is not configured for webvh operations
+     */
+    private getWebVHManager;
+    /**
+     * Gets or creates the BtcoCelManager instance
+     *
+     * @throws Error if BitcoinManager is not configured for btco operations
+     */
+    private get btcoManager();
+    /**
+     * Creates a new asset with a CEL event log
+     *
+     * This method creates an asset at the configured layer. Note that
+     * new assets can only be created at the peer layer - for other layers,
+     * create at peer first and then migrate.
+     *
+     * @param name - Human-readable name for the asset
+     * @param resources - External resources associated with the asset
+     * @returns Promise resolving to an EventLog with the create event
+     *
+     * @throws Error if signer produces invalid proof
+     * @throws Error if trying to create at non-peer layer
+     *
+     * @example
+     * ```typescript
+     * const log = await cel.create('My Asset', [
+     *   createExternalReference(imageData, 'image/png')
+     * ]);
+     * ```
+     */
+    create(name: string, resources: ExternalReference[]): Promise<EventLog>;
+    /**
+     * Updates an existing event log by appending an update event
+     *
+     * The new event is cryptographically linked to the previous event
+     * via a hash chain (previousEvent field).
+     *
+     * @param log - The existing event log to update
+     * @param data - The update data (new metadata, resources, etc.)
+     * @returns Promise resolving to a new EventLog with the update event appended
+     *
+     * @throws Error if the log is empty or deactivated
+     * @throws Error if signer produces invalid proof
+     *
+     * @example
+     * ```typescript
+     * const updated = await cel.update(log, {
+     *   description: 'Updated description',
+     *   tags: ['art', 'digital']
+     * });
+     * ```
+     */
+    update(log: EventLog, data: unknown): Promise<EventLog>;
+    /**
+     * Verifies all proofs and hash chain integrity in an event log
+     *
+     * This method verifies:
+     * - Each event has at least one proof
+     * - Each proof is structurally valid
+     * - The hash chain is intact (each event links to previous)
+     *
+     * @param log - The event log to verify
+     * @param options - Optional verification options
+     * @returns Promise resolving to VerificationResult with detailed status
+     *
+     * @example
+     * ```typescript
+     * const result = await cel.verify(log);
+     * if (result.verified) {
+     *   console.log('Log is valid!');
+     * } else {
+     *   console.error('Verification failed:', result.errors);
+     * }
+     * ```
+     */
+    verify(log: EventLog, options?: VerifyOptions): Promise<VerificationResult>;
+    /**
+     * Migrates an event log to a target layer
+     *
+     * Migration adds an update event with migration data and (optionally)
+     * witness proofs. The valid migration paths are:
+     * - peer → webvh
+     * - webvh → btco
+     * - peer → btco (requires intermediate webvh migration)
+     *
+     * @param log - The event log to migrate
+     * @param targetLayer - The layer to migrate to
+     * @param options - Optional migration options (e.g., domain for webvh)
+     * @returns Promise resolving to the migrated EventLog
+     *
+     * @throws Error if migration path is invalid
+     * @throws Error if required config is missing for target layer
+     *
+     * @example
+     * ```typescript
+     * // Migrate peer to webvh
+     * const webvhLog = await cel.migrate(peerLog, 'webvh', {
+     *   domain: 'example.com'
+     * });
+     *
+     * // Migrate webvh to btco
+     * const btcoLog = await cel.migrate(webvhLog, 'btco');
+     * ```
+     */
+    migrate(log: EventLog, targetLayer: CelLayer, options?: {
+        domain?: string;
+    }): Promise<EventLog>;
+    /**
+     * 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
+     *
+     * @example
+     * ```typescript
+     * const state = cel.getCurrentState(log);
+     * console.log(state.name);        // Asset name
+     * console.log(state.layer);       // Current layer
+     * console.log(state.deactivated); // Whether deactivated
+     * ```
+     */
+    getCurrentState(log: EventLog): AssetState;
+    /**
+     * Determines the current layer of an event log by examining its events
+     *
+     * @param log - The event log to examine
+     * @returns The current layer of the log
+     */
+    private getCurrentLayer;
+    /**
+     * Extracts the domain from a webvh log's migration event
+     *
+     * @param log - The event log to examine
+     * @returns The domain if found, undefined otherwise
+     */
+    private extractDomainFromLog;
+    /**
+     * Gets the configured layer for this instance
+     */
+    get currentLayer(): CelLayer;
+}