@originals/sdk 1.1.0

package/tests/integration/TelemetryIntegration.test.ts

@@ -0,0 +1,395 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { OriginalsSDK } from '../../src/core/OriginalsSDK';
+import type { OriginalsConfig } from '../../src/types';
+import type { LogOutput, LogEntry } from '../../src/utils/Logger';
+
+describe('Telemetry Integration', () => {
+  let logEntries: LogEntry[];
+  let mockOutput: LogOutput;
+  let config: OriginalsConfig;
+  
+  beforeEach(() => {
+    logEntries = [];
+    mockOutput = {
+      write: (entry: LogEntry) => {
+        logEntries.push(entry);
+      }
+    };
+    
+    config = {
+      network: 'regtest',
+      defaultKeyType: 'ES256K',
+      logging: {
+        level: 'debug',
+        outputs: [mockOutput]
+      },
+      metrics: {
+        enabled: true
+      }
+    };
+  });
+  
+  describe('SDK initialization', () => {
+    test('should log SDK initialization', () => {
+      const sdk = new OriginalsSDK(config);
+      
+      // Should have logged initialization
+      const initLogs = logEntries.filter(e => e.message.includes('Initializing'));
+      expect(initLogs.length).toBeGreaterThan(0);
+      
+      const successLogs = logEntries.filter(e => e.message.includes('initialized successfully'));
+      expect(successLogs.length).toBeGreaterThan(0);
+    });
+    
+    test('should have logger and metrics accessible', () => {
+      const sdk = new OriginalsSDK(config);
+      
+      expect(sdk.logger).toBeDefined();
+      expect(sdk.metrics).toBeDefined();
+    });
+  });
+  
+  describe('lifecycle operations with logging', () => {
+    test('should log asset creation', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'info',
+          outputs: [mockOutput]
+        }
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      logEntries = []; // Reset log entries
+      
+      const asset = await sdk.lifecycle.createAsset(resources);
+      
+      // Should have logged asset creation
+      const creationLogs = logEntries.filter(e => e.message.includes('Creating asset'));
+      expect(creationLogs.length).toBeGreaterThan(0);
+      
+      const successLogs = logEntries.filter(e => e.message.includes('Asset created successfully'));
+      expect(successLogs.length).toBeGreaterThan(0);
+      
+      // Check that metrics were recorded
+      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
+      expect(lifecycleMetrics.assetsCreated).toBeGreaterThan(0);
+    });
+    
+    test('should log with performance timing', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'debug',
+          outputs: [mockOutput]
+        }
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      logEntries = [];
+      
+      await sdk.lifecycle.createAsset(resources);
+      
+      // Should have logged with duration
+      const timedLogs = logEntries.filter(e => 
+        e.message.includes('completed') && e.duration !== undefined
+      );
+      expect(timedLogs.length).toBeGreaterThan(0);
+      
+      // Duration should be reasonable
+      const duration = timedLogs[0].duration!;
+      expect(duration).toBeGreaterThan(0);
+      expect(duration).toBeLessThan(10000); // Less than 10 seconds
+    });
+  });
+  
+  describe('event logging integration', () => {
+    test('should automatically log events', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'info',
+          outputs: [mockOutput],
+          eventLogging: {
+            'asset:created': 'info'
+          }
+        }
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      logEntries = [];
+      
+      const asset = await sdk.lifecycle.createAsset(resources);
+      
+      // Wait for microtask (event is deferred)
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      // Should have logged the asset:created event
+      const eventLogs = logEntries.filter(e => e.context.includes('Events'));
+      expect(eventLogs.length).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('metrics collection', () => {
+    test('should collect metrics from lifecycle operations', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        metrics: {
+          enabled: true
+        }
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      await sdk.lifecycle.createAsset(resources);
+      await sdk.lifecycle.createAsset(resources);
+      
+      // Get metrics from LifecycleManager
+      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
+      
+      expect(lifecycleMetrics.assetsCreated).toBe(2);
+    });
+    
+    test('should export metrics in JSON format', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K'
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      await sdk.lifecycle.createAsset(resources);
+      
+      const lifecycleMetrics = (sdk.lifecycle as any).metrics;
+      const json = lifecycleMetrics.export('json');
+      
+      expect(() => JSON.parse(json)).not.toThrow();
+      
+      const parsed = JSON.parse(json);
+      expect(parsed.assetsCreated).toBeGreaterThan(0);
+    });
+    
+    test('should export metrics in Prometheus format', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K'
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      await sdk.lifecycle.createAsset(resources);
+      
+      const lifecycleMetrics = (sdk.lifecycle as any).metrics;
+      const prometheus = lifecycleMetrics.export('prometheus');
+      
+      expect(prometheus).toContain('originals_assets_created_total');
+    });
+  });
+  
+  describe('error logging', () => {
+    test('should log errors during operations', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'error',
+          outputs: [mockOutput]
+        }
+      });
+      
+      logEntries = [];
+      
+      // Try to create asset with invalid resources
+      try {
+        await sdk.lifecycle.createAsset([]);
+      } catch (error) {
+        // Expected to fail
+      }
+      
+      // Should have logged the error
+      const errorLogs = logEntries.filter(e => e.level === 'error');
+      expect(errorLogs.length).toBeGreaterThan(0);
+    });
+    
+    test('should record error metrics', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K'
+      });
+      
+      // Try to create asset with invalid resources
+      try {
+        await sdk.lifecycle.createAsset([]);
+      } catch (error) {
+        // Expected to fail
+      }
+      
+      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
+      
+      // Should have recorded an error
+      expect(Object.keys(lifecycleMetrics.errors).length).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('child loggers', () => {
+    test('should use hierarchical context in logs', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'info',
+          outputs: [mockOutput]
+        }
+      });
+      
+      const childLogger = sdk.logger.child('TestModule');
+      
+      logEntries = [];
+      childLogger.info('Test message');
+      
+      expect(logEntries.length).toBe(1);
+      expect(logEntries[0].context).toBe('SDK:TestModule');
+    });
+  });
+  
+  describe('configuration options', () => {
+    test('should respect log level configuration', () => {
+      const sdk = new OriginalsSDK({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'warn',
+          outputs: [mockOutput]
+        }
+      });
+      
+      logEntries = [];
+      
+      sdk.logger.debug('Debug message');
+      sdk.logger.info('Info message');
+      sdk.logger.warn('Warn message');
+      
+      // Only warn and above should be logged
+      expect(logEntries.length).toBe(1);
+      expect(logEntries[0].level).toBe('warn');
+    });
+    
+    test('should support custom event logging configuration', async () => {
+      const sdk = OriginalsSDK.create({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'info',
+          outputs: [mockOutput],
+          eventLogging: {
+            'asset:created': 'info',
+            'asset:migrated': false // Disable migration logging
+          }
+        }
+      });
+      
+      const resources = [
+        {
+          id: 'test-resource',
+          type: 'text',
+          contentType: 'text/plain',
+          hash: 'abc123',
+          content: 'Hello World'
+        }
+      ];
+      
+      logEntries = [];
+      
+      await sdk.lifecycle.createAsset(resources);
+      
+      // Wait for events
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      // Should have logs (configuration doesn't crash)
+      expect(logEntries.length).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('data sanitization', () => {
+    test('should sanitize sensitive data in logs', () => {
+      const sdk = new OriginalsSDK({
+        network: 'regtest',
+        defaultKeyType: 'ES256K',
+        logging: {
+          level: 'info',
+          outputs: [mockOutput],
+          sanitizeLogs: true
+        }
+      });
+      
+      logEntries = [];
+      
+      sdk.logger.info('User operation', {
+        username: 'alice',
+        privateKey: 'z6Mk...',
+        operation: 'create'
+      });
+      
+      expect(logEntries.length).toBe(1);
+      expect(logEntries[0].data.username).toBe('alice');
+      expect(logEntries[0].data.privateKey).toBe('[REDACTED]');
+      expect(logEntries[0].data.operation).toBe('create');
+    });
+  });
+});
+

package/tests/integration/WebVhPublish.test.ts

@@ -0,0 +1,48 @@
+/** Canonical test aggregator created by combine-tests script. */
+
+/** Inlined from WebVhPublish.integration.part.ts */
+import { describe, test, expect } from 'bun:test';
+import { OriginalsSDK } from '../../src';
+import { AssetResource } from '../../src/types';
+import { MockKeyStore } from '../mocks/MockKeyStore';
+
+describe('WebVH publish end-to-end', () => {
+  const keyStore = new MockKeyStore();
+  const sdk = OriginalsSDK.create({ network: 'regtest', keyStore });
+  const publisherDid = 'did:webvh:example.com:alice';
+
+  test('createAsset → publishToWeb yields did:webvh and provenance event', async () => {
+    const resources: AssetResource[] = [
+      { id: 'r1', type: 'data', contentType: 'text/plain', hash: 'abc123', content: 'hello' }
+    ];
+
+    const asset = await sdk.lifecycle.createAsset(resources);
+    const published = await sdk.lifecycle.publishToWeb(asset, publisherDid);
+    
+    // Asset migrated to did:webvh layer
+    expect(published.currentLayer).toBe('did:webvh');
+    expect(published.id.startsWith('did:peer:')).toBe(true);
+    
+    // Binding to publisher's did:webvh
+    const webBinding = (published as any).bindings?.['did:webvh'];
+    expect(typeof webBinding).toBe('string');
+    expect(webBinding).toBe(publisherDid);
+
+    const resolved = await sdk.did.resolveDID(webBinding!);
+    expect(resolved?.id).toBe(webBinding);
+
+    // Resources have DID-based URLs (not .well-known)
+    expect(Array.isArray(published.resources)).toBe(true);
+    for (const r of published.resources) {
+      expect(typeof r.url).toBe('string');
+      expect((r.url as string).startsWith(publisherDid)).toBe(true);
+      expect((r.url as string).includes('/resources/')).toBe(true);
+    }
+
+    // Credentials may or may not be attached (best-effort)
+    // If the publisher DID doesn't have keys, credentials won't be issued
+    // This is acceptable - the publish operation succeeds regardless
+    const creds = (published as any).credentials || [];
+    expect(Array.isArray(creds)).toBe(true);
+  });
+});

package/tests/integration/migration/peer-to-webvh.test.ts

@@ -0,0 +1,172 @@
+/**
+ * Integration tests for peer → webvh migration
+ */
+
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { OriginalsSDK } from '../../../src';
+import { MigrationManager } from '../../../src/migration';
+import { MigrationStateEnum } from '../../../src/migration/types';
+
+describe('Peer to WebVH Migration', () => {
+  let sdk: OriginalsSDK;
+  let migrationManager: MigrationManager;
+
+  beforeEach(() => {
+    // Reset singleton
+    MigrationManager.resetInstance();
+
+    // Create SDK instance
+    sdk = OriginalsSDK.create({
+      network: 'signet',
+      defaultKeyType: 'Ed25519'
+    });
+
+    // Initialize migration manager
+    migrationManager = MigrationManager.getInstance(
+      sdk['config'],
+      sdk.did,
+      sdk.credentials
+    );
+  });
+
+  test('should successfully migrate from peer to webvh', async () => {
+    // Create a peer DID
+    const resources = [
+      {
+        id: 'resource-1',
+        type: 'Image',
+        contentType: 'image/png',
+        hash: 'abc123',
+        content: 'test-content'
+      }
+    ];
+
+    const peerDid = await sdk.did.createDIDPeer(resources);
+
+    // Migrate to webvh
+    const result = await migrationManager.migrate({
+      sourceDid: peerDid.id,
+      targetLayer: 'webvh',
+      domain: 'example.com'
+    });
+
+    // Verify migration success
+    expect(result.success).toBe(true);
+    expect(result.state).toBe(MigrationStateEnum.COMPLETED);
+    expect(result.targetDid).toBeDefined();
+    expect(result.targetDid).toContain('did:webvh:');
+    expect(result.sourceDid).toBe(peerDid.id);
+
+    // Verify audit record was created
+    expect(result.auditRecord).toBeDefined();
+    expect(result.auditRecord.finalState).toBe(MigrationStateEnum.COMPLETED);
+    expect(result.auditRecord.errors).toHaveLength(0);
+  });
+
+  test('should fail migration with invalid domain', async () => {
+    const resources = [
+      {
+        id: 'resource-1',
+        type: 'Image',
+        contentType: 'image/png',
+        hash: 'abc123'
+      }
+    ];
+
+    const peerDid = await sdk.did.createDIDPeer(resources);
+
+    // Attempt migration without domain
+    const result = await migrationManager.migrate({
+      sourceDid: peerDid.id,
+      targetLayer: 'webvh'
+      // Missing domain
+    });
+
+    // Verify migration failed
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(result.error?.code).toBe('VALIDATION_FAILED');
+  });
+
+  test('should track migration state throughout process', async () => {
+    const resources = [
+      {
+        id: 'resource-1',
+        type: 'Image',
+        contentType: 'image/png',
+        hash: 'abc123'
+      }
+    ];
+
+    const peerDid = await sdk.did.createDIDPeer(resources);
+
+    // Start migration
+    const migrationPromise = migrationManager.migrate({
+      sourceDid: peerDid.id,
+      targetLayer: 'webvh',
+      domain: 'example.com'
+    });
+
+    const result = await migrationPromise;
+
+    // Check final state
+    const state = await migrationManager.getMigrationStatus(result.migrationId);
+    expect(state).toBeDefined();
+    expect(state.state).toBe(MigrationStateEnum.COMPLETED);
+    expect(state.progress).toBe(100);
+  });
+
+  test('should get migration history for DID', async () => {
+    const resources = [
+      {
+        id: 'resource-1',
+        type: 'Image',
+        contentType: 'image/png',
+        hash: 'abc123'
+      }
+    ];
+
+    const peerDid = await sdk.did.createDIDPeer(resources);
+
+    // Perform migration
+    await migrationManager.migrate({
+      sourceDid: peerDid.id,
+      targetLayer: 'webvh',
+      domain: 'example.com'
+    });
+
+    // Get migration history
+    const history = await migrationManager.getMigrationHistory(peerDid.id);
+
+    expect(history).toBeDefined();
+    expect(history.length).toBeGreaterThan(0);
+    expect(history[0].sourceDid).toBe(peerDid.id);
+    expect(history[0].targetLayer).toBe('webvh');
+  });
+
+  test('should estimate migration cost', async () => {
+    const resources = [
+      {
+        id: 'resource-1',
+        type: 'Image',
+        contentType: 'image/png',
+        hash: 'abc123'
+      }
+    ];
+
+    const peerDid = await sdk.did.createDIDPeer(resources);
+
+    // Estimate cost
+    const cost = await migrationManager.estimateMigrationCost(
+      peerDid.id,
+      'webvh'
+    );
+
+    expect(cost).toBeDefined();
+    expect(cost.totalCost).toBeDefined();
+    expect(cost.networkFees).toBeDefined();
+    expect(cost.storageCost).toBeDefined();
+    expect(cost.totalCost).toBeDefined();
+    expect(cost.currency).toBe('sats');
+  });
+});