Block err handling

packages/block/src/block/block.ts

@@ -5,8 +5,11 @@ import { Blob4844Tx, Capability } from '@ethereumjs/tx'
 import {
   BIGINT_0,
   CLRequestType,
+  ErrorCode,
   KECCAK256_RLP,
   KECCAK256_RLP_ARRAY,
+  UsageError,
+  ValueError,
   bytesToHex,
   equalsBytes,
 } from '@ethereumjs/util'
@@ -133,38 +136,50 @@ export class Block {
         const msg = this._errorMsg(
           'Block initialization with uncleHeaders on a PoA network is not allowed',
         )
-        throw new Error(msg)
+        throw new UsageError(msg, ErrorCode.INVALID_OPTION_USAGE)
       }
       if (this.common.consensusType() === ConsensusType.ProofOfStake) {
         const msg = this._errorMsg(
           'Block initialization with uncleHeaders on a PoS network is not allowed',
         )
-        throw new Error(msg)
+        throw new UsageError(msg, ErrorCode.INVALID_OPTION_USAGE)
       }
     }
 
     if (!this.common.isActivatedEIP(4895) && withdrawals !== undefined) {
-      throw new Error('Cannot have a withdrawals field if EIP 4895 is not active')
+      throw new UsageError(
+        'Cannot have a withdrawals field if EIP 4895 is not active',
+        ErrorCode.EIP_NOT_ACTIVATED,
+      )
     }
 
     if (
       !this.common.isActivatedEIP(6800) &&
       executionWitness !== undefined &&
       executionWitness !== null
     ) {
-      throw new Error(`Cannot have executionWitness field if EIP 6800 is not active `)
+      throw new UsageError(
+        `Cannot have executionWitness field if EIP 6800 is not active `,
+        ErrorCode.EIP_NOT_ACTIVATED,
+      )
     }
 
     if (!this.common.isActivatedEIP(7685) && requests !== undefined) {
-      throw new Error(`Cannot have requests field if EIP 7685 is not active`)
+      throw new UsageError(
+        `Cannot have requests field if EIP 7685 is not active`,
+        ErrorCode.EIP_NOT_ACTIVATED,
+      )
     }
 
     // Requests should be sorted in monotonically ascending order based on type
     // and whatever internal sorting logic is defined by each request type
     if (requests !== undefined && requests.length > 1) {
       for (let x = 1; x < requests.length; x++) {
         if (requests[x].type < requests[x - 1].type)
-          throw new Error('requests are not sorted in ascending order')
+          throw new ValueError(
+            'requests are not sorted in ascending order',
+            ErrorCode.INVALID_VALUE,
+          )
       }
     }
     const freeze = opts?.freeze ?? true
@@ -250,7 +265,7 @@ export class Block {
 
   async requestsTrieIsValid(requestsInput?: CLRequest<CLRequestType>[]): Promise<boolean> {
     if (!this.common.isActivatedEIP(7685)) {
-      throw new Error('EIP 7685 is not activated')
+      throw new UsageError('EIP 7685 is not activated', ErrorCode.EIP_NOT_ACTIVATED)
     }
 
     const requests = requestsInput ?? this.requests!
@@ -459,7 +474,7 @@ export class Block {
    */
   async withdrawalsTrieIsValid(): Promise<boolean> {
     if (!this.common.isActivatedEIP(4895)) {
-      throw new Error('EIP 4895 is not activated')
+      throw new UsageError('EIP 4895 is not activated', ErrorCode.EIP_NOT_ACTIVATED)
     }
 
     let result

packages/block/src/consensus/clique.ts

@@ -4,6 +4,8 @@ import {
   Address,
   BIGINT_0,
   BIGINT_27,
+  ErrorCode,
+  UsageError,
   bigIntToBytes,
   bytesToBigInt,
   concatBytes,
@@ -28,7 +30,7 @@ export function requireClique(header: BlockHeader, name: string) {
     const msg = header['_errorMsg'](
       `BlockHeader.${name}() call only supported for clique PoA networks`,
     )
-    throw new Error(msg)
+    throw new UsageError(msg, ErrorCode.INVALID_METHOD_CALL)
   }
 }
 
@@ -84,7 +86,7 @@ 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)
+    throw new UsageError(msg, ErrorCode.INVALID_METHOD_CALL)
   }
 
   const start = CLIQUE_EXTRA_VANITY

packages/block/src/header/constructors.ts

@@ -1,5 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
-import { bigIntToBytes, equalsBytes } from '@ethereumjs/util'
+import { ErrorCode, ValueError, bigIntToBytes, equalsBytes } from '@ethereumjs/util'
 
 import { generateCliqueBlockExtraData } from '../consensus/clique.js'
 import { numberToHex, valuesArrayToHeaderData } from '../helpers.js'
@@ -34,22 +34,34 @@ export function createBlockHeaderFromBytesArray(values: BlockHeaderBytes, opts:
       eip1559ActivationBlock !== undefined &&
       equalsBytes(eip1559ActivationBlock, number as Uint8Array)
     ) {
-      throw new Error('invalid header. baseFeePerGas should be provided')
+      throw new ValueError(
+        'invalid header. baseFeePerGas should be provided',
+        ErrorCode.INVALID_VALUE,
+      )
     }
   }
   if (header.common.isActivatedEIP(4844)) {
     if (excessBlobGas === undefined) {
-      throw new Error('invalid header. excessBlobGas should be provided')
+      throw new ValueError(
+        'invalid header. excessBlobGas should be provided',
+        ErrorCode.INVALID_VALUE,
+      )
     } else if (blobGasUsed === undefined) {
-      throw new Error('invalid header. blobGasUsed should be provided')
+      throw new ValueError(
+        'invalid header. blobGasUsed should be provided',
+        ErrorCode.INVALID_VALUE,
+      )
     }
   }
   if (header.common.isActivatedEIP(4788) && parentBeaconBlockRoot === undefined) {
-    throw new Error('invalid header. parentBeaconBlockRoot should be provided')
+    throw new ValueError(
+      'invalid header. parentBeaconBlockRoot should be provided',
+      ErrorCode.INVALID_VALUE,
+    )
   }
 
   if (header.common.isActivatedEIP(7685) && requestsRoot === undefined) {
-    throw new Error('invalid header. requestsRoot should be provided')
+    throw new ValueError('invalid header. requestsRoot should be provided', ErrorCode.INVALID_VALUE)
   }
   return header
 }
@@ -66,7 +78,7 @@ export function createBlockHeaderFromRLP(
 ) {
   const values = RLP.decode(serializedHeaderData)
   if (!Array.isArray(values)) {
-    throw new Error('Invalid serialized header input. Must be array')
+    throw new ValueError('Invalid serialized header input. Must be array', ErrorCode.INVALID_VALUE)
   }
   return createBlockHeaderFromBytesArray(values as Uint8Array[], opts)
 }

packages/block/src/header/header.ts

@@ -6,9 +6,12 @@ import {
   BIGINT_1,
   BIGINT_2,
   BIGINT_7,
+  ErrorCode,
   KECCAK256_RLP,
   KECCAK256_RLP_ARRAY,
   TypeOutput,
+  UsageError,
+  ValueError,
   bigIntToHex,
   bigIntToUnpaddedBytes,
   bytesToHex,
@@ -75,10 +78,13 @@ export class BlockHeader {
    */
   get prevRandao() {
     if (!this.common.isActivatedEIP(4399)) {
-      const msg = this._errorMsg(
+      throw new UsageError(
         'The prevRandao parameter can only be accessed when EIP-4399 is activated',
+        ErrorCode.EIP_NOT_ACTIVATED,
+        {
+          objectContext: this.errorStr(),
+        },
       )
-      throw new Error(msg)
     }
     return this.mixHash
   }
@@ -179,7 +185,10 @@ export class BlockHeader {
       toType(headerData.requestsRoot, TypeOutput.Uint8Array) ?? hardforkDefaults.requestsRoot
 
     if (!this.common.isActivatedEIP(1559) && baseFeePerGas !== undefined) {
-      throw new Error('A base fee for a block can only be set with EIP1559 being activated')
+      throw new UsageError(
+        'A base fee for a block can only be set with EIP1559 being activated',
+        ErrorCode.EIP_NOT_ACTIVATED,
+      )
     }
 
     if (!this.common.isActivatedEIP(4895) && withdrawalsRoot !== undefined) {
@@ -258,33 +267,41 @@ export class BlockHeader {
     const { parentHash, stateRoot, transactionsTrie, receiptTrie, mixHash, nonce } = this
 
     if (parentHash.length !== 32) {
-      const msg = this._errorMsg(`parentHash must be 32 bytes, received ${parentHash.length} bytes`)
-      throw new Error(msg)
+      throw new ValueError(`parentHash must be 32 bytes`, ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${parentHash.length} bytes`,
+      })
     }
     if (stateRoot.length !== 32) {
-      const msg = this._errorMsg(`stateRoot must be 32 bytes, received ${stateRoot.length} bytes`)
-      throw new Error(msg)
+      throw new ValueError(`stateRoot must be 32 bytes`, ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${stateRoot.length} bytes`,
+      })
     }
     if (transactionsTrie.length !== 32) {
-      const msg = this._errorMsg(
-        `transactionsTrie must be 32 bytes, received ${transactionsTrie.length} bytes`,
-      )
-      throw new Error(msg)
+      throw new ValueError('transactionsTrie must be 32 bytes', ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${bytesToHex(transactionsTrie)} (${transactionsTrie.length} bytes)`,
+      })
     }
     if (receiptTrie.length !== 32) {
-      const msg = this._errorMsg(
-        `receiptTrie must be 32 bytes, received ${receiptTrie.length} bytes`,
-      )
-      throw new Error(msg)
+      throw new ValueError('receiptTrie must be 32 bytes', ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${bytesToHex(receiptTrie)} (${receiptTrie.length} bytes)`,
+      })
     }
     if (mixHash.length !== 32) {
-      const msg = this._errorMsg(`mixHash must be 32 bytes, received ${mixHash.length} bytes`)
-      throw new Error(msg)
+      throw new ValueError('mixHash must be 32 bytes', ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${bytesToHex(mixHash)} (${mixHash.length} bytes)`,
+      })
     }
 
     if (nonce.length !== 8) {
-      const msg = this._errorMsg(`nonce must be 8 bytes, received ${nonce.length} bytes`)
-      throw new Error(msg)
+      throw new ValueError('nonce must be 8 bytes', ErrorCode.INVALID_VALUE_LENGTH, {
+        objectContext: this.errorStr(),
+        received: `${bytesToHex(nonce)} (${nonce.length} bytes)`,
+      })
     }
 
     // check if the block used too much gas
@@ -429,8 +446,9 @@ export class BlockHeader {
         }
       }
       if (error) {
-        const msg = this._errorMsg(`Invalid PoS block: ${errorMsg}`)
-        throw new Error(msg)
+        throw new ValueError(`Invalid PoS block${errorMsg}`, ErrorCode.INVALID_OBJECT, {
+          objectContext: this.errorStr(),
+        })
       }
     }
   }
@@ -659,14 +677,22 @@ export class BlockHeader {
    */
   ethashCanonicalDifficulty(parentBlockHeader: BlockHeader): bigint {
     if (this.common.consensusType() !== ConsensusType.ProofOfWork) {
-      const msg = this._errorMsg('difficulty calculation is only supported on PoW chains')
-      throw new Error(msg)
+      throw new UsageError(
+        'difficulty calculation is only supported on PoW chains',
+        ErrorCode.INVALID_METHOD_CALL,
+        {
+          objectContext: this.errorStr(),
+        },
+      )
     }
     if (this.common.consensusAlgorithm() !== ConsensusAlgorithm.Ethash) {
-      const msg = this._errorMsg(
+      throw new UsageError(
         'difficulty calculation currently only supports the ethash algorithm',
+        ErrorCode.INVALID_METHOD_CALL,
+        {
+          objectContext: this.errorStr(),
+        },
       )
-      throw new Error(msg)
     }
     const blockTs = this.timestamp
     const { timestamp: parentTs, difficulty: parentDif } = parentBlockHeader