Block consensus methods refactoring

packages/block/src/block.ts

@@ -507,15 +507,6 @@ export class Block {
     }
   }
 
-  /**
-   * Returns the canonical difficulty for this block.
-   *
-   * @param parentBlock - the parent of this `Block`
-   */
-  ethashCanonicalDifficulty(parentBlock: Block): bigint {
-    return this.header.ethashCanonicalDifficulty(parentBlock.header)
-  }
-
   /**
    * Validates if the block gasLimit remains in the boundaries set by the protocol.
    * Throws if invalid

packages/block/src/consensus/clique.ts

@@ -0,0 +1,129 @@
+import { ConsensusAlgorithm } from '@ethereumjs/common'
+import { RLP } from '@ethereumjs/rlp'
+import {
+  Address,
+  BIGINT_0,
+  BIGINT_27,
+  bytesToBigInt,
+  createAddressFromPublicKey,
+  createZeroAddress,
+  ecrecover,
+  equalsBytes,
+} from '@ethereumjs/util'
+
+import type { BlockHeader } from '../index.js'
+import type { CliqueConfig } from '@ethereumjs/common'
+
+// Fixed number of extra-data prefix bytes reserved for signer vanity
+export const CLIQUE_EXTRA_VANITY = 32
+// Fixed number of extra-data suffix bytes reserved for signer seal
+export const CLIQUE_EXTRA_SEAL = 65
+
+// This function is not exported in the index file to keep it internal
+export function _requireClique(header: BlockHeader, name: string) {
+  if (header.common.consensusAlgorithm() !== ConsensusAlgorithm.Clique) {
+    const msg = header['_errorMsg'](
+      `BlockHeader.${name}() call only supported for clique PoA networks`,
+    )
+    throw new Error(msg)
+  }
+}
+
+/**
+ * PoA clique signature hash without the seal.
+ */
+export function cliqueSigHash(header: BlockHeader) {
+  _requireClique(header, 'cliqueSigHash')
+  const raw = header.raw()
+  raw[12] = header.extraData.subarray(0, header.extraData.length - CLIQUE_EXTRA_SEAL)
+  return header['keccakFunction'](RLP.encode(raw))
+}
+
+/**
+ * Checks if the block header is an epoch transition
+ * header (only clique PoA, throws otherwise)
+ */
+export function cliqueIsEpochTransition(header: BlockHeader): boolean {
+  _requireClique(header, 'cliqueIsEpochTransition')
+  const epoch = BigInt((header.common.consensusConfig() as CliqueConfig).epoch)
+  // Epoch transition block if the block number has no
+  // remainder on the division by the epoch length
+  return header.number % epoch === BIGINT_0
+}
+
+/**
+ * Returns extra vanity data
+ * (only clique PoA, throws otherwise)
+ */
+export function cliqueExtraVanity(header: BlockHeader): Uint8Array {
+  _requireClique(header, 'cliqueExtraVanity')
+  return header.extraData.subarray(0, CLIQUE_EXTRA_VANITY)
+}
+
+/**
+ * Returns extra seal data
+ * (only clique PoA, throws otherwise)
+ */
+export function cliqueExtraSeal(header: BlockHeader): Uint8Array {
+  _requireClique(header, 'cliqueExtraSeal')
+  return header.extraData.subarray(-CLIQUE_EXTRA_SEAL)
+}
+
+/**
+ * Returns a list of signers
+ * (only clique PoA, throws otherwise)
+ *
+ * This function throws if not called on an epoch
+ * transition block and should therefore be used
+ * in conjunction with {@link BlockHeader.cliqueIsEpochTransition}
+ */
+export function cliqueEpochTransitionSigners(header: BlockHeader): Address[] {
+  _requireClique(header, 'cliqueEpochTransitionSigners')
+  if (!cliqueIsEpochTransition(header)) {
+    const msg = header['_errorMsg']('Signers are only included in epoch transition blocks (clique)')
+    throw new Error(msg)
+  }
+
+  const start = CLIQUE_EXTRA_VANITY
+  const end = header.extraData.length - CLIQUE_EXTRA_SEAL
+  const signerBytes = header.extraData.subarray(start, end)
+
+  const signerList: Uint8Array[] = []
+  const signerLength = 20
+  for (let start = 0; start <= signerBytes.length - signerLength; start += signerLength) {
+    signerList.push(signerBytes.subarray(start, start + signerLength))
+  }
+  return signerList.map((buf) => new Address(buf))
+}
+
+/**
+ * Returns the signer address
+ */
+export function cliqueSigner(header: BlockHeader): Address {
+  _requireClique(header, 'cliqueSigner')
+  const extraSeal = cliqueExtraSeal(header)
+  // Reasonable default for default blocks
+  if (extraSeal.length === 0 || equalsBytes(extraSeal, new Uint8Array(65))) {
+    return createZeroAddress()
+  }
+  const r = extraSeal.subarray(0, 32)
+  const s = extraSeal.subarray(32, 64)
+  const v = bytesToBigInt(extraSeal.subarray(64, 65)) + BIGINT_27
+  const pubKey = ecrecover(cliqueSigHash(header), v, r, s)
+  return createAddressFromPublicKey(pubKey)
+}
+
+/**
+ * Verifies the signature of the block (last 65 bytes of extraData field)
+ * (only clique PoA, throws otherwise)
+ *
+ *  Method throws if signature is invalid
+ */
+export function cliqueVerifySignature(header: BlockHeader, signerList: Address[]): boolean {
+  _requireClique(header, 'cliqueVerifySignature')
+  const signerAddress = cliqueSigner(header)
+  const signerFound = signerList.find((signer) => {
+    return signer.equals(signerAddress)
+  })
+  return !!signerFound
+}

packages/block/src/consensus/ethash.ts

@@ -0,0 +1,10 @@
+import type { Block } from '../index.js'
+
+/**
+ * Returns the canonical difficulty for this block.
+ *
+ * @param parentBlock - the parent of this `Block`
+ */
+export function ethashCanonicalDifficulty(block: Block, parentBlock: Block): bigint {
+  return block.header.ethashCanonicalDifficulty(parentBlock.header)
+}

packages/block/src/consensus/index.ts

@@ -0,0 +1,12 @@
+export {
+  CLIQUE_EXTRA_SEAL,
+  CLIQUE_EXTRA_VANITY,
+  cliqueEpochTransitionSigners,
+  cliqueExtraSeal,
+  cliqueExtraVanity,
+  cliqueIsEpochTransition,
+  cliqueSigHash,
+  cliqueSigner,
+  cliqueVerifySignature,
+} from './clique.js'
+export * from './ethash.js'

packages/block/src/header.ts

@@ -13,13 +13,10 @@ import {
   bigIntToBytes,
   bigIntToHex,
   bigIntToUnpaddedBytes,
-  bytesToBigInt,
   bytesToHex,
   bytesToUtf8,
   concatBytes,
-  createAddressFromPublicKey,
   createZeroAddress,
-  ecrecover,
   ecsign,
   equalsBytes,
   hexToBytes,
@@ -28,12 +25,18 @@ import {
 } from '@ethereumjs/util'
 import { keccak256 } from 'ethereum-cryptography/keccak.js'
 
-import { CLIQUE_EXTRA_SEAL, CLIQUE_EXTRA_VANITY } from './clique.js'
+import { _requireClique } from './consensus/clique.js'
 import { fakeExponential } from './helpers.js'
 import { paramsBlock } from './params.js'
 
+import {
+  CLIQUE_EXTRA_SEAL,
+  CLIQUE_EXTRA_VANITY,
+  cliqueIsEpochTransition,
+  cliqueSigHash,
+} from './index.js'
+
 import type { BlockHeaderBytes, BlockOptions, HeaderData, JsonHeader } from './types.js'
-import type { CliqueConfig } from '@ethereumjs/common'
 
 interface HeaderCache {
   hash: Uint8Array | undefined
@@ -387,7 +390,7 @@ export class BlockHeader {
     if (this.common.consensusAlgorithm() === ConsensusAlgorithm.Clique) {
       // PoA/Clique
       const minLength = CLIQUE_EXTRA_VANITY + CLIQUE_EXTRA_SEAL
-      if (!this.cliqueIsEpochTransition()) {
+      if (!cliqueIsEpochTransition(this)) {
         // ExtraData length on epoch transition
         if (this.extraData.length !== minLength) {
           const msg = this._errorMsg(
@@ -669,15 +672,6 @@ export class BlockHeader {
     return this.number === BIGINT_0
   }
 
-  protected _requireClique(name: string) {
-    if (this.common.consensusAlgorithm() !== ConsensusAlgorithm.Clique) {
-      const msg = this._errorMsg(
-        `BlockHeader.${name}() call only supported for clique PoA networks`,
-      )
-      throw new Error(msg)
-    }
-  }
-
   /**
    * Returns the canonical difficulty for this block.
    *
@@ -751,56 +745,16 @@ export class BlockHeader {
     return dif
   }
 
-  /**
-   * PoA clique signature hash without the seal.
-   */
-  cliqueSigHash() {
-    this._requireClique('cliqueSigHash')
-    const raw = this.raw()
-    raw[12] = this.extraData.subarray(0, this.extraData.length - CLIQUE_EXTRA_SEAL)
-    return this.keccakFunction(RLP.encode(raw))
-  }
-
-  /**
-   * Checks if the block header is an epoch transition
-   * header (only clique PoA, throws otherwise)
-   */
-  cliqueIsEpochTransition(): boolean {
-    this._requireClique('cliqueIsEpochTransition')
-    const epoch = BigInt((this.common.consensusConfig() as CliqueConfig).epoch)
-    // Epoch transition block if the block number has no
-    // remainder on the division by the epoch length
-    return this.number % epoch === BIGINT_0
-  }
-
-  /**
-   * Returns extra vanity data
-   * (only clique PoA, throws otherwise)
-   */
-  cliqueExtraVanity(): Uint8Array {
-    this._requireClique('cliqueExtraVanity')
-    return this.extraData.subarray(0, CLIQUE_EXTRA_VANITY)
-  }
-
-  /**
-   * Returns extra seal data
-   * (only clique PoA, throws otherwise)
-   */
-  cliqueExtraSeal(): Uint8Array {
-    this._requireClique('cliqueExtraSeal')
-    return this.extraData.subarray(-CLIQUE_EXTRA_SEAL)
-  }
-
   /**
    * Seal block with the provided signer.
    * Returns the final extraData field to be assigned to `this.extraData`.
    * @hidden
    */
   private cliqueSealBlock(privateKey: Uint8Array) {
-    this._requireClique('cliqueSealBlock')
+    _requireClique(this, 'cliqueSealBlock')
 
     const ecSignFunction = this.common.customCrypto?.ecsign ?? ecsign
-    const signature = ecSignFunction(this.cliqueSigHash(), privateKey)
+    const signature = ecSignFunction(cliqueSigHash(this), privateKey)
     const signatureB = concatBytes(signature.r, signature.s, bigIntToBytes(signature.v - BIGINT_27))
 
     const extraDataWithoutSeal = this.extraData.subarray(
@@ -811,65 +765,6 @@ export class BlockHeader {
     return extraData
   }
 
-  /**
-   * Returns a list of signers
-   * (only clique PoA, throws otherwise)
-   *
-   * This function throws if not called on an epoch
-   * transition block and should therefore be used
-   * in conjunction with {@link BlockHeader.cliqueIsEpochTransition}
-   */
-  cliqueEpochTransitionSigners(): Address[] {
-    this._requireClique('cliqueEpochTransitionSigners')
-    if (!this.cliqueIsEpochTransition()) {
-      const msg = this._errorMsg('Signers are only included in epoch transition blocks (clique)')
-      throw new Error(msg)
-    }
-
-    const start = CLIQUE_EXTRA_VANITY
-    const end = this.extraData.length - CLIQUE_EXTRA_SEAL
-    const signerBytes = this.extraData.subarray(start, end)
-
-    const signerList: Uint8Array[] = []
-    const signerLength = 20
-    for (let start = 0; start <= signerBytes.length - signerLength; start += signerLength) {
-      signerList.push(signerBytes.subarray(start, start + signerLength))
-    }
-    return signerList.map((buf) => new Address(buf))
-  }
-
-  /**
-   * Verifies the signature of the block (last 65 bytes of extraData field)
-   * (only clique PoA, throws otherwise)
-   *
-   *  Method throws if signature is invalid
-   */
-  cliqueVerifySignature(signerList: Address[]): boolean {
-    this._requireClique('cliqueVerifySignature')
-    const signerAddress = this.cliqueSigner()
-    const signerFound = signerList.find((signer) => {
-      return signer.equals(signerAddress)
-    })
-    return !!signerFound
-  }
-
-  /**
-   * Returns the signer address
-   */
-  cliqueSigner(): Address {
-    this._requireClique('cliqueSigner')
-    const extraSeal = this.cliqueExtraSeal()
-    // Reasonable default for default blocks
-    if (extraSeal.length === 0 || equalsBytes(extraSeal, new Uint8Array(65))) {
-      return createZeroAddress()
-    }
-    const r = extraSeal.subarray(0, 32)
-    const s = extraSeal.subarray(32, 64)
-    const v = bytesToBigInt(extraSeal.subarray(64, 65)) + BIGINT_27
-    const pubKey = ecrecover(this.cliqueSigHash(), v, r, s)
-    return createAddressFromPublicKey(pubKey)
-  }
-
   /**
    * Returns the rlp encoding of the block header.
    */

packages/block/src/index.ts

@@ -1,4 +1,5 @@
 export { Block } from './block.js'
+export * from './consensus/index.js'
 export * from './constructors.js'
 export { type BeaconPayloadJson, executionPayloadFromBeaconPayload } from './from-beacon-payload.js'
 export { BlockHeader } from './header.js'