EthJS monorepo-wide errors: EVM package

config/eslint.cjs

@@ -116,7 +116,13 @@ module.exports = {
     'simple-import-sort/exports': 'error',
     'sort-imports': ['error', { ignoreDeclarationSort: true }],
     'ethereumjs/noBuffer': 'error',
-    'no-restricted-syntax': 'off',
+    'no-restricted-syntax': [
+      'error',
+      {
+        selector: "ThrowStatement > NewExpression[callee.name='Error']",
+        message: "Throwing default JS Errors is not allowed. It is only possible to throw `EthereumJSError` (see the util package)",
+      }
+    ]
   },
   parserOptions: {
     extraFileExtensions: ['.json'],
@@ -129,6 +135,7 @@ module.exports = {
       rules: {
         'implicit-dependencies/no-implicit': 'off',
         'import/no-extraneous-dependencies': 'off',
+        'no-restricted-syntax': 'off',
       },
     },
     {
@@ -138,14 +145,14 @@ module.exports = {
         'import/no-extraneous-dependencies': 'off',
         'no-console': 'off',
         '@typescript-eslint/no-unused-vars': 'off',
+        'no-restricted-syntax': 'off'
       },
     },
     {
       files: ['packages/statemanager/src/**', 'packages/vm/src/**', ],
       rules: {
         '@typescript-eslint/no-use-before-define': 'off',
         'no-invalid-this': 'off',
-        'no-restricted-syntax': 'off',
       },
     },
     {
@@ -157,11 +164,30 @@ module.exports = {
         '@typescript-eslint/no-unused-vars': 'off',
       },
     },
+    {
+      files: ['packages/devp2p/src/ext/**'],
+      rules: {
+        'no-restricted-syntax': 'off'
+      },
+    },
+    {
+      files: ['packages/client/src/ext/**'],
+      rules: {
+        'no-restricted-syntax': 'off'
+      },
+    },
     {
       files: ['packages/wallet/**'],
       rules: {
         'github/array-foreach': 'warn',
         'no-prototype-builtins': 'warn',
+        'no-restricted-syntax': 'off'
+      },
+    },
+    {
+      files: ['packages/rlp/**'],
+      rules: {
+        'no-restricted-syntax': 'off'
       },
     },
   ],

packages/binarytree/src/binaryTree.ts

@@ -1,4 +1,5 @@
 import {
+  EthereumJSErrorUnsetCode,
   Lock,
   bitsToBytes,
   bytesToBits,
@@ -55,7 +56,7 @@ export class BinaryTree {
     this._opts = opts
 
     if (opts.db instanceof CheckpointDB) {
-      throw new Error('Cannot pass in an instance of CheckpointDB')
+      throw EthereumJSErrorUnsetCode('Cannot pass in an instance of CheckpointDB')
     }
     this._db = new CheckpointDB({ db: opts.db, cacheSize: opts.cacheSize })
 
@@ -97,7 +98,7 @@ export class BinaryTree {
       }
 
       if (value.length !== this._hashLen) {
-        throw new Error(`Invalid root length. Roots are ${this._hashLen} bytes`)
+        throw EthereumJSErrorUnsetCode(`Invalid root length. Roots are ${this._hashLen} bytes`)
       }
 
       this._root = value
@@ -130,7 +131,8 @@ export class BinaryTree {
    * If the stem is not found, will return an empty array.
    */
   async get(stem: Uint8Array, suffixes: number[]): Promise<(Uint8Array | null)[]> {
-    if (stem.length !== 31) throw new Error(`expected stem with length 31; got ${stem.length}`)
+    if (stem.length !== 31)
+      throw EthereumJSErrorUnsetCode(`expected stem with length 31; got ${stem.length}`)
     this.DEBUG && this.debug(`Stem: ${bytesToHex(stem)}; Suffix: ${suffixes}`, ['get'])
     const stemPath = await this.findPath(stem)
     if (stemPath.node instanceof StemBinaryNode) {
@@ -159,9 +161,10 @@ export class BinaryTree {
    * @returns A Promise that resolves once the value is stored.
    */
   async put(stem: Uint8Array, suffixes: number[], values: (Uint8Array | null)[]): Promise<void> {
-    if (stem.length !== 31) throw new Error(`expected stem with length 31, got ${stem.length}`)
+    if (stem.length !== 31)
+      throw EthereumJSErrorUnsetCode(`expected stem with length 31, got ${stem.length}`)
     if (values.length > 0 && values.length !== suffixes.length)
-      throw new Error(
+      throw EthereumJSErrorUnsetCode(
         `expected number of values (${values.length}) to equal number of suffixes (${suffixes.length})`,
       )
 
@@ -178,7 +181,7 @@ export class BinaryTree {
     const foundPath = await this.findPath(stem)
 
     // We should always at least get the root node back
-    if (foundPath.stack.length === 0) throw new Error(`Root node not found in trie`)
+    if (foundPath.stack.length === 0) throw EthereumJSErrorUnsetCode(`Root node not found in trie`)
 
     // Step 1) Create or update the stem node
     let stemNode: StemBinaryNode
@@ -259,7 +262,9 @@ export class BinaryTree {
         this.DEBUG &&
           this.debug(`Updated parent internal node hash for path ${path.join(',')}`, ['put'])
       } else {
-        throw new Error(`Expected internal node at path ${path.join(',')}, got ${node}`)
+        throw EthereumJSErrorUnsetCode(
+          `Expected internal node at path ${path.join(',')}, got ${node}`,
+        )
       }
     }
 
@@ -419,7 +424,7 @@ export class BinaryTree {
 
     // Get the root node.
     let rawNode = await this._db.get(this.root())
-    if (rawNode === undefined) throw new Error('root node should exist')
+    if (rawNode === undefined) throw EthereumJSErrorUnsetCode('root node should exist')
     const rootNode = decodeBinaryNode(rawNode)
 
     this.DEBUG && this.debug(`Starting with Root Node: [${bytesToHex(this.root())}]`, ['find_path'])
@@ -450,7 +455,7 @@ export class BinaryTree {
 
       // Look up child node by its node hash.
       rawNode = await this._db.get(childNode.hash)
-      if (rawNode === undefined) throw new Error(`missing node at ${childNode.path}`)
+      if (rawNode === undefined) throw EthereumJSErrorUnsetCode(`missing node at ${childNode.path}`)
       const decodedNode = decodeBinaryNode(rawNode)
 
       // Determine how many bits match between keyInBits and the stored path in childNode.
@@ -577,15 +582,15 @@ export class BinaryTree {
    * @param proof
    */
   async fromProof(_proof: any): Promise<void> {
-    throw new Error('Not implemented')
+    throw EthereumJSErrorUnsetCode('Not implemented')
   }
 
   /**
    * Creates a proof from a tree and key that can be verified using {@link BinaryTree.verifyBinaryProof}.
    * @param key
    */
   async createBinaryProof(_key: Uint8Array): Promise<any> {
-    throw new Error('Not implemented')
+    throw EthereumJSErrorUnsetCode('Not implemented')
   }
 
   /**
@@ -601,15 +606,15 @@ export class BinaryTree {
     _key: Uint8Array,
     _proof: any,
   ): Promise<Uint8Array | null> {
-    throw new Error('Not implemented')
+    throw EthereumJSErrorUnsetCode('Not implemented')
   }
 
   /**
    * The `data` event is given an `Object` that has two properties; the `key` and the `value`. Both should be Uint8Arrays.
    * @return Returns a [stream](https://nodejs.org/dist/latest-v12.x/docs/api/stream.html#stream_class_stream_readable) of the contents of the `tree`
    */
   createReadStream(): any {
-    throw new Error('Not implemented')
+    throw EthereumJSErrorUnsetCode('Not implemented')
   }
 
   /**
@@ -668,7 +673,7 @@ export class BinaryTree {
    */
   async commit(): Promise<void> {
     if (!this.hasCheckpoints()) {
-      throw new Error('trying to commit when not checkpointed')
+      throw EthereumJSErrorUnsetCode('trying to commit when not checkpointed')
     }
 
     await this._lock.acquire()
@@ -684,7 +689,7 @@ export class BinaryTree {
    */
   async revert(): Promise<void> {
     if (!this.hasCheckpoints()) {
-      throw new Error('trying to revert when not checkpointed')
+      throw EthereumJSErrorUnsetCode('trying to revert when not checkpointed')
     }
 
     await this._lock.acquire()
@@ -707,7 +712,7 @@ export class BinaryTree {
     }
 
     if (msg.length !== 32 && msg.length !== 64) {
-      throw new Error('Data must be 32 or 64 bytes')
+      throw EthereumJSErrorUnsetCode('Data must be 32 or 64 bytes')
     }
 
     return Uint8Array.from(this._opts.hashFunction.call(undefined, msg))

packages/binarytree/src/node/internalNode.ts

@@ -1,5 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
-import { bitsToBytes, bytesToBits } from '@ethereumjs/util'
+import { EthereumJSErrorUnsetCode, bitsToBytes, bytesToBits } from '@ethereumjs/util'
 
 import { BinaryNodeType } from './types.js'
 
@@ -17,13 +17,13 @@ export class InternalBinaryNode {
   static fromRawNode(rawNode: Uint8Array[]): InternalBinaryNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== BinaryNodeType.Internal) {
-      throw new Error('Invalid node type')
+      throw EthereumJSErrorUnsetCode('Invalid node type')
     }
 
     // The length of the rawNode should be the # of children * 2 (for hash and path) + 1 for the node type
 
     if (rawNode.length !== 2 * 2 + 1) {
-      throw new Error('Invalid node length')
+      throw EthereumJSErrorUnsetCode('Invalid node length')
     }
     const [, leftChildHash, rightChildHash, leftChildRawPath, rightChildRawPath] = rawNode
 
@@ -32,13 +32,13 @@ export class InternalBinaryNode {
       const decoded = RLP.decode(rawPath)
 
       if (!Array.isArray(decoded) || decoded.length !== 2) {
-        throw new Error('Invalid RLP encoding for child path')
+        throw EthereumJSErrorUnsetCode('Invalid RLP encoding for child path')
       }
 
       const [encodedLength, encodedPath] = decoded as Uint8Array[]
 
       if (encodedLength.length !== 1) {
-        throw new Error('Invalid path length encoding')
+        throw EthereumJSErrorUnsetCode('Invalid path length encoding')
       }
 
       const pathLength = encodedLength[0]
@@ -62,7 +62,7 @@ export class InternalBinaryNode {
    */
   static create(children?: (ChildBinaryNode | null)[]): InternalBinaryNode {
     if (children !== undefined && children.length !== 2) {
-      throw new Error('Internal node must have 2 children')
+      throw EthereumJSErrorUnsetCode('Internal node must have 2 children')
     }
     return new InternalBinaryNode({ children })
   }

packages/binarytree/src/node/stemNode.ts

@@ -1,4 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
+import { EthereumJSErrorUnsetCode } from '@ethereumjs/util'
 
 import { BinaryNodeType, NODE_WIDTH } from './types.js'
 
@@ -18,12 +19,12 @@ export class StemBinaryNode {
   static fromRawNode(rawNode: Uint8Array[]): StemBinaryNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== BinaryNodeType.Stem) {
-      throw new Error('Invalid node type')
+      throw EthereumJSErrorUnsetCode('Invalid node type')
     }
 
     // The length of the rawNode should be the # of values (node width) + 2 for the node type and the stem
     if (rawNode.length !== NODE_WIDTH + 2) {
-      throw new Error('Invalid node length')
+      throw EthereumJSErrorUnsetCode('Invalid node length')
     }
 
     const stem = rawNode[1]

packages/binarytree/src/node/util.ts

@@ -1,4 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
+import { EthereumJSErrorUnsetCode } from '@ethereumjs/util'
 
 import { InternalBinaryNode } from './internalNode.js'
 import { StemBinaryNode } from './stemNode.js'
@@ -12,14 +13,14 @@ export function decodeRawBinaryNode(raw: Uint8Array[]): BinaryNode {
     case BinaryNodeType.Stem:
       return StemBinaryNode.fromRawNode(raw)
     default:
-      throw new Error('Invalid node type')
+      throw EthereumJSErrorUnsetCode('Invalid node type')
   }
 }
 
 export function decodeBinaryNode(raw: Uint8Array) {
   const decoded = RLP.decode(Uint8Array.from(raw)) as Uint8Array[]
   if (!Array.isArray(decoded)) {
-    throw new Error('Invalid node')
+    throw EthereumJSErrorUnsetCode('Invalid node')
   }
   return decodeRawBinaryNode(decoded)
 }