@originals/sdk 1.4.2 → 1.4.5

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

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

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

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

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