@originals/sdk 1.1.0

package/tests/unit/utils/satoshi-validation.test.ts

@@ -0,0 +1,354 @@
+import { describe, test, expect } from 'bun:test';
+import { 
+  validateSatoshiNumber, 
+  parseSatoshiIdentifier, 
+  assertValidSatoshi,
+  MAX_SATOSHI_SUPPLY 
+} from '../../../src/utils/satoshi-validation';
+import { StructuredError } from '../../../src/utils/telemetry';
+
+describe('satoshi-validation', () => {
+  describe('validateSatoshiNumber', () => {
+    describe('valid satoshi numbers', () => {
+      test('accepts zero', () => {
+        const result = validateSatoshiNumber(0);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts one', () => {
+        const result = validateSatoshiNumber(1);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts valid positive number', () => {
+        const result = validateSatoshiNumber(123456789);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts string representation of valid number', () => {
+        const result = validateSatoshiNumber('123456789');
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts maximum supply', () => {
+        const result = validateSatoshiNumber(MAX_SATOSHI_SUPPLY);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts maximum supply as string', () => {
+        const result = validateSatoshiNumber(String(MAX_SATOSHI_SUPPLY));
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+
+      test('accepts large valid ordinal number', () => {
+        const result = validateSatoshiNumber('1066296127976657');
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeUndefined();
+      });
+    });
+
+    describe('invalid formats', () => {
+      test('rejects null', () => {
+        const result = validateSatoshiNumber(null as any);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('cannot be null, undefined, or empty string');
+      });
+
+      test('rejects undefined', () => {
+        const result = validateSatoshiNumber(undefined as any);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('cannot be null, undefined, or empty string');
+      });
+
+      test('rejects empty string', () => {
+        const result = validateSatoshiNumber('');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('cannot be null, undefined, or empty string');
+      });
+
+      test('rejects whitespace-only string', () => {
+        const result = validateSatoshiNumber('   ');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('cannot be empty or whitespace-only string');
+      });
+
+      test('rejects negative number', () => {
+        const result = validateSatoshiNumber(-1);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects negative string', () => {
+        const result = validateSatoshiNumber('-123');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects decimal number', () => {
+        const result = validateSatoshiNumber(123.456);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects decimal string', () => {
+        const result = validateSatoshiNumber('123.456');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects scientific notation', () => {
+        const result = validateSatoshiNumber('1e5');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects non-numeric string', () => {
+        const result = validateSatoshiNumber('abc');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects alphanumeric string', () => {
+        const result = validateSatoshiNumber('123abc');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects string with spaces', () => {
+        const result = validateSatoshiNumber('123 456');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects infinity', () => {
+        const result = validateSatoshiNumber(Infinity);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+
+      test('rejects NaN', () => {
+        const result = validateSatoshiNumber(NaN);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain('non-negative integer');
+      });
+    });
+
+    describe('range validation', () => {
+      test('rejects value exceeding maximum supply', () => {
+        const result = validateSatoshiNumber(MAX_SATOSHI_SUPPLY + 1);
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain("within Bitcoin's total supply");
+      });
+
+      test('rejects extremely large value', () => {
+        const result = validateSatoshiNumber('999999999999999999');
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain("within Bitcoin's total supply");
+      });
+
+      test('accepts value at boundary', () => {
+        const result = validateSatoshiNumber(MAX_SATOSHI_SUPPLY);
+        expect(result.valid).toBe(true);
+      });
+
+      test('accepts value just below boundary', () => {
+        const result = validateSatoshiNumber(MAX_SATOSHI_SUPPLY - 1);
+        expect(result.valid).toBe(true);
+      });
+    });
+  });
+
+  describe('parseSatoshiIdentifier', () => {
+    describe('plain satoshi numbers', () => {
+      test('parses valid plain number string', () => {
+        const result = parseSatoshiIdentifier('123456');
+        expect(result).toBe(123456);
+      });
+
+      test('parses zero', () => {
+        const result = parseSatoshiIdentifier('0');
+        expect(result).toBe(0);
+      });
+
+      test('parses large ordinal', () => {
+        const result = parseSatoshiIdentifier('1066296127976657');
+        expect(result).toBe(1066296127976657);
+      });
+    });
+
+    describe('did:btco DIDs', () => {
+      test('extracts satoshi from mainnet DID', () => {
+        const result = parseSatoshiIdentifier('did:btco:123456');
+        expect(result).toBe(123456);
+      });
+
+      test('extracts satoshi from testnet DID', () => {
+        const result = parseSatoshiIdentifier('did:btco:test:123456');
+        expect(result).toBe(123456);
+      });
+
+      test('extracts satoshi from signet DID', () => {
+        const result = parseSatoshiIdentifier('did:btco:sig:789012');
+        expect(result).toBe(789012);
+      });
+
+      test('extracts large ordinal from DID', () => {
+        const result = parseSatoshiIdentifier('did:btco:1066296127976657');
+        expect(result).toBe(1066296127976657);
+      });
+
+      test('handles whitespace around DID', () => {
+        const result = parseSatoshiIdentifier('  did:btco:123456  ');
+        expect(result).toBe(123456);
+      });
+    });
+
+    describe('error handling', () => {
+      test('throws on empty string', () => {
+        expect(() => parseSatoshiIdentifier('')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('')).toThrow('non-empty string');
+      });
+
+      test('throws on whitespace-only string', () => {
+        expect(() => parseSatoshiIdentifier('   ')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('   ')).toThrow('cannot be empty');
+      });
+
+      test('throws on null', () => {
+        expect(() => parseSatoshiIdentifier(null as any)).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier(null as any)).toThrow('must be a non-empty string');
+      });
+
+      test('throws on invalid satoshi in DID', () => {
+        expect(() => parseSatoshiIdentifier('did:btco:-123')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco:-123')).toThrow('non-negative integer');
+      });
+
+      test('throws on invalid satoshi format', () => {
+        expect(() => parseSatoshiIdentifier('abc')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('abc')).toThrow('non-negative integer');
+      });
+
+      test('throws on decimal satoshi', () => {
+        expect(() => parseSatoshiIdentifier('123.456')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('123.456')).toThrow('non-negative integer');
+      });
+
+      test('throws on satoshi exceeding max supply', () => {
+        const tooLarge = String(MAX_SATOSHI_SUPPLY + 1);
+        expect(() => parseSatoshiIdentifier(tooLarge)).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier(tooLarge)).toThrow("within Bitcoin's total supply");
+      });
+
+      test('throws on invalid did:btco format with too few parts', () => {
+        expect(() => parseSatoshiIdentifier('did:btco')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco')).toThrow('non-negative integer');
+      });
+
+      test('throws on invalid did:btco format with too many parts', () => {
+        expect(() => parseSatoshiIdentifier('did:btco:test:123:extra')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco:test:123:extra')).toThrow('Invalid did:btco DID format');
+      });
+
+      test('throws on invalid network in did:btco', () => {
+        expect(() => parseSatoshiIdentifier('did:btco:invalid:123')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco:invalid:123')).toThrow('unsupported network');
+      });
+
+      test('throws on mainnet prefix in 4-part format', () => {
+        // mainnet should use 3-part format (did:btco:123), not 4-part (did:btco:mainnet:123)
+        expect(() => parseSatoshiIdentifier('did:btco:mainnet:123')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco:mainnet:123')).toThrow('unsupported network');
+      });
+
+      test('throws on regtest prefix', () => {
+        expect(() => parseSatoshiIdentifier('did:btco:regtest:123')).toThrow(StructuredError);
+        expect(() => parseSatoshiIdentifier('did:btco:regtest:123')).toThrow('unsupported network');
+      });
+    });
+
+    describe('validation integration', () => {
+      test('validates extracted satoshi', () => {
+        expect(() => parseSatoshiIdentifier('did:btco:test:-1')).toThrow();
+        expect(() => parseSatoshiIdentifier('did:btco:abc')).toThrow();
+      });
+    });
+  });
+
+  describe('assertValidSatoshi', () => {
+    test('does not throw for valid satoshi', () => {
+      expect(() => assertValidSatoshi(123456)).not.toThrow();
+      expect(() => assertValidSatoshi('123456')).not.toThrow();
+      expect(() => assertValidSatoshi(0)).not.toThrow();
+    });
+
+    test('throws StructuredError for invalid satoshi', () => {
+      expect(() => assertValidSatoshi('')).toThrow(StructuredError);
+      expect(() => assertValidSatoshi(-1)).toThrow(StructuredError);
+      expect(() => assertValidSatoshi('abc')).toThrow(StructuredError);
+    });
+
+    test('throws with error code INVALID_SATOSHI', () => {
+      try {
+        assertValidSatoshi('');
+        fail('Should have thrown');
+      } catch (error: any) {
+        expect(error).toBeInstanceOf(StructuredError);
+        expect(error.code).toBe('INVALID_SATOSHI');
+      }
+    });
+
+    test('includes descriptive error message', () => {
+      try {
+        assertValidSatoshi('');
+        fail('Should have thrown');
+      } catch (error: any) {
+        expect(error.message).toContain('cannot be null, undefined, or empty string');
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    test('handles zero correctly', () => {
+      expect(validateSatoshiNumber(0).valid).toBe(true);
+      expect(validateSatoshiNumber('0').valid).toBe(true);
+      expect(parseSatoshiIdentifier('0')).toBe(0);
+    });
+
+    test('handles very long valid number string', () => {
+      const longValid = '100000000000000';
+      expect(validateSatoshiNumber(longValid).valid).toBe(true);
+      expect(parseSatoshiIdentifier(longValid)).toBe(100000000000000);
+    });
+
+    test('trims whitespace from input', () => {
+      expect(validateSatoshiNumber('  123  ').valid).toBe(true);
+      expect(parseSatoshiIdentifier('  123  ')).toBe(123);
+    });
+
+    test('rejects Infinity in validateSatoshiNumber', () => {
+      const result = validateSatoshiNumber(Infinity);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    test('rejects decimal number', () => {
+      const result = validateSatoshiNumber(123.5);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    test('rejects negative number', () => {
+      const result = validateSatoshiNumber(-5);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+});

package/tests/unit/utils/serialization.test.ts

@@ -0,0 +1,124 @@
+import { describe, test, expect } from 'bun:test';
+import { serializeDIDDocument, deserializeDIDDocument, serializeCredential, deserializeCredential, canonicalizeDocument } from '../../../src/utils/serialization';
+
+describe('serialization utils', () => {
+  test('serialize/deserialize DID document roundtrip', () => {
+    const doc: any = { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:peer:abc' };
+    const ser = serializeDIDDocument(doc);
+    const round = deserializeDIDDocument(ser);
+    expect(round).toEqual(doc);
+  });
+
+  test('serialize/deserialize VC roundtrip', () => {
+    const vc: any = { '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:peer:abc', issuanceDate: new Date().toISOString(), credentialSubject: { id: 'did:peer:abc' } };
+    const ser = serializeCredential(vc);
+    const round = deserializeCredential(ser);
+    expect(round).toEqual(vc);
+  });
+
+  test('canonicalizeDocument normalizes nested structures deterministically', async () => {
+    const context = {
+      '@version': 1.1,
+      id: '@id',
+      type: '@type',
+      name: 'https://schema.org/name',
+      details: {
+        '@id': 'https://example.org/details',
+        '@context': {
+          '@version': 1.1,
+          count: 'https://example.org/count',
+          tags: {
+            '@id': 'https://example.org/tags',
+            '@container': '@set'
+          }
+        }
+      }
+    };
+
+    const docA = {
+      '@context': context,
+      id: 'urn:example:1',
+      type: ['ExampleCredential'],
+      name: 'Sample',
+      details: {
+        count: 2,
+        tags: ['b', 'a']
+      }
+    };
+
+    const docB = {
+      name: 'Sample',
+      details: {
+        tags: ['a', 'b'],
+        count: 2
+      },
+      type: ['ExampleCredential'],
+      id: 'urn:example:1',
+      '@context': context
+    };
+
+    const canonA = await canonicalizeDocument(docA);
+    const canonB = await canonicalizeDocument(docB);
+    expect(canonA).toEqual(canonB);
+  });
+
+  test('deserializeDIDDocument throws on invalid JSON', () => {
+    expect(() => deserializeDIDDocument('{invalid')).toThrow('Invalid DID Document JSON');
+  });
+
+  test('deserializeCredential throws on invalid JSON', () => {
+    expect(() => deserializeCredential('{invalid')).toThrow('Invalid Verifiable Credential JSON');
+  });
+
+  test('canonicalizeDocument with custom documentLoader', async () => {
+    const customLoader = async (url: string) => {
+      return {
+        documentUrl: url,
+        document: { 
+          '@context': {
+            '@version': 1.1,
+            'TestType': 'https://example.org/TestType',
+            'id': '@id',
+            'type': '@type'
+          }
+        },
+        contextUrl: null
+      };
+    };
+
+    const doc = {
+      '@context': 'https://custom.example/context',
+      id: 'urn:test:1',
+      type: 'TestType'
+    };
+
+    const canon = await canonicalizeDocument(doc, { documentLoader: customLoader });
+    expect(typeof canon).toBe('string');
+    // canonicalizeDocument might return empty string for certain contexts/documents
+    expect(canon).toBeDefined();
+  });
+
+  test('canonicalizeDocument throws error with message when canonize fails', async () => {
+    const invalidDoc = {
+      '@context': 'https://invalid-context-that-doesnt-exist-12345.example/',
+      id: 'urn:test:1'
+    };
+
+    await expect(canonicalizeDocument(invalidDoc)).rejects.toThrow('Failed to canonicalize document');
+  });
+
+  test('canonicalizeDocument handles non-Error thrown values', async () => {
+    // This is difficult to test directly, but we can verify the error handling path exists
+    const doc = {
+      '@context': ['https://www.w3.org/2018/credentials/v1'],
+      id: 'urn:test:1',
+      type: 'TestType'
+    };
+
+    // Normal case should work
+    const canon = await canonicalizeDocument(doc);
+    expect(typeof canon).toBe('string');
+  });
+});
+
+

package/tests/unit/utils/telemetry.test.ts

@@ -0,0 +1,52 @@
+import { describe, test, expect, mock } from 'bun:test';
+import { emitTelemetry, emitError, StructuredError } from '../../../src/utils/telemetry';
+
+describe('utils/telemetry', () => {
+  test('emitTelemetry invokes onEvent with default level info', () => {
+    const onEvent = mock();
+    emitTelemetry({ onEvent }, { name: 'event-1' });
+    expect(onEvent).toHaveBeenCalledTimes(1);
+    const arg = onEvent.mock.calls[0][0];
+    expect(arg.name).toBe('event-1');
+    expect(arg.level).toBe('info');
+  });
+
+  test('emitTelemetry respects provided level', () => {
+    const onEvent = mock();
+    emitTelemetry({ onEvent }, { name: 'event-2', level: 'debug' });
+    expect(onEvent).toHaveBeenCalledTimes(1);
+    expect(onEvent.mock.calls[0][0].level).toBe('debug');
+  });
+
+  test('emitTelemetry is no-op when hooks missing or handler absent', () => {
+    expect(() => emitTelemetry(undefined, { name: 'noop' })).not.toThrow();
+    expect(() => emitTelemetry({}, { name: 'noop' })).not.toThrow();
+  });
+
+  test('emitTelemetry swallows handler exceptions', () => {
+    const onEvent = mock(() => { throw new Error('boom'); });
+    expect(() => emitTelemetry({ onEvent }, { name: 'err' })).not.toThrow();
+  });
+
+  test('StructuredError holds code, message, and optional details', () => {
+    const err = new StructuredError('E_TEST', 'message', { a: 1 });
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe('StructuredError');
+    expect(err.code).toBe('E_TEST');
+    expect(err.message).toBe('message');
+    expect(err.details).toEqual({ a: 1 });
+  });
+
+  test('emitError calls onError and swallows handler exceptions', () => {
+    const onErrorOk = mock();
+    const se = new StructuredError('E', 'm');
+    emitError({ onError: onErrorOk }, se);
+    expect(onErrorOk).toHaveBeenCalledWith(se);
+
+    const onErrorThrow = mock(() => { throw new Error('boom'); });
+    expect(() => emitError({ onError: onErrorThrow }, se)).not.toThrow();
+    expect(() => emitError(undefined, se)).not.toThrow();
+    expect(() => emitError({}, se)).not.toThrow();
+  });
+});
+

package/tests/unit/utils/validation.test.ts

@@ -0,0 +1,141 @@
+import { describe, test, expect, spyOn } from 'bun:test';
+import { validateDID, validateCredential, validateDIDDocument, hashResource } from '../../../src/utils/validation';
+
+describe('validation utils', () => {
+  test('validateDID supports peer, webvh, btco', () => {
+    expect(validateDID('did:peer:123')).toBe(true);
+    expect(validateDID('did:webvh:example.com:abc')).toBe(true);
+    expect(validateDID('did:btco:123')).toBe(true);
+    expect(validateDID('did:web:example.com')).toBe(false);
+    expect(validateDID('invalid')).toBe(false);
+    // Cover defensive branch: regex.test returns true but match returns null
+    const testSpy = spyOn(RegExp.prototype, 'test').mockReturnValueOnce(true);
+    const matchSpy = spyOn(String.prototype, 'match').mockReturnValueOnce(null as any);
+    expect(validateDID('did:peer:abc')).toBe(false);
+    testSpy.mockRestore();
+    matchSpy.mockRestore();
+  });
+
+  test('validateCredential basic VC shape', () => {
+    const vc: any = {
+      '@context': ['https://www.w3.org/2018/credentials/v1'],
+      type: ['VerifiableCredential', 'Test'],
+      issuer: 'did:peer:abc',
+      issuanceDate: new Date().toISOString(),
+      credentialSubject: { id: 'did:peer:abc', foo: 'bar' }
+    };
+    expect(validateCredential(vc)).toBe(true);
+  });
+
+  test('validateCredential accepts issuer object with DID id', () => {
+    const vc: any = {
+      '@context': ['https://www.w3.org/2018/credentials/v1'],
+      type: ['VerifiableCredential'],
+      issuer: { id: 'did:webvh:example.com:abc' },
+      issuanceDate: new Date().toISOString(),
+      credentialSubject: { id: 'did:webvh:example.com:abc' }
+    };
+    expect(validateCredential(vc)).toBe(true);
+  });
+
+  test('validateCredential returns false when issuer object has no id', () => {
+    const vc: any = {
+      '@context': ['https://www.w3.org/2018/credentials/v1'],
+      type: ['VerifiableCredential'],
+      issuer: { name: 'Test Issuer' },
+      issuanceDate: new Date().toISOString(),
+      credentialSubject: { id: 'did:webvh:example.com:abc' }
+    };
+    expect(validateCredential(vc)).toBe(false);
+  });
+
+  test('validateCredential negative cases', () => {
+    expect(validateCredential({} as any)).toBe(false);
+    // Fails on missing type array
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: undefined, issuer: 'did:peer:x', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any)).toBe(false);
+    // Fails on missing VerifiableCredential type
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['Other'], issuer: 'did:peer:x', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any)).toBe(false);
+    // Fails on missing issuanceDate
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:peer:x', credentialSubject: {} } as any)).toBe(false);
+    // Fails on missing credentialSubject
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:peer:x', issuanceDate: new Date().toISOString() } as any)).toBe(false);
+    // Fails when VC v1 context missing
+    expect(validateCredential({ '@context': ['https://example.com/ctx'], type: ['VerifiableCredential'], issuer: 'did:peer:x', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any)).toBe(false);
+    // Fails when issuer is not DID
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'https://example.com', issuanceDate: new Date().toISOString(), credentialSubject: {} } as any)).toBe(false);
+    // Fails when issuer object has non-DID id
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: { id: 'example.com' }, issuanceDate: new Date().toISOString(), credentialSubject: {} } as any)).toBe(false);
+    // Fails when issuanceDate is not valid ISO
+    expect(validateCredential({ '@context': ['https://www.w3.org/2018/credentials/v1'], type: ['VerifiableCredential'], issuer: 'did:peer:x', issuanceDate: 'not-a-date', credentialSubject: {} } as any)).toBe(false);
+  });
+
+  test('validateDIDDocument shape', () => {
+    const didDoc: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      verificationMethod: [
+        { id: '#key-1', type: 'Ed25519VerificationKey2020', controller: 'did:peer:abc', publicKeyMultibase: 'z...' }
+      ]
+    };
+    expect(validateDIDDocument(didDoc)).toBe(true);
+  });
+
+  test('validateDIDDocument negative cases', () => {
+    expect(validateDIDDocument({} as any)).toBe(false);
+    expect(validateDIDDocument({ '@context': [], id: 'invalid' } as any)).toBe(false);
+    const badVm: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      verificationMethod: [{ id: '#1', type: 'X', controller: '', publicKeyMultibase: '' }, { id: null }]
+    };
+    expect(validateDIDDocument(badVm)).toBe(false);
+    // invalid multibase prefix for VM
+    const badMultibase: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      verificationMethod: [{ id: '#key', type: 'Ed25519VerificationKey2020', controller: 'did:peer:abc', publicKeyMultibase: 'xabc' }]
+    };
+    expect(validateDIDDocument(badMultibase)).toBe(false);
+    // invalid controller on verificationMethod
+    const badVmController: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      verificationMethod: [{ id: '#key', type: 'Ed25519VerificationKey2020', controller: 'not-a-did', publicKeyMultibase: 'zabc' }]
+    };
+    expect(validateDIDDocument(badVmController)).toBe(false);
+    // invalid controller array
+    const badControllers: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      controller: ['not-a-did']
+    };
+    expect(validateDIDDocument(badControllers)).toBe(false);
+  });
+
+  test('validateDIDDocument with controller array passes when entries are DIDs', () => {
+    const ok: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:peer:abc',
+      controller: ['did:peer:abc', 'did:webvh:example.com:abc']
+    };
+    expect(validateDIDDocument(ok)).toBe(true);
+  });
+
+  test('hashResource returns sha256 hex', () => {
+    const hash = hashResource(Buffer.from('hello'));
+    expect(hash).toHaveLength(64);
+    expect(/[0-9a-f]{64}/.test(hash)).toBe(true);
+  });
+});
+
+/** Inlined from validation.no-vm.part.ts */
+
+describe('validateDIDDocument when verificationMethod absent', () => {
+  test('returns true for valid doc with no verificationMethod property', () => {
+    const didDoc: any = {
+      '@context': ['https://www.w3.org/ns/did/v1'],
+      id: 'did:btco:1234'
+    };
+    expect(validateDIDDocument(didDoc)).toBe(true);
+  });
+});