@originals/sdk 1.4.2 → 1.4.3

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

@@ -1,185 +0,0 @@
-import { describe, test, expect, spyOn } from 'bun:test';
-import { OriginalsSDK } from '../../../src';
-import { DIDDocument, AssetResource } from '../../../src/types';
-
-const resources: AssetResource[] = [
-  { id: 'r1', type: 'data', contentType: 'application/json', hash: 'cafebabe' }
-];
-
-describe('DIDManager', () => {
-  const sdk = OriginalsSDK.create();
-
-  test('createDIDPeer returns a valid DID document (expected to fail until implemented)', async () => {
-    const didDoc = await sdk.did.createDIDPeer(resources);
-    expect(didDoc.id.startsWith('did:peer:')).toBe(true);
-    expect(didDoc['@context']).toBeDefined();
-    // Includes Multikey verification method
-    expect(Array.isArray(didDoc.verificationMethod)).toBe(true);
-    const vm = didDoc.verificationMethod![0];
-    expect(vm.type).toBe('Multikey');
-    expect(vm.publicKeyMultibase[0]).toBe('z');
-    const decoded = multikey.decodePublicKey(vm.publicKeyMultibase);
-    expect(decoded && decoded.key instanceof Uint8Array).toBe(true);
-    // Relationships reference by fragment
-    expect(didDoc.authentication).toContain(vm.id);
-    expect(didDoc.assertionMethod).toContain(vm.id);
-  });
-
-  test('migrateToDIDWebVH converts to did:webvh (expected to fail until implemented)', async () => {
-    const didDoc: DIDDocument = { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:peer:xyz' };
-    const webDoc = await sdk.did.migrateToDIDWebVH(didDoc, 'example.com');
-    expect(webDoc.id.startsWith('did:webvh:')).toBe(true);
-  });
-
-  test('migrateToDIDWebVH preserves VMs and services and stable slug', async () => {
-    const peer: DIDDocument = {
-      '@context': ['https://www.w3.org/ns/did/v1', 'https://w3id.org/security/multikey/v1'],
-      id: 'did:peer:abc123',
-      verificationMethod: [{ id: 'did:peer:abc123#0', type: 'Multikey', controller: 'did:peer:abc123', publicKeyMultibase: multikey.encodePublicKey(new Uint8Array(32).fill(7), 'Ed25519') }],
-      authentication: ['did:peer:abc123#0'],
-      assertionMethod: ['did:peer:abc123#0'],
-      service: [{ id: '#svc', type: 'Example', serviceEndpoint: 'https://api.example/svc' }]
-    };
-    const web = await sdk.did.migrateToDIDWebVH(peer, 'Example.COM');
-    expect(web.id).toBe('did:webvh:example.com:abc123');
-    expect(web.verificationMethod?.[0].publicKeyMultibase).toBe(peer.verificationMethod![0].publicKeyMultibase);
-    expect(web.service?.[0].id).toBe('#svc');
-  });
-
-  test('migrateToDIDBTCO converts to did:btco (expected to fail until implemented)', async () => {
-    const didDoc: DIDDocument = { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:webvh:example.com:xyz' };
-    const btcoDoc = await sdk.did.migrateToDIDBTCO(didDoc, '123');
-    expect(btcoDoc.id.startsWith('did:btco:')).toBe(true);
-  });
-
-  test('resolveDID resolves documents (expected to fail until implemented)', async () => {
-    const doc = await sdk.did.resolveDID('did:peer:abc');
-    expect(doc).not.toBeNull();
-  });
-
-  test('validateDIDDocument returns true for valid doc (expected to fail until implemented)', () => {
-    const doc: DIDDocument = { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:peer:xyz' };
-    expect(sdk.did.validateDIDDocument(doc)).toBe(true);
-  });
-});
-
-/** Inlined from DIDManager.createBtco.part.ts */
-import { multikey } from '../../../src/crypto/Multikey';
-
-describe('DIDManager.createBtcoDidDocument method', () => {
-  test('creates btco DID document via manager wrapper', () => {
-    const sdk = OriginalsSDK.create();
-    const pub = new Uint8Array(32).fill(1);
-    const doc = sdk.did.createBtcoDidDocument('123', 'mainnet', { publicKey: pub, keyType: 'Ed25519' });
-    expect(doc.id).toBe('did:btco:123');
-    const vm = doc.verificationMethod![0];
-    expect(vm.id).toBe('did:btco:123#0');
-    const decoded = multikey.decodePublicKey(vm.publicKeyMultibase);
-    expect(decoded.type).toBe('Ed25519');
-  });
-});
-
-
-
-
-/** Inlined from DIDManager.getLayer.throw.part.ts */
-import { DIDManager } from '../../../src/did/DIDManager';
-
-describe('DIDManager.getLayerFromDID error branch', () => {
-  test('throws Unsupported DID method', () => {
-    const dm: any = new DIDManager({} as any);
-    expect(() => dm["getLayerFromDID"]('did:example:xyz')).toThrow('Unsupported DID method');
-  });
-});
-
-
-
-
-/** Inlined from DIDManager.private.part.ts */
-
-describe('DIDManager private getLayerFromDID', () => {
-  const sdk = OriginalsSDK.create();
-  const dm: any = sdk.did as any;
-
-  test('returns correct layer for each DID method (expected to pass)', () => {
-    expect(dm["getLayerFromDID"]('did:peer:abc')).toBe('did:peer');
-    expect(dm["getLayerFromDID"]('did:webvh:example.com:abc')).toBe('did:webvh');
-    expect(dm["getLayerFromDID"]('did:btco:123')).toBe('did:btco');
-  });
-
-  test('throws on unsupported method (expected to pass)', () => {
-    expect(() => dm["getLayerFromDID"]('did:web:example.com')).toThrow('Unsupported DID method');
-  });
-});
-
-
-
-
-
-/** Inlined from DIDManager.resolve.catch.part.ts */
-import { BtcoDidResolver } from '../../../src/did/BtcoDidResolver';
-
-describe('DIDManager.resolveDID catch path', () => {
-  test('returns null when resolver throws', async () => {
-    const sdk = OriginalsSDK.create({ bitcoinRpcUrl: 'http://localhost:3000', network: 'mainnet' });
-    const spy = spyOn(BtcoDidResolver.prototype as any, 'resolve');
-    spy.mockImplementationOnce(async () => { throw new Error('resolver failed'); });
-    const res = await sdk.did.resolveDID('did:btco:123');
-    expect(res).toBeNull();
-    spy.mockRestore();
-  });
-});
-
-
-
-
-/** Inlined from DIDManager.resolve.defaults.part.ts */
-
-describe('DIDManager.resolveDID uses default rpcUrl and network fallbacks', () => {
-  test('falls back to http://localhost:3000 and mainnet when config missing', async () => {
-    const dm = new DIDManager({} as any);
-    const spy = spyOn(BtcoDidResolver.prototype as any, 'resolve');
-    spy.mockResolvedValueOnce({ didDocument: { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:btco:xyz' } });
-    const res = await dm.resolveDID('did:btco:xyz');
-    expect(res?.id).toBe('did:btco:xyz');
-    spy.mockRestore();
-  });
-});
-
-
-
-
-/** Inlined from DIDManager.resolve.methods.part.ts */
-
-describe('DIDManager.resolveDID covers btco method variants', () => {
-  test('resolves did:btco:test:* via resolver', async () => {
-    const sdk = OriginalsSDK.create({ bitcoinRpcUrl: 'http://x', network: 'mainnet' });
-    const spy = spyOn(BtcoDidResolver.prototype as any, 'resolve');
-    spy.mockResolvedValueOnce({ didDocument: { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:btco:test:1' } });
-    const res = await sdk.did.resolveDID('did:btco:test:1');
-    expect(res?.id).toBe('did:btco:test:1');
-    spy.mockRestore();
-  });
-
-  test('resolves did:btco:sig:* via resolver', async () => {
-    const sdk = OriginalsSDK.create({ bitcoinRpcUrl: 'http://x', network: 'mainnet' });
-    const spy = spyOn(BtcoDidResolver.prototype as any, 'resolve');
-    spy.mockResolvedValueOnce({ didDocument: { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:btco:sig:2' } });
-    const res = await sdk.did.resolveDID('did:btco:sig:2');
-    expect(res?.id).toBe('did:btco:sig:2');
-    spy.mockRestore();
-  });
-});
-
-
-
-
-/** Inlined from DIDManager.validate.false.part.ts */
-
-describe('DIDManager.validateDIDDocument false branch', () => {
-  test('returns false when context missing', () => {
-    const dm = new DIDManager({} as any);
-    const res = dm.validateDIDDocument({ id: 'did:peer:xyz' } as any);
-    expect(res).toBe(false);
-  });
-});

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

@@ -1,160 +0,0 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Ed25519Verifier } from '../../../src/did/Ed25519Verifier';
-import { signAsync, getPublicKeyAsync } from '@noble/ed25519';
-
-describe('Ed25519Verifier', () => {
-  // Test data - valid Ed25519 key pair
-  const privateKey = new Uint8Array(32);
-  privateKey.fill(1); // Simple test key
-
-  let publicKey32Bytes: Uint8Array;
-  let publicKey33Bytes: Uint8Array;
-
-  const verificationMethodId = 'did:example:123#key-1';
-  const message = new TextEncoder().encode('test message');
-
-  // Initialize the public key before all tests
-  beforeAll(async () => {
-    publicKey32Bytes = await getPublicKeyAsync(privateKey);
-
-    // Public key with version byte prefix (33 bytes)
-    publicKey33Bytes = new Uint8Array(33);
-    publicKey33Bytes[0] = 0x00; // version byte
-    publicKey33Bytes.set(publicKey32Bytes, 1);
-  });
-
-  describe('constructor', () => {
-    test('creates verifier without parameters', () => {
-      const verifier = new Ed25519Verifier();
-      expect(verifier).toBeDefined();
-      expect(verifier.getVerificationMethodId()).toBeUndefined();
-      expect(verifier.getPublicKey()).toBeUndefined();
-    });
-
-    test('creates verifier with verificationMethodId only', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId);
-      expect(verifier.getVerificationMethodId()).toBe(verificationMethodId);
-      expect(verifier.getPublicKey()).toBeUndefined();
-    });
-
-    test('creates verifier with both parameters', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId, publicKey32Bytes);
-      expect(verifier.getVerificationMethodId()).toBe(verificationMethodId);
-      expect(verifier.getPublicKey()).toEqual(publicKey32Bytes);
-    });
-
-    test('creates verifier with publicKey only', () => {
-      const verifier = new Ed25519Verifier(undefined, publicKey32Bytes);
-      expect(verifier.getVerificationMethodId()).toBeUndefined();
-      expect(verifier.getPublicKey()).toEqual(publicKey32Bytes);
-    });
-  });
-
-  describe('verify()', () => {
-    test('verifies valid signature with 32-byte public key', async () => {
-      const verifier = new Ed25519Verifier();
-      const signature = await signAsync(message, privateKey);
-      const result = await verifier.verify(signature, message, publicKey32Bytes);
-      expect(result).toBe(true);
-    });
-
-    test('verifies valid signature with 33-byte public key (slices off version byte)', async () => {
-      const verifier = new Ed25519Verifier();
-      const signature = await signAsync(message, privateKey);
-      // Pass the 33-byte key - verifier should slice off first byte
-      const result = await verifier.verify(signature, message, publicKey33Bytes);
-      expect(result).toBe(true);
-    });
-
-    test('rejects invalid signature', async () => {
-      const verifier = new Ed25519Verifier();
-      const signature = await signAsync(message, privateKey);
-      const wrongMessage = new TextEncoder().encode('wrong message');
-      const result = await verifier.verify(signature, wrongMessage, publicKey32Bytes);
-      expect(result).toBe(false);
-    });
-
-    test('rejects invalid public key length (too short)', async () => {
-      const verifier = new Ed25519Verifier();
-      const signature = await signAsync(message, privateKey);
-      const invalidKey = new Uint8Array(16); // Too short
-      const result = await verifier.verify(signature, message, invalidKey);
-      expect(result).toBe(false);
-    });
-
-    test('rejects invalid public key length (too long)', async () => {
-      const verifier = new Ed25519Verifier();
-      const signature = await signAsync(message, privateKey);
-      const invalidKey = new Uint8Array(64); // Too long
-      const result = await verifier.verify(signature, message, invalidKey);
-      expect(result).toBe(false);
-    });
-
-    test('handles verification errors gracefully', async () => {
-      const verifier = new Ed25519Verifier();
-      const invalidSignature = new Uint8Array(32); // Invalid signature (wrong length)
-      const result = await verifier.verify(invalidSignature, message, publicKey32Bytes);
-      expect(result).toBe(false);
-    });
-
-    test('verifies signature with different publicKey than constructor', async () => {
-      const differentPublicKey = new Uint8Array(32);
-      differentPublicKey.fill(2);
-      const verifier = new Ed25519Verifier(verificationMethodId, differentPublicKey);
-
-      // Should use the publicKey parameter, not constructor's publicKey
-      const signature = await signAsync(message, privateKey);
-      const result = await verifier.verify(signature, message, publicKey32Bytes);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('getVerificationMethodId()', () => {
-    test('returns verificationMethodId when set', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId);
-      expect(verifier.getVerificationMethodId()).toBe(verificationMethodId);
-    });
-
-    test('returns undefined when not set', () => {
-      const verifier = new Ed25519Verifier();
-      expect(verifier.getVerificationMethodId()).toBeUndefined();
-    });
-  });
-
-  describe('getPublicKey()', () => {
-    test('returns publicKey when set', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId, publicKey32Bytes);
-      expect(verifier.getPublicKey()).toEqual(publicKey32Bytes);
-    });
-
-    test('returns undefined when not set', () => {
-      const verifier = new Ed25519Verifier();
-      expect(verifier.getPublicKey()).toBeUndefined();
-    });
-  });
-
-  describe('getPublicKeyMultibase()', () => {
-    test('returns multibase encoded publicKey when set', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId, publicKey32Bytes);
-      const multibase = verifier.getPublicKeyMultibase();
-      expect(multibase).toBeDefined();
-      expect(multibase?.startsWith('z')).toBe(true);
-
-      // Verify it's a valid base64 encoding
-      const base64Part = multibase?.slice(1);
-      expect(base64Part).toBeDefined();
-      const decoded = Buffer.from(base64Part!, 'base64');
-      expect(new Uint8Array(decoded)).toEqual(publicKey32Bytes);
-    });
-
-    test('returns undefined when publicKey not set', () => {
-      const verifier = new Ed25519Verifier();
-      expect(verifier.getPublicKeyMultibase()).toBeUndefined();
-    });
-
-    test('returns undefined when only verificationMethodId is set', () => {
-      const verifier = new Ed25519Verifier(verificationMethodId);
-      expect(verifier.getPublicKeyMultibase()).toBeUndefined();
-    });
-  });
-});