@originals/sdk 1.5.0 → 1.6.1

package/dist/index.d.ts

@@ -40,4 +40,17 @@ export { sha256Bytes } from './utils/hash.js';
 export { OrdMockProvider } from './adapters/providers/OrdMockProvider.js';
 export { FeeOracleMock } from './adapters/FeeOracleMock.js';
 export type { OrdinalsProvider, FeeOracleAdapter, StorageAdapter } from './adapters/types.js';
+export { OriginalsCel, type CelLayer, type CelSigner, type OriginalsCelConfig, type OriginalsCelOptions, } from './cel/OriginalsCel.js';
+export type { EventLog, LogEntry, EventType, DataIntegrityProof, WitnessProof, ExternalReference, VerificationResult, EventVerification, AssetState, CreateOptions, UpdateOptions, DeactivateOptions, VerifyOptions, } from './cel/types.js';
+export { createEventLog, updateEventLog, deactivateEventLog, verifyEventLog, witnessEvent, } from './cel/algorithms/index.js';
+export { computeDigestMultibase, verifyDigestMultibase, decodeDigestMultibase, } from './cel/hash.js';
+export { createExternalReference, verifyExternalReference, } from './cel/ExternalReferenceManager.js';
+export { PeerCelManager } from './cel/layers/PeerCelManager.js';
+export { WebVHCelManager } from './cel/layers/WebVHCelManager.js';
+export { BtcoCelManager } from './cel/layers/BtcoCelManager.js';
+export type { WitnessService } from './cel/witnesses/WitnessService.js';
+export { HttpWitness, HttpWitnessError } from './cel/witnesses/HttpWitness.js';
+export { BitcoinWitness, BitcoinWitnessError, type BitcoinWitnessProof } from './cel/witnesses/BitcoinWitness.js';
+export { serializeEventLogJson, parseEventLogJson, } from './cel/serialization/json.js';
+export { serializeEventLogCbor, parseEventLogCbor, } from './cel/serialization/cbor.js';
 export default OriginalsSDK;

package/dist/index.js

@@ -48,5 +48,17 @@ export { sha256Bytes } from './utils/hash.js';
 // Adapter exports (for testing and custom integrations)
 export { OrdMockProvider } from './adapters/providers/OrdMockProvider.js';
 export { FeeOracleMock } from './adapters/FeeOracleMock.js';
+// CEL (Cryptographic Event Log) exports
+export { OriginalsCel, } from './cel/OriginalsCel.js';
+export { createEventLog, updateEventLog, deactivateEventLog, verifyEventLog, witnessEvent, } from './cel/algorithms/index.js';
+export { computeDigestMultibase, verifyDigestMultibase, decodeDigestMultibase, } from './cel/hash.js';
+export { createExternalReference, verifyExternalReference, } from './cel/ExternalReferenceManager.js';
+export { PeerCelManager } from './cel/layers/PeerCelManager.js';
+export { WebVHCelManager } from './cel/layers/WebVHCelManager.js';
+export { BtcoCelManager } from './cel/layers/BtcoCelManager.js';
+export { HttpWitness, HttpWitnessError } from './cel/witnesses/HttpWitness.js';
+export { BitcoinWitness, BitcoinWitnessError } from './cel/witnesses/BitcoinWitness.js';
+export { serializeEventLogJson, parseEventLogJson, } from './cel/serialization/json.js';
+export { serializeEventLogCbor, parseEventLogCbor, } from './cel/serialization/cbor.js';
 // Default export
 export default OriginalsSDK;

package/dist/kinds/KindRegistry.js

@@ -162,53 +162,83 @@ export class KindRegistry {
         };
         // Add kind-specific metadata templates
         switch (kind) {
-            case OriginalKind.App:
+            case OriginalKind.App: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const appMetadata = {
+                    runtime: 'node',
+                    entrypoint: 'index.js',
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
                 return {
                     ...base,
-                    metadata: {
-                        runtime: 'node',
-                        entrypoint: 'index.js',
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: appMetadata,
+                };
+            }
+            case OriginalKind.Agent: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const agentMetadata = {
+                    capabilities: [],
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 };
-            case OriginalKind.Agent:
                 return {
                     ...base,
-                    metadata: {
-                        capabilities: [],
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: agentMetadata,
+                };
+            }
+            case OriginalKind.Module: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const moduleMetadata = {
+                    format: 'esm',
+                    main: 'index.js',
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 };
-            case OriginalKind.Module:
                 return {
                     ...base,
-                    metadata: {
-                        format: 'esm',
-                        main: 'index.js',
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: moduleMetadata,
+                };
+            }
+            case OriginalKind.Dataset: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const datasetMetadata = {
+                    format: 'json',
+                    schema: {},
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 };
-            case OriginalKind.Dataset:
                 return {
                     ...base,
-                    metadata: {
-                        format: 'json',
-                        schema: {},
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: datasetMetadata,
+                };
+            }
+            case OriginalKind.Media: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const mediaMetadata = {
+                    mediaType: 'image',
+                    mimeType: 'image/png',
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 };
-            case OriginalKind.Media:
                 return {
                     ...base,
-                    metadata: {
-                        mediaType: 'image',
-                        mimeType: 'image/png',
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: mediaMetadata,
+                };
+            }
+            case OriginalKind.Document: {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const documentMetadata = {
+                    format: 'markdown',
+                    content: 'content',
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 };
-            case OriginalKind.Document:
                 return {
                     ...base,
-                    metadata: {
-                        format: 'markdown',
-                        content: 'content',
-                    },
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata: documentMetadata,
                 };
+            }
             default:
                 return base;
         }

package/dist/lifecycle/BatchOperations.d.ts

@@ -8,6 +8,8 @@
  * - Pre-validation of all items
  * - Detailed timing and error tracking
  */
+import type { AssetResource } from '../types';
+import type { OriginalsAsset } from './OriginalsAsset';
 /**
  * Result of a batch operation containing successful and failed items
  */
@@ -132,16 +134,16 @@ export declare class BatchValidator {
     /**
      * Validate batch of resources for asset creation
      */
-    validateBatchCreate(resourcesList: any[][]): ValidationResult[];
+    validateBatchCreate(resourcesList: AssetResource[][]): ValidationResult[];
     /**
      * Validate batch of assets for inscription
      */
-    validateBatchInscription(assets: any[]): ValidationResult[];
+    validateBatchInscription(assets: OriginalsAsset[]): ValidationResult[];
     /**
      * Validate batch of transfer operations
      */
     validateBatchTransfer(transfers: Array<{
-        asset: any;
+        asset: OriginalsAsset;
         to: string;
     }>): ValidationResult[];
 }

package/dist/lifecycle/BatchOperations.js

@@ -185,6 +185,7 @@ export class BatchValidator {
                     errors.push(`Item ${index}, resource ${i}: Invalid resource object`);
                     continue;
                 }
+                // AssetResource is properly typed, so we can access properties directly
                 if (!resource.id || typeof resource.id !== 'string') {
                     errors.push(`Item ${index}, resource ${i}: Missing or invalid id`);
                 }
@@ -214,13 +215,15 @@ export class BatchValidator {
             if (!asset.id || typeof asset.id !== 'string') {
                 errors.push(`Item ${index}: Missing or invalid asset id`);
             }
-            if (!asset.currentLayer) {
+            const currentLayer = asset.currentLayer;
+            if (!currentLayer) {
                 errors.push(`Item ${index}: Missing currentLayer`);
             }
-            else if (asset.currentLayer === 'did:btco') {
+            else if (currentLayer === 'did:btco') {
                 errors.push(`Item ${index}: Asset already inscribed on Bitcoin`);
             }
-            if (!asset.resources || !Array.isArray(asset.resources) || asset.resources.length === 0) {
+            const resources = asset.resources;
+            if (!resources || !Array.isArray(resources) || resources.length === 0) {
                 errors.push(`Item ${index}: Asset must have at least one resource`);
             }
             return { isValid: errors.length === 0, errors };
@@ -239,8 +242,11 @@ export class BatchValidator {
             if (!transfer.asset || typeof transfer.asset !== 'object') {
                 errors.push(`Item ${index}: Invalid asset`);
             }
-            else if (transfer.asset.currentLayer !== 'did:btco') {
-                errors.push(`Item ${index}: Asset must be inscribed on Bitcoin before transfer`);
+            else {
+                const currentLayer = transfer.asset.currentLayer;
+                if (currentLayer !== 'did:btco') {
+                    errors.push(`Item ${index}: Asset must be inscribed on Bitcoin before transfer`);
+                }
             }
             if (!transfer.to || typeof transfer.to !== 'string') {
                 errors.push(`Item ${index}: Invalid destination address`);

package/dist/lifecycle/LifecycleManager.d.ts

@@ -358,5 +358,5 @@ export declare class LifecycleManager {
      * }
      * ```
      */
-    validateMigration(asset: OriginalsAsset, targetLayer: LayerType): Promise<MigrationValidation>;
+    validateMigration(asset: OriginalsAsset, targetLayer: LayerType): MigrationValidation;
 }

package/dist/lifecycle/LifecycleManager.js

@@ -131,8 +131,8 @@ export class LifecycleManager {
                         }
                     };
                     // Emit from both LifecycleManager and asset emitters
-                    this.eventEmitter.emit(event);
-                    asset.eventEmitter.emit(event);
+                    void this.eventEmitter.emit(event);
+                    void asset.eventEmitter.emit(event);
                 });
                 stopTimer();
                 this.logger.info('Asset created successfully', { assetId: asset.id });
@@ -156,8 +156,8 @@ export class LifecycleManager {
                         }
                     };
                     // Emit from both LifecycleManager and asset emitters
-                    this.eventEmitter.emit(event);
-                    asset.eventEmitter.emit(event);
+                    void this.eventEmitter.emit(event);
+                    void asset.eventEmitter.emit(event);
                 });
                 stopTimer();
                 this.logger.info('Asset created successfully', { assetId: asset.id });
@@ -249,7 +249,7 @@ export class LifecycleManager {
                     }
                 };
                 // Emit from LifecycleManager
-                this.eventEmitter.emit(event);
+                void this.eventEmitter.emit(event);
             });
             stopTimer();
             this.logger.info('Typed Original created successfully', {
@@ -387,7 +387,7 @@ export class LifecycleManager {
             if (asset.currentLayer !== 'did:peer') {
                 throw new Error('Asset must be in did:peer layer to publish to web');
             }
-            const { publisherDid, signer } = await this.extractPublisherInfo(publisherDidOrSigner);
+            const { publisherDid, signer } = this.extractPublisherInfo(publisherDidOrSigner);
             const { domain, userPath } = this.parseWebVHDid(publisherDid);
             this.logger.info('Publishing asset to web', { assetId: asset.id, publisherDid });
             // Publish resources to storage
@@ -396,7 +396,7 @@ export class LifecycleManager {
             const originalPeerDid = asset.id;
             // Migrate asset to did:webvh layer
             await asset.migrate('did:webvh');
-            asset.bindings = { ...asset.bindings, 'did:peer': originalPeerDid, 'did:webvh': publisherDid };
+            asset.bindings = { ...(asset.bindings || {}), 'did:peer': originalPeerDid, 'did:webvh': publisherDid };
             // Issue publication credential (best-effort)
             await this.issuePublicationCredential(asset, publisherDid, signer);
             stopTimer();
@@ -415,7 +415,7 @@ export class LifecycleManager {
             throw error;
         }
     }
-    async extractPublisherInfo(publisherDidOrSigner) {
+    extractPublisherInfo(publisherDidOrSigner) {
         if (typeof publisherDidOrSigner === 'string') {
             // If it's already a did:webvh DID, use it as-is
             if (publisherDidOrSigner.startsWith('did:webvh:')) {
@@ -430,8 +430,8 @@ export class LifecycleManager {
             return { publisherDid };
         }
         const signer = publisherDidOrSigner;
-        const vmId = await signer.getVerificationMethodId();
-        const publisherDid = vmId.includes('#') ? vmId.split('#')[0] : vmId;
+        const resolvedVmId = signer.getVerificationMethodId();
+        const publisherDid = resolvedVmId.includes('#') ? resolvedVmId.split('#')[0] : resolvedVmId;
         if (!publisherDid.startsWith('did:webvh:')) {
             throw new Error('Signer must be associated with a did:webvh identifier');
         }
@@ -457,12 +457,14 @@ export class LifecycleManager {
             const data = resource.content
                 ? Buffer.from(resource.content)
                 : Buffer.from(resource.hash);
-            if (typeof storage.put === 'function') {
-                await storage.put(`${domain}/${relativePath}`, data, { contentType: resource.contentType });
+            const storageWithPut = storage;
+            const storageWithPutObject = storage;
+            if (typeof storageWithPut.put === 'function') {
+                await storageWithPut.put(`${domain}/${relativePath}`, data, { contentType: resource.contentType });
             }
-            else {
+            else if (typeof storageWithPutObject.putObject === 'function') {
                 const encoded = new TextEncoder().encode(resource.content || resource.hash);
-                await storage.putObject(domain, relativePath, encoded);
+                await storageWithPutObject.putObject(domain, relativePath, encoded);
             }
             resource.url = resourceUrl;
             await this.emitResourcePublishedEvent(asset, resource, resourceUrl, publisherDid, domain);
@@ -501,7 +503,7 @@ export class LifecycleManager {
                 toLayer: 'did:webvh',
                 migratedAt: new Date().toISOString()
             };
-            const unsigned = await this.credentialManager.createResourceCredential('ResourceMigrated', subject, publisherDid);
+            const unsigned = this.credentialManager.createResourceCredential('ResourceMigrated', subject, publisherDid);
             const signed = signer
                 ? await this.credentialManager.signCredentialWithExternalSigner(unsigned, signer)
                 : await this.signWithKeyStore(unsigned, publisherDid);
@@ -545,8 +547,9 @@ export class LifecycleManager {
             }
         }
         // If not found, try to find ANY key that starts with the issuer DID
-        if (!privateKey && typeof this.keyStore.getAllVerificationMethodIds === 'function') {
-            const allVmIds = this.keyStore.getAllVerificationMethodIds();
+        const keyStoreWithGetAll = this.keyStore;
+        if (!privateKey && typeof keyStoreWithGetAll.getAllVerificationMethodIds === 'function') {
+            const allVmIds = keyStoreWithGetAll.getAllVerificationMethodIds();
             for (const testVmId of allVmIds) {
                 if (testVmId.startsWith(issuer)) {
                     const key = await this.keyStore.getPrivateKey(testVmId);
@@ -573,6 +576,9 @@ export class LifecycleManager {
                 throw new Error('Private key not found in keyStore');
             }
         }
+        if (!vmId) {
+            throw new Error('Verification method ID could not be determined');
+        }
         return this.credentialManager.signCredential(credential, privateKey, vmId);
     }
     async inscribeOnBitcoin(asset, feeRate) {
@@ -621,7 +627,7 @@ export class LifecycleManager {
             const bindingValue = inscription.satoshi
                 ? `did:btco:${inscription.satoshi}`
                 : `did:btco:${inscription.inscriptionId}`;
-            asset.bindings = Object.assign({}, asset.bindings, { 'did:btco': bindingValue });
+            asset.bindings = Object.assign({}, asset.bindings || {}, { 'did:btco': bindingValue });
             stopTimer();
             this.logger.info('Asset inscribed on Bitcoin successfully', {
                 assetId: asset.id,
@@ -674,6 +680,7 @@ export class LifecycleManager {
                 txid: latestMigration?.transactionId ?? 'unknown-tx',
                 vout: 0
             };
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const tx = await bm.transferInscription(inscription, newOwner);
             await asset.recordTransfer(asset.id, newOwner, tx.txid);
             stopTimer();
@@ -720,7 +727,7 @@ export class LifecycleManager {
         });
         try {
             // Use batch executor to process all asset creations
-            const result = await this.batchExecutor.execute(resourcesList, async (resources, index) => {
+            const result = await this.batchExecutor.execute(resourcesList, async (resources, _index) => {
                 const asset = await this.createAsset(resources);
                 return asset;
             }, options, batchId // Pass the pre-generated batchId for event correlation
@@ -792,7 +799,7 @@ export class LifecycleManager {
             itemCount: assets.length
         });
         try {
-            const result = await this.batchExecutor.execute(assets, async (asset, index) => {
+            const result = await this.batchExecutor.execute(assets, async (asset, _index) => {
                 return await this.publishToWeb(asset, domain);
             }, options, batchId // Pass the pre-generated batchId for event correlation
             );
@@ -871,7 +878,7 @@ export class LifecycleManager {
             // Calculate total data size for all assets
             const totalDataSize = this.calculateTotalDataSize(assets);
             // Estimate savings from batch inscription
-            const estimatedSavings = await this.estimateBatchSavings(assets, options?.feeRate);
+            const estimatedSavings = this.estimateBatchSavings(assets, options?.feeRate);
             // Create manifests for all assets
             const manifests = assets.map(asset => ({
                 assetId: asset.id,
@@ -913,7 +920,8 @@ export class LifecycleManager {
                 const contentSize = asset.resources.reduce((sum, r) => {
                     const content = r.content;
                     if (content) {
-                        return sum + (typeof content === 'string' ? Buffer.byteLength(content) : content.length || 0);
+                        const length = typeof content === 'string' ? Buffer.byteLength(content) : content.length;
+                        return sum + (length || 0);
                     }
                     return sum;
                 }, 0);
@@ -947,14 +955,15 @@ export class LifecycleManager {
                 // Add batch metadata to provenance
                 const provenance = asset.getProvenance();
                 const latestMigration = provenance.migrations[provenance.migrations.length - 1];
-                latestMigration.batchId = batchId;
-                latestMigration.batchInscription = true;
-                latestMigration.batchIndex = i; // Store index as metadata
-                latestMigration.feePaid = feePerAsset[i];
+                const migrationWithBatchData = latestMigration;
+                migrationWithBatchData.batchId = batchId;
+                migrationWithBatchData.batchInscription = true;
+                migrationWithBatchData.batchIndex = i; // Store index as metadata
+                migrationWithBatchData.feePaid = feePerAsset[i];
                 const bindingValue = inscription.satoshi
                     ? `did:btco:${inscription.satoshi}`
                     : `did:btco:${individualInscriptionId}`;
-                asset.bindings = Object.assign({}, asset.bindings, { 'did:btco': bindingValue });
+                asset.bindings = Object.assign({}, asset.bindings || {}, { 'did:btco': bindingValue });
                 successful.push({
                     index: i,
                     result: asset,
@@ -1020,7 +1029,7 @@ export class LifecycleManager {
             itemCount: assets.length
         });
         try {
-            const result = await this.batchExecutor.execute(assets, async (asset, index) => {
+            const result = await this.batchExecutor.execute(assets, async (asset, _index) => {
                 return await this.inscribeOnBitcoin(asset, options?.feeRate);
             }, options, batchId // Pass the pre-generated batchId for event correlation
             );
@@ -1087,7 +1096,7 @@ export class LifecycleManager {
             itemCount: transfers.length
         });
         try {
-            const result = await this.batchExecutor.execute(transfers, async (transfer, index) => {
+            const result = await this.batchExecutor.execute(transfers, async (transfer, _index) => {
                 return await this.transferOwnership(transfer.asset, transfer.to);
             }, options, batchId // Pass the pre-generated batchId for event correlation
             );
@@ -1138,7 +1147,7 @@ export class LifecycleManager {
     /**
      * Estimate cost savings from batch inscription vs individual inscriptions
      */
-    async estimateBatchSavings(assets, feeRate) {
+    estimateBatchSavings(assets, feeRate) {
         // Calculate total size for batch
         const batchSize = this.calculateTotalDataSize(assets);
         // Estimate individual sizes
@@ -1264,7 +1273,7 @@ export class LifecycleManager {
             message: 'Validating migration...'
         });
         // Pre-flight validation
-        const validation = await this.validateMigration(asset, 'did:webvh');
+        const validation = this.validateMigration(asset, 'did:webvh');
         if (!validation.valid) {
             onProgress?.({
                 phase: 'failed',
@@ -1333,7 +1342,7 @@ export class LifecycleManager {
             message: 'Validating migration...'
         });
         // Pre-flight validation
-        const validation = await this.validateMigration(asset, 'did:btco');
+        const validation = this.validateMigration(asset, 'did:btco');
         if (!validation.valid) {
             onProgress?.({
                 phase: 'failed',
@@ -1598,7 +1607,7 @@ export class LifecycleManager {
      * }
      * ```
      */
-    async validateMigration(asset, targetLayer) {
+    validateMigration(asset, targetLayer) {
         const errors = [];
         const warnings = [];
         const checks = {

package/dist/lifecycle/OriginalsAsset.js

@@ -28,7 +28,7 @@ export class OriginalsAsset {
             resourcesByIdMap.set(resource.id, existing);
         }
         // Process each resource ID's versions in sorted order
-        for (const [resourceId, resourceVersions] of resourcesByIdMap.entries()) {
+        for (const resourceVersions of resourcesByIdMap.values()) {
             // Sort by version number (ascending)
             const sorted = resourceVersions.sort((a, b) => {
                 const versionA = a.version || 1;
@@ -336,7 +336,7 @@ export class OriginalsAsset {
         };
         // Emit asynchronously (don't block)
         queueMicrotask(() => {
-            this.eventEmitter.emit(event);
+            void this.eventEmitter.emit(event);
         });
         return newResource;
     }