@originals/sdk 1.4.2 → 1.4.5

package/src/resources/types.ts

@@ -1,202 +0,0 @@
-/**
- * Resource types for the Originals SDK ResourceManager.
- * 
- * Resources in the Originals protocol are immutable, content-addressed entities
- * that can be versioned through a linked hash chain.
- */
-
-import { AssetResource } from '../types/common';
-
-/**
- * Supported resource types for categorization
- */
-export type ResourceType = 
-  | 'image'
-  | 'text'
-  | 'code'
-  | 'data'
-  | 'audio'
-  | 'video'
-  | 'document'
-  | 'binary'
-  | 'other';
-
-/**
- * Options for creating a new resource
- */
-export interface ResourceOptions {
-  /** Logical resource ID (optional - will be generated if not provided) */
-  id?: string;
-  
-  /** Resource type category */
-  type: ResourceType;
-  
-  /** MIME content type (e.g., 'text/plain', 'image/png') */
-  contentType: string;
-  
-  /** Optional URL if resource is externally hosted */
-  url?: string;
-  
-  /** Optional description of the resource */
-  description?: string;
-  
-  /** Maximum allowed size in bytes (optional, uses default if not specified) */
-  maxSize?: number;
-}
-
-/**
- * Options for updating an existing resource
- */
-export interface ResourceUpdateOptions {
-  /** New content type (optional - inherits from previous version if not specified) */
-  contentType?: string;
-  
-  /** Description of changes made in this version */
-  changes?: string;
-}
-
-/**
- * Result of resource validation
- */
-export interface ResourceValidationResult {
-  /** Whether the resource is valid */
-  valid: boolean;
-  
-  /** Array of error messages if validation failed */
-  errors: string[];
-  
-  /** Array of warning messages (non-fatal issues) */
-  warnings: string[];
-}
-
-/**
- * A resource with its content and metadata
- */
-export interface Resource extends AssetResource {
-  /** The actual content (for in-memory resources) */
-  content?: string;
-  
-  /** Binary content as base64-encoded string */
-  contentBase64?: string;
-  
-  /** Description of the resource */
-  description?: string;
-}
-
-/**
- * Complete history of a resource including all versions
- */
-export interface ResourceVersionHistory {
-  /** Logical resource ID (stable across all versions) */
-  resourceId: string;
-  
-  /** All versions in chronological order (oldest first) */
-  versions: Resource[];
-  
-  /** The current (latest) version */
-  currentVersion: Resource;
-  
-  /** Total number of versions */
-  versionCount: number;
-}
-
-/**
- * Configuration for the ResourceManager
- */
-export interface ResourceManagerConfig {
-  /** Default maximum resource size in bytes (default: 10MB) */
-  defaultMaxSize?: number;
-  
-  /** Whether to store content in memory (default: true) */
-  storeContent?: boolean;
-  
-  /** Allowed MIME types (if empty, all types allowed) */
-  allowedContentTypes?: string[];
-  
-  /** Whether to enable strict MIME type validation (default: true) */
-  strictMimeValidation?: boolean;
-}
-
-/**
- * Common MIME types and their resource type mappings
- */
-export const MIME_TYPE_MAP: Record<string, ResourceType> = {
-  // Images
-  'image/png': 'image',
-  'image/jpeg': 'image',
-  'image/gif': 'image',
-  'image/webp': 'image',
-  'image/svg+xml': 'image',
-  'image/bmp': 'image',
-  'image/tiff': 'image',
-  
-  // Text
-  'text/plain': 'text',
-  'text/html': 'text',
-  'text/css': 'text',
-  'text/csv': 'text',
-  'text/markdown': 'text',
-  
-  // Code
-  'text/javascript': 'code',
-  'application/javascript': 'code',
-  'text/typescript': 'code',
-  'application/typescript': 'code',
-  'text/x-python': 'code',
-  'application/x-python-code': 'code',
-  'text/x-rust': 'code',
-  'text/x-go': 'code',
-  'text/x-java': 'code',
-  'text/x-c': 'code',
-  'text/x-cpp': 'code',
-  
-  // Data formats
-  'application/json': 'data',
-  'application/xml': 'data',
-  'text/xml': 'data',
-  'application/yaml': 'data',
-  'text/yaml': 'data',
-  'application/toml': 'data',
-  
-  // Documents
-  'application/pdf': 'document',
-  'application/msword': 'document',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'document',
-  'application/vnd.ms-excel': 'document',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'document',
-  'application/vnd.ms-powerpoint': 'document',
-  'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'document',
-  
-  // Audio
-  'audio/mpeg': 'audio',
-  'audio/mp3': 'audio',
-  'audio/wav': 'audio',
-  'audio/ogg': 'audio',
-  'audio/webm': 'audio',
-  'audio/flac': 'audio',
-  
-  // Video
-  'video/mp4': 'video',
-  'video/webm': 'video',
-  'video/ogg': 'video',
-  'video/quicktime': 'video',
-  'video/x-msvideo': 'video',
-  
-  // Binary
-  'application/octet-stream': 'binary',
-  'application/zip': 'binary',
-  'application/gzip': 'binary',
-  'application/x-tar': 'binary',
-  'application/wasm': 'binary',
-};
-
-/**
- * Default configuration values
- */
-export const DEFAULT_RESOURCE_CONFIG: Required<ResourceManagerConfig> = {
-  defaultMaxSize: 10 * 1024 * 1024, // 10MB
-  storeContent: true,
-  allowedContentTypes: [],
-  strictMimeValidation: true,
-};
-

package/src/storage/LocalStorageAdapter.ts

@@ -1,61 +0,0 @@
-// Local adapter is optional in this environment; keeping implementation but avoid Node typings
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { GetObjectResult, LocalStorageAdapterOptions, StorageAdapter } from './StorageAdapter';
-
-export class LocalStorageAdapter implements StorageAdapter {
-  private baseDir: string;
-  private baseUrl?: string;
-
-  constructor(options: LocalStorageAdapterOptions) {
-    this.baseDir = options.baseDir;
-    this.baseUrl = options.baseUrl;
-  }
-
-  private resolvePath(domain: string, objectPath: string): string {
-    const safeDomain = domain.replace(/[^a-zA-Z0-9.-]/g, '_');
-    const cleanPath = objectPath.replace(/^\/+/, '');
-    return path.join(this.baseDir, safeDomain, cleanPath);
-  }
-
-  private toUrl(domain: string, objectPath: string): string {
-    const cleanPath = objectPath.replace(/^\/+/, '');
-    if (this.baseUrl) {
-      const trimmed = this.baseUrl.replace(/\/$/, '');
-      return `${trimmed}/${domain}/${cleanPath}`;
-    }
-    return `file://${this.resolvePath(domain, cleanPath)}`;
-  }
-
-  async putObject(domain: string, objectPath: string, content: Uint8Array | string): Promise<string> {
-    const fullPath = this.resolvePath(domain, objectPath);
-    await fs.mkdir(path.dirname(fullPath), { recursive: true });
-    const data = typeof content === 'string' ? Buffer.from(content) : Buffer.from(content);
-    await fs.writeFile(fullPath, data);
-    return this.toUrl(domain, objectPath);
-  }
-
-  async getObject(domain: string, objectPath: string): Promise<GetObjectResult | null> {
-    const fullPath = this.resolvePath(domain, objectPath);
-    try {
-      const content = await fs.readFile(fullPath);
-      return { content: new Uint8Array(content) };
-    } catch (e: any) {
-      if (e && e.code === 'ENOENT') return null;
-      throw e;
-    }
-  }
-
-  async exists(domain: string, objectPath: string): Promise<boolean> {
-    const fullPath = this.resolvePath(domain, objectPath);
-    try {
-      await fs.access(fullPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-

package/src/storage/MemoryStorageAdapter.ts

@@ -1,29 +0,0 @@
-import { GetObjectResult, StorageAdapter } from './StorageAdapter';
-
-type DomainPath = string;
-
-const globalStore: Map<DomainPath, Uint8Array> = new Map();
-
-function key(domain: string, objectPath: string): string {
-  const cleanPath = objectPath.replace(/^\/+/, '');
-  return `${domain}::${cleanPath}`;
-}
-
-export class MemoryStorageAdapter implements StorageAdapter {
-  async putObject(domain: string, objectPath: string, content: Uint8Array | string): Promise<string> {
-    const data = typeof content === 'string' ? new TextEncoder().encode(content) : content;
-    globalStore.set(key(domain, objectPath), data);
-    return `mem://${domain}/${objectPath.replace(/^\/+/, '')}`;
-  }
-
-  async getObject(domain: string, objectPath: string): Promise<GetObjectResult | null> {
-    const stored = globalStore.get(key(domain, objectPath));
-    if (!stored) return null;
-    return { content: stored };
-  }
-
-  async exists(domain: string, objectPath: string): Promise<boolean> {
-    return globalStore.has(key(domain, objectPath));
-  }
-}
-

package/src/storage/StorageAdapter.ts

@@ -1,25 +0,0 @@
-export interface PutOptions {
-  contentType?: string;
-}
-
-export interface GetObjectResult {
-  content: Uint8Array;
-  contentType?: string;
-}
-
-export interface StorageAdapter {
-  // Writes content at a path under a logical domain root and returns a public URL
-  putObject(domain: string, path: string, content: Uint8Array | string, options?: PutOptions): Promise<string>;
-
-  // Reads content from a path under a domain root
-  getObject(domain: string, path: string): Promise<GetObjectResult | null>;
-
-  // Checks whether a path exists
-  exists(domain: string, path: string): Promise<boolean>;
-}
-
-export interface LocalStorageAdapterOptions {
-  baseDir: string;
-  baseUrl?: string;
-}
-

package/src/types/bitcoin.ts

@@ -1,98 +0,0 @@
-// Bitcoin/Ordinals types
-export interface OrdinalsInscription {
-  satoshi: string; // Unique satoshi identifier
-  inscriptionId: string;
-  content: Buffer;
-  contentType: string;
-  txid: string;
-  vout: number;
-  blockHeight?: number;
-}
-
-export interface BitcoinTransaction {
-  txid: string;
-  vin: TransactionInput[];
-  vout: TransactionOutput[];
-  fee: number;
-  blockHeight?: number;
-  confirmations?: number;
-}
-
-export interface TransactionInput {
-  txid: string;
-  vout: number;
-  scriptSig?: string;
-  witness?: string[];
-}
-
-export interface TransactionOutput {
-  value: number; // satoshis
-  scriptPubKey: string;
-  address?: string;
-}
-
-export interface Utxo {
-  txid: string;
-  vout: number;
-  value: number; // satoshis
-  scriptPubKey?: string;
-  address?: string;
-  inscriptions?: string[]; // inscription ids located on this outpoint
-  locked?: boolean; // if true, cannot be spent due to wallet locks
-}
-
-/**
- * Extended UTXO interface that tracks whether it contains an Ordinals resource (inscription)
- */
-export interface ResourceUtxo extends Utxo {
-  /** True if this UTXO contains an inscription or other Ordinals resource */
-  hasResource?: boolean;
-}
-
-/**
- * Strategy for selecting UTXOs
- */
-export type UtxoSelectionStrategy = 'minimize_change' | 'minimize_inputs' | 'optimize_size';
-
-/**
- * Options for resource-aware UTXO selection
- */
-export interface ResourceUtxoSelectionOptions {
-  /** Required amount in satoshis */
-  requiredAmount: number;
-  /** Fee rate in satoshis per vbyte */
-  feeRate: number;
-  /** Allow using UTXOs that contain resources (default: false) */
-  allowResourceUtxos?: boolean;
-  /** Prefer older UTXOs (default: false) */
-  preferOlder?: boolean;
-  /** Prefer UTXOs with value closer to required amount (default: false) */
-  preferCloserAmount?: boolean;
-  /** List of UTXO IDs to avoid using (format: "txid:vout") */
-  avoidUtxoIds?: string[];
-}
-
-/**
- * Result of resource-aware UTXO selection
- */
-export interface ResourceUtxoSelectionResult {
-  /** Selected UTXOs for the transaction */
-  selectedUtxos: ResourceUtxo[];
-  /** Total value of selected UTXOs */
-  totalSelectedValue: number;
-  /** Estimated transaction fee in satoshis */
-  estimatedFee: number;
-  /** Change amount in satoshis (0 if less than dust) */
-  changeAmount: number;
-}
-
-export const DUST_LIMIT_SATS = 546;
-
-export interface KeyPair {
-  privateKey: string; // multibase encoded
-  publicKey: string;  // multibase encoded
-}
-
-export type KeyType = 'ES256K' | 'Ed25519' | 'ES256';
-
-

package/src/types/common.ts

@@ -1,92 +0,0 @@
-import { StorageAdapter, FeeOracleAdapter, OrdinalsProvider } from '../adapters';
-import { TelemetryHooks } from '../utils/telemetry';
-import type { LogLevel, LogOutput } from '../utils/Logger';
-import type { EventLoggingConfig } from '../utils/EventLogger';
-import type { WebVHNetworkName } from './network';
-
-// Base types for the Originals protocol
-export type LayerType = 'did:peer' | 'did:webvh' | 'did:btco';
-
-export interface OriginalsConfig {
-  network: 'mainnet' | 'regtest' | 'signet';
-  bitcoinRpcUrl?: string;
-  defaultKeyType: 'ES256K' | 'Ed25519' | 'ES256';
-  keyStore?: KeyStore;
-  enableLogging?: boolean;
-  // WebVH network selection (defaults to 'pichu' - production)
-  webvhNetwork?: WebVHNetworkName;
-  // Optional pluggable adapters
-  storageAdapter?: StorageAdapter;
-  feeOracle?: FeeOracleAdapter;
-  ordinalsProvider?: OrdinalsProvider;
-  // Optional telemetry hooks
-  telemetry?: TelemetryHooks;
-  // Enhanced logging configuration
-  logging?: {
-    level?: LogLevel;
-    outputs?: LogOutput[];
-    includeTimestamps?: boolean;
-    includeContext?: boolean;
-    eventLogging?: EventLoggingConfig;
-    sanitizeLogs?: boolean; // Remove sensitive data
-  };
-  // Metrics configuration
-  metrics?: {
-    enabled?: boolean;
-    exportFormat?: 'json' | 'prometheus';
-    collectCache?: boolean;
-  };
-}
-
-export interface AssetResource {
-  id: string;                      // Logical resource ID (stable across versions)
-  type: string;                    // 'image', 'text', 'code', 'data', etc.
-  url?: string;
-  content?: string;
-  contentType: string;
-  hash: string;                    // Content hash (unique per version)
-  size?: number;
-  version?: number;                // Version number (default 1)
-  previousVersionHash?: string;    // Link to previous version (by content hash)
-  createdAt?: string;              // ISO timestamp of when this version was created
-}
-
-export interface KeyStore {
-  getPrivateKey(verificationMethodId: string): Promise<string | null>;
-  setPrivateKey(verificationMethodId: string, privateKey: string): Promise<void>;
-}
-
-/**
- * External signer interface for DID operations (compatible with didwebvh-ts)
- * This allows integration with external key management systems like Turnkey
- */
-export interface ExternalSigner {
-  /**
-   * Sign data and return a proof value
-   * @param input - The signing input containing document and proof
-   * @returns The proof value (typically multibase-encoded signature)
-   */
-  sign(input: { document: Record<string, unknown>; proof: Record<string, unknown> }): Promise<{ proofValue: string }>;
-  
-  /**
-   * Get the verification method ID for this signer
-   * @returns The verification method ID (e.g., "did:key:z6Mk...")
-   */
-  getVerificationMethodId(): string;
-}
-
-/**
- * External verifier interface for DID operations (compatible with didwebvh-ts)
- */
-export interface ExternalVerifier {
-  /**
-   * Verify a signature
-   * @param signature - The signature bytes
-   * @param message - The message bytes that were signed
-   * @param publicKey - The public key bytes
-   * @returns True if the signature is valid
-   */
-  verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
-}
-
-

package/src/types/credentials.ts

@@ -1,88 +0,0 @@
-import { LayerType } from './common';
-
-// Verifiable Credentials types
-export interface VerifiableCredential {
-  '@context': string[];
-  type: string[];
-  id?: string;
-  issuer: string | Issuer;
-  issuanceDate: string;
-  expirationDate?: string;
-  credentialSubject: CredentialSubject;
-  credentialStatus?: CredentialStatus;
-  proof?: Proof | Proof[];
-}
-
-export interface Issuer {
-  id: string;
-  name?: string;
-}
-
-export interface CredentialSubject {
-  id?: string;
-  [key: string]: any;
-}
-
-export interface CredentialStatus {
-  id: string;
-  type: string;
-}
-
-export interface Proof {
-  type: string;
-  created: string;
-  verificationMethod: string;
-  proofPurpose: string;
-  proofValue: string;
-}
-
-export interface VerifiablePresentation {
-  '@context': string[];
-  type: string[];
-  id?: string;
-  holder: string;
-  verifiableCredential: VerifiableCredential[];
-  proof?: Proof | Proof[];
-}
-
-export interface ResourceCreatedCredential extends VerifiableCredential {
-  credentialSubject: {
-    id: string;
-    resourceId: string;
-    resourceType: string;
-    createdAt: string;
-    creator: string;
-  };
-}
-
-export interface ResourceUpdatedCredential extends VerifiableCredential {
-  credentialSubject: {
-    id: string;
-    resourceId: string;
-    updatedAt: string;
-    updateReason?: string;
-  };
-}
-
-export interface ResourceMigratedCredential extends VerifiableCredential {
-  credentialSubject: {
-    id: string;
-    resourceId: string;
-    fromLayer: LayerType;
-    toLayer: LayerType;
-    migratedAt: string;
-    migrationReason?: string;
-  };
-}
-
-export interface KeyRecoveryCredential extends VerifiableCredential {
-  credentialSubject: {
-    id: string; // DID that was recovered
-    recoveredAt: string; // ISO 8601 timestamp
-    recoveryReason: string; // "key_compromise" or other reason
-    previousVerificationMethods: string[]; // IDs of compromised keys
-    newVerificationMethod: string; // ID of new key
-  };
-}
-
-

package/src/types/did.ts

@@ -1,31 +0,0 @@
-// W3C DID Document types
-export interface DIDDocument {
-  '@context': string[];
-  id: string;
-  verificationMethod?: VerificationMethod[];
-  authentication?: (string | VerificationMethod)[];
-  assertionMethod?: (string | VerificationMethod)[];
-  keyAgreement?: (string | VerificationMethod)[];
-  capabilityInvocation?: (string | VerificationMethod)[];
-  capabilityDelegation?: (string | VerificationMethod)[];
-  service?: ServiceEndpoint[];
-  controller?: string[];
-  alsoKnownAs?: string[];
-}
-
-export interface VerificationMethod {
-  id: string;
-  type: string;
-  controller: string;
-  publicKeyMultibase: string;
-  revoked?: string; // ISO 8601 timestamp when the key was revoked
-  compromised?: string; // ISO 8601 timestamp when the key was marked as compromised
-}
-
-export interface ServiceEndpoint {
-  id: string;
-  type: string;
-  serviceEndpoint: string | object;
-}
-
-

package/src/types/external-shims.d.ts

@@ -1,53 +0,0 @@
-declare module 'cbor-js' {
-  export function encode(value: unknown): ArrayBuffer | Uint8Array;
-  export function decode(buffer: ArrayBufferLike): unknown;
-  const _default: {
-    encode: typeof encode;
-    decode: typeof decode;
-  };
-  export default _default;
-}
-
-declare module 'multiformats/bases/base64' {
-  export const base64url: {
-    encode: (bytes: Uint8Array) => string;
-    decode: (s: string) => Uint8Array;
-  };
-}
-
-declare module 'jsonld';
-declare module 'b58';
-declare module '@aviarytech/did-peer' {
-  export interface ServiceEndpoint {
-    id: string;
-    type: string;
-    serviceEndpoint: string | Record<string, unknown>;
-    [key: string]: unknown;
-  }
-
-  export interface IDIDDocument {
-    '@context'?: string | string[];
-    id: string;
-    controller?: string | string[];
-    verificationMethod?: IDIDDocumentVerificationMethod[];
-    authentication?: Array<string | IDIDDocumentVerificationMethod>;
-    assertionMethod?: Array<string | IDIDDocumentVerificationMethod>;
-    keyAgreement?: Array<string | IDIDDocumentVerificationMethod>;
-    capabilityInvocation?: Array<string | IDIDDocumentVerificationMethod>;
-    capabilityDelegation?: Array<string | IDIDDocumentVerificationMethod>;
-    service?: ServiceEndpoint[];
-    [key: string]: unknown;
-  }
-
-  export type IDIDDocumentVerificationMethod = { id?: string; type: string; controller?: string; publicKeyMultibase?: string };
-  export function create(numalgo: number, authenticationKeys: IDIDDocumentVerificationMethod[], encryptionKeys?: IDIDDocumentVerificationMethod[], service?: ServiceEndpoint): Promise<string>;
-  export function createNumAlgo0(authenticationKey: IDIDDocumentVerificationMethod): Promise<string>;
-  export function createNumAlgo2(authenticationKeys: IDIDDocumentVerificationMethod[], encryptionKeys?: IDIDDocumentVerificationMethod[], service?: ServiceEndpoint[]): Promise<string>;
-  export function createNumAlgo4(authenticationKeys: IDIDDocumentVerificationMethod[], encryptionKeys?: IDIDDocumentVerificationMethod[], service?: ServiceEndpoint[]): Promise<string>;
-  export function resolve(did: string, repository?: Record<string, unknown>): Promise<IDIDDocument>;
-}
-
-// Global shims for non-DOM/node test environments
-declare const global: Record<string, unknown> & typeof globalThis;
-declare function setTimeout(handler: (...args: unknown[]) => void, timeout?: number, ...args: unknown[]): number;
-