Merge branch 'master' into client-rpc-payload-limit

Author: jochem-brouwer

.nvmrc

@@ -0,0 +1 @@
+20 

packages/block/README.md

@@ -240,6 +240,39 @@ void main()
 
 Starting with v10 this library supports requests to the consensus layer which have been introduced with [EIP-7685](https://eips.ethereum.org/EIPS/eip-7685) (`Hardfork.Prague` or higher). See the `@ethereumjs/util` [Request](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/util#module-request) README section for an overview of current request types.
 
+```ts
+// ./examples/clrequests.ts
+
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+import { createCLRequest, CLRequestType, hexToBytes, bytesToHex } from '@ethereumjs/util'
+import { sha256 } from 'ethereum-cryptography/sha256.js'
+
+import { createBlock, genRequestsRoot } from '../src'
+
+// Enable EIP-7685 to support CLRequests
+const common = new Common({ chain: Mainnet, hardfork: Hardfork.Cancun, eips: [7685] })
+
+// Create the three CLRequest types (Deposit, Withdrawal, Consolidation)
+const depositData = hexToBytes('0x00...') // Deposit request data
+const depositRequest = createCLRequest(depositData)
+
+const withdrawalData = hexToBytes('0x01...') // Withdrawal request data
+const withdrawalRequest = createCLRequest(withdrawalData)
+
+const consolidationData = hexToBytes('0x02...') // Consolidation request data
+const consolidationRequest = createCLRequest(consolidationData)
+
+// CLRequests must be sorted by type (Deposit=0, Withdrawal=1, Consolidation=2)
+const requests = [depositRequest, withdrawalRequest, consolidationRequest]
+
+// Generate the requestsHash
+const requestsHash = genRequestsRoot(requests, sha256)
+
+// Create a block with the CLRequests hash
+const block = createBlock({ header: { requestsHash } }, { common })
+console.log(`Created block with CLRequests hash: 0x${bytesToHex(block.hash())}`)
+```
+
 ### Consensus Types
 
 ### Proof-of-Stake

packages/block/examples/clrequests.ts

@@ -0,0 +1,57 @@
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+import { CLRequestType, bytesToHex, createCLRequest, hexToBytes } from '@ethereumjs/util'
+import { sha256 } from 'ethereum-cryptography/sha256.js'
+
+import { createBlock, genRequestsRoot } from '../src'
+
+// Enable EIP-7685 to support CLRequests
+const common = new Common({ chain: Mainnet, hardfork: Hardfork.Cancun, eips: [7685] })
+
+// Create examples of the three CLRequest types
+const createExampleRequests = () => {
+  // Create a deposit request (type 0)
+  const depositData = hexToBytes(
+    '0x00ac842878bb70009552a4cfcad801d6e659c50bd50d7d03306790cb455ce7363c5b6972f0159d170f625a99b2064dbefc010000000000000000000000818ccb1c4eda80270b04d6df822b1e72dd83c3030040597307000000a747f75c72d0cf0d2b52504c7385b516f0523e2f0842416399f42b4aee5c6384a5674f6426b1cc3d0827886fa9b909e616f5c9f61f986013ed2b9bf37071cbae951136265b549f44e3c8e26233c0433e9124b7fd0dc86e82f9fedfc0a179d7690000000000000000',
+  )
+  const depositRequest = createCLRequest(depositData)
+
+  // Create a withdrawal request (type 1)
+  const withdrawalData = hexToBytes(
+    '0x01000000000000000000000000000000000000000001000000000000000000000de0b6b3a7640000',
+  )
+  const withdrawalRequest = createCLRequest(withdrawalData)
+
+  // Create a consolidation request (type 2)
+  const consolidationData = hexToBytes('0x020000000100000000000000000000000000000000000001')
+  const consolidationRequest = createCLRequest(consolidationData)
+
+  // CLRequests must be sorted by type (Deposit=0, Withdrawal=1, Consolidation=2)
+  return [depositRequest, withdrawalRequest, consolidationRequest]
+}
+
+// Generate a block with CLRequests
+function createBlockWithCLRequests() {
+  const requests = createExampleRequests()
+  console.log(`Created ${requests.length} CLRequests:`)
+
+  for (const req of requests) {
+    console.log(
+      `- Type: ${req.type} (${Object.keys(CLRequestType).find(
+        (k) => CLRequestType[k as keyof typeof CLRequestType] === req.type,
+      )})`,
+    )
+  }
+
+  // Generate the requestsHash by hashing all the CLRequests
+  const requestsHash = genRequestsRoot(requests, sha256)
+  console.log(`Generated requestsHash: 0x${bytesToHex(requestsHash)}`)
+
+  // Create a block with the CLRequests hash
+  const block = createBlock({ header: { requestsHash } }, { common })
+  console.log(`Created block hash: 0x${bytesToHex(block.hash())}`)
+
+  return block
+}
+
+// Execute
+createBlockWithCLRequests()

packages/block/test/clrequests.spec.ts

@@ -0,0 +1,133 @@
+import { Common, Hardfork, Mainnet } from '@ethereumjs/common'
+import { CLRequestType, createCLRequest, equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { sha256 } from 'ethereum-cryptography/sha256.js'
+import { assert, describe, it } from 'vitest'
+
+import { createBlock, genRequestsRoot } from '../src/index.ts'
+
+import type { CLRequest } from '@ethereumjs/util'
+
+describe('[Block]: CLRequests tests', () => {
+  // Common with EIP-7685 enabled (CLRequests)
+  const common = new Common({ chain: Mainnet, hardfork: Hardfork.Cancun, eips: [7685] })
+
+  function createDepositRequest(): CLRequest<CLRequestType> {
+    // Example deposit data
+    const sampleDepositRequest = hexToBytes(
+      '0x00ac842878bb70009552a4cfcad801d6e659c50bd50d7d03306790cb455ce7363c5b6972f0159d170f625a99b2064dbefc010000000000000000000000818ccb1c4eda80270b04d6df822b1e72dd83c3030040597307000000a747f75c72d0cf0d2b52504c7385b516f0523e2f0842416399f42b4aee5c6384a5674f6426b1cc3d0827886fa9b909e616f5c9f61f986013ed2b9bf37071cbae951136265b549f44e3c8e26233c0433e9124b7fd0dc86e82f9fedfc0a179d7690000000000000000',
+    )
+    return createCLRequest(sampleDepositRequest)
+  }
+
+  function createWithdrawalRequest(): CLRequest<CLRequestType> {
+    // Type 1 (Withdrawal) + example data
+    const withdrawalData = hexToBytes(
+      '0x01000000000000000000000000000000000000000001000000000000000000000de0b6b3a7640000',
+    )
+    return createCLRequest(withdrawalData)
+  }
+
+  function createConsolidationRequest(): CLRequest<CLRequestType> {
+    // Type 2 (Consolidation) + example data
+    const consolidationData = hexToBytes('0x020000000100000000000000000000000000000000000001')
+    return createCLRequest(consolidationData)
+  }
+
+  it('should create a block with deposit request', () => {
+    const depositRequest = createDepositRequest()
+    assert.equal(depositRequest.type, CLRequestType.Deposit, 'should be a deposit request')
+
+    const requestsHash = genRequestsRoot([depositRequest], sha256)
+    const block = createBlock(
+      {
+        header: { requestsHash },
+      },
+      { common },
+    )
+
+    assert.isDefined(block.header.requestsHash, 'block should have requestsHash')
+    assert.isTrue(
+      equalsBytes(block.header.requestsHash!, requestsHash),
+      'requestsHash should match the expected value',
+    )
+  })
+
+  it('should create a block with withdrawal request', () => {
+    const withdrawalRequest = createWithdrawalRequest()
+    assert.equal(withdrawalRequest.type, CLRequestType.Withdrawal, 'should be a withdrawal request')
+
+    const requestsHash = genRequestsRoot([withdrawalRequest], sha256)
+    const block = createBlock(
+      {
+        header: { requestsHash },
+      },
+      { common },
+    )
+
+    assert.isDefined(block.header.requestsHash, 'block should have requestsHash')
+    assert.isTrue(
+      equalsBytes(block.header.requestsHash!, requestsHash),
+      'requestsHash should match the expected value',
+    )
+  })
+
+  it('should create a block with consolidation request', () => {
+    const consolidationRequest = createConsolidationRequest()
+    assert.equal(
+      consolidationRequest.type,
+      CLRequestType.Consolidation,
+      'should be a consolidation request',
+    )
+
+    const requestsHash = genRequestsRoot([consolidationRequest], sha256)
+    const block = createBlock(
+      {
+        header: { requestsHash },
+      },
+      { common },
+    )
+
+    assert.isDefined(block.header.requestsHash, 'block should have requestsHash')
+    assert.isTrue(
+      equalsBytes(block.header.requestsHash!, requestsHash),
+      'requestsHash should match the expected value',
+    )
+  })
+
+  it('should create a block with multiple CLRequests', () => {
+    const depositRequest = createDepositRequest()
+    const withdrawalRequest = createWithdrawalRequest()
+    const consolidationRequest = createConsolidationRequest()
+
+    // Requests should be sorted by type
+    const requests = [depositRequest, withdrawalRequest, consolidationRequest]
+    const requestsHash = genRequestsRoot(requests, sha256)
+
+    const block = createBlock(
+      {
+        header: { requestsHash },
+      },
+      { common },
+    )
+
+    assert.isDefined(block.header.requestsHash, 'block should have requestsHash')
+    assert.isTrue(
+      equalsBytes(block.header.requestsHash!, requestsHash),
+      'requestsHash should match the expected value',
+    )
+  })
+
+  it('should validate the requests are sorted by type', () => {
+    const depositRequest = createDepositRequest()
+    const withdrawalRequest = createWithdrawalRequest()
+
+    // Requests in wrong order should throw
+    const requests = [withdrawalRequest, depositRequest]
+
+    assert.throws(
+      () => genRequestsRoot(requests, sha256),
+      'requests are not sorted in ascending order',
+      'should throw when requests are not sorted by type',
+    )
+  })
+})

packages/client/src/net/peerpool.ts

@@ -213,7 +213,7 @@ export class PeerPool {
    * @emits {@link Event.POOL_PEER_ADDED}
    */
   add(peer?: Peer) {
-    if (peer && peer.id && !this.pool.get(peer.id)) {
+    if (peer?.id !== undefined && !this.pool.get(peer.id)) {
       this.pool.set(peer.id, peer)
       peer.pooled = true
       this.config.events.emit(Event.POOL_PEER_ADDED, peer)

packages/client/src/rpc/modules/admin.ts

@@ -95,9 +95,10 @@ export class Admin {
         name: peer.rlpxPeer?.['_hello']?.clientId ?? null,
         protocols: {
           eth: {
-            head: peer.eth?.updatedBestHeader
-              ? bytesToHex(peer.eth.updatedBestHeader?.hash())
-              : bytesToHex(peer.eth?.status.bestHash),
+            head:
+              peer.eth?.updatedBestHeader !== undefined
+                ? bytesToHex(peer.eth.updatedBestHeader.hash())
+                : bytesToHex(peer.eth?.status.bestHash ?? new Uint8Array()),
             difficulty: peer.eth?.status.td.toString(10),
             version: peer.eth?.['versions'].slice(-1)[0] ?? null,
           },

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

@@ -337,9 +337,10 @@ export class AccountFetcher extends Fetcher<JobTask, AccountData[], AccountData>
     const { task, partialResult } = job
     const { first } = task
     // Snap protocol will automatically pad it with 32 bytes left, so we don't need to worry
-    const origin = partialResult
-      ? bigIntToBytes(bytesToBigInt(partialResult[partialResult.length - 1].hash) + BIGINT_1)
-      : bigIntToBytes(first)
+    const origin =
+      partialResult !== undefined
+        ? bigIntToBytes(bytesToBigInt(partialResult[partialResult.length - 1].hash) + BIGINT_1)
+        : bigIntToBytes(first)
     return setLengthLeft(origin, 32)
   }
 
@@ -470,9 +471,12 @@ export class AccountFetcher extends Fetcher<JobTask, AccountData[], AccountData>
     const fullResult = (job.partialResult ?? []).concat(result)
 
     // update highest known hash
-    const highestReceivedhash = result.at(-1)?.hash as Uint8Array
+    const highestReceivedhash = result.at(-1)?.hash
     if (this.highestKnownHash) {
-      if (compareBytes(highestReceivedhash, this.highestKnownHash) > 0) {
+      if (
+        highestReceivedhash !== undefined &&
+        compareBytes(highestReceivedhash, this.highestKnownHash) > 0
+      ) {
         this.highestKnownHash = highestReceivedhash
       }
     } else {

packages/client/test/sync/fetcher/accountfetcher.spec.ts

@@ -188,20 +188,19 @@ describe('[AccountFetcher]', async () => {
       address: 'random',
       latest: vi.fn(),
     }
-    const partialResult: any = [
-      [
-        {
-          hash: new Uint8Array(0),
-          body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
-        },
-        {
-          hash: new Uint8Array(0),
-          body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
-        },
-      ],
+    const partialResult = [
+      {
+        hash: new Uint8Array(0),
+        body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
+      },
+      {
+        hash: new Uint8Array(0),
+        body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
+      },
     ]
     const job = { peer, partialResult, task }
-    const result = (await fetcher.request(job as any)) as any
+    const result = await fetcher.request(job as any)
+    assert.isDefined(result)
     assert.equal(
       JSON.stringify(result[0]),
       JSON.stringify({ skipped: true }),
@@ -219,17 +218,15 @@ describe('[AccountFetcher]', async () => {
       first: BigInt(1),
       count: BigInt(3),
     })
-    const partialResult: any = [
-      [
-        {
-          hash: new Uint8Array(0),
-          body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
-        },
-        {
-          hash: new Uint8Array(0),
-          body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
-        },
-      ],
+    const partialResult = [
+      {
+        hash: new Uint8Array(0),
+        body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
+      },
+      {
+        hash: new Uint8Array(0),
+        body: [new Uint8Array(0), new Uint8Array(0), new Uint8Array(0), new Uint8Array(0)],
+      },
     ]
 
     const task = { count: 3, first: BigInt(1) }

packages/client/test/sync/fetcher/storagefetcher.spec.ts

@@ -255,10 +255,10 @@ describe('[StorageFetcher]', async () => {
       pool,
       root: utf8ToBytes(''),
     } as StorageFetcherOptions)
-    const partialResult: any = [
+    const partialResult = [
       [
-        [{ hash: utf8ToBytes(''), body: utf8ToBytes('') }],
-        [{ hash: utf8ToBytes(''), body: utf8ToBytes('') }],
+        { hash: utf8ToBytes(''), body: utf8ToBytes('') },
+        { hash: utf8ToBytes(''), body: utf8ToBytes('') },
       ],
     ]
 
@@ -276,7 +276,7 @@ describe('[StorageFetcher]', async () => {
         },
       ],
     }
-    const resData = RLP.decode(hexToBytes(_storageRangesRLP)) as unknown
+    const resData = RLP.decode(hexToBytes(_storageRangesRLP))
     const res = p.decode(
       p.messages.filter((message) => message.name === 'StorageRanges')[0],
       resData,

packages/ethash/package.json

@@ -44,7 +44,7 @@
     "spellcheck": "npm run spellcheck:ts && npm run spellcheck:md",
     "spellcheck:ts": "npx cspell --gitignore -c ../../config/cspell-ts.json \"./**/*.ts\" --cache --show-suggestions --show-context",
     "spellcheck:md": "npx cspell --gitignore -c ../../config/cspell-md.json \"**.md\" --cache --show-suggestions --show-context",
-    "test": "npx vitest run -c ../../config/vitest.config.mts",
+    "test": "npx vitest run -c ./vite.config.ts",
     "tsc": "../../config/cli/ts-compile.sh"
   },
   "dependencies": {