common -> custom chains: API adoption, preparations for dedicated test file for custom chain creation

Author: holgerd77

packages/common/src/chains/index.ts

@@ -1,4 +1,9 @@
 import { chainsType } from './../types'
+import mainnet from './mainnet.json'
+import ropsten from './ropsten.json'
+import rinkeby from './rinkeby.json'
+import kovan from './kovan.json'
+import goerli from './goerli.json'
 
 /**
  * @hidden
@@ -12,11 +17,11 @@ export function _getInitializedChains() {
       '42': 'kovan',
       '5': 'goerli',
     },
-    mainnet: require('./mainnet.json'),
-    ropsten: require('./ropsten.json'),
-    rinkeby: require('./rinkeby.json'),
-    kovan: require('./kovan.json'),
-    goerli: require('./goerli.json'),
+    mainnet,
+    ropsten,
+    rinkeby,
+    kovan,
+    goerli,
   }
   return chains
 }

packages/common/src/index.ts

@@ -31,19 +31,18 @@ export interface CommonOpts {
    * - [EIP-2537](https://eips.ethereum.org/EIPS/eip-2537) - BLS12-381 precompiles
    */
   eips?: number[]
-  /**
-   * Directory to look for custom chains
-   */
-  customChainDir?: string
   /**
    * Initialize (in addition to the supported chains) with the selected
-   * custom chains from customChainDir
+   * custom chains
+   *
+   * Usage (directly with the respective chain intialization via the `chain` option):
    *
-   * Please provide a list of strings matching a corresponding .json file
-   * in customChainDir named by the chain name, e.g.`['myCustomChain']
-   * to read the configuration parameters from a file named 'myCustomChain.json'
+   * ```javascript
+   * import myCustomChain1 from '[PATH_TO_MY_CHAINS]/myCustomChain1.json'
+   * const common = new Common({ chain: 'myCustomChain1', customChains: [ myCustomChain1 ]})
+   * ```
    */
-  initCustomChains?: string[]
+  customChains?: Chain[]
 }
 
 interface hardforkOptions {
@@ -63,6 +62,7 @@ export default class Common {
   private _hardfork: string
   private _supportedHardforks: Array<string> = []
   private _eips: number[] = []
+  private _customChains: Chain[]
 
   /**
    * Creates a Common object for a custom chain, based on a standard one. It uses all the [[Chain]]
@@ -114,6 +114,7 @@ export default class Common {
    * @constructor
    */
   constructor(opts: CommonOpts) {
+    this._customChains = opts.customChains ?? []
     this._chainParams = this.setChain(opts.chain)
     this._hardfork = this.DEFAULT_HARDFORK
     if (opts.supportedHardforks) {
@@ -137,6 +138,11 @@ export default class Common {
     if (typeof chain === 'number' || typeof chain === 'string') {
       this._chainParams = Common._getChainParams(chain)
     } else if (typeof chain === 'object') {
+      if (this._customChains.length > 0) {
+        throw new Error(
+          'Chain must be a string or number when initialized with customChains passed in'
+        )
+      }
       const required = ['networkId', 'genesis', 'hardforks', 'bootstrapNodes']
       for (const param of required) {
         if ((<any>chain)[param] === undefined) {

packages/common/tests/chains.ts

@@ -119,39 +119,4 @@ tape('[Common]: Initialization / Chain params', function (t: tape.Test) {
 
     st.end()
   })
-
-  t.test(
-    'Should provide correct access to private network chain parameters',
-    function (st: tape.Test) {
-      const chainParams = require('./testnet.json')
-      const c = new Common({ chain: chainParams, hardfork: 'byzantium' })
-      st.equal(c.chainName(), 'testnet', 'should initialize with chain name')
-      st.equal(c.chainId(), 12345, 'should return correct chain Id')
-      st.equal(c.networkId(), 12345, 'should return correct network Id')
-      st.equal(
-        c.genesis().hash,
-        '0xaa00000000000000000000000000000000000000000000000000000000000000',
-        'should return correct genesis hash'
-      )
-      st.equal(c.hardforks()[3]['block'], 3, 'should return correct hardfork data')
-      st.equal(c.bootstrapNodes()[1].ip, '10.0.0.2', 'should return a bootstrap node array')
-
-      st.end()
-    }
-  )
-
-  t.test('Should handle custom chain parameters with missing field', function (st: tape.Test) {
-    const chainParams = require('./testnet.json')
-    delete chainParams['hardforks']
-    st.throws(
-      function () {
-        new Common({ chain: chainParams })
-      },
-      /Missing required/,
-      'should throw an exception on missing parameter'
-    ) // eslint-disable-line no-new
-
-    st.comment('-----------------------------------------------------------------')
-    st.end()
-  })
 })

packages/common/tests/customChains.ts

@@ -0,0 +1,58 @@
+import tape from 'tape'
+import Common from '../src/'
+import testnet from './data/testnet.json'
+
+tape('[Common]: Custom chains', function (t: tape.Test) {
+  t.test(
+    'chain -> object: should provide correct access to private network chain parameters',
+    function (st: tape.Test) {
+      const c = new Common({ chain: testnet, hardfork: 'byzantium' })
+      st.equal(c.chainName(), 'testnet', 'should initialize with chain name')
+      st.equal(c.chainId(), 12345, 'should return correct chain Id')
+      st.equal(c.networkId(), 12345, 'should return correct network Id')
+      st.equal(
+        c.genesis().hash,
+        '0xaa00000000000000000000000000000000000000000000000000000000000000',
+        'should return correct genesis hash'
+      )
+      st.equal(c.hardforks()[3]['block'], 3, 'should return correct hardfork data')
+      st.equal(c.bootstrapNodes()[1].ip, '10.0.0.2', 'should return a bootstrap node array')
+
+      st.end()
+    }
+  )
+
+  t.test(
+    'chain -> object: should handle custom chain parameters with missing field',
+    function (st: tape.Test) {
+      const chainParams = Object.assign({}, testnet)
+      delete (chainParams as any)['hardforks']
+      st.throws(
+        function () {
+          new Common({ chain: chainParams })
+        },
+        /Missing required/,
+        'should throw an exception on missing parameter'
+      ) // eslint-disable-line no-new
+
+      st.comment('-----------------------------------------------------------------')
+      st.end()
+    }
+  )
+
+  t.test('customChains parameter: ', (st) => {
+    const c = new Common({ chain: testnet, hardfork: 'byzantium' })
+    st.equal(c.chainName(), 'testnet', 'should initialize with chain name')
+    st.equal(c.chainId(), 12345, 'should return correct chain Id')
+    st.equal(c.networkId(), 12345, 'should return correct network Id')
+    st.equal(
+      c.genesis().hash,
+      '0xaa00000000000000000000000000000000000000000000000000000000000000',
+      'should return correct genesis hash'
+    )
+    st.equal(c.hardforks()[3]['block'], 3, 'should return correct hardfork data')
+    st.equal(c.bootstrapNodes()[1].ip, '10.0.0.2', 'should return a bootstrap node array')
+
+    st.end()
+  })
+})