@originals/sdk 1.1.0

package/tests/integration/CredentialManager.test.ts

@@ -0,0 +1,42 @@
+/** 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

@@ -0,0 +1,41 @@
+/** 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

@@ -0,0 +1,351 @@
+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`);
+  });
+});