@originals/sdk 1.8.0 → 1.8.2

package/src/index.ts

@@ -0,0 +1,204 @@
+/* istanbul ignore file */
+// Initialize noble crypto libraries first (must run before any crypto operations)
+import './crypto/noble-init.js';
+
+import { OriginalsSDK } from './core/OriginalsSDK.js';
+
+// Main exports
+export { OriginalsSDK } from './core/OriginalsSDK.js';
+export type { 
+  OriginalsSDKOptions,
+  OriginalResult,
+  CreateOriginalOptions,
+  UpdateOriginalOptions,
+  CreateDIDOriginalOptions,
+  UpdateDIDOriginalOptions
+} from './core/OriginalsSDK.js';
+export { OriginalsAsset } from './lifecycle/OriginalsAsset.js';
+export type { ProvenanceChain } from './lifecycle/OriginalsAsset.js';
+
+// Type exports
+export * from './types/index.js';
+
+// Manager exports
+export { DIDManager, type CreateWebVHOptions, type CreateWebVHResult } from './did/DIDManager.js';
+export { KeyManager } from './did/KeyManager.js';
+export { Ed25519Verifier } from './did/Ed25519Verifier.js';
+export * as encoding from './utils/encoding.js';
+export { 
+  CredentialManager,
+  type ResourceCreatedSubject,
+  type ResourceUpdatedSubject,
+  type MigrationSubject,
+  type OwnershipSubject,
+  type CredentialChainOptions,
+  type SelectiveDisclosureOptions,
+  type DerivedProofResult
+} from './vc/CredentialManager.js';
+export { 
+  LifecycleManager,
+  type CostEstimate,
+  type MigrationValidation,
+  type LifecycleProgress,
+  type ProgressCallback,
+  type LifecycleOperationOptions
+} from './lifecycle/LifecycleManager.js';
+export { BitcoinManager } from './bitcoin/BitcoinManager.js';
+export { OrdinalsClient } from './bitcoin/OrdinalsClient.js';
+export { buildTransferTransaction } from './bitcoin/transfer.js';
+export { selectUtxos, UtxoSelectionError, estimateFeeSats } from './bitcoin/utxo.js';
+export { 
+  selectUtxos as selectUtxosSimple,
+  selectResourceUtxos,
+  selectUtxosForPayment,
+  tagResourceUtxos,
+  estimateTransactionSize
+} from './bitcoin/utxo-selection.js';
+export { calculateFee } from './bitcoin/fee-calculation.js';
+export { BBSCryptosuiteUtils } from './vc/cryptosuites/bbs.js';
+export { BbsSimple } from './vc/cryptosuites/bbsSimple.js';
+export * from './storage/index.js';
+
+// Resource management exports
+export { ResourceManager } from './resources/index.js';
+export type {
+  Resource,
+  ResourceOptions,
+  ResourceUpdateOptions,
+  ResourceVersionHistory,
+  ResourceManagerConfig,
+  ResourceValidationResult,
+  ResourceType,
+} from './resources/index.js';
+export { MIME_TYPE_MAP, DEFAULT_RESOURCE_CONFIG } from './resources/index.js';
+
+// Crypto exports
+export { Signer, ES256KSigner, Ed25519Signer, ES256Signer, Bls12381G2Signer } from './crypto/Signer.js';
+export { multikey } from './crypto/Multikey.js';
+export type { MultikeyType } from './crypto/Multikey.js';
+
+// Event system exports
+export * from './events/index.js';
+
+// Migration system exports
+export { MigrationManager } from './migration/index.js';
+export * from './migration/types.js';
+
+// Batch operations exports
+export {
+  BatchOperationExecutor,
+  BatchValidator,
+  BatchError,
+  type BatchResult,
+  type BatchOperationOptions,
+  type BatchInscriptionOptions,
+  type BatchInscriptionResult,
+  type ValidationResult as BatchValidationResult
+} from './lifecycle/BatchOperations.js';
+
+// Kind system exports
+export {
+  OriginalKind,
+  KindRegistry,
+  type DependencyRef,
+  type BaseManifest,
+  type AppMetadata,
+  type AgentMetadata,
+  type ModuleMetadata,
+  type DatasetMetadata,
+  type MediaMetadata,
+  type DocumentMetadata,
+  type KindMetadataMap,
+  type KindMetadata,
+  type OriginalManifest,
+  type AppManifest,
+  type AgentManifest,
+  type ModuleManifest,
+  type DatasetManifest,
+  type MediaManifest,
+  type DocumentManifest,
+  type AnyManifest,
+  type ValidationResult as KindValidationResult,
+  type ValidationError as KindValidationError,
+  type ValidationWarning,
+  type CreateTypedOriginalOptions,
+  type KindValidator,
+  BaseKindValidator,
+  ValidationUtils,
+  AppValidator,
+  AgentValidator,
+  ModuleValidator,
+  DatasetValidator,
+  MediaValidator,
+  DocumentValidator,
+} from './kinds/index.js';
+
+// Utility exports
+export * from './utils/validation.js';
+export * from './utils/satoshi-validation.js';
+export * from './utils/serialization.js';
+export * from './utils/retry.js';
+export * from './utils/telemetry.js';
+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';
+export type { OrdinalsProvider, FeeOracleAdapter, StorageAdapter } from './adapters/types.js';
+
+// CEL (Cryptographic Event Log) exports
+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';
+
+// Default export
+export default OriginalsSDK;

package/src/kinds/KindRegistry.ts

@@ -0,0 +1,320 @@
+/**
+ * Kind Registry
+ * 
+ * Central registry for Original kinds, providing validation and type management.
+ */
+
+import { 
+  OriginalKind, 
+  type OriginalManifest, 
+  type ValidationResult, 
+  type CreateTypedOriginalOptions,
+} from './types';
+import { 
+  type KindValidator,
+  ValidationUtils,
+  AppValidator,
+  AgentValidator,
+  ModuleValidator,
+  DatasetValidator,
+  MediaValidator,
+  DocumentValidator,
+} from './validators';
+
+/**
+ * Registry for Original kinds
+ * 
+ * Provides centralized validation and type information for all kinds.
+ */
+export class KindRegistry {
+  private static instance: KindRegistry;
+  private validators: Map<OriginalKind, KindValidator<OriginalKind>>;
+  
+  private constructor() {
+    this.validators = new Map();
+    this.registerDefaultValidators();
+  }
+  
+  /**
+   * Get the singleton instance
+   */
+  static getInstance(): KindRegistry {
+    if (!KindRegistry.instance) {
+      KindRegistry.instance = new KindRegistry();
+    }
+    return KindRegistry.instance;
+  }
+  
+  /**
+   * Register default validators for all built-in kinds
+   */
+  private registerDefaultValidators(): void {
+    this.validators.set(OriginalKind.App, new AppValidator());
+    this.validators.set(OriginalKind.Agent, new AgentValidator());
+    this.validators.set(OriginalKind.Module, new ModuleValidator());
+    this.validators.set(OriginalKind.Dataset, new DatasetValidator());
+    this.validators.set(OriginalKind.Media, new MediaValidator());
+    this.validators.set(OriginalKind.Document, new DocumentValidator());
+  }
+  
+  /**
+   * Register a custom validator for a kind
+   * Can be used to override built-in validators or add new kinds
+   */
+  registerValidator<K extends OriginalKind>(
+    kind: K, 
+    validator: KindValidator<K>
+  ): void {
+    this.validators.set(kind, validator as KindValidator<OriginalKind>);
+  }
+  
+  /**
+   * Get the validator for a kind
+   */
+  getValidator<K extends OriginalKind>(kind: K): KindValidator<K> | undefined {
+    return this.validators.get(kind) as KindValidator<K> | undefined;
+  }
+  
+  /**
+   * Check if a kind is registered
+   */
+  hasKind(kind: OriginalKind): boolean {
+    return this.validators.has(kind);
+  }
+  
+  /**
+   * Get all registered kinds
+   */
+  getRegisteredKinds(): OriginalKind[] {
+    return Array.from(this.validators.keys());
+  }
+  
+  /**
+   * Validate a manifest
+   * 
+   * @param manifest - The manifest to validate
+   * @param options - Validation options
+   * @returns Validation result
+   */
+  validate<K extends OriginalKind>(
+    manifest: OriginalManifest<K>,
+    options?: CreateTypedOriginalOptions
+  ): ValidationResult {
+    // First check if kind is valid
+    if (!manifest.kind) {
+      return ValidationUtils.failure([
+        ValidationUtils.error('MISSING_KIND', 'Manifest must specify a kind', 'kind'),
+      ]);
+    }
+    
+    // Check if kind is registered
+    if (!this.hasKind(manifest.kind)) {
+      return ValidationUtils.failure([
+        ValidationUtils.error(
+          'UNKNOWN_KIND',
+          `Unknown kind: "${manifest.kind}". Registered kinds: ${this.getRegisteredKinds().join(', ')}`,
+          'kind',
+          manifest.kind,
+        ),
+      ]);
+    }
+    
+    // Get validator and run validation
+    const validator = this.getValidator(manifest.kind);
+    if (!validator) {
+      return ValidationUtils.failure([
+        ValidationUtils.error('VALIDATOR_NOT_FOUND', `No validator found for kind: ${manifest.kind}`, 'kind'),
+      ]);
+    }
+    
+    const result = validator.validate(manifest);
+    
+    // In strict mode, treat warnings as errors
+    if (options?.strictMode && result.warnings.length > 0) {
+      const warningErrors = result.warnings.map(w => 
+        ValidationUtils.error(
+          `STRICT_${w.code}`,
+          `[Warning treated as error] ${w.message}`,
+          w.path,
+        )
+      );
+      return ValidationUtils.failure([...result.errors, ...warningErrors], []);
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Validate a manifest and throw if invalid
+   */
+  validateOrThrow<K extends OriginalKind>(
+    manifest: OriginalManifest<K>,
+    options?: CreateTypedOriginalOptions
+  ): void {
+    if (options?.skipValidation) {
+      return;
+    }
+    
+    const result = this.validate(manifest, options);
+    
+    if (!result.isValid) {
+      const errorMessages = result.errors.map(e => {
+        const path = e.path ? ` at ${e.path}` : '';
+        return `[${e.code}]${path}: ${e.message}`;
+      });
+      
+      throw new Error(`Manifest validation failed:\n${errorMessages.join('\n')}`);
+    }
+  }
+  
+  /**
+   * Check if a value is a valid OriginalKind
+   */
+  static isValidKind(value: unknown): value is OriginalKind {
+    return typeof value === 'string' && Object.values(OriginalKind).includes(value as OriginalKind);
+  }
+  
+  /**
+   * Parse a kind string to OriginalKind
+   * Accepts both full URIs (originals:kind:app) and short names (app)
+   */
+  static parseKind(value: string): OriginalKind | null {
+    // Check if it's already a full kind URI
+    if (KindRegistry.isValidKind(value)) {
+      return value;
+    }
+    
+    // Try to match short name
+    const normalized = value.toLowerCase().trim();
+    for (const kind of Object.values(OriginalKind)) {
+      const shortName = kind.split(':').pop()?.toLowerCase();
+      if (shortName === normalized) {
+        return kind;
+      }
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Get the short name of a kind (e.g., "app" from "originals:kind:app")
+   */
+  static getShortName(kind: OriginalKind): string {
+    return kind.split(':').pop() || kind;
+  }
+  
+  /**
+   * Get human-readable display name for a kind
+   */
+  static getDisplayName(kind: OriginalKind): string {
+    const shortName = KindRegistry.getShortName(kind);
+    return shortName.charAt(0).toUpperCase() + shortName.slice(1);
+  }
+  
+  /**
+   * Create an empty manifest template for a kind
+   * Useful for scaffolding new Originals
+   */
+  static createTemplate<K extends OriginalKind>(
+    kind: K,
+    name: string,
+    version = '1.0.0'
+  ): Partial<OriginalManifest<K>> {
+    const base = {
+      kind,
+      name,
+      version,
+      resources: [],
+    };
+    
+    // Add kind-specific metadata templates
+    switch (kind) {
+      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
+        } as any;
+        return {
+          ...base,
+          // 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
+        } as any;
+        return {
+          ...base,
+          // 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
+        } as any;
+        return {
+          ...base,
+          // 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
+        } as any;
+        return {
+          ...base,
+          // 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
+        } as any;
+        return {
+          ...base,
+          // 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
+        } as any;
+        return {
+          ...base,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          metadata: documentMetadata,
+        };
+      }
+        
+      default:
+        return base;
+    }
+  }
+}
+

package/src/kinds/index.ts

@@ -0,0 +1,74 @@
+/**
+ * Originals Kind System
+ * 
+ * Provides typed "Kinds" for Originals - a classification system that
+ * enables kind-specific validation, metadata schemas, and behaviors.
+ * 
+ * @example
+ * ```typescript
+ * import { OriginalKind, KindRegistry } from '@originals/sdk';
+ * 
+ * // Create an App Original manifest
+ * const appManifest = {
+ *   kind: OriginalKind.App,
+ *   name: 'MyApp',
+ *   version: '1.0.0',
+ *   resources: [entrypointResource],
+ *   metadata: {
+ *     runtime: 'node',
+ *     entrypoint: 'index.js',
+ *   },
+ * };
+ * 
+ * // Validate the manifest
+ * const registry = KindRegistry.getInstance();
+ * const result = registry.validate(appManifest);
+ * if (!result.isValid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+
+// Type exports
+export {
+  OriginalKind,
+  type DependencyRef,
+  type BaseManifest,
+  type AppMetadata,
+  type AgentMetadata,
+  type ModuleMetadata,
+  type DatasetMetadata,
+  type MediaMetadata,
+  type DocumentMetadata,
+  type KindMetadataMap,
+  type KindMetadata,
+  type OriginalManifest,
+  type AppManifest,
+  type AgentManifest,
+  type ModuleManifest,
+  type DatasetManifest,
+  type MediaManifest,
+  type DocumentManifest,
+  type AnyManifest,
+  type ValidationResult,
+  type ValidationError,
+  type ValidationWarning,
+  type CreateTypedOriginalOptions,
+} from './types';
+
+// Registry export
+export { KindRegistry } from './KindRegistry';
+
+// Validator exports (for extension/customization)
+export {
+  type KindValidator,
+  BaseKindValidator,
+  ValidationUtils,
+  AppValidator,
+  AgentValidator,
+  ModuleValidator,
+  DatasetValidator,
+  MediaValidator,
+  DocumentValidator,
+} from './validators';
+