@originals/sdk 1.4.2 → 1.4.5

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

@@ -1,452 +0,0 @@
-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

@@ -1,45 +0,0 @@
-/** 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;
-  });
-});