@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/vc/CredentialManager.test.ts

@@ -1,487 +0,0 @@
-import { describe, test, expect, afterEach, spyOn } from 'bun:test';
-import { OriginalsSDK } from '../../../src';
-import { VerifiableCredential, CredentialSubject, Proof } from '../../../src/types';
-import * as secp256k1 from '@noble/secp256k1';
-import * as ed25519 from '@noble/ed25519';
-import { p256 } from '@noble/curves/p256';
-import { multikey } from '../../../src/crypto/Multikey';
-
-describe('CredentialManager', () => {
-  const sdk = OriginalsSDK.create();
-
-  const subject: CredentialSubject = {
-    id: 'did:peer:subject',
-    resourceId: 'res1',
-    resourceType: 'text',
-    createdAt: new Date().toISOString(),
-    creator: 'did:peer:issuer'
-  } as any;
-
-  const baseVC: VerifiableCredential = {
-    '@context': ['https://www.w3.org/2018/credentials/v1'],
-    type: ['VerifiableCredential', 'ResourceCreated'],
-    issuer: 'did:peer:issuer',
-    issuanceDate: new Date().toISOString(),
-    credentialSubject: subject
-  };
-
-  test('createResourceCredential builds VC for each type (expected to fail until implemented)', async () => {
-    const created = await sdk.credentials.createResourceCredential('ResourceCreated', subject, 'did:peer:issuer');
-    expect(created.type).toContain('ResourceCreated');
-
-    const updated = await sdk.credentials.createResourceCredential('ResourceUpdated', subject, 'did:peer:issuer');
-    expect(updated.type).toContain('ResourceUpdated');
-
-    const migrated = await sdk.credentials.createResourceCredential('ResourceMigrated', subject, 'did:peer:issuer');
-    expect(migrated.type).toContain('ResourceMigrated');
-  });
-
-  test('signCredential/verifyCredential works for ES256K', async () => {
-    const sdkES256K = OriginalsSDK.create({ defaultKeyType: 'ES256K' });
-    const sk = secp256k1.utils.randomPrivateKey();
-    const pk = secp256k1.getPublicKey(sk, true);
-    const skMb = multikey.encodePrivateKey(sk, 'Secp256k1');
-    const pkMb = multikey.encodePublicKey(pk, 'Secp256k1');
-    const signed = await sdkES256K.credentials.signCredential(baseVC, skMb, pkMb);
-    expect(signed.proof).toBeDefined();
-    await expect(sdkES256K.credentials.verifyCredential(signed)).resolves.toBe(true);
-  });
-
-  test('verifyCredential returns false when no proof present (expected to pass)', async () => {
-    await expect(sdk.credentials.verifyCredential(baseVC)).resolves.toBe(false);
-  });
-
-  test('createPresentation bundles VCs (expected to fail until implemented)', async () => {
-    const pres = await sdk.credentials.createPresentation([baseVC], 'did:peer:holder');
-    expect(pres.verifiableCredential.length).toBeGreaterThan(0);
-  });
-
-  test('verifyCredential returns false when proof missing fields', async () => {
-    const vc: VerifiableCredential = { ...baseVC, proof: { 
-      type: 'DataIntegrityProof',
-      created: new Date().toISOString(),
-      verificationMethod: '',
-      proofPurpose: 'assertionMethod',
-      proofValue: ''
-    } as any };
-    await expect(sdk.credentials.verifyCredential(vc)).resolves.toBe(false);
-  });
-
-  test('verifyCredential uses data-integrity verifier path when cryptosuite present', async () => {
-    const sdkEd = OriginalsSDK.create({ defaultKeyType: 'Ed25519' });
-    const edSk = new Uint8Array(32).fill(1);
-    const signed = await sdkEd.credentials.signCredential(baseVC, multikey.encodePrivateKey(edSk, 'Ed25519'), 'did:ex#key');
-    (signed as any).proof.cryptosuite = 'eddsa-rdfc-2022';
-    const res = await sdkEd.credentials.verifyCredential(signed);
-    expect(typeof res).toBe('boolean');
-  });
-
-  test('verifyCredential returns false on invalid multibase proofValue', async () => {
-    const vc: VerifiableCredential = { ...baseVC, proof: { 
-      type: 'DataIntegrityProof',
-      created: new Date().toISOString(),
-      verificationMethod: multikey.encodePublicKey(new Uint8Array(33).fill(3), 'Secp256k1'),
-      proofPurpose: 'assertionMethod',
-      proofValue: 'xnot-multibase'
-    } } as any;
-    await expect(sdk.credentials.verifyCredential(vc)).resolves.toBe(false);
-  });
-
-  test('verifyCredential returns false when signer throws (catch path)', async () => {
-    const vc: VerifiableCredential = { ...baseVC, proof: { 
-      type: 'DataIntegrityProof',
-      created: new Date().toISOString(),
-      verificationMethod: multikey.encodePublicKey(new Uint8Array(33).fill(4), 'Secp256k1'),
-      proofPurpose: 'assertionMethod',
-      proofValue: 'z' + Buffer.from('sig').toString('base64url')
-    } } as any;
-    const cm: any = sdk.credentials as any;
-    const original = cm.getSigner;
-    cm.getSigner = () => ({
-      verify: () => { throw new Error('boom'); },
-      sign: async () => Buffer.from('')
-    });
-    await expect(sdk.credentials.verifyCredential(vc)).resolves.toBe(false);
-    cm.getSigner = original;
-  });
-
-  test('signCredential/verifyCredential works for Ed25519', async () => {
-    const sdkEd = OriginalsSDK.create({ defaultKeyType: 'Ed25519' });
-    const sk = ed25519.utils.randomPrivateKey();
-    const pk = await (ed25519 as any).getPublicKeyAsync(sk);
-    const skMb = multikey.encodePrivateKey(sk, 'Ed25519');
-    const pkMb = multikey.encodePublicKey(pk, 'Ed25519');
-    const signed = await sdkEd.credentials.signCredential(baseVC, skMb, pkMb);
-    expect(signed.proof).toBeDefined();
-    await expect(sdkEd.credentials.verifyCredential(signed)).resolves.toBe(true);
-  });
-
-  test('signCredential/verifyCredential works for ES256', async () => {
-    const sdkES256 = OriginalsSDK.create({ defaultKeyType: 'ES256' });
-    const sk = p256.utils.randomPrivateKey();
-    const pk = p256.getPublicKey(sk, true);
-    const skMb = multikey.encodePrivateKey(sk, 'P256');
-    const pkMb = multikey.encodePublicKey(pk, 'P256');
-    const signed = await sdkES256.credentials.signCredential(baseVC, skMb, pkMb);
-    expect(signed.proof).toBeDefined();
-    await expect(sdkES256.credentials.verifyCredential(signed)).resolves.toBe(true);
-  });
-});
-
-/** Inlined from CredentialManager.did-fallback-present.part.ts */
-import { CredentialManager } from '../../../src/vc/CredentialManager';
-import { DIDManager } from '../../../src/did/DIDManager';
-
-describe('CredentialManager verification method resolution', () => {
-  const baseConfig = { network: 'mainnet', defaultKeyType: 'ES256K' } as any;
-  const credentialTemplate: VerifiableCredential = {
-    '@context': ['https://www.w3.org/2018/credentials/v1'],
-    type: ['VerifiableCredential', 'ResourceCreated'],
-    issuer: 'did:example:issuer',
-    issuanceDate: new Date().toISOString(),
-    credentialSubject: { id: 'did:example:subject' }
-  } as any;
-
-  test('resolves DID verificationMethod to multibase key material', async () => {
-    const signingManager = new CredentialManager(baseConfig);
-    const sk = secp256k1.utils.randomPrivateKey();
-    const pk = secp256k1.getPublicKey(sk, true);
-    const skMb = multikey.encodePrivateKey(sk, 'Secp256k1');
-    const pkMb = multikey.encodePublicKey(pk, 'Secp256k1');
-    const verificationMethod = 'did:example:123#key-1';
-
-    const signed = await signingManager.signCredential(credentialTemplate, skMb, verificationMethod);
-
-    const dm = new DIDManager(baseConfig);
-    spyOn(dm, 'resolveDID').mockResolvedValue({
-      '@context': ['https://www.w3.org/ns/did/v1'],
-      id: 'did:example:123',
-      verificationMethod: [
-        {
-          id: verificationMethod,
-          type: 'Multikey',
-          controller: 'did:example:123',
-          publicKeyMultibase: pkMb
-        }
-      ]
-    } as any);
-
-    const verifyingManager = new CredentialManager(baseConfig, dm);
-    await expect(verifyingManager.verifyCredential(signed)).resolves.toBe(true);
-  });
-
-  test('falls back to proof.publicKeyMultibase when DID resolution lacks key material', async () => {
-    const signingManager = new CredentialManager(baseConfig);
-    const sk = secp256k1.utils.randomPrivateKey();
-    const pk = secp256k1.getPublicKey(sk, true);
-    const skMb = multikey.encodePrivateKey(sk, 'Secp256k1');
-    const pkMb = multikey.encodePublicKey(pk, 'Secp256k1');
-    const verificationMethod = 'did:example:456#key-1';
-
-    const signed = await signingManager.signCredential(credentialTemplate, skMb, verificationMethod);
-    (signed.proof as any).publicKeyMultibase = pkMb;
-
-    const dm = new DIDManager(baseConfig);
-    spyOn(dm, 'resolveDID').mockResolvedValue({
-      '@context': ['https://www.w3.org/ns/did/v1'],
-      id: 'did:example:456'
-    } as any);
-
-    const verifyingManager = new CredentialManager(baseConfig, dm);
-    await expect(verifyingManager.verifyCredential(signed)).resolves.toBe(true);
-  });
-});
-
-describe('CredentialManager verify with didManager present but legacy path', () => {
-  test('verifyCredential returns false when legacy proof invalid and didManager present', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any, dm);
-    const vc: any = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate: new Date().toISOString(),
-      credentialSubject: {},
-      proof: { type: 'DataIntegrityProof', created: new Date().toISOString(), verificationMethod: multikey.encodePublicKey(new Uint8Array(33).fill(5), 'Secp256k1'), proofPurpose: 'assertionMethod', proofValue: 'z' + Buffer.from('bad').toString('base64url') }
-    };
-    const ok = await cm.verifyCredential(vc);
-    expect(ok).toBe(false);
-  });
-});
-
-
-
-
-/** Inlined from CredentialManager.did-fallback-with-didmgr.part.ts */
-import { registerVerificationMethod, verificationMethodRegistry } from '../../../src/vc/documentLoader';
-
-describe('CredentialManager with didManager provided falls back to local signer when VM incomplete', () => {
-  afterEach(() => {
-    verificationMethodRegistry.clear();
-  });
-  test('covers didManager gate with fallback path', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any, dm);
-    // Register VM without publicKeyMultibase so DID path cannot proceed and will fall back
-    registerVerificationMethod({ id: 'did:ex:vm#fallback', controller: 'did:ex' } as any);
-
-    const sk = secp256k1.utils.randomPrivateKey();
-    const skMb = multikey.encodePrivateKey(sk, 'Secp256k1');
-
-    const vc: any = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate: new Date().toISOString(),
-      credentialSubject: {}
-    };
-
-    const signed = await cm.signCredential(vc, skMb, 'did:ex:vm#fallback');
-    expect(signed.proof).toBeDefined();
-  });
-});
-
-
-/** Inlined from CredentialManager.fallback-branch.part.ts */
-
-describe('CredentialManager DID path fallback when VM doc lacks type', () => {
-  afterEach(() => {
-    verificationMethodRegistry.clear();
-  });
-  test('falls back to legacy signing if DID loader returns VM missing fields', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any, dm);
-    // Register minimal VM without type/publicKeyMultibase so DID path cannot proceed to Issuer
-    registerVerificationMethod({ id: 'did:ex:vm#x', controller: 'did:ex' } as any);
-    const sk = new Uint8Array(32).fill(1);
-    const pk = new Uint8Array(33).fill(2);
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const signed = await cm.signCredential(vc, multikey.encodePrivateKey(sk, 'Secp256k1'), 'did:ex:vm#x');
-    expect(signed.proof).toBeDefined();
-  });
-});
-
-
-
-
-/** Inlined from CredentialManager.local-verify.no-did.part.ts */
-
-describe('CredentialManager local verify path without didManager', () => {
-  test('signs and verifies locally when didManager is undefined', async () => {
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'ES256K' } as any);
-    const baseVC: VerifiableCredential = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate: new Date().toISOString(),
-      credentialSubject: {}
-    } as any;
-    const sk = secp256k1.utils.randomPrivateKey();
-    const pk = secp256k1.getPublicKey(sk, true);
-    const skMb = multikey.encodePrivateKey(sk, 'Secp256k1');
-    const pkMb = multikey.encodePublicKey(pk, 'Secp256k1');
-    const signed = await cm.signCredential(baseVC, skMb, pkMb);
-    const ok = await cm.verifyCredential(signed);
-    expect(ok).toBe(true);
-  });
-
-  test('signCredential is deterministic for reordered credentialSubject properties', async () => {
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const seed = new Uint8Array(32).fill(11);
-    const skMb = multikey.encodePrivateKey(seed, 'Ed25519');
-    const pk = await (ed25519 as any).getPublicKeyAsync(seed);
-    const pkMb = multikey.encodePublicKey(pk, 'Ed25519');
-    const issuanceDate = '2024-01-01T00:00:00Z';
-
-    const credentialA: VerifiableCredential = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate,
-      credentialSubject: {
-        id: 'did:ex:subject',
-        role: 'member',
-        profile: {
-          nickname: 'alice',
-          stats: {
-            followers: 10,
-            posts: 3
-          }
-        }
-      }
-    } as any;
-
-    const credentialB: VerifiableCredential = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate,
-      credentialSubject: {
-        profile: {
-          stats: {
-            posts: 3,
-            followers: 10
-          },
-          nickname: 'alice'
-        },
-        role: 'member',
-        id: 'did:ex:subject'
-      }
-    } as any;
-
-    const signedA = await cm.signCredential(credentialA, skMb, pkMb);
-    const signedB = await cm.signCredential(credentialB, skMb, pkMb);
-
-    // Handle both single proof and proof array cases
-    const proofA = Array.isArray(signedA.proof) ? signedA.proof[0] : signedA.proof;
-    const proofB = Array.isArray(signedB.proof) ? signedB.proof[0] : signedB.proof;
-    expect(proofA?.proofValue).toEqual(proofB?.proofValue);
-    await expect(cm.verifyCredential(signedA)).resolves.toBe(true);
-    await expect(cm.verifyCredential(signedB)).resolves.toBe(true);
-  });
-
-  test('verifyCredential succeeds when proof fields are reordered', async () => {
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const seed = new Uint8Array(32).fill(13);
-    const skMb = multikey.encodePrivateKey(seed, 'Ed25519');
-    const pk = await (ed25519 as any).getPublicKeyAsync(seed);
-    const pkMb = multikey.encodePublicKey(pk, 'Ed25519');
-
-    const credential: VerifiableCredential = {
-      '@context': ['https://www.w3.org/2018/credentials/v1'],
-      type: ['VerifiableCredential'],
-      issuer: 'did:ex',
-      issuanceDate: '2024-01-01T00:00:00Z',
-      credentialSubject: {
-        id: 'did:ex:subject',
-        role: 'member'
-      }
-    } as any;
-
-    const signed = await cm.signCredential(credential, skMb, pkMb);
-    const proof = signed.proof as Proof;
-    const reorderedProof: Proof = {
-      proofValue: proof.proofValue,
-      verificationMethod: proof.verificationMethod!,
-      proofPurpose: proof.proofPurpose,
-      created: proof.created,
-      type: proof.type
-    };
-
-    const mutatedCredential: VerifiableCredential = {
-      ...signed,
-      proof: reorderedProof
-    } as any;
-
-    await expect(cm.verifyCredential(mutatedCredential)).resolves.toBe(true);
-  });
-});
-
-
-
-
-/** Inlined from CredentialManager.missing-type-default.part.ts */
-describe('CredentialManager DID path with VM missing type defaults to Multikey', () => {
-  afterEach(() => {
-    verificationMethodRegistry.clear();
-  });
-  test('uses default type when document.type is absent', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any, dm);
-    const sk = new Uint8Array(32).fill(5);
-    const pk = new Uint8Array(32).fill(7);
-    const pkMb = multikey.encodePublicKey(pk, 'Ed25519');
-    const skMb = multikey.encodePrivateKey(sk, 'Ed25519');
-    // Register VM without type so code path uses document.type || 'Multikey'
-    registerVerificationMethod({ id: 'did:ex:vm#3', controller: 'did:ex', publicKeyMultibase: pkMb } as any);
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const signed = await cm.signCredential(vc, skMb, 'did:ex:vm#3');
-    expect(signed.proof).toBeDefined();
-  });
-});
-
-
-
-
-/** Inlined from CredentialManager.more.part.ts */
-
-describe('CredentialManager additional branches', () => {
-  afterEach(() => {
-    verificationMethodRegistry.clear();
-  });
-  test('getSigner default case used for unknown key type', async () => {
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Unknown' as any });
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const sk = new Uint8Array(32).fill(1);
-    const pk = new Uint8Array(33).fill(2);
-    const signed = await cm.signCredential(vc, multikey.encodePrivateKey(sk, 'Secp256k1'), multikey.encodePublicKey(pk, 'Secp256k1'));
-    expect(signed.proof).toBeDefined();
-  });
-
-  test('signCredential uses DID-based path with documentLoader', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any, dm);
-    const sk = new Uint8Array(32).fill(9);
-    const pk = new Uint8Array(32).fill(7);
-    const vm = { id: 'did:ex:vm#1', controller: 'did:ex', publicKeyMultibase: (await import('../../../src/crypto/Multikey')).multikey.encodePublicKey(pk, 'Ed25519'), type: 'Multikey' } as any;
-    registerVerificationMethod(vm as any);
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const skMb = (await import('../../../src/crypto/Multikey')).multikey.encodePrivateKey(sk, 'Ed25519');
-    const signed = await cm.signCredential(vc, skMb, 'did:ex:vm#1');
-    expect(signed.proof).toBeDefined();
-  });
-
-  test('signCredential uses issuer object.id when issuer is object', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any, dm);
-    const sk = new Uint8Array(32).fill(4);
-    const pk = new Uint8Array(32).fill(6);
-    const { multikey } = await import('../../../src/crypto/Multikey');
-    const vm = { id: 'did:ex:vm#2', controller: 'did:ex', publicKeyMultibase: multikey.encodePublicKey(pk, 'Ed25519'), type: 'Multikey' } as any;
-    registerVerificationMethod(vm as any);
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: { id: 'did:ex' }, issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const skMb = multikey.encodePrivateKey(sk, 'Ed25519');
-    const signed = await cm.signCredential(vc, skMb, 'did:ex:vm#2');
-    expect(signed.proof).toBeDefined();
-  });
-
-  test('verifyCredential takes cryptosuite from proof array first element', async () => {
-    const dm = new DIDManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any);
-    const cm = new CredentialManager({ network: 'mainnet', defaultKeyType: 'Ed25519' } as any, dm);
-    const { multikey } = await import('../../../src/crypto/Multikey');
-    const sk = new Uint8Array(32).fill(11);
-    const pk = new Uint8Array(32).fill(12);
-    const skMb = multikey.encodePrivateKey(sk, 'Ed25519');
-    const pkMb = multikey.encodePublicKey(pk, 'Ed25519');
-    const loader = async (iri: string) => {
-      if (iri.includes('#')) return { document: { '@context': ['https://www.w3.org/ns/credentials/v2'], id: iri, publicKeyMultibase: pkMb }, documentUrl: iri, contextUrl: null };
-      return { document: { '@context': { '@version': 1.1 } }, documentUrl: iri, contextUrl: null } as any;
-    };
-    const issuer = new (await import('../../../src/vc/Issuer')).Issuer(dm, { id: 'did:ex#k', controller: 'did:ex', publicKeyMultibase: pkMb, secretKeyMultibase: skMb } as any);
-    // Register VM so verifier documentLoader can resolve the key by fragment
-    registerVerificationMethod({ id: 'did:ex#k', type: 'Multikey', controller: 'did:ex', publicKeyMultibase: pkMb } as any);
-    const unsigned: any = { id: 'urn:cred:x', type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const vc = await issuer.issueCredential(unsigned, { proofPurpose: 'assertionMethod', documentLoader: loader as any });
-    (vc as any).proof = [ (vc as any).proof ];
-    // In some environments verifyCredential may return false due to signature differences,
-    // but we still exercise the branch; assert boolean return rather than strict true.
-    const verified = await cm.verifyCredential(vc);
-    expect(typeof verified).toBe('boolean');
-  });
-});
-
-
-
-
-/** Inlined from CredentialManager.type-fallback.part.ts */
-
-describe('CredentialManager.getSigner default case when config keyType undefined', () => {
-  test('defaults to ES256K', async () => {
-    const cm = new CredentialManager({ network: 'mainnet' } as any);
-    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:ex', issuanceDate: new Date().toISOString(), credentialSubject: {} };
-    const sk = new Uint8Array(32).fill(3);
-    const pk = new Uint8Array(33).fill(2);
-    const signed = await cm.signCredential(vc, multikey.encodePrivateKey(sk, 'Secp256k1'), multikey.encodePublicKey(pk, 'Secp256k1'));
-    expect(signed.proof).toBeDefined();
-  });
-});

package/tests/unit/vc/Issuer.test.ts

@@ -1,107 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { Issuer } from '../../../src/vc/Issuer';
-import * as ed25519 from '@noble/ed25519';
-import { multikey } from '../../../src/crypto/Multikey';
-import { DIDManager } from '../../../src/did/DIDManager';
-
-describe('diwings Issuer', () => {
-  const didManager = new DIDManager({} as any);
-  const did = 'did:peer:issuer1';
-  const sk = new Uint8Array(32).map((_, i) => (i + 1) & 0xff);
-  const pk = ed25519.getPublicKey(sk);
-  const vm = {
-    id: `${did}#keys-1`,
-    controller: did,
-    type: 'Multikey',
-    publicKeyMultibase: multikey.encodePublicKey(pk, 'Ed25519'),
-    secretKeyMultibase: multikey.encodePrivateKey(sk, 'Ed25519')
-  };
-
-  const baseCredential = {
-    type: ['VerifiableCredential', 'Test'],
-    issuer: did,
-    issuanceDate: new Date().toISOString(),
-    credentialSubject: { id: 'did:peer:subject1' }
-  } as any;
-
-  test('issues v2 presentation and produces proof referencing challenge/domain', async () => {
-    const issuer = new Issuer(didManager, vm);
-    const vp = await issuer.issuePresentation(
-      {
-        type: ['VerifiablePresentation'],
-        holder: did,
-        verifiableCredential: []
-      } as any,
-      { proofPurpose: 'authentication', challenge: 'abc', domain: 'example.org' }
-    );
-    expect(vp['@context'][0]).toContain('/ns/credentials/v2');
-    expect(vp.proof).toBeDefined();
-  });
-
-  test('throws if missing secret key', async () => {
-    const issuer = new Issuer(didManager, { ...vm, secretKeyMultibase: undefined });
-    await expect(issuer.issueCredential(baseCredential, { proofPurpose: 'assertionMethod' })).rejects.toThrow('Missing secretKeyMultibase');
-  });
-
-  test('issues v2 credential and produces proof', async () => {
-    const issuer = new Issuer(didManager, vm);
-    const vc = await issuer.issueCredential(baseCredential, { proofPurpose: 'assertionMethod' });
-    expect(vc['@context'][0]).toContain('/ns/credentials/v2');
-    expect(vc.proof).toBeDefined();
-  });
-});
-
-/** Inlined from Issuer.more.part.ts */
-
-describe('Issuer branches', () => {
-  const dm = new DIDManager({} as any);
-  const vm = {
-    id: 'did:ex:1#key-1',
-    controller: 'did:ex:1',
-    publicKeyMultibase: 'z', // force decode failure -> default Ed25519 path
-    secretKeyMultibase: 'z7' // invalid but never used due to loader use only
-  } as any;
-
-  test('throws when missing secretKeyMultibase', async () => {
-    const issuer = new Issuer(dm, { ...vm, secretKeyMultibase: undefined });
-    await expect(issuer.issueCredential({ id: 'urn:cred:1', type: ['VerifiableCredential'], issuer: 'did:ex:1', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any, { proofPurpose: 'assertionMethod' })).rejects.toThrow('Missing secretKeyMultibase');
-  });
-
-  test('issuePresentation throws when secretKeyMultibase missing', async () => {
-    const issuer = new Issuer(dm, { ...vm, secretKeyMultibase: undefined });
-    await expect(issuer.issuePresentation({ holder: 'did:ex:1' } as any, { proofPurpose: 'authentication' })).rejects.toThrow('Missing secretKeyMultibase');
-  });
-
-  test('issueCredential uses issuer object id when provided', async () => {
-    const issuer = new Issuer(dm, { ...vm, secretKeyMultibase: 'z7' });
-    await expect(issuer.issueCredential({ id: 'urn:cred:2', type: ['VerifiableCredential'], issuer: { id: 'did:ex:1' } as any, issuanceDate: new Date().toISOString(), credentialSubject: {} } as any, { proofPurpose: 'assertionMethod' })).rejects.toThrow();
-  });
-
-  test('issueCredential falls back to controller when issuer missing', async () => {
-    const issuer = new Issuer(dm, { ...vm, secretKeyMultibase: 'z7' });
-    await expect(issuer.issueCredential({ id: 'urn:cred:3', type: ['VerifiableCredential'], issuanceDate: new Date().toISOString(), credentialSubject: {} } as any, { proofPurpose: 'assertionMethod' })).rejects.toThrow();
-  });
-});
-
-
-
-
-/** Inlined from Issuer.unsupported.part.ts */
-
-describe('Issuer unsupported key types', () => {
-  const dm = new DIDManager({} as any);
-
-  test('issueCredential throws for non-Ed25519', async () => {
-    const pubMb = multikey.encodePublicKey(new Uint8Array(33).fill(1), 'Secp256k1');
-    const secMb = multikey.encodePrivateKey(new Uint8Array(32).fill(2), 'Secp256k1');
-    const issuer = new Issuer(dm, { id: 'did:ex:3#k', controller: 'did:ex:3', publicKeyMultibase: pubMb, secretKeyMultibase: secMb });
-    await expect(issuer.issueCredential({ id: 'urn:cred:2', type: ['VerifiableCredential'], issuer: 'did:ex:3', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any, { proofPurpose: 'assertionMethod' })).rejects.toThrow('Only Ed25519 supported');
-  });
-
-  test('issuePresentation throws for non-Ed25519', async () => {
-    const pubMb = multikey.encodePublicKey(new Uint8Array(33).fill(1), 'Secp256k1');
-    const secMb = multikey.encodePrivateKey(new Uint8Array(32).fill(2), 'Secp256k1');
-    const issuer = new Issuer(dm, { id: 'did:ex:3#k', controller: 'did:ex:3', publicKeyMultibase: pubMb, secretKeyMultibase: secMb });
-    await expect(issuer.issuePresentation({ holder: 'did:ex:3' } as any, { proofPurpose: 'authentication' })).rejects.toThrow('Only Ed25519 supported');
-  });
-});