@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/core/OriginalsSDK.test.ts

@@ -1,152 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from 'bun:test';
-import { OriginalsSDK } from '../../../src';
-import { signAsync, getPublicKeyAsync } from '@noble/ed25519';
-
-describe('OriginalsSDK', () => {
-  test('create() returns instance with managers and defaults', () => {
-    const sdk = OriginalsSDK.create();
-    expect(sdk).toBeInstanceOf(OriginalsSDK);
-    expect(sdk.did).toBeDefined();
-    expect(sdk.credentials).toBeDefined();
-    expect(sdk.lifecycle).toBeDefined();
-    expect(sdk.bitcoin).toBeDefined();
-  });
-
-  test('create() accepts config overrides', () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest', enableLogging: true });
-    expect(sdk).toBeInstanceOf(OriginalsSDK);
-  });
-
-  test('constructor throws error when config is null', () => {
-    expect(() => new OriginalsSDK(null as any)).toThrow('Configuration object is required');
-  });
-
-  test('constructor throws error when config is not an object', () => {
-    expect(() => new OriginalsSDK('invalid' as any)).toThrow('Configuration object is required');
-  });
-
-  test('constructor throws error when network is invalid', () => {
-    expect(() => new OriginalsSDK({ network: 'invalid' as any, defaultKeyType: 'ES256K' }))
-      .toThrow('Invalid network: must be mainnet, regtest, or signet');
-  });
-
-  test('constructor throws error when network is missing', () => {
-    expect(() => new OriginalsSDK({ defaultKeyType: 'ES256K' } as any))
-      .toThrow('Invalid network: must be mainnet, regtest, or signet');
-  });
-
-  test('constructor throws error when defaultKeyType is invalid', () => {
-    expect(() => new OriginalsSDK({ network: 'mainnet', defaultKeyType: 'invalid' as any }))
-      .toThrow('Invalid defaultKeyType: must be ES256K, Ed25519, or ES256');
-  });
-
-  test('constructor throws error when defaultKeyType is missing', () => {
-    expect(() => new OriginalsSDK({ network: 'mainnet' } as any))
-      .toThrow('Invalid defaultKeyType: must be ES256K, Ed25519, or ES256');
-  });
-
-  describe('validateBitcoinConfig', () => {
-    test('does not throw when ordinalsProvider is configured', () => {
-      const mockProvider = {
-        getInscription: mock(() => Promise.resolve({ id: 'test', content: new Uint8Array() })),
-        getBalance: mock(() => Promise.resolve(1000)),
-        getUtxos: mock(() => Promise.resolve([])),
-        inscribe: mock(() => Promise.resolve({ txid: 'test', vout: 0 })),
-        broadcastTx: mock(() => Promise.resolve('txid')),
-        estimateFee: mock(() => Promise.resolve(10)),
-      };
-
-      const sdk = OriginalsSDK.create({ ordinalsProvider: mockProvider });
-      expect(() => sdk.validateBitcoinConfig()).not.toThrow();
-    });
-
-    test('throws StructuredError when ordinalsProvider is not configured', () => {
-      const sdk = OriginalsSDK.create();
-      expect(() => sdk.validateBitcoinConfig()).toThrow('Bitcoin operations require an ordinalsProvider');
-    });
-  });
-
-  describe('verifyDIDSignature', () => {
-    let privateKey: Uint8Array;
-    let publicKey32: Uint8Array;
-    let publicKey33: Uint8Array;
-    const message = new TextEncoder().encode('test message');
-
-    beforeEach(async () => {
-      privateKey = new Uint8Array(32).fill(1);
-      publicKey32 = await getPublicKeyAsync(privateKey);
-      publicKey33 = new Uint8Array(33);
-      publicKey33[0] = 0x00;
-      publicKey33.set(publicKey32, 1);
-    });
-
-    test('verifies valid signature with 32-byte public key', async () => {
-      const signature = await signAsync(message, privateKey);
-      const result = await OriginalsSDK.verifyDIDSignature(signature, message, publicKey32);
-      expect(result).toBe(true);
-    });
-
-    test('verifies valid signature with 33-byte public key (slices off version byte)', async () => {
-      const signature = await signAsync(message, privateKey);
-      const result = await OriginalsSDK.verifyDIDSignature(signature, message, publicKey33);
-      expect(result).toBe(true);
-    });
-
-    test('returns false for invalid signature', async () => {
-      const signature = await signAsync(message, privateKey);
-      const wrongMessage = new TextEncoder().encode('wrong message');
-      const result = await OriginalsSDK.verifyDIDSignature(signature, wrongMessage, publicKey32);
-      expect(result).toBe(false);
-    });
-
-    test('throws error for invalid public key length', async () => {
-      const signature = await signAsync(message, privateKey);
-      const invalidKey = new Uint8Array(16);
-      await expect(OriginalsSDK.verifyDIDSignature(signature, message, invalidKey))
-        .rejects.toThrow('Invalid Ed25519 public key length: 16');
-    });
-
-    test('returns false on verification error', async () => {
-      const invalidSignature = new Uint8Array(32); // Invalid signature
-      const result = await OriginalsSDK.verifyDIDSignature(invalidSignature, message, publicKey32);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('prepareDIDDataForSigning', () => {
-    test('calls didwebvh-ts prepareDataForSigning', async () => {
-      const document = { id: 'did:webvh:example.com' };
-      const proof = { type: 'DataIntegrityProof' };
-
-      // This test verifies the method exists and delegates to didwebvh-ts
-      const result = await OriginalsSDK.prepareDIDDataForSigning(document, proof);
-      expect(result).toBeInstanceOf(Uint8Array);
-    });
-  });
-
-  describe('createOriginal', () => {
-    test('throws error for unsupported type', async () => {
-      const options = {
-        type: 'invalid' as any,
-        domain: 'example.com',
-      };
-
-      await expect(OriginalsSDK.createOriginal(options))
-        .rejects.toThrow('Unsupported Original type: invalid');
-    });
-  });
-
-  describe('updateOriginal', () => {
-    test('throws error for unsupported type', async () => {
-      const options = {
-        type: 'invalid' as any,
-        log: [],
-      };
-
-      await expect(OriginalsSDK.updateOriginal(options))
-        .rejects.toThrow('Unsupported Original type');
-    });
-  });
-});
-
-

package/tests/unit/crypto/Multikey.test.ts

@@ -1,206 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import {
-  multikey,
-  validateMultikeyFormat,
-  MULTICODEC_ED25519_PUB_HEADER,
-  MULTICODEC_ED25519_PRIV_HEADER,
-  MULTICODEC_SECP256K1_PUB_HEADER,
-  MULTICODEC_SECP256K1_PRIV_HEADER,
-  MULTICODEC_P256_PUB_HEADER,
-  MULTICODEC_P256_PRIV_HEADER,
-  MULTICODEC_BLS12381_G2_PUB_HEADER,
-  MULTICODEC_BLS12381_G2_PRIV_HEADER
-} from '../../../src/crypto/Multikey';
-import { base58 } from '@scure/base';
-
-function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a, 0);
-  out.set(b, a.length);
-  return out;
-}
-
-describe('Multikey encode/decode', () => {
-  const edPub = new Uint8Array(32).map((_, i) => (i + 1) & 0xff);
-  const edPriv = new Uint8Array(32).map((_, i) => (i + 2) & 0xff);
-  const secpPub = new Uint8Array(33).map((_, i) => (i + 3) & 0xff);
-  const secpPriv = new Uint8Array(32).map((_, i) => (i + 4) & 0xff);
-  const p256Pub = new Uint8Array(33).map((_, i) => (i + 7) & 0xff);
-  const p256Priv = new Uint8Array(32).map((_, i) => (i + 8) & 0xff);
-
-  test('encode/decode Ed25519', () => {
-    const pub = multikey.encodePublicKey(edPub, 'Ed25519');
-    const priv = multikey.encodePrivateKey(edPriv, 'Ed25519');
-    const decPub = multikey.decodePublicKey(pub);
-    const decPriv = multikey.decodePrivateKey(priv);
-    expect(Array.from(decPub.key)).toEqual(Array.from(edPub));
-    expect(decPub.type).toBe('Ed25519');
-    expect(Array.from(decPriv.key)).toEqual(Array.from(edPriv));
-    expect(decPriv.type).toBe('Ed25519');
-  });
-
-  test('encode/decode Secp256k1', () => {
-    const pub = multikey.encodePublicKey(secpPub, 'Secp256k1');
-    const priv = multikey.encodePrivateKey(secpPriv, 'Secp256k1');
-    const decPub = multikey.decodePublicKey(pub);
-    const decPriv = multikey.decodePrivateKey(priv);
-    expect(Array.from(decPub.key)).toEqual(Array.from(secpPub));
-    expect(decPub.type).toBe('Secp256k1');
-    expect(Array.from(decPriv.key)).toEqual(Array.from(secpPriv));
-    expect(decPriv.type).toBe('Secp256k1');
-  });
-
-  test('encode/decode P256', () => {
-    const pub = multikey.encodePublicKey(p256Pub, 'P256');
-    const priv = multikey.encodePrivateKey(p256Priv, 'P256');
-    const decPub = multikey.decodePublicKey(pub);
-    const decPriv = multikey.decodePrivateKey(priv);
-    expect(Array.from(decPub.key)).toEqual(Array.from(p256Pub));
-    expect(decPub.type).toBe('P256');
-    expect(Array.from(decPriv.key)).toEqual(Array.from(p256Priv));
-    expect(decPriv.type).toBe('P256');
-  });
-
-  test('decode errors: invalid multibase prefix', () => {
-    expect(() => multikey.decodePublicKey('xabc')).toThrow();
-    expect(() => multikey.decodePrivateKey('xabc')).toThrow();
-  });
-
-  test('decode errors: unsupported type header', () => {
-    const unknownHeader = new Uint8Array([0x00, 0x00]);
-    const fakeKey = new Uint8Array([1, 2, 3, 4]);
-    const mb = 'z' + base58.encode(concatBytes(unknownHeader, fakeKey));
-    expect(() => multikey.decodePublicKey(mb)).toThrow('Unsupported key type');
-    expect(() => multikey.decodePrivateKey(mb)).toThrow('Unsupported key type');
-  });
-
-  test('encode/decode Bls12381G2', () => {
-    const blsPub = new Uint8Array(96).map((_, i) => (i + 5) & 0xff);
-    const blsPriv = new Uint8Array(32).map((_, i) => (i + 6) & 0xff);
-    const pub = multikey.encodePublicKey(blsPub, 'Bls12381G2');
-    const priv = multikey.encodePrivateKey(blsPriv, 'Bls12381G2');
-    const decPub = multikey.decodePublicKey(pub);
-    const decPriv = multikey.decodePrivateKey(priv);
-    expect(Array.from(decPub.key)).toEqual(Array.from(blsPub));
-    expect(decPub.type).toBe('Bls12381G2');
-    expect(Array.from(decPriv.key)).toEqual(Array.from(blsPriv));
-    expect(decPriv.type).toBe('Bls12381G2');
-  });
-});
-
-describe('validateMultikeyFormat', () => {
-  test('throws on null/undefined key', () => {
-    expect(() => validateMultikeyFormat(null as any, 'Ed25519', false)).toThrow('Invalid multibase key format. Key must be a non-empty string.');
-    expect(() => validateMultikeyFormat(undefined as any, 'Ed25519', false)).toThrow('Invalid multibase key format. Key must be a non-empty string.');
-  });
-
-  test('throws on empty string', () => {
-    expect(() => validateMultikeyFormat('', 'Ed25519', false)).toThrow('Invalid multibase key format. Key must be a non-empty string.');
-  });
-
-  test('throws on non-z prefix', () => {
-    expect(() => validateMultikeyFormat('xABC123', 'Ed25519', false)).toThrow('Invalid multibase key format. Keys must use z-base58btc encoding (prefix "z").');
-  });
-
-  test('throws on invalid base58 decode', () => {
-    expect(() => validateMultikeyFormat('z!!!', 'Ed25519', false)).toThrow('Invalid multibase key format. Keys must use multicodec headers. Decode error:');
-  });
-
-  test('throws when decoded length is less than 2 bytes', () => {
-    const shortEncoded = 'z' + base58.encode(new Uint8Array([0x01]));
-    expect(() => validateMultikeyFormat(shortEncoded, 'Ed25519', false)).toThrow('Invalid multibase key format. Keys must use multicodec headers.');
-  });
-
-  test('throws on mismatched Ed25519 public key header', () => {
-    // Wrong header for Ed25519
-    const wrongHeader = new Uint8Array([0x00, 0x00]);
-    const fakeKey = new Uint8Array(32).fill(1);
-    const encoded = 'z' + base58.encode(concatBytes(wrongHeader, fakeKey));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', false)).toThrow('Invalid multibase key format. Expected Ed25519 public key');
-  });
-
-  test('throws on mismatched Ed25519 private key header', () => {
-    const wrongHeader = new Uint8Array([0x00, 0x00]);
-    const fakeKey = new Uint8Array(32).fill(1);
-    const encoded = 'z' + base58.encode(concatBytes(wrongHeader, fakeKey));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', true)).toThrow('Invalid multibase key format. Expected Ed25519 private key');
-  });
-
-  test('throws on wrong Ed25519 public key length', () => {
-    const pub = new Uint8Array(31).fill(1); // Should be 32
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_ED25519_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', false)).toThrow('Invalid multibase key format. Expected Ed25519 public key to be 32 bytes');
-  });
-
-  test('throws on wrong Ed25519 private key length', () => {
-    const priv = new Uint8Array(31).fill(1); // Should be 32
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_ED25519_PRIV_HEADER, priv));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', true)).toThrow('Invalid multibase key format. Expected Ed25519 private key to be 32 bytes');
-  });
-
-  test('validates correct Ed25519 public key', () => {
-    const pub = new Uint8Array(32).fill(1);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_ED25519_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', false)).not.toThrow();
-  });
-
-  test('validates correct Ed25519 private key', () => {
-    const priv = new Uint8Array(32).fill(1);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_ED25519_PRIV_HEADER, priv));
-    expect(() => validateMultikeyFormat(encoded, 'Ed25519', true)).not.toThrow();
-  });
-
-  test('validates correct Secp256k1 public key (33 bytes)', () => {
-    const pub = new Uint8Array(33).fill(2);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_SECP256K1_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Secp256k1', false)).not.toThrow();
-  });
-
-  test('validates correct Secp256k1 private key (32 bytes)', () => {
-    const priv = new Uint8Array(32).fill(2);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_SECP256K1_PRIV_HEADER, priv));
-    expect(() => validateMultikeyFormat(encoded, 'Secp256k1', true)).not.toThrow();
-  });
-
-  test('throws on wrong Secp256k1 public key length', () => {
-    const pub = new Uint8Array(32).fill(2); // Should be 33
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_SECP256K1_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Secp256k1', false)).toThrow('Invalid multibase key format. Expected Secp256k1 public key to be 33 bytes');
-  });
-
-  test('validates correct P256 public key (33 bytes)', () => {
-    const pub = new Uint8Array(33).fill(3);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_P256_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'P256', false)).not.toThrow();
-  });
-
-  test('validates correct P256 private key (32 bytes)', () => {
-    const priv = new Uint8Array(32).fill(3);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_P256_PRIV_HEADER, priv));
-    expect(() => validateMultikeyFormat(encoded, 'P256', true)).not.toThrow();
-  });
-
-  test('validates correct Bls12381G2 public key (96 bytes)', () => {
-    const pub = new Uint8Array(96).fill(4);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_BLS12381_G2_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Bls12381G2', false)).not.toThrow();
-  });
-
-  test('validates correct Bls12381G2 private key (32 bytes)', () => {
-    const priv = new Uint8Array(32).fill(4);
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_BLS12381_G2_PRIV_HEADER, priv));
-    expect(() => validateMultikeyFormat(encoded, 'Bls12381G2', true)).not.toThrow();
-  });
-
-  test('throws on wrong Bls12381G2 public key length', () => {
-    const pub = new Uint8Array(95).fill(4); // Should be 96
-    const encoded = 'z' + base58.encode(concatBytes(MULTICODEC_BLS12381_G2_PUB_HEADER, pub));
-    expect(() => validateMultikeyFormat(encoded, 'Bls12381G2', false)).toThrow('Invalid multibase key format. Expected Bls12381G2 public key to be 96 bytes');
-  });
-
-  test('re-throws validation errors as-is', () => {
-    // This tests the error re-throwing logic for errors that start with "Invalid multibase key format"
-    expect(() => validateMultikeyFormat('', 'Ed25519', false)).toThrow('Invalid multibase key format. Key must be a non-empty string.');
-  });
-});
-