@bsv/wallet-toolbox 1.5.20 → 1.6.1

package/src/services/chaintracker/chaintracks/util/__tests/ChaintracksFetch.test.ts

@@ -0,0 +1,60 @@
+import { Hash } from '@bsv/sdk'
+import { BulkHeaderFilesInfo } from '../BulkHeaderFile'
+import { ChaintracksFetch } from '../ChaintracksFetch'
+import { asArray, asString } from '../../../../../utility/utilityHelpers.noBuffer'
+import { validBulkHeaderFilesByFileHash } from '../validBulkHeaderFilesByFileHash'
+
+describe('ChaintracksFetch tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 fetchJson', async () => {
+    const fetch = new ChaintracksFetch()
+    const cdnUrl = 'https://cdn.projectbabbage.com/blockheaders/'
+    //const jsonResource = `${cdnUrl}/testNetV2.json`
+    const jsonResource = `${cdnUrl}/testNetBlockHeaders.json`
+    const info: BulkHeaderFilesInfo = await fetch.fetchJson(jsonResource)
+    expect(info).toBeDefined()
+    expect(info.files.length).toBeGreaterThan(4)
+  })
+
+  test('1 download', async () => {
+    const fetch = new ChaintracksFetch()
+    const cdnUrl = 'https://cdn.projectbabbage.com/blockheaders/'
+    const url = `${cdnUrl}/testNet_0.headers`
+    const data = await fetch.download(url)
+    expect(data.length).toBe(8000000)
+    const fileHash = asString(Hash.sha256(asArray(data)), 'base64')
+    expect(validBulkHeaderFilesByFileHash()[fileHash]).toBeDefined()
+  })
+
+  test.skip('2 download faster crypto.subtle sha256', async () => {
+    const fetch = new ChaintracksFetch()
+    const cdnUrl = 'https://cdn.projectbabbage.com/blockheaders/'
+    const url = `${cdnUrl}/testNet_0.headers`
+    const data = await fetch.download(url)
+    expect(data.length).toBe(8000000)
+    const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', Uint8Array.from(data)))
+    const fileHash = asString(hash, 'base64')
+    expect(validBulkHeaderFilesByFileHash()[fileHash]).toBeDefined()
+  })
+
+  test('3 download', async () => {
+    const fetch = new ChaintracksFetch()
+    const cdnUrl = 'https://cdn.projectbabbage.com/blockheaders/'
+    const url = `${cdnUrl}/testNet_4.headers`
+    const data = await fetch.download(url)
+    expect(data.length).toBe(80 * 100000)
+    const fileHash = asString(Hash.sha256(asArray(data)), 'base64')
+    expect(validBulkHeaderFilesByFileHash()[fileHash]).toBeDefined()
+  })
+
+  test('4 download', async () => {
+    const fetch = new ChaintracksFetch()
+    const cdnUrl = 'https://cdn.projectbabbage.com/blockheaders/'
+    const url = `${cdnUrl}/mainNet_2.headers`
+    const data = await fetch.download(url)
+    expect(data.length).toBe(80 * 100000)
+    const fileHash = asString(Hash.sha256(asArray(data)), 'base64')
+    expect(validBulkHeaderFilesByFileHash()[fileHash]).toBeDefined()
+  })
+})

package/src/services/chaintracker/chaintracks/util/__tests/HeightRange.test.ts

@@ -0,0 +1,67 @@
+import { HeightRange } from '../HeightRange'
+
+describe('testing HeightRange', () => {
+  const hr = (a: number, b: number) => new HeightRange(a, b)
+  test('length', () => {
+    expect(hr(1, 1).length).toBe(1)
+    expect(hr(1, 10).length).toBe(10)
+    expect(hr(1, 0).length).toBe(0)
+    expect(hr(1, -10).length).toBe(0)
+  })
+  test('copy', () => {
+    expect(hr(4, 8).copy()).toEqual(hr(4, 8))
+  })
+  test('intersect', () => {
+    expect(hr(4, 8).intersect(hr(1, 2)).isEmpty).toBe(true)
+    expect(hr(4, 8).intersect(hr(1, 3)).isEmpty).toBe(true)
+    expect(hr(4, 8).intersect(hr(1, 4))).toEqual(hr(4, 4))
+    expect(hr(4, 8).intersect(hr(1, 7))).toEqual(hr(4, 7))
+    expect(hr(4, 8).intersect(hr(1, 8))).toEqual(hr(4, 8))
+    expect(hr(4, 8).intersect(hr(1, 10))).toEqual(hr(4, 8))
+    expect(hr(4, 8).intersect(hr(4, 10))).toEqual(hr(4, 8))
+    expect(hr(4, 8).intersect(hr(5, 10))).toEqual(hr(5, 8))
+    expect(hr(4, 8).intersect(hr(6, 10))).toEqual(hr(6, 8))
+    expect(hr(4, 8).intersect(hr(7, 10))).toEqual(hr(7, 8))
+    expect(hr(4, 8).intersect(hr(8, 10))).toEqual(hr(8, 8))
+    expect(hr(4, 8).intersect(hr(9, 10)).isEmpty).toBe(true)
+    expect(hr(4, 8).intersect(hr(10, 10)).isEmpty).toBe(true)
+    expect(hr(4, -8).intersect(hr(4, 10)).isEmpty).toBe(true)
+    expect(hr(4, -8).intersect(hr(4, -10)).isEmpty).toBe(true)
+    expect(hr(4, 8).intersect(hr(9, -10)).isEmpty).toBe(true)
+  })
+  test('union', () => {
+    expect(() => hr(4, 8).union(hr(1, 2))).toThrow()
+    expect(hr(4, 8).union(hr(1, 3))).toEqual(hr(1, 8))
+    expect(hr(4, 8).union(hr(1, 4))).toEqual(hr(1, 8))
+    expect(hr(4, 8).union(hr(1, 7))).toEqual(hr(1, 8))
+    expect(hr(4, 8).union(hr(1, 8))).toEqual(hr(1, 8))
+    expect(hr(4, 8).union(hr(1, 10))).toEqual(hr(1, 10))
+    expect(hr(4, 8).union(hr(4, 10))).toEqual(hr(4, 10))
+    expect(hr(4, 8).union(hr(5, 10))).toEqual(hr(4, 10))
+    expect(hr(4, 8).union(hr(6, 10))).toEqual(hr(4, 10))
+    expect(hr(4, 8).union(hr(7, 10))).toEqual(hr(4, 10))
+    expect(hr(4, 8).union(hr(8, 10))).toEqual(hr(4, 10))
+    expect(hr(4, 8).union(hr(9, 10))).toEqual(hr(4, 10))
+    expect(() => hr(4, 8).union(hr(10, 10))).toThrow()
+    expect(hr(4, -8).union(hr(4, 10))).toEqual(hr(4, 10))
+    expect(hr(4, -8).union(hr(4, -10)).isEmpty).toBe(true)
+    expect(hr(4, 8).union(hr(9, -10))).toEqual(hr(4, 8))
+  })
+  test('subtract', () => {
+    expect(() => hr(4, 8).subtract(hr(5, 7))).toThrow()
+    expect(hr(4, 8).subtract(hr(1, 3))).toEqual(hr(4, 8))
+    expect(hr(4, 8).subtract(hr(1, 4))).toEqual(hr(5, 8))
+    expect(hr(4, 8).subtract(hr(1, 7))).toEqual(hr(8, 8))
+    expect(hr(4, 8).subtract(hr(1, 8)).isEmpty).toBe(true)
+    expect(hr(4, 8).subtract(hr(1, 10)).isEmpty).toBe(true)
+    expect(hr(4, 8).subtract(hr(4, 10)).isEmpty).toBe(true)
+    expect(hr(4, 8).subtract(hr(5, 10))).toEqual(hr(4, 4))
+    expect(hr(4, 8).subtract(hr(6, 10))).toEqual(hr(4, 5))
+    expect(hr(4, 8).subtract(hr(7, 10))).toEqual(hr(4, 6))
+    expect(hr(4, 8).subtract(hr(8, 10))).toEqual(hr(4, 7))
+    expect(hr(4, 8).subtract(hr(9, 10))).toEqual(hr(4, 8))
+    expect(hr(4, -8).subtract(hr(4, 10)).isEmpty).toBe(true)
+    expect(hr(4, -8).subtract(hr(4, -10)).isEmpty).toBe(true)
+    expect(hr(4, 8).subtract(hr(9, -10))).toEqual(hr(4, 8))
+  })
+})

package/src/services/chaintracker/chaintracks/util/__tests/SingleWriterMultiReaderLock.test.ts

@@ -0,0 +1,49 @@
+import { SingleWriterMultiReaderLock } from '../SingleWriterMultiReaderLock'
+
+class TestLock {
+  private lock: SingleWriterMultiReaderLock = new SingleWriterMultiReaderLock()
+  private value: number = 0
+
+  async readValue(): Promise<number> {
+    return this.lock.withReadLock(async () => {
+      // Simulate some read delay
+      await new Promise(resolve => setTimeout(resolve, 10))
+      return this.value
+    })
+  }
+
+  async writeValue(newValue: number): Promise<number> {
+    return this.lock.withWriteLock(async () => {
+      // Simulate some write delay
+      await new Promise(resolve => setTimeout(resolve, 50))
+      this.value = newValue
+      return this.value
+    })
+  }
+
+  async test(): Promise<number[]> {
+    const promises: Promise<number>[] = []
+    const readCount = 3
+    for (let i = 0; i < readCount; i++) promises.push(this.readValue())
+    promises.push(this.writeValue(42))
+    promises.push(this.writeValue(43))
+    promises.push(this.writeValue(47))
+    for (let i = 0; i < readCount; i++) promises.push(this.readValue())
+    promises.push(this.writeValue(44))
+    promises.push(this.writeValue(45))
+    promises.push(this.writeValue(46))
+    for (let i = 0; i < readCount; i++) promises.push(this.readValue())
+    const results = await Promise.all(promises)
+    return results
+  }
+}
+
+describe('SingleWriterMultiReaderLock tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0_', async () => {
+    const t = new TestLock()
+    const r = await t.test()
+    expect(r).toEqual([0, 0, 0, 42, 43, 47, 46, 46, 46, 44, 45, 46, 46, 46, 46])
+  })
+})

package/src/services/chaintracker/chaintracks/util/blockHeaderUtilities.ts

@@ -1,43 +1,82 @@
 import { validateAgainstDirtyHashes } from './dirtyHashes'
 import { BigNumber, Hash, Utils } from '@bsv/sdk'
-
-import { asArray, asBuffer, asString } from '../../../../utility/utilityHelpers.buffer'
-import { doubleSha256BE, doubleSha256LE } from '../../../../utility/utilityHelpers'
-import { BaseBlockHeader, BlockHeader } from '../Api/BlockHeaderApi'
+import { asArray, asString } from '../../../../utility/utilityHelpers.noBuffer'
+import { doubleSha256BE } from '../../../../utility/utilityHelpers'
 import { Chain } from '../../../../sdk/types'
+import { ChaintracksFsApi } from '../Api/ChaintracksFsApi'
+import { ReaderUint8Array } from '../../../../utility/ReaderUint8Array'
+import { BulkHeaderFileInfo } from './BulkHeaderFile'
+import { ChaintracksFetchApi } from '../Api/ChaintracksFetchApi'
+import { isKnownValidBulkHeaderFile } from './validBulkHeaderFilesByFileHash'
+import { WERR_INVALID_OPERATION, WERR_INVALID_PARAMETER } from '../../../../sdk/WERR_errors'
+import { BaseBlockHeader, BlockHeader } from '../../../../sdk/WalletServices.interfaces'
 
 /**
  * Computes sha256 hash of file contents read as bytes with no encoding.
  * @param filepath Full filepath to file.
- * @param bufferSize Optional read buffer size to use. Defaults to 80,000 bytes.
+ * @param bufferSize Optional read buffer size to use. Defaults to 80,000 bytes. Currently ignored.
  * @returns `{hash, length}` where `hash` is base64 string form of file hash and `length` is file length in bytes.
  */
-/*
 export async function sha256HashOfBinaryFile(
+  fs: ChaintracksFsApi,
   filepath: string,
   bufferSize = 80000
 ): Promise<{ hash: string; length: number }> {
-  const file = await fs.open(filepath, 'r')
-  try {
-    let length = 0
-
-    const sha256 = new Hash.SHA256()
-    const readBuf = Buffer.alloc(bufferSize)
-
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const rr = await file.read(readBuf, 0, readBuf.length)
-      if (!rr.bytesRead) break
-      length += rr.bytesRead
-      sha256.update(asArray(rr.buffer))
-    }
+  const sha256 = new Hash.SHA256()
+  const bytes = await fs.readFile(filepath)
+  const length = bytes.length
+  sha256.update(asArray(bytes))
+  return { hash: Utils.toBase64(sha256.digest()), length }
+}
 
-    return { hash: Utils.toBase64(sha256.digest()), length }
-  } finally {
-    await file.close()
+/**
+ * Validates the contents of a bulk header file.
+ * @param bf BulkHeaderFileInfo containing `data` to validate.
+ * @param prevHash Required previous header hash.
+ * @param prevChainWork Required previous chain work.
+ * @param fetch Optional ChaintracksFetchApi instance for fetching data.
+ * @returns Validated BulkHeaderFileInfo with `validated` set to true.
+ */
+export async function validateBulkFileData(
+  bf: BulkHeaderFileInfo,
+  prevHash: string,
+  prevChainWork: string,
+  fetch?: ChaintracksFetchApi
+): Promise<BulkHeaderFileInfo> {
+  const vbf = { ...bf }
+
+  if (!vbf.data && vbf.sourceUrl && fetch) {
+    const url = fetch.pathJoin(vbf.sourceUrl, vbf.fileName)
+    vbf.data = await fetch.download(url)
   }
+
+  if (!vbf.data) throw new WERR_INVALID_OPERATION(`bulk file ${vbf.fileName} data is unavailable`)
+
+  if (vbf.count <= 0)
+    throw new WERR_INVALID_PARAMETER('bf.count', `expected count to be greater than 0, but got ${vbf.count}`)
+
+  if (vbf.data.length !== vbf.count * 80)
+    throw new WERR_INVALID_PARAMETER(
+      'bf.data',
+      `bulk file ${vbf.fileName} data length ${vbf.data.length} does not match expected count ${vbf.count}`
+    )
+
+  vbf.fileHash = asString(Hash.sha256(asArray(vbf.data)), 'base64')
+  if (bf.fileHash && bf.fileHash !== vbf.fileHash)
+    throw new WERR_INVALID_PARAMETER('bf.fileHash', `expected ${bf.fileHash} but got ${vbf.fileHash}`)
+
+  if (!isKnownValidBulkHeaderFile(vbf)) {
+    const { lastHeaderHash, lastChainWork } = validateBufferOfHeaders(vbf.data, prevHash, 0, undefined, prevChainWork)
+    vbf.lastHash = lastHeaderHash
+    vbf.lastChainWork = lastChainWork!
+    if (vbf.firstHeight === 0) {
+      validateGenesisHeader(vbf.data, vbf.chain!)
+    }
+  }
+  vbf.validated = true
+
+  return vbf
 }
-*/
 
 /**
  * Validate headers contained in an array of bytes. The headers must be consecutive block headers, 80 bytes long,
@@ -48,26 +87,61 @@ export async function sha256HashOfBinaryFile(
  * @param count Optional number of headers to validate. Validates to end of buffer if missing.
  * @returns Header hash of last header validated or previousHash if there where none.
  */
-export function validateBufferOfHeaders(buffer: number[], previousHash: string, offset = 0, count = -1): string {
+export function validateBufferOfHeaders(
+  buffer: Uint8Array,
+  previousHash: string,
+  offset = 0,
+  count = -1,
+  previousChainWork?: string
+): { lastHeaderHash: string; lastChainWork: string | undefined } {
   if (count < 0) count = Math.floor((buffer.length - offset) / 80)
   count = Math.max(0, count)
   let lastHeaderHash = previousHash
+  let lastChainWork = previousChainWork
   for (let i = 0; i < count; i++) {
     const headerStart = offset + i * 80
     const headerEnd = headerStart + 80
     if (headerEnd > buffer.length) {
-      throw {
-        message: `header ${i} missing bytes for header at offset ${headerStart} in buffer of length ${buffer.length}`
-      }
+      throw new WERR_INVALID_PARAMETER(
+        'buffer',
+        `multiple of 80 bytes long. header ${i} missing bytes for header at offset ${headerStart} in buffer of length ${buffer.length}`
+      )
     }
     const header = buffer.slice(headerStart, headerEnd)
+    const h = deserializeBaseBlockHeader(header)
     const hashPrev = asString(header.slice(4, 36).reverse())
     if (lastHeaderHash !== hashPrev)
       throw { message: `header ${i} invalid previousHash ${lastHeaderHash} vs ${hashPrev}` }
     lastHeaderHash = asString(doubleSha256BE(header))
     validateAgainstDirtyHashes(lastHeaderHash)
+    if (lastChainWork) {
+      lastChainWork = addWork(lastChainWork, convertBitsToWork(h.bits))
+    }
+  }
+  return { lastHeaderHash, lastChainWork }
+}
+
+/**
+ * Verifies that buffer begins with valid genesis block header for the specified chain.
+ * @param buffer
+ * @param chain
+ */
+export function validateGenesisHeader(buffer: Uint8Array, chain: Chain): void {
+  const header = buffer.slice(0, 80)
+  const h = deserializeBlockHeader(header, 0, 0)
+  const gh = genesisHeader(chain)
+  if (
+    h.bits !== gh.bits ||
+    h.previousHash !== gh.previousHash ||
+    h.merkleRoot !== gh.merkleRoot ||
+    h.time !== gh.time ||
+    h.nonce !== gh.nonce ||
+    h.version !== gh.version ||
+    h.height !== gh.height ||
+    h.hash !== gh.hash
+  ) {
+    throw new WERR_INVALID_PARAMETER('buffer', `genesis header for chain ${chain}`)
   }
-  return lastHeaderHash
 }
 
 /**
@@ -90,7 +164,7 @@ export function isMoreWork(work1: string, work2: string): boolean {
  * @returns Sum of work1 + work2 as Buffer encoded chainWork value
  */
 export function addWork(work1: string, work2: string): string {
-  const sum = new BigNumber(asArray(work1), 16).add(new BigNumber(asArray(work2), 16))
+  const sum = new BigNumber(work1, 16).add(new BigNumber(work2, 16))
   return workBNtoBuffer(sum)
 }
 
@@ -99,7 +173,7 @@ export function addWork(work1: string, work2: string): string {
  * @returns work1 - work2 as Buffer encoded chainWork value
  */
 export function subWork(work1: string, work2: string): string {
-  const sum = new BigNumber(asArray(work1), 16).sub(new BigNumber(asArray(work2), 16))
+  const sum = new BigNumber(work1, 16).sub(new BigNumber(work2, 16))
   return workBNtoBuffer(sum)
 }
 
@@ -139,13 +213,13 @@ export function convertBitsToWork(bits: number | number[]): string {
 }
 
 export function deserializeBaseBlockHeaders(
-  buffer: number[],
+  buffer: number[] | Uint8Array,
   offset = 0,
   count?: number | undefined
 ): BaseBlockHeader[] {
   const headers: BaseBlockHeader[] = []
   while ((!count || headers.length < count) && offset + 80 <= buffer.length && offset >= 0) {
-    headers.push(deserializeBlockHeader(buffer, offset))
+    headers.push(deserializeBaseBlockHeader(buffer, offset))
     offset += 80
   }
   return headers
@@ -153,7 +227,7 @@ export function deserializeBaseBlockHeaders(
 
 export function deserializeBlockHeaders(
   firstHeight: number,
-  buffer: number[],
+  buffer: number[] | Uint8Array,
   offset = 0,
   count?: number | undefined
 ): BlockHeader[] {
@@ -161,7 +235,7 @@ export function deserializeBlockHeaders(
   let nextHeight = firstHeight
   while ((!count || headers.length < count) && offset + 80 <= buffer.length && offset >= 0) {
     const baseBuffer = buffer.slice(offset, offset + 80)
-    const base = deserializeBlockHeader(baseBuffer)
+    const base = deserializeBaseBlockHeader(baseBuffer)
     const header = {
       ...base,
       height: nextHeight++,
@@ -173,23 +247,6 @@ export function deserializeBlockHeaders(
   return headers
 }
 
-/**
- * Extract an array of block hashes and of merkleRoots from a buffer of serialized block headers.
- * @param buffer
- */
-export function extractHashesAndRoots(buffer: Buffer): { hashes: Buffer[]; merkleRoots: Buffer[] } {
-  const hashes: Buffer[] = []
-  const merkleRoots: Buffer[] = []
-  for (let i = 0; i < buffer.length / 80; i++) {
-    const offset = i * 80
-    const hash = asBuffer(doubleSha256LE(asArray(buffer.subarray(offset, 80 + offset))).reverse())
-    const merkleRoot = buffer.subarray(36 + offset, 68 + offset).reverse()
-    hashes.push(hash)
-    merkleRoots.push(merkleRoot)
-  }
-  return { hashes, merkleRoots }
-}
-
 /**
  * Given a block header, ensures that its format is correct. This does not
  * check its difficulty or validity relative to the chain of headers.
@@ -345,8 +402,8 @@ export function validateHeaderDifficulty(hash: Buffer, bits: number) {
  * @returns doule sha256 hash of header bytes reversed
  * @publicbody
  */
-export function blockHash(header: BaseBlockHeader | number[]): string {
-  const a = !Array.isArray(header) ? serializeBlockHeader(header) : header
+export function blockHash(header: BaseBlockHeader | number[] | Uint8Array): string {
+  const a = !Array.isArray(header) && !(header instanceof Uint8Array) ? serializeBaseBlockHeader(header) : header
   if (a.length !== 80) throw new Error('Block header must be 80 bytes long.')
   return asString(doubleSha256BE(a))
 }
@@ -359,7 +416,7 @@ export function blockHash(header: BaseBlockHeader | number[]): string {
  * @returns 80 byte Buffer
  * @publicbody
  */
-export function serializeBlockHeader(header: BaseBlockHeader, buffer?: number[], offset?: number): number[] {
+export function serializeBaseBlockHeader(header: BaseBlockHeader, buffer?: number[], offset?: number): number[] {
   const writer = new Utils.Writer()
   writer.writeUInt32LE(header.version)
   writer.write(asArray(header.previousHash).reverse())
@@ -370,17 +427,33 @@ export function serializeBlockHeader(header: BaseBlockHeader, buffer?: number[],
   const data = writer.toArray()
   if (buffer) {
     offset ||= 0
-    buffer.splice(offset, buffer.length, ...data)
+    for (let i = 0; i < data.length; i++) {
+      if (offset + i >= buffer.length) {
+        throw new Error(`Buffer overflow at offset ${offset + i} for data length ${data.length}`)
+      }
+      buffer[offset + i] = data[i]
+    }
+  }
+  return data
+}
+
+export function serializeBaseBlockHeaders(headers: BlockHeader[]): Uint8Array {
+  const data = new Uint8Array(headers.length * 80)
+  let i = -1
+  for (const header of headers) {
+    i++
+    const d = serializeBaseBlockHeader(header)
+    data.set(d, i * 80)
   }
   return data
 }
 
 /**
- * Deserialize a block header from an 80 byte buffer
+ * Deserialize a BaseBlockHeader from an 80 byte buffer
  * @publicbody
  */
-export function deserializeBlockHeader(buffer: number[], offset = 0): BaseBlockHeader {
-  const reader = new Utils.Reader(buffer, offset)
+export function deserializeBaseBlockHeader(buffer: number[] | Uint8Array, offset = 0): BaseBlockHeader {
+  const reader = ReaderUint8Array.makeReader(buffer, offset)
   const header: BaseBlockHeader = {
     version: reader.readUInt32LE(),
     previousHash: asString(reader.read(32).reverse()),
@@ -392,6 +465,16 @@ export function deserializeBlockHeader(buffer: number[], offset = 0): BaseBlockH
   return header
 }
 
+export function deserializeBlockHeader(buffer: number[] | Uint8Array, offset = 0, height: number): BlockHeader {
+  const base = deserializeBaseBlockHeader(buffer, offset)
+  const header: BlockHeader = {
+    ...base,
+    height,
+    hash: asString(doubleSha256BE(buffer.slice(offset, offset + 80)))
+  }
+  return header
+}
+
 /**
  * Returns the genesis block for the specified chain.
  * @publicbody
@@ -425,7 +508,7 @@ export function genesisHeader(chain: Chain): BlockHeader {
  * @publicbody
  */
 export function genesisBuffer(chain: Chain): number[] {
-  return serializeBlockHeader(genesisHeader(chain))
+  return serializeBaseBlockHeader(genesisHeader(chain))
 }
 
 /**
@@ -453,7 +536,7 @@ export function convertUint32ToBuffer(n: number, littleEndian = true): number[]
   return littleEndian ? a : a.reverse()
 }
 
-export function writeUInt32LE(n: number, a: number[], offset: number): number {
+export function writeUInt32LE(n: number, a: number[] | Uint8Array, offset: number): number {
   a[offset++] = n & 0xff // lowest byte
   a[offset++] = (n >> 8) & 0xff
   a[offset++] = (n >> 16) & 0xff
@@ -461,7 +544,7 @@ export function writeUInt32LE(n: number, a: number[], offset: number): number {
   return offset
 }
 
-export function writeUInt32BE(n: number, a: number[], offset: number): number {
+export function writeUInt32BE(n: number, a: number[] | Uint8Array, offset: number): number {
   a[offset++] = (n >> 24) & 0xff // highest byte
   a[offset++] = (n >> 16) & 0xff
   a[offset++] = (n >> 8) & 0xff
@@ -469,11 +552,11 @@ export function writeUInt32BE(n: number, a: number[], offset: number): number {
   return offset
 }
 
-export function readUInt32LE(a: number[], offset: number): number {
+export function readUInt32LE(a: number[] | Uint8Array, offset: number): number {
   return a[offset++] | (a[offset++] << 8) | (a[offset++] << 16) | (a[offset++] << 24)
 }
 
-export function readUInt32BE(a: number[], offset: number): number {
+export function readUInt32BE(a: number[] | Uint8Array, offset: number): number {
   return (a[offset++] << 24) | (a[offset++] << 16) | (a[offset++] << 8) | a[offset++]
 }
 
@@ -483,7 +566,7 @@ export function readUInt32BE(a: number[], offset: number): number {
  * @returns a number value in the Uint32 value range
  * @publicbody
  */
-export function convertBufferToUint32(buffer: number[], littleEndian = true): number {
+export function convertBufferToUint32(buffer: number[] | Uint8Array, littleEndian = true): number {
   const a = littleEndian ? buffer : buffer.slice().reverse()
   const n = a[0] | (a[1] << 8) | (a[2] << 16) | (a[3] << 24)
   return n