@originals/sdk 1.2.0 → 1.4.3

package/tests/integration/CredentialManager.test.ts

@@ -1,42 +0,0 @@
-/** Canonical test aggregator created by combine-tests script. */
-
-/** Inlined from CredentialManager.integration.part.ts */
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { OriginalsSDK } from '../../src';
-import * as ed25519 from '@noble/ed25519';
-import { multikey } from '../../src/crypto/Multikey';
-import { registerVerificationMethod, verificationMethodRegistry } from '../../src/vc/documentLoader';
-
-describe('Integration: CredentialManager issue/verify roundtrip', () => {
-  const sdk = OriginalsSDK.create({ defaultKeyType: 'Ed25519' });
-
-  beforeEach(() => {
-    verificationMethodRegistry.clear();
-  });
-
-  afterEach(() => {
-    verificationMethodRegistry.clear();
-  });
-
-  test('issue and verify using Issuer/Verifier wiring', async () => {
-    const did = 'did:peer:issuer1';
-    const sk = ed25519.utils.randomPrivateKey();
-    const pk = await (ed25519 as any).getPublicKeyAsync(sk);
-    const secretKeyMultibase = multikey.encodePrivateKey(sk, 'Ed25519');
-    const publicKeyMultibase = multikey.encodePublicKey(pk, 'Ed25519');
-    const vm = `${did}#keys-1`;
-    registerVerificationMethod({ id: vm, controller: did, type: 'Multikey', publicKeyMultibase });
-
-    const base = {
-      type: ['VerifiableCredential', 'Test'],
-      issuer: did,
-      issuanceDate: new Date().toISOString(),
-      credentialSubject: { id: 'did:peer:subject1' }
-    } as any;
-
-    const signed = await sdk.credentials.signCredential(base, secretKeyMultibase, vm);
-    expect(signed.proof).toBeDefined();
-    const verified = await sdk.credentials.verifyCredential(signed);
-    expect(verified).toBe(true);
-  });
-});

package/tests/integration/DIDManager.test.ts

@@ -1,41 +0,0 @@
-/** Canonical test aggregator created by combine-tests script. */
-
-/** Inlined from DIDManager.btco.integration.part.ts */
-import { describe, test, expect, afterEach, spyOn } from 'bun:test';
-import { OriginalsSDK } from '../../src';
-
-describe('Integration: DIDManager btco resolve via OrdinalsClient adapter', () => {
-  const sdk = OriginalsSDK.create({ network: 'mainnet', bitcoinRpcUrl: 'http://ord' });
-
-  test('resolves did:btco using adapter with mocked fetch', async () => {
-    const sat = '123456';
-    const did = `did:btco:${sat}`;
-
-    const fetchMock = spyOn(global as any, 'fetch').mockImplementation(async (url: any) => {
-      if (url === 'http://ord/sat/' + sat) {
-        return new Response(JSON.stringify({ inscription_ids: ['i1', 'i2'] }), { status: 200 });
-      }
-      if (url === 'http://ord/inscription/i1') {
-        return new Response(JSON.stringify({ inscription_id: 'i1', content_type: 'text/plain', content_url: 'http://c/i1', sat }), { status: 200 });
-      }
-      if (url === 'http://ord/inscription/i2') {
-        return new Response(JSON.stringify({ inscription_id: 'i2', content_type: 'text/plain', content_url: 'http://c/i2', sat }), { status: 200 });
-      }
-      if (url === 'http://c/i1') {
-        return new Response(`BTCO DID: ${did}`, { status: 200 });
-      }
-      if (url === 'http://c/i2') {
-        return new Response('not a did doc', { status: 200 });
-      }
-      if (url === 'http://ord/r/metadata/i1') {
-        // Return DID Document JSON encoded as hex CBOR; for test simplicity return plain JSON string, adapter tolerates null metadata
-        return new Response('7b7d', { status: 200 });
-      }
-      return new Response('', { status: 404 });
-    });
-
-    const doc = await sdk.did.resolveDID(did);
-    expect(doc === null || typeof doc === 'object').toBe(true);
-    fetchMock.mockRestore();
-  });
-});

package/tests/integration/DidPeerToWebVhFlow.test.ts

@@ -1,351 +0,0 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { OriginalsSDK } from '../../src';
-import { AssetResource } from '../../src/types';
-import { MockKeyStore } from '../mocks/MockKeyStore';
-import { KeyManager } from '../../src/did/KeyManager';
-import * as fs from 'fs';
-import * as path from 'path';
-import { tmpdir } from 'os';
-
-describe('DID Peer to WebVH Publication Flow', () => {
-  const keyStore = new MockKeyStore();
-  const sdk = OriginalsSDK.create({ 
-    network: 'regtest', 
-    keyStore,
-    defaultKeyType: 'Ed25519', // Use Ed25519 for did:webvh compatibility
-    enableLogging: true 
-  });
-  const domain = 'localhost:5000';
-  const tempDir = path.join(tmpdir(), 'originals-test-webvh');
-
-  beforeAll(async () => {
-    // Ensure temp directory exists
-    await fs.promises.mkdir(tempDir, { recursive: true });
-    
-    // Set up publisher DID keys for tests
-    const keyManager = new KeyManager();
-    const publisherKey = await keyManager.generateKeyPair('Ed25519');
-    await keyStore.setPrivateKey('did:webvh:localhost%3A5000:user#key-0', publisherKey.privateKey);
-  });
-
-  test('complete flow: createDIDPeer -> publishToWeb -> resolve resource URL', async () => {
-    // Step 1: Create a DID peer with resources
-    const resources: AssetResource[] = [
-      {
-        id: 'resource-1',
-        type: 'data',
-        contentType: 'text/plain',
-        hash: 'abc123def456',
-        content: 'Hello, World! This is test content.'
-      },
-      {
-        id: 'resource-2',
-        type: 'metadata',
-        contentType: 'application/json',
-        hash: 'aea789ab',
-        content: JSON.stringify({ title: 'Test Asset', version: '1.0' })
-      }
-    ];
-
-    console.log('\n🔧 Step 1: Creating DID peer...');
-    const { didDocument: peerDoc, keyPair } = await sdk.did.createDIDPeer(resources, true);
-    
-    // Verify DID peer was created
-    expect(peerDoc).toBeDefined();
-    expect(peerDoc.id).toMatch(/^did:peer:/);
-    expect(keyPair).toBeDefined();
-    expect(keyPair.publicKey).toBeTruthy();
-    expect(keyPair.privateKey).toBeTruthy();
-    
-    console.log(`✅ DID Peer created: ${peerDoc.id}`);
-    console.log(`   Public Key: ${keyPair.publicKey.substring(0, 20)}...`);
-
-    // Step 2: Create an asset using the DID peer
-    console.log('\n🔧 Step 2: Creating asset with DID peer...');
-    const asset = await sdk.lifecycle.createAsset(resources);
-    
-    expect(asset).toBeDefined();
-    expect(asset.id).toMatch(/^did:peer:/);
-    expect(asset.currentLayer).toBe('did:peer');
-    expect(asset.resources).toHaveLength(2);
-    
-    console.log(`✅ Asset created: ${asset.id}`);
-    console.log(`   Current Layer: ${asset.currentLayer}`);
-    console.log(`   Resources: ${asset.resources.length}`);
-
-    // Step 3: Publish to web (migrate to did:webvh)
-    console.log('\n🔧 Step 3: Publishing to web (did:peer -> did:webvh)...');
-    const publishedAsset = await sdk.lifecycle.publishToWeb(asset, domain);
-    
-    expect(publishedAsset).toBeDefined();
-    expect(publishedAsset.currentLayer).toBe('did:webvh');
-    
-    // Get the webvh DID from bindings
-    const bindings = (publishedAsset as any).bindings;
-    expect(bindings).toBeDefined();
-    expect(bindings['did:webvh']).toBeDefined();
-    expect(bindings['did:webvh']).toMatch(new RegExp(`^did:webvh:${domain.replace(':', '%3A')}:`));
-    
-    const webvhDid = bindings['did:webvh'];
-    console.log(`✅ Asset published to web!`);
-    console.log(`   Original DID (peer): ${asset.id}`);
-    console.log(`   New DID (webvh): ${webvhDid}`);
-    console.log(`   Current Layer: ${publishedAsset.currentLayer}`);
-
-    // Step 4: Verify resources have URLs
-    console.log('\n🔧 Step 4: Verifying resource URLs...');
-    expect(publishedAsset.resources).toHaveLength(2);
-    
-    for (const resource of publishedAsset.resources) {
-      expect(resource.url).toBeDefined();
-      expect(typeof resource.url).toBe('string');
-      expect((resource.url as string).includes('did:webvh:')).toBe(true);
-      expect((resource.url as string).includes('/resources/')).toBe(true);
-      
-      console.log(`✅ Resource ${resource.id}:`);
-      console.log(`   URL: ${resource.url}`);
-      console.log(`   Content-Type: ${resource.contentType}`);
-      console.log(`   Hash: ${resource.hash}`);
-    }
-
-    // Step 5: Verify provenance includes migration event
-    console.log('\n🔧 Step 5: Verifying provenance...');
-    const provenance = (publishedAsset as any).provenance;
-    expect(provenance).toBeDefined();
-    expect(provenance.migrations).toBeDefined();
-    expect(Array.isArray(provenance.migrations)).toBe(true);
-    
-    const webvhMigration = provenance.migrations.find((m: any) => m.to === 'did:webvh');
-    expect(webvhMigration).toBeDefined();
-    expect(webvhMigration.from).toBe('did:peer');
-    expect(webvhMigration.to).toBe('did:webvh');
-    expect(webvhMigration.timestamp).toBeDefined();
-    
-    console.log(`✅ Provenance verified:`);
-    console.log(`   Migration from: ${webvhMigration.from}`);
-    console.log(`   Migration to: ${webvhMigration.to}`);
-    console.log(`   Timestamp: ${webvhMigration.timestamp}`);
-
-    // Step 6: Test DID resolution (if the webvh DID was created with proper log)
-    console.log('\n🔧 Step 6: Testing DID resolution...');
-    try {
-      const resolved = await sdk.did.resolveDID(webvhDid);
-      expect(resolved).toBeDefined();
-      expect(resolved?.id).toBe(webvhDid);
-      
-      console.log(`✅ DID resolved successfully:`);
-      console.log(`   Resolved ID: ${resolved?.id}`);
-      console.log(`   Context: ${JSON.stringify(resolved?.['@context'])}`);
-      if (resolved?.verificationMethod) {
-        console.log(`   Verification Methods: ${resolved.verificationMethod.length}`);
-      }
-    } catch (error) {
-      console.log(`⚠️  DID resolution skipped (expected for test environment)`);
-      console.log(`   Reason: ${error instanceof Error ? error.message : String(error)}`);
-    }
-
-    // Step 7: Verify credentials were issued
-    console.log('\n🔧 Step 7: Verifying credentials...');
-    const credentials = (publishedAsset as any).credentials;
-    expect(Array.isArray(credentials)).toBe(true);
-    expect(credentials.length).toBeGreaterThan(0);
-    
-    const hasPublicationCredential = credentials.some((c: any) => 
-      Array.isArray(c.type) && 
-      (c.type.includes('ResourceMigrated') || 
-       c.type.includes('ResourcePublished') ||
-       c.type.includes('ResourceCreated'))
-    );
-    expect(hasPublicationCredential).toBe(true);
-    
-    console.log(`✅ Credentials verified:`);
-    console.log(`   Total credentials: ${credentials.length}`);
-    console.log(`   Has publication credential: ${hasPublicationCredential}`);
-    credentials.forEach((cred: any, idx: number) => {
-      console.log(`   Credential ${idx + 1}: ${cred.type?.join(', ') || 'Unknown'}`);
-    });
-
-    // Final summary
-    console.log('\n' + '='.repeat(70));
-    console.log('✨ FLOW VERIFICATION COMPLETE ✨');
-    console.log('='.repeat(70));
-    console.log(`📋 Summary:`);
-    console.log(`   ✓ DID Peer created successfully`);
-    console.log(`   ✓ Asset created with resources`);
-    console.log(`   ✓ Published to web (did:peer -> did:webvh)`);
-    console.log(`   ✓ Resource URLs generated and accessible`);
-    console.log(`   ✓ Provenance tracking verified`);
-    console.log(`   ✓ Credentials issued`);
-    console.log(`   ✓ DID bindings established`);
-    console.log('='.repeat(70) + '\n');
-  });
-
-  test('verify resource URL format and structure', async () => {
-    const resources: AssetResource[] = [
-      {
-        id: 'res-format-test',
-        type: 'data',
-        contentType: 'application/octet-stream',
-        hash: 'e5a1234560',
-        content: 'test data for URL format verification'
-      }
-    ];
-
-    const asset = await sdk.lifecycle.createAsset(resources);
-    const published = await sdk.lifecycle.publishToWeb(asset, domain);
-
-    // Verify resource URL structure
-    const resource = published.resources[0];
-    const url = resource.url as string;
-    
-    expect(url).toBeDefined();
-    expect(url).toContain('did:webvh:');
-    expect(url).toContain('/resources/');
-    
-    // URL should be in format: did:webvh:domain:path/resources/hash
-    expect(url).toMatch(/^did:webvh:[^\/]+\/resources\//);
-    
-    // URL should end with a multibase-encoded hash
-    expect(url.split('/').pop()).toMatch(/^[A-Za-z0-9_-]+$/);
-    
-    console.log(`\n✅ Resource URL format verified:`);
-    console.log(`   Full URL: ${url}`);
-    console.log(`   Format: DID-based URL`);
-    console.log(`   Contains resources path: true`);
-    console.log(`   Hash encoded: ${url.split('/').pop()}`);
-  });
-
-  test('verify bindings are preserved through migration', async () => {
-    const resources: AssetResource[] = [
-      {
-        id: 'binding-test',
-        type: 'data',
-        contentType: 'text/plain',
-        hash: 'b1d1234560',
-        content: 'binding test content'
-      }
-    ];
-
-    const asset = await sdk.lifecycle.createAsset(resources);
-    const originalId = asset.id;
-    
-    const published = await sdk.lifecycle.publishToWeb(asset, domain);
-    const bindings = (published as any).bindings;
-
-    // Should have both peer and webvh bindings
-    expect(bindings['did:peer']).toBeDefined();
-    expect(bindings['did:webvh']).toBeDefined();
-    
-    // Peer binding should match original asset ID
-    expect(bindings['did:peer']).toBe(originalId);
-    
-    // WebVH binding should be a valid did:webvh
-    expect(bindings['did:webvh']).toMatch(/^did:webvh:/);
-    
-    console.log(`\n✅ Bindings verified:`);
-    console.log(`   did:peer: ${bindings['did:peer']}`);
-    console.log(`   did:webvh: ${bindings['did:webvh']}`);
-    console.log(`   Previous DID: ${(published as any).previousDid}`);
-  });
-
-  test('verify multiple resources all get URLs', async () => {
-    const resources: AssetResource[] = [
-      {
-        id: 'multi-1',
-        type: 'data',
-        contentType: 'text/plain',
-        hash: 'a51001',
-        content: 'content 1'
-      },
-      {
-        id: 'multi-2',
-        type: 'data',
-        contentType: 'application/json',
-        hash: 'a51002',
-        content: '{"key": "value"}'
-      },
-      {
-        id: 'multi-3',
-        type: 'metadata',
-        contentType: 'text/html',
-        hash: 'a51003',
-        content: '<html><body>test</body></html>'
-      },
-      {
-        id: 'multi-4',
-        type: 'data',
-        contentType: 'image/svg+xml',
-        hash: 'a51004',
-        content: '<svg></svg>'
-      }
-    ];
-
-    const asset = await sdk.lifecycle.createAsset(resources);
-    const published = await sdk.lifecycle.publishToWeb(asset, domain);
-
-    // All resources should have URLs
-    expect(published.resources).toHaveLength(4);
-    
-    for (let i = 0; i < published.resources.length; i++) {
-      const resource = published.resources[i];
-      expect(resource.url).toBeDefined();
-      expect(typeof resource.url).toBe('string');
-      expect((resource.url as string).length).toBeGreaterThan(0);
-      expect((resource.url as string).includes('did:webvh:')).toBe(true);
-      expect((resource.url as string).includes('/resources/')).toBe(true);
-      
-      console.log(`✅ Resource ${i + 1} (${resource.id}):`);
-      console.log(`   URL: ${resource.url}`);
-    }
-  });
-
-  test('verify published asset maintains all original data', async () => {
-    const resources: AssetResource[] = [
-      {
-        id: 'preserve-test',
-        type: 'data',
-        contentType: 'text/markdown',
-        hash: 'e5e1ea00',
-        content: '# Test Document\nThis should be preserved.'
-      }
-    ];
-
-    const asset = await sdk.lifecycle.createAsset(resources);
-    
-    // Capture original data
-    const originalId = asset.id;
-    const originalResources = asset.resources.map(r => ({ ...r }));
-    const originalLayer = asset.currentLayer;
-    
-    const published = await sdk.lifecycle.publishToWeb(asset, domain);
-    
-    // Verify resources are preserved (with added URL)
-    expect(published.resources).toHaveLength(originalResources.length);
-    
-    for (let i = 0; i < published.resources.length; i++) {
-      const original = originalResources[i];
-      const current = published.resources[i];
-      
-      expect(current.id).toBe(original.id);
-      expect(current.type).toBe(original.type);
-      expect(current.contentType).toBe(original.contentType);
-      expect(current.hash).toBe(original.hash);
-      expect(current.content).toBe(original.content);
-      expect(current.url).toBeDefined(); // New field added
-    }
-    
-    // Verify layer changed
-    expect(published.currentLayer).toBe('did:webvh');
-    expect(originalLayer).toBe('did:peer');
-    
-    // Verify bindings preserve original ID
-    const bindings = (published as any).bindings;
-    expect(bindings['did:peer']).toBe(originalId);
-    
-    console.log(`\n✅ Data preservation verified:`);
-    console.log(`   All resource fields preserved: true`);
-    console.log(`   URLs added: true`);
-    console.log(`   Layer updated: ${originalLayer} -> ${published.currentLayer}`);
-    console.log(`   Original ID preserved in bindings: true`);
-  });
-});