@originals/sdk 1.1.0

package/tests/unit/did/KeyManager.test.ts

@@ -0,0 +1,452 @@
+import { describe, test, expect } from 'bun:test';
+import { KeyManager } from '../../../src/did/KeyManager';
+import { DIDDocument, KeyPair, KeyType } from '../../../src/types';
+
+describe('KeyManager', () => {
+  const km = new KeyManager();
+
+  test('generateKeyPair ES256K works', async () => {
+    const kp = await km.generateKeyPair('ES256K');
+    expect(kp.privateKey.startsWith('z')).toBe(true);
+    expect(kp.publicKey.startsWith('z')).toBe(true);
+  });
+
+  test('generateKeyPair Ed25519 works', async () => {
+    const kp = await km.generateKeyPair('Ed25519');
+    expect(kp.privateKey.startsWith('z')).toBe(true);
+    expect(kp.publicKey.startsWith('z')).toBe(true);
+  });
+
+  test('decodePublicKeyMultibase invalid input throws', () => {
+    expect(() => km.decodePublicKeyMultibase('abc')).toThrow('Invalid multibase string');
+  });
+
+  test('encode/decode multibase roundtrip', () => {
+    const pub = Buffer.from('hello');
+    const encoded = km.encodePublicKeyMultibase(pub, 'ES256K' as KeyType);
+    const decoded = km.decodePublicKeyMultibase(encoded);
+    expect(Buffer.from(decoded.key)).toEqual(Buffer.from(pub));
+    expect(decoded.type).toBe('ES256K');
+  });
+
+  test('decodePublicKeyMultibase handles Ed25519 multikey values', () => {
+    const pub = Buffer.from([0, 255, 1, 2, 3, 4, 5]);
+    const encoded = km.encodePublicKeyMultibase(pub, 'Ed25519' as KeyType);
+    const decoded = km.decodePublicKeyMultibase(encoded);
+    expect(Buffer.from(decoded.key)).toEqual(Buffer.from(pub));
+    expect(decoded.type).toBe('Ed25519');
+  });
+
+  test('rotateKeys updates DID document keys', async () => {
+    const didDoc: DIDDocument = { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:peer:xyz' };
+    const pair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, pair);
+    expect(rotated.verificationMethod?.[0].publicKeyMultibase).toBe(pair.publicKey);
+    // Verify that multikey context is added when using Multikey verification method
+    expect(rotated['@context']).toContain('https://w3id.org/security/multikey/v1');
+    expect(rotated.verificationMethod?.[0].type).toBe('Multikey');
+  });
+
+  test('rotateKeys marks old keys as revoked', async () => {
+    // Start with a DID document that has an existing verification method
+    const initialPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:test123',
+      verificationMethod: [{
+        id: 'did:peer:test123#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:test123',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:test123#keys-0']
+    };
+
+    // Rotate to new key
+    const newPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, newPair);
+
+    // Verify old key is revoked
+    expect(rotated.verificationMethod).toHaveLength(2);
+    expect(rotated.verificationMethod?.[0].revoked).toBeDefined();
+    expect(rotated.verificationMethod?.[0].revoked).toMatch(/^\d{4}-\d{2}-\d{2}T/); // ISO 8601 format
+    
+    // Verify new key is not revoked
+    expect(rotated.verificationMethod?.[1].revoked).toBeUndefined();
+    expect(rotated.verificationMethod?.[1].publicKeyMultibase).toBe(newPair.publicKey);
+  });
+
+  test('rotateKeys updates authentication and assertionMethod arrays', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      verificationMethod: [{
+        id: 'did:peer:abc#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:abc',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:abc#keys-0'],
+      assertionMethod: ['did:peer:abc#keys-0']
+    };
+
+    const newPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, newPair);
+
+    // Verify authentication and assertionMethod reference only new key
+    expect(rotated.authentication).toEqual(['did:peer:abc#keys-1']);
+    expect(rotated.assertionMethod).toEqual(['did:peer:abc#keys-1']);
+  });
+
+  test('rotateKeys preserves service endpoints and other properties', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('ES256' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:xyz',
+      verificationMethod: [{
+        id: 'did:peer:xyz#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:xyz',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:xyz#keys-0'],
+      service: [{
+        id: 'did:peer:xyz#service-1',
+        type: 'MessagingService',
+        serviceEndpoint: 'https://example.com/endpoint'
+      }],
+      keyAgreement: ['did:peer:xyz#key-agreement-1']
+    };
+
+    const newPair: KeyPair = await km.generateKeyPair('ES256' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, newPair);
+
+    // Verify service endpoints are preserved
+    expect(rotated.service).toEqual(didDoc.service);
+    expect(rotated.keyAgreement).toEqual(didDoc.keyAgreement);
+  });
+
+  test('rotateKeys maintains DID document validity with proper context', async () => {
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:validity-test'
+    };
+
+    const newPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, newPair);
+
+    // Verify proper context is included
+    expect(rotated['@context']).toContain('https://www.w3.org/ns/did/v1');
+    expect(rotated['@context']).toContain('https://w3id.org/security/multikey/v1');
+    expect(rotated['@context']).toContain('https://w3id.org/security/v1');
+    
+    // Verify structure is valid
+    expect(rotated.id).toBe('did:peer:validity-test');
+    expect(rotated.verificationMethod).toBeDefined();
+    expect(rotated.authentication).toBeDefined();
+  });
+
+  test('rotateKeys does not duplicate multikey context if already present', async () => {
+    const didDoc: DIDDocument = { 
+      '@context': ['https://www.w3.org/ns/did/v1', 'https://w3id.org/security/multikey/v1'], 
+      id: 'did:peer:abc' 
+    };
+    const pair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, pair);
+    
+    // Count occurrences of multikey context
+    const contextCount = rotated['@context'].filter(c => c === 'https://w3id.org/security/multikey/v1').length;
+    expect(contextCount).toBe(1);
+    expect(rotated['@context']).toContain('https://w3id.org/security/multikey/v1');
+  });
+
+  test('recoverFromCompromise generates new keys correctly', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:compromised123',
+      verificationMethod: [{
+        id: 'did:peer:compromised123#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:compromised123',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:compromised123#keys-0']
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify result structure
+    expect(result).toHaveProperty('didDocument');
+    expect(result).toHaveProperty('recoveryCredential');
+    expect(result).toHaveProperty('newKeyPair');
+
+    // Verify new key was generated
+    expect(result.didDocument.verificationMethod).toHaveLength(2);
+    const newKey = result.didDocument.verificationMethod?.[1];
+    expect(newKey?.publicKeyMultibase).toBeDefined();
+    expect(newKey?.publicKeyMultibase).not.toBe(initialPair.publicKey);
+    
+    // Verify new key pair is returned and matches the verification method
+    expect(result.newKeyPair).toBeDefined();
+    expect(result.newKeyPair.publicKey).toBe(newKey?.publicKeyMultibase);
+    expect(result.newKeyPair.privateKey).toBeDefined();
+  });
+
+  test('recoverFromCompromise marks all existing keys as compromised', async () => {
+    const pair1: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const pair2: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:multi-key',
+      verificationMethod: [
+        {
+          id: 'did:peer:multi-key#keys-0',
+          type: 'Multikey',
+          controller: 'did:peer:multi-key',
+          publicKeyMultibase: pair1.publicKey
+        },
+        {
+          id: 'did:peer:multi-key#keys-1',
+          type: 'Multikey',
+          controller: 'did:peer:multi-key',
+          publicKeyMultibase: pair2.publicKey
+        }
+      ],
+      authentication: ['did:peer:multi-key#keys-0']
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify all old keys are marked as compromised
+    expect(result.didDocument.verificationMethod).toHaveLength(3);
+    expect(result.didDocument.verificationMethod?.[0].compromised).toBeDefined();
+    expect(result.didDocument.verificationMethod?.[0].compromised).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    expect(result.didDocument.verificationMethod?.[1].compromised).toBeDefined();
+    expect(result.didDocument.verificationMethod?.[1].compromised).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    
+    // Verify new key is not compromised
+    expect(result.didDocument.verificationMethod?.[2].compromised).toBeUndefined();
+  });
+
+  test('recoverFromCompromise creates properly formatted recovery credential', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:recovery-test',
+      verificationMethod: [{
+        id: 'did:peer:recovery-test#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:recovery-test',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:recovery-test#keys-0']
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+    const credential = result.recoveryCredential;
+
+    // Verify credential structure
+    expect(credential['@context']).toContain('https://www.w3.org/2018/credentials/v1');
+    expect(credential['@context']).toContain('https://w3id.org/security/v1');
+    expect(credential.type).toContain('VerifiableCredential');
+    expect(credential.type).toContain('KeyRecoveryCredential');
+    expect(credential.issuer).toBe('did:peer:recovery-test');
+    expect(credential.issuanceDate).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+
+    // Verify credential subject
+    expect(credential.credentialSubject.id).toBe('did:peer:recovery-test');
+    expect(credential.credentialSubject.recoveryReason).toBe('key_compromise');
+    expect(credential.credentialSubject.previousVerificationMethods).toEqual(['did:peer:recovery-test#keys-0']);
+    expect(credential.credentialSubject.newVerificationMethod).toBe('did:peer:recovery-test#keys-1');
+  });
+
+  test('recoverFromCompromise updates authentication to use new key', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('ES256' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:auth-update',
+      verificationMethod: [{
+        id: 'did:peer:auth-update#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:auth-update',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:auth-update#keys-0'],
+      assertionMethod: ['did:peer:auth-update#keys-0']
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify authentication and assertionMethod reference new key
+    expect(result.didDocument.authentication).toEqual(['did:peer:auth-update#keys-1']);
+    expect(result.didDocument.assertionMethod).toEqual(['did:peer:auth-update#keys-1']);
+  });
+
+  test('recoverFromCompromise preserves service endpoints', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:service-test',
+      verificationMethod: [{
+        id: 'did:peer:service-test#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:service-test',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:service-test#keys-0'],
+      service: [{
+        id: 'did:peer:service-test#endpoint-1',
+        type: 'LinkedDomains',
+        serviceEndpoint: 'https://example.com'
+      }]
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify service endpoints are preserved
+    expect(result.didDocument.service).toEqual(didDoc.service);
+  });
+
+  test('recoverFromCompromise uses same key type as original', async () => {
+    // Test with ES256K
+    const es256kPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const didDocES256K: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:keytype-test',
+      verificationMethod: [{
+        id: 'did:peer:keytype-test#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:keytype-test',
+        publicKeyMultibase: es256kPair.publicKey
+      }]
+    };
+
+    const resultES256K = await km.recoverFromCompromise(didDocES256K);
+    const newKeyMultibase = resultES256K.didDocument.verificationMethod?.[1].publicKeyMultibase;
+    
+    // Decode to verify key type
+    expect(newKeyMultibase).toBeDefined();
+    const decoded = km.decodePublicKeyMultibase(newKeyMultibase!);
+    expect(decoded.type).toBe('ES256K');
+  });
+
+  test('recoverFromCompromise handles DID document with no existing keys', async () => {
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:no-keys'
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify new key was generated with default type (Ed25519)
+    expect(result.didDocument.verificationMethod).toHaveLength(1);
+    expect(result.didDocument.verificationMethod?.[0].id).toBe('did:peer:no-keys#keys-0');
+    
+    // Verify recovery credential lists no previous keys
+    expect(result.recoveryCredential.credentialSubject.previousVerificationMethods).toEqual([]);
+  });
+
+  test('rotateKeys preserves all optional DID document properties', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:full-props',
+      verificationMethod: [{
+        id: 'did:peer:full-props#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:full-props',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:full-props#keys-0'],
+      keyAgreement: ['did:peer:full-props#key-agreement-1'],
+      capabilityInvocation: ['did:peer:full-props#capability-1'],
+      capabilityDelegation: ['did:peer:full-props#delegation-1'],
+      service: [{
+        id: 'did:peer:full-props#service-1',
+        type: 'MessagingService',
+        serviceEndpoint: 'https://example.com'
+      }]
+    };
+
+    const newPair: KeyPair = await km.generateKeyPair('ES256K' as KeyType);
+    const rotated = await km.rotateKeys(didDoc, newPair);
+
+    // Verify all properties are preserved
+    expect(rotated.keyAgreement).toEqual(didDoc.keyAgreement);
+    expect(rotated.capabilityInvocation).toEqual(didDoc.capabilityInvocation);
+    expect(rotated.capabilityDelegation).toEqual(didDoc.capabilityDelegation);
+    expect(rotated.service).toEqual(didDoc.service);
+  });
+
+  test('recoverFromCompromise preserves all optional DID document properties', async () => {
+    const initialPair: KeyPair = await km.generateKeyPair('Ed25519' as KeyType);
+    const didDoc: DIDDocument = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:full-recovery',
+      verificationMethod: [{
+        id: 'did:peer:full-recovery#keys-0',
+        type: 'Multikey',
+        controller: 'did:peer:full-recovery',
+        publicKeyMultibase: initialPair.publicKey
+      }],
+      authentication: ['did:peer:full-recovery#keys-0'],
+      keyAgreement: ['did:peer:full-recovery#key-agreement-1'],
+      capabilityInvocation: ['did:peer:full-recovery#capability-1'],
+      capabilityDelegation: ['did:peer:full-recovery#delegation-1'],
+      service: [{
+        id: 'did:peer:full-recovery#service-1',
+        type: 'LinkedDomains',
+        serviceEndpoint: 'https://example.com'
+      }]
+    };
+
+    const result = await km.recoverFromCompromise(didDoc);
+
+    // Verify all properties are preserved
+    expect(result.didDocument.keyAgreement).toEqual(didDoc.keyAgreement);
+    expect(result.didDocument.capabilityInvocation).toEqual(didDoc.capabilityInvocation);
+    expect(result.didDocument.capabilityDelegation).toEqual(didDoc.capabilityDelegation);
+    expect(result.didDocument.service).toEqual(didDoc.service);
+  });
+
+  test('decodePublicKeyMultibase validates input', () => {
+    expect(() => km.decodePublicKeyMultibase('bad')).toThrow('Invalid multibase string');
+  });
+
+  test('generateKeyPair supports ES256 (P-256)', async () => {
+    const kp = await km.generateKeyPair('ES256' as KeyType);
+    expect(kp).toHaveProperty('privateKey');
+    expect(kp).toHaveProperty('publicKey');
+    expect(kp.privateKey).toMatch(/^z/);
+    expect(kp.publicKey).toMatch(/^z/);
+  });
+
+  test('generateKeyPair throws on unsupported type', async () => {
+    await expect(km.generateKeyPair('UNSUPPORTED' as KeyType)).rejects.toThrow('Unsupported key type');
+  });
+
+  test('constructor initializes utils helpers without throwing', () => {
+    const instance = new KeyManager();
+    expect(instance).toBeInstanceOf(KeyManager);
+    // call utils to cover helper branches
+    const secp = require('@noble/secp256k1');
+    const ed = require('@noble/ed25519');
+    if (secp.utils && typeof secp.utils.hmacSha256Sync === 'function') {
+      secp.utils.hmacSha256Sync(new Uint8Array([1]), new Uint8Array([2]));
+    }
+    if (ed.utils && typeof ed.utils.sha512Sync === 'function') {
+      ed.utils.sha512Sync(new Uint8Array([3]));
+    }
+  });
+
+  test('constructor covers utils undefined branch (creates helpers when missing)', () => {
+    // In Bun, the utils property is readonly, so we skip this test
+    // The KeyManager constructor now handles readonly utils gracefully
+    const km2 = new KeyManager();
+    expect(km2).toBeInstanceOf(KeyManager);
+  });
+});
+
+

package/tests/unit/did/OrdinalsClientProviderAdapter.test.ts

@@ -0,0 +1,45 @@
+/** Canonical test aggregator created by combine-tests script. */
+
+/** Inlined from OrdinalsClientProviderAdapter.branches.part.ts */
+import { describe, test, expect } from 'bun:test';
+import { OrdinalsClient } from '../../../src/bitcoin/OrdinalsClient';
+import { OrdinalsClientProviderAdapter } from '../../../src/did/providers/OrdinalsClientProviderAdapter';
+
+describe('OrdinalsClientProviderAdapter branches', () => {
+  test('throws when baseUrl is empty in resolveInscription', async () => {
+    const client = new OrdinalsClient('http://example.com', 'mainnet');
+    const adapter = new OrdinalsClientProviderAdapter(client as any, '');
+    await expect(adapter.resolveInscription('abc')).rejects.toThrow('requires a baseUrl');
+  });
+
+  test('handles non-ok response from fetch', async () => {
+    const client = new OrdinalsClient('http://example.com', 'mainnet');
+    const adapter = new OrdinalsClientProviderAdapter(client as any, 'http://api');
+    const originalFetch = global.fetch as any;
+    (global as any).fetch = async () => ({ ok: false, status: 404, statusText: 'Not Found' });
+    await expect(adapter.resolveInscription('abc')).rejects.toThrow('Failed to resolve inscription');
+    (global as any).fetch = originalFetch;
+  });
+
+  test('maps missing fields from JSON with fallbacks', async () => {
+    const client = new OrdinalsClient('http://example.com', 'mainnet');
+    const adapter = new OrdinalsClientProviderAdapter(client as any, 'http://api/');
+    const originalFetch = global.fetch as any;
+    (global as any).fetch = async () => ({ ok: true, json: async () => ({}) });
+    const info = await adapter.resolveInscription('abc');
+    expect(info.content_type).toBe('text/plain');
+    expect(info.content_url).toBe('http://api/content/abc');
+    expect(typeof info.sat).toBe('number');
+    (global as any).fetch = originalFetch;
+  });
+
+  test('maps sat number without coercion path', async () => {
+    const client = new OrdinalsClient('http://example.com', 'mainnet');
+    const adapter = new OrdinalsClientProviderAdapter(client as any, 'http://api');
+    const originalFetch = global.fetch as any;
+    (global as any).fetch = async () => ({ ok: true, json: async () => ({ inscription_id: 'abc', sat: 42, content_type: 'text/plain', content_url: 'http://api/content/abc' }) });
+    const info = await adapter.resolveInscription('abc');
+    expect(info.sat).toBe(42);
+    (global as any).fetch = originalFetch;
+  });
+});