util: prefixed hex string type improvements (#3995)

* chore: revert startsWith0x

* util: fix hexToBytes in usage

* util: remoe redundant byte checking

* chore: more type adjustments

* format: linting

* monorepo: more type issues

* util: undo remove undefined

* chore: more type fixes

* client: remove typecasting

* client: simplify typecasting

* common: remove typecasting

* chore: remove unused import

* chore: address review comments

* chore: remove unused var

* chore: strictEqual

Author: gabrocheleau

packages/binarytree/test/node/internalNode.spec.ts

@@ -2,17 +2,16 @@ import { equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { assert, describe, it } from 'vitest'
 
 import { BinaryNodeType, InternalBinaryNode, decodeBinaryNode } from '../../src/index.ts'
-import {} from '../../src/types.ts'
 
 describe('InternalBinaryNode', () => {
   it('should round-trip encode and decode an internal node', () => {
     // Create dummy child pointers:
     const leftCanonicalChild = {
-      hash: hexToBytes('0x' + '11'.repeat(32)),
+      hash: hexToBytes(`0x${'11'.repeat(32)}`),
       path: [0, 1, 1, 0, 1, 0],
     }
     const rightCanonicalChild = {
-      hash: hexToBytes('0x' + '22'.repeat(32)),
+      hash: hexToBytes(`0x${'22'.repeat(32)}`),
       path: [1, 1, 0, 0],
     }
     const node = InternalBinaryNode.create([leftCanonicalChild, rightCanonicalChild])

packages/binarytree/test/node/stemNode.spec.ts

@@ -7,14 +7,14 @@ import { StemBinaryNode } from '../../src/node/stemNode.ts'
 describe('StemBinaryNode', () => {
   it('should round-trip encode and decode a stem node', () => {
     // Create a 31-byte stem (for example, all 0x01 bytes)
-    const stem = hexToBytes('0x' + '01'.repeat(31))
+    const stem = hexToBytes(`0x${'01'.repeat(31)}`)
 
     // Create an array of 256 possible values (initially all null)
     const values: (Uint8Array | null)[] = new Array(256).fill(null)
     // Set a few non-null values at specific indices
-    const value3 = hexToBytes('0x' + '02'.repeat(32))
-    const value100 = hexToBytes('0x' + '03'.repeat(32))
-    const value255 = hexToBytes('0x' + '04'.repeat(32))
+    const value3 = hexToBytes(`0x${'02'.repeat(32)}`)
+    const value100 = hexToBytes(`0x${'03'.repeat(32)}`)
+    const value255 = hexToBytes(`0x${'04'.repeat(32)}`)
     values[3] = value3
     values[100] = value100
     values[255] = value255

packages/block/src/block/constructors.ts

@@ -31,7 +31,7 @@ import {
   executionPayloadFromBeaconPayload,
 } from '../index.ts'
 
-import type { EthersProvider, PrefixedHexString, WithdrawalBytes } from '@ethereumjs/util'
+import type { EthersProvider, WithdrawalBytes } from '@ethereumjs/util'
 import type { BeaconPayloadJSON } from '../from-beacon-payload.ts'
 import type {
   BlockBytes,
@@ -339,7 +339,7 @@ export async function createBlockFromExecutionPayload(
   const txs = []
   for (const [index, serializedTx] of transactions.entries()) {
     try {
-      const tx = createTxFromRLP(hexToBytes(serializedTx as PrefixedHexString), {
+      const tx = createTxFromRLP(hexToBytes(serializedTx), {
         common: opts?.common,
       })
       txs.push(tx)
@@ -377,7 +377,7 @@ export async function createBlockFromExecutionPayload(
     throw Error('Missing executionWitness for EIP-6800 activated executionPayload')
   }
   // Verify blockHash matches payload
-  if (!equalsBytes(block.hash(), hexToBytes(payload.blockHash as PrefixedHexString))) {
+  if (!equalsBytes(block.hash(), hexToBytes(payload.blockHash))) {
     const validationError = `Invalid blockHash, expected: ${
       payload.blockHash
     }, received: ${bytesToHex(block.hash())}`

packages/block/test/block.spec.ts

@@ -2,12 +2,12 @@ import { Common, Hardfork, Mainnet, createCustomCommon } from '@ethereumjs/commo
 import { RLP } from '@ethereumjs/rlp'
 import {
   goerliChainConfig,
-  preLondonTestDataBlocks1,
-  preLondonTestDataBlocks2,
+  preLondonTestDataBlocks1RLP,
+  preLondonTestDataBlocks2RLP,
   testnetMergeChainConfig,
 } from '@ethereumjs/testdata'
 import { createLegacyTx } from '@ethereumjs/tx'
-import { KECCAK256_RLP_ARRAY, bytesToHex, equalsBytes, hexToBytes, toBytes } from '@ethereumjs/util'
+import { KECCAK256_RLP_ARRAY, bytesToHex, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { assert, describe, it } from 'vitest'
 
 import { genTransactionsTrieRoot } from '../src/helpers.ts'
@@ -25,7 +25,7 @@ import {
 import { genesisHashesTestData } from './testdata/genesisHashesTest.ts'
 import { testdataFromRPCGoerliData } from './testdata/testdata-from-rpc-goerli.ts'
 
-import type { NestedUint8Array, PrefixedHexString } from '@ethereumjs/util'
+import type { NestedUint8Array } from '@ethereumjs/util'
 
 describe('[Block]: block functions', () => {
   it('should test block initialization', () => {
@@ -137,7 +137,7 @@ describe('[Block]: block functions', () => {
 
   it('should test block validation on pow chain', async () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.Istanbul })
-    const blockRlp = hexToBytes(preLondonTestDataBlocks1.blocks[0].rlp as PrefixedHexString)
+    const blockRlp = hexToBytes(preLondonTestDataBlocks1RLP.blockRLP)
     try {
       createBlockFromRLP(blockRlp, { common })
       assert.isTrue(true, 'should pass')
@@ -163,7 +163,7 @@ describe('[Block]: block functions', () => {
   }
 
   it('should test transaction validation - invalid tx trie', async () => {
-    const blockRlp = hexToBytes(preLondonTestDataBlocks1.blocks[0].rlp as PrefixedHexString)
+    const blockRlp = hexToBytes(preLondonTestDataBlocks1RLP.blockRLP)
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.London })
     const block = createBlockFromRLP(blockRlp, { common, freeze: false })
     await testTransactionValidation(block)
@@ -205,7 +205,7 @@ describe('[Block]: block functions', () => {
 
   it('should test transaction validation with legacy tx in london', async () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.London })
-    const blockRlp = hexToBytes(preLondonTestDataBlocks1.blocks[0].rlp as PrefixedHexString)
+    const blockRlp = hexToBytes(preLondonTestDataBlocks1RLP.blockRLP)
     const block = createBlockFromRLP(blockRlp, { common, freeze: false })
     await testTransactionValidation(block)
     // @ts-expect-error -- Assigning to read-only property
@@ -219,7 +219,7 @@ describe('[Block]: block functions', () => {
 
   it('should test uncles hash validation', async () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.Istanbul })
-    const blockRlp = hexToBytes(preLondonTestDataBlocks2.blocks[2].rlp as PrefixedHexString)
+    const blockRlp = hexToBytes(preLondonTestDataBlocks2RLP.block2RLP)
     const block = createBlockFromRLP(blockRlp, { common, freeze: false })
     assert.equal(block.uncleHashIsValid(), true)
     // @ts-expect-error -- Assigning to read-only property
@@ -356,31 +356,23 @@ describe('[Block]: block functions', () => {
 
   it('should return the same block data from raw()', () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.Istanbul })
-    const block = createBlockFromRLP(
-      toBytes(preLondonTestDataBlocks2.blocks[2].rlp as PrefixedHexString),
-      {
-        common,
-      },
-    )
+    const block = createBlockFromRLP(hexToBytes(preLondonTestDataBlocks2RLP.block2RLP), {
+      common,
+    })
     const createBlockFromRaw = createBlockFromBytesArray(block.raw(), { common })
     assert.isTrue(equalsBytes(block.hash(), createBlockFromRaw.hash()))
   })
 
   it('should test toJSON', () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.Istanbul })
-    const block = createBlockFromRLP(
-      toBytes(preLondonTestDataBlocks2.blocks[2].rlp as PrefixedHexString),
-      {
-        common,
-      },
-    )
+    const block = createBlockFromRLP(hexToBytes(preLondonTestDataBlocks2RLP.block2RLP), {
+      common,
+    })
     assert.equal(typeof block.toJSON(), 'object')
   })
 
   it('DAO hardfork', () => {
-    const blockData = RLP.decode(
-      preLondonTestDataBlocks2.blocks[0].rlp as PrefixedHexString,
-    ) as NestedUint8Array
+    const blockData = RLP.decode(preLondonTestDataBlocks2RLP.block0RLP) as NestedUint8Array
     // Set block number from test block to mainnet DAO fork block 1920000
     blockData[0][8] = hexToBytes('0x1D4C00')
 

packages/blockchain/test/index.spec.ts

@@ -5,7 +5,7 @@ import {
   createBlockHeaderFromBytesArray,
 } from '@ethereumjs/block'
 import { Common, Hardfork, Holesky, Mainnet, Sepolia } from '@ethereumjs/common'
-import { goerliChainConfig, mainnetBlocks, preLondonTestDataBlocks1 } from '@ethereumjs/testdata'
+import { goerliChainConfig, mainnetBlocks, preLondonTestDataBlocks1RLP } from '@ethereumjs/testdata'
 import { MapDB, bytesToHex, equalsBytes, hexToBytes, utf8ToBytes } from '@ethereumjs/util'
 import { assert, describe, it } from 'vitest'
 
@@ -14,7 +14,6 @@ import { Blockchain, createBlockchain, createBlockchainFromBlocksData } from '..
 import { createTestDB, generateBlockchain, generateBlocks, isConsecutive } from './util.ts'
 
 import type { Block, BlockOptions } from '@ethereumjs/block'
-import type { PrefixedHexString } from '@ethereumjs/util'
 
 describe('blockchain test', () => {
   it('should not crash on getting head of a blockchain without a genesis', async () => {
@@ -581,15 +580,15 @@ describe('blockchain test', () => {
 
   it('should add block with body', async () => {
     const common = new Common({ chain: Mainnet, hardfork: Hardfork.Istanbul })
-    const genesisRlp = hexToBytes(preLondonTestDataBlocks1.genesisRLP as PrefixedHexString)
+    const genesisRlp = hexToBytes(preLondonTestDataBlocks1RLP.genesisRLP)
     const genesisBlock = createBlockFromRLP(genesisRlp, { common })
     const blockchain = await createBlockchain({
       validateBlocks: true,
       validateConsensus: false,
       genesisBlock,
     })
 
-    const blockRlp = hexToBytes(preLondonTestDataBlocks1.blocks[0].rlp as PrefixedHexString)
+    const blockRlp = hexToBytes(preLondonTestDataBlocks1RLP.blockRLP)
     const block = createBlockFromRLP(blockRlp, { common })
     await blockchain.putBlock(block)
   })

packages/client/bin/utils.ts

@@ -52,7 +52,7 @@ import { Event } from '../src/types.ts'
 import { parseMultiaddrs } from '../src/util/index.ts'
 import { setupMetrics } from '../src/util/metrics.ts'
 
-import type { CustomCrypto, GenesisState } from '@ethereumjs/common'
+import type { CustomCrypto, GenesisState, GethGenesis } from '@ethereumjs/common'
 import type { Address, PrefixedHexString } from '@ethereumjs/util'
 import type { Logger } from '../src/logging.ts'
 import type { ClientOpts } from '../src/types.ts'
@@ -495,7 +495,7 @@ async function setupDevnet(prefundAddress: Address, args: ClientOpts) {
             epoch: 30000,
           },
         }
-  const defaultChainData = {
+  const defaultChainData: GethGenesis = {
     config: {
       chainId: 123456,
       homesteadBlock: 0,
@@ -521,6 +521,7 @@ async function setupDevnet(prefundAddress: Address, args: ClientOpts) {
     gasUsed: '0x0',
     parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
     baseFeePerGas: 7,
+    alloc: {},
   }
   const extraData =
     args.dev === 'pow' ? '0x' + '0'.repeat(32) : '0x' + '0'.repeat(64) + addr + '0'.repeat(130)

packages/client/src/sync/fetcher/trienodefetcher.ts

@@ -347,7 +347,7 @@ export class TrieNodeFetcher extends Fetcher<JobTask, Uint8Array[], Uint8Array>
           // add account node data to account trie
           const node = decodeMPTNode(nodeData)
           if (node instanceof LeafMPTNode) {
-            const key = bytesToUnprefixedHex(pathToHexKey(path, node.key(), 'keybyte'))
+            const key = bytesToHex(pathToHexKey(path, node.key(), 'keybyte'))
             ops.push({
               type: 'put',
               key: hexToBytes(key),
@@ -365,9 +365,7 @@ export class TrieNodeFetcher extends Fetcher<JobTask, Uint8Array[], Uint8Array>
               for (const [path, data] of pathToStorageNode) {
                 const storageNode = decodeMPTNode(data)
                 if (storageNode instanceof LeafMPTNode) {
-                  const storageKey = bytesToUnprefixedHex(
-                    pathToHexKey(path, storageNode.key(), 'keybyte'),
-                  )
+                  const storageKey = bytesToHex(pathToHexKey(path, storageNode.key(), 'keybyte'))
                   storageTrieOps.push({
                     type: 'put',
                     key: hexToBytes(storageKey),

packages/client/src/util/vkt.ts

@@ -16,9 +16,11 @@ export async function generateVKTStateRoot(genesisState: GenesisState, common: C
   const state = new StatefulVerkleStateManager({ common })
   await state['_trie'].createRootNode()
   await state.checkpoint()
-  for (const addressStr of Object.keys(genesisState)) {
+  for (const addressStr of Object.keys(genesisState) as PrefixedHexString[]) {
     const addrState = genesisState[addressStr]
-    let nonce, balance, code
+    let nonce: PrefixedHexString | undefined
+    let balance: PrefixedHexString | bigint
+    let code: PrefixedHexString | undefined
     let storage: StoragePair[] | undefined
     if (Array.isArray(addrState)) {
       ;[balance, code, storage, nonce] = addrState
@@ -51,8 +53,8 @@ export async function generateVKTStateRoot(genesisState: GenesisState, common: C
 
     // Put account data
     const account = createPartialAccount({
-      nonce: nonce as PrefixedHexString,
-      balance: balance as PrefixedHexString,
+      nonce,
+      balance,
       codeHash,
       codeSize: codeBuf.byteLength,
     })

packages/client/test/integration/miner.spec.ts

@@ -1,4 +1,9 @@
-import { Hardfork, createCommonFromGethGenesis, parseGethGenesisState } from '@ethereumjs/common'
+import {
+  type GethGenesis,
+  Hardfork,
+  createCommonFromGethGenesis,
+  parseGethGenesisState,
+} from '@ethereumjs/common'
 import { Address, bytesToHex, concatBytes, hexToBytes } from '@ethereumjs/util'
 import { assert, describe, it } from 'vitest'
 
@@ -12,7 +17,7 @@ import type { EthereumClient } from '../../src/index.ts'
 
 async function setupDevnet(prefundAddress: Address) {
   const addr = prefundAddress.toString().slice(2)
-  const defaultChainData = {
+  const defaultChainData: GethGenesis = {
     config: {
       chainId: 123456,
       homesteadBlock: 0,
@@ -37,6 +42,7 @@ async function setupDevnet(prefundAddress: Address) {
     gasUsed: '0x0',
     parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
     baseFeePerGas: 7,
+    alloc: {},
   }
   const extraData = concatBytes(new Uint8Array(32), prefundAddress.toBytes(), new Uint8Array(65))
 

packages/client/test/integration/pow.spec.ts

@@ -1,5 +1,10 @@
 import { rmSync } from 'fs'
-import { Hardfork, createCommonFromGethGenesis, parseGethGenesisState } from '@ethereumjs/common'
+import {
+  type GethGenesis,
+  Hardfork,
+  createCommonFromGethGenesis,
+  parseGethGenesisState,
+} from '@ethereumjs/common'
 import { assert, describe, it } from 'vitest'
 
 import { Config } from '../../src/index.ts'
@@ -18,7 +23,7 @@ async function setupPowDevnet(prefundAddress: Address, cleanStart: boolean) {
   const addr = prefundAddress.toString().slice(2)
   const consensusConfig = { ethash: true }
 
-  const defaultChainData = {
+  const defaultChainData: GethGenesis = {
     config: {
       chainId: 123456,
       homesteadBlock: 0,
@@ -44,9 +49,10 @@ async function setupPowDevnet(prefundAddress: Address, cleanStart: boolean) {
     gasUsed: '0x0',
     parentHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
     baseFeePerGas: 7,
+    alloc: {},
   }
-  const extraData = '0x' + '0'.repeat(32)
-  const chainData = {
+  const extraData = `0x${'0'.repeat(32)}`
+  const chainData: GethGenesis = {
     ...defaultChainData,
     extraData,
     alloc: { [addr]: { balance: '0x10000000000000000000' } },