Draft Inverse Bloom Filter

packages/primitives/tests/block-header.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest';
+import { BlockHeader } from '~/src/block-header';
+import { Bytes } from '~/src/bytes';
+
+describe('Success cases', () => {
+  // Test cases with different block header representations
+  type BlockHeaderCase = {
+    raw: {
+      version: number;
+      previousBlockHash: Uint8Array;
+      merkleRoot: Uint8Array;
+      timestamp: number;
+      bits: number;
+      nonce: number;
+    };
+    representations: {
+      bytes: Uint8Array;
+      hex: string;
+    };
+  };
+
+  const testCases: BlockHeaderCase[] = [
+    {
+      raw: {
+        version: 592633856,
+        previousBlockHash: Bytes.fromHex(
+          'df4da87b838b2dde9aaf26cb08380f15a57f32d99f2007000000000000000000',
+        ).toBytes(),
+        merkleRoot: Bytes.fromHex(
+          '5e8a3ccc570da3eddb5c67853385e72aad4c830b2eedb4f23943d09513a0b476',
+        ).toBytes(),
+        timestamp: 1737338908,
+        bits: 402807112,
+        nonce: 3478133258,
+      },
+      representations: {
+        bytes: Bytes.fromHex(
+          '00e05223df4da87b838b2dde9aaf26cb08380f15a57f32d99f20070000000000000000005e8a3ccc570da3eddb5c67853385e72aad4c830b2eedb4f23943d09513a0b4761cb08d67485902180a1a50cf',
+        ).toBytes(),
+        hex: '00e05223df4da87b838b2dde9aaf26cb08380f15a57f32d99f20070000000000000000005e8a3ccc570da3eddb5c67853385e72aad4c830b2eedb4f23943d09513a0b4761cb08d67485902180a1a50cf',
+      },
+    },
+  ];
+
+  // Test from methods with their respective types
+  const fromMethods = [
+    { name: 'fromBytes', key: 'bytes' },
+    { name: 'fromHex', key: 'hex' },
+  ] as const;
+
+  fromMethods.forEach(({ name, key }) => {
+    it.each(testCases)(`${name}()`, ({ raw, representations }) => {
+      const blockHeader = BlockHeader[name](representations[key]);
+      expect(blockHeader.toRaw()).toStrictEqual(raw);
+    });
+  });
+
+  // Test generic from method
+  it.each(testCases)('from(Uint8Array)', ({ raw, representations }) => {
+    const blockHeader = BlockHeader.from(representations.bytes);
+    expect(blockHeader.toRaw()).toStrictEqual(raw);
+  });
+
+  it.each(testCases)('from(string)', ({ raw, representations }) => {
+    const blockHeader = BlockHeader.from(representations.hex);
+    expect(blockHeader.toRaw()).toStrictEqual(raw);
+  });
+
+  // Test to methods with their respective types
+  const toMethods = [
+    { name: 'toBytes', key: 'bytes' },
+    { name: 'toHex', key: 'hex' },
+  ] as const;
+
+  toMethods.forEach(({ name, key }) => {
+    it.each(testCases)(`${name}()`, ({ raw, representations }) => {
+      const blockHeader = BlockHeader.fromRaw(raw);
+      expect(blockHeader[name]()).toStrictEqual(representations[key]);
+    });
+  });
+
+  // Test getter methods
+  it.each(testCases)('getter methods return correct values', ({ raw }) => {
+    const blockHeader = BlockHeader.fromRaw(raw);
+    expect(blockHeader.getVersion()).toBe(raw.version);
+    expect(blockHeader.getPreviousBlockHash()).toStrictEqual(
+      raw.previousBlockHash,
+    );
+    expect(blockHeader.getMerkleRoot()).toStrictEqual(raw.merkleRoot);
+    expect(blockHeader.getTimestamp()).toBe(raw.timestamp);
+    expect(blockHeader.getBits()).toBe(raw.bits);
+    expect(blockHeader.getNonce()).toBe(raw.nonce);
+  });
+
+  // Test hex getter methods
+  it.each(testCases)('hex getter methods return correct values', ({ raw }) => {
+    const blockHeader = BlockHeader.fromRaw(raw);
+    expect(blockHeader.getPreviousBlockHashHex()).toBe(
+      Bytes.fromBytes(raw.previousBlockHash).toHex(),
+    );
+    expect(blockHeader.getMerkleRootHex()).toBe(
+      Bytes.fromBytes(raw.merkleRoot).toHex(),
+    );
+  });
+
+  // Test hash methods
+  it.each(testCases)('getHash() returns correct hash', ({ raw }) => {
+    const blockHeader = BlockHeader.fromRaw(raw);
+    const hash = blockHeader.getHash();
+    expect(hash).toBeInstanceOf(Uint8Array);
+    expect(hash.length).toBe(32);
+  });
+
+  it.each(testCases)('getHashHex() returns correct hash hex', ({ raw }) => {
+    const blockHeader = BlockHeader.fromRaw(raw);
+    const hashHex = blockHeader.getHashHex();
+    expect(typeof hashHex).toBe('string');
+    expect(hashHex.length).toBe(64);
+  });
+
+  // Test validation method
+  it.each(testCases)(
+    'isValid() returns true for valid inputs',
+    ({ representations }) => {
+      expect(BlockHeader.isValid(representations.bytes)).toBe(true);
+      expect(BlockHeader.isValid(representations.hex)).toBe(true);
+    },
+  );
+});
+
+describe('Error cases', () => {
+  const invalidCases = [
+    {
+      method: 'fromBytes',
+      input: new Uint8Array(79), // Wrong length (should be 80 bytes)
+    },
+    {
+      method: 'fromHex',
+      input: 'invalid_hex',
+    },
+    {
+      method: 'fromHex',
+      input: '00'.repeat(79), // Wrong length (should be 80 bytes / 160 hex chars)
+    },
+  ];
+
+  invalidCases.forEach(({ method, input }) => {
+    it(`${method}() throws on invalid input`, () => {
+      expect(() => BlockHeader[method](input)).toThrow();
+    });
+  });
+
+  it('isValid() returns false for invalid inputs', () => {
+    expect(BlockHeader.isValid(new Uint8Array(79))).toBe(false);
+    expect(BlockHeader.isValid('invalid_hex')).toBe(false);
+    expect(BlockHeader.isValid('00'.repeat(79))).toBe(false);
+  });
+});