ethereumjs/ethereumjs-common-3-test

查看test能够让你更好滴了解其API文档的使用

ethereumjs-common/tests/chains.js

const tape = require('tape')
const Common = require('../index.js')

tape('[Common]: Initialization / Chain params', function (t) {
  t.test('Should initialize with chain provided', function (st) {//只使用chain来初始化一个Common对象
    let c = new Common('mainnet')//使用的是mainnet链
    st.equal(c.chainName(), 'mainnet', 'should initialize with chain name')//使用chainName API得到当前链名
    st.equal(c.chainId(), , 'should return correct chain Id') //得到chainId
    st.equal(c.networkId(), , 'should return correct network Id') //得到networkId
    st.equal(c.hardfork(), null, 'should set hardfork to null') //使用的硬分叉，因为没有设置，所以是null
    st.equal(c._isSupportedHardfork('constantinople'), true, 'should not restrict supported HFs') //是否支持constantinople硬分叉，这是默认支持的硬分叉类型中的一种，所以返回true

    c = new Common() //也可以使用chain ID数字来表示mainnet链
    st.equal(c.chainName(), 'mainnet', 'should initialize with chain Id')

    st.end()
  })

  t.test('Should initialize with chain and hardfork provided', function (st) { //使用chain和hardfork两个参数来初始化对象
    let c = new Common('mainnet', 'byzantium') //chain = mainnet ，hardfork = byzantium
    st.equal(c.hardfork(), 'byzantium', 'should return correct hardfork name')

    st.end()
  })

  t.test('Should initialize with supportedHardforks provided', function (st) { //使用chain、hardfork和supportedHardforks三个参数来初始化对象
    let c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople']) //supportedHardforks = ['byzantium', 'constantinople']，设置只支持这两个硬分叉类型
    st.equal(c._isSupportedHardfork('byzantium'), true, 'should return true for supported HF')
    st.equal(c._isSupportedHardfork('spuriousDragon'), false, 'should return false for unsupported HF')//因为supportedHardforks中没有它，所以不支持

    st.end()
  })

  t.test('Should handle initialization errors', function (st) {
    st.throws(function () { new Common('chainnotexisting') }, /not supported$/, 'should throw an exception on non-existing chain') // eslint-disable-line no-new ，不是支持的chain类型
    st.throws(function () { new Common('mainnet', 'hardforknotexisting') }, /not supported$/, 'should throw an exception on non-existing hardfork') // eslint-disable-line no-new ，不是支持的hardfork类型
    st.throws(function () { new Common('mainnet', 'spuriousDragon', ['byzantium', 'constantinople']) }, /supportedHardforks$/, 'should throw an exception on conflicting active/supported HF params') // eslint-disable-line no-new ，不是supportedHardforks中包含的hardfork类型

    st.end()
  })

  t.test('Should provide correct access to chain parameters', function (st) {
    let c = new Common('mainnet')
    st.equal(c.genesis().hash, '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3', 'should return correct genesis hash')//返回当前链的初始状态中的hash值
    st.equal(c.hardforks()[]['block'], , 'should return correct hardfork data')//返回当前链的硬分叉数组中第四个分叉的'block'值
    st.equal(c.bootstrapNodes()[].port, , 'should return a bootstrap node array')//返回当前链的所有bootstrap节点字典中第一个节点的端口port值

    st.end()
  })

  t.test('Should be able to access data for all chains provided', function (st) {
    let c = new Common('mainnet')
    st.equal(c.genesis().hash, '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3', 'mainnet')
    c.setChain('ropsten') //重新将链设置为ropsten
    st.equal(c.genesis().hash, '0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d', 'ropsten')
    c.setChain('rinkeby')
    st.equal(c.genesis().hash, '0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177', 'rinkeby')
    c.setChain('kovan')
    st.equal(c.genesis().hash, '0xa3c565fc15c7478862d50ccd6561e3c06b24cc509bf388941c25ea985ce32cb9', 'kovan')
    c.setChain('goerli')
    st.equal(c.genesis().hash, '0xfa57319d09fd8a32faaf18d338c8a925a5a7975285bf29ecd024e083cba8abb1', 'goerli')

    st.end()
  })

  t.test('Should provide correct access to private network chain parameters', function (st) {//如果你连接的chain不是上面那些定义好的chain，而是你私有的或定制的，初始化的方式是下面这样的
    let chainParams = require('./testnet.json') //testnet.json中是具体的链描述信息
    let c = new Common(chainParams, 'byzantium')
    st.equal(c.chainName(), 'testnet', 'should initialize with chain name')
    st.equal(c.chainId(), , 'should return correct chain Id')
    st.equal(c.networkId(), , 'should return correct network Id')
    st.equal(c.genesis().hash, '0xaa00000000000000000000000000000000000000000000000000000000000000', 'should return correct genesis hash')
    st.equal(c.hardforks()[]['block'], , 'should return correct hardfork data')
    st.equal(c.bootstrapNodes()[].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) {
    let chainParams = require('./testnet.json')
    delete chainParams['hardforks'] //如果有任何内容的缺失，初始化时将报错
    st.throws(function () { new Common(chainParams) }, /Missing required/, 'should throw an exception on missing parameter') // eslint-disable-line no-new

    st.end()
  })
})

ethereumjs-common/tests/hardforks.js

const tape = require('tape')
const Common = require('../index.js')

tape('[Common]: Hardfork logic', function (t) {
  t.test('Hardfork access', function (st) {
    let supportedHardforks = [ //设置支持的硬分支类型
      'chainstart',
      'homestead',
      'dao',
      'tangerineWhistle',
      'spuriousDragon',
      'byzantium',
      'constantinople'
    ]
    let c

    for (let hardfork of supportedHardforks) {
      c = new Common('mainnet', hardfork)
      st.equal(c.hardfork(), hardfork, hardfork)
    }

    st.end()
  })

  t.test('hardforkBlock()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.hardforkBlock('byzantium'), , 'should return the correct HF change block for byzantium (provided)') //得到byzantium分叉开始的区块数

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkBlock(), , 'should return the correct HF change block for byzantium (set)')

    st.end()
  })

  t.test('isHardforkBlock()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.isHardforkBlock(, 'byzantium'), true, 'should return true for HF change block for byzantium (provided)')
    st.equal(c.isHardforkBlock(, 'byzantium'), false, 'should return false for another block for byzantium (provided)')

    c = new Common('ropsten', 'byzantium')
    st.equal(c.isHardforkBlock(), true, 'should return true for HF change block for byzantium (set)')
    st.equal(c.isHardforkBlock(), false, 'should return false for another block for byzantium (set)')

    st.end()
  })

  t.test('activeHardforks()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.activeHardforks().length, , 'should return 5 active hardforks for Ropsten') //说明ropsten链中有5个活跃分叉类型
    st.equal(c.activeHardforks()[]['name'], 'spuriousDragon', 'should return the correct HF data for Ropsten')
    st.equal(c.activeHardforks().length, , 'should return 3 active hardforks for Ropsten up to block 9')//即直到区块9有的活跃分叉个数为3
    st.equal(c.activeHardforks().length, , 'should return 4 active hardforks for Ropsten up to block 10')

    c = new Common('ropsten', null, ['spuriousDragon', 'byzantium', 'constantinople'])
    //onlySupported: true说明只支持supportedHardforks里面的分叉，所以返回的结果就从5变成了2，只包含了2个活跃分叉类型
    st.equal(c.activeHardforks(null, { onlySupported: true }).length, , 'should return 2 active HFs when restricted to supported HFs')

    st.end()
  })

  t.test('activeHardfork()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.activeHardfork(), 'byzantium', 'should return byzantium as latest active HF for Ropsten') //说明整条链最新的分叉为byzantium
    st.equal(c.activeHardfork(), 'spuriousDragon', 'should return spuriousDragon as latest active HF for Ropsten for block 10') //即到区块10的最新分叉类型为spuriousDragon

    c = new Common('ropsten', null, ['tangerineWhistle', 'spuriousDragon'])
    //返回'spuriousDragon'，因为supportedHardforks里最新的类型为它
    st.equal(c.activeHardfork(null, { onlySupported: true }), 'spuriousDragon', 'should return spuriousDragon as latest active HF for Ropsten with limited supported hardforks')

    st.end()
  })

  t.test('hardforkIsActiveOnBlock() / activeOnBlock()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), true, 'Ropsten, byzantium (provided), 1700000 -> true')
    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), true, 'Ropsten, byzantium (provided), 1700005 -> true')
    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), false, 'Ropsten, byzantium (provided), 1699999 -> false')

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkIsActiveOnBlock(null, ), true, 'Ropsten, byzantium (set), 1700000 -> true')
    st.equal(c.activeOnBlock(), true, 'Ropsten, byzantium (set), 1700000 -> true (alias function)')
    st.equal(c.hardforkIsActiveOnBlock(null, ), true, 'Ropsten, byzantium (set), 1700005 -> true')
    st.equal(c.hardforkIsActiveOnBlock(null, ), false, 'Ropsten, byzantium (set), 1699999 -> false')

    st.end()
  })

  t.test('hardforkGteHardfork()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.hardforkGteHardfork('constantinople', 'byzantium'), true, 'Ropsten, constantinople >= byzantium (provided) -> true')
    st.equal(c.hardforkGteHardfork('constantinople', 'byzantium', { onlyActive: true }), false, 'Ropsten, constantinople >= byzantium (provided), onlyActive -> fale')
    st.equal(c.hardforkGteHardfork('byzantium', 'byzantium'), true, 'Ropsten, byzantium >= byzantium (provided) -> true')
    st.equal(c.hardforkGteHardfork('spuriousDragon', 'byzantium'), false, 'Ropsten, spuriousDragon >= byzantium (provided) -> false')

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkGteHardfork(null, 'spuriousDragon'), true, 'Ropsten, byzantium (set) >= spuriousDragon -> true')
    st.equal(c.gteHardfork('spuriousDragon'), true, 'Ropsten, byzantium (set) >= spuriousDragon -> true (alias function)')
    st.equal(c.hardforkGteHardfork(null, 'spuriousDragon', { onlyActive: true }), true, 'Ropsten, byzantium (set) >= spuriousDragon, onlyActive -> true')
    st.equal(c.hardforkGteHardfork(null, 'byzantium'), true, 'Ropsten, byzantium (set) >= byzantium -> true')
    st.equal(c.hardforkGteHardfork(null, 'constantinople'), false, 'Ropsten, byzantium (set) >= constantinople -> false')

    st.end()
  })

  t.test('hardforkIsActiveOnChain()', function (st) {
    let c = new Common('ropsten')
    st.equal(c.hardforkIsActiveOnChain('byzantium'), true, 'should return true for byzantium (provided) on Ropsten')
    st.equal(c.hardforkIsActiveOnChain('dao'), false, 'should return false for dao (provided) on Ropsten')
    st.equal(c.hardforkIsActiveOnChain('constantinople'), false, 'should return false for constantinople (provided) on Ropsten')
    st.equal(c.hardforkIsActiveOnChain('notexistinghardfork'), false, 'should return false for a non-existing HF (provided) on Ropsten')
    //因为这里并没有设置，但是使用了onlySupported: true，所以会报出"spuriousDragon"为不支持的分叉的错误
    st.doesNotThrow(function () { c.hardforkIsActiveOnChain('spuriousDragon', { onlySupported: true }) }, /unsupported hardfork$/, 'should not throw with unsupported Hf (provided) and onlySupported set to false') // eslint-disable-line no-new

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkIsActiveOnChain(), true, 'should return true for byzantium (set) on Ropsten')

    c = new Common('ropsten', null, ['byzantium', 'constantinople'])
    st.throws(function () { c.hardforkIsActiveOnChain('spuriousDragon', { onlySupported: true }) }, /not set as supported in supportedHardforks$/, 'should throw with unsupported Hf and onlySupported set to true') // eslint-disable-line no-new

    st.end()
  })

  t.test('consensus()/finality()', function (st) {
    let c = new Common('mainnet')
    st.equal(c.consensus('byzantium'), 'pow', 'should return pow for byzantium consensus')//返回byzantium分叉共识为'pow'
    st.equal(c.consensus('constantinople'), 'pow', 'should return pow for constantinople consensus')
    st.equal(c.finality('byzantium'), null, 'should return null for byzantium finality')

    st.end()
  })
})

ethereumjs-common/tests/params.js

const tape = require('tape')
const Common = require('../index.js')

tape('[Common]: Parameter access', function (t) {//这个测试就是获取参数值
  t.test('Basic usage', function (st) {
    let c = new Common('mainnet')
    st.equal(c.param('gasPrices', 'ecAdd', 'byzantium'), , 'Should return correct value when HF directly provided')

    c.setHardfork('byzantium')
    st.equal(c.param('gasPrices', 'ecAdd'), , 'Should return correct value for HF set in class')

    st.end()
  })

  t.test('Error cases', function (st) {
    let c = new Common('mainnet')
    st.throws(function () { c.param('gasPrices', 'ecAdd') }, /neither a hardfork set nor provided by param$/, 'Should throw when no hardfork set or provided')
    st.throws(function () { c.param('gasPrizes', 'ecAdd', 'byzantium') }, /Topic gasPrizes not defined$/, 'Should throw when called with non-existing topic')
    st.throws(function () { c.param('gasPrices', 'notexistingvalue', 'byzantium') }, /value for notexistingvalue not found$/, 'Should throw when called with non-existing value')

    c.setHardfork('byzantium')
    st.equal(c.param('gasPrices', 'ecAdd'), , 'Should return correct value for HF set in class')

    c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople'])
    st.throws(function () { c.param('gasPrices', 'expByte', 'spuriousDragon') }, /supportedHardforks$/, 'Should throw when calling param() with an unsupported hardfork')
    st.throws(function () { c.paramByBlock('gasPrices', 'expByte', ) }, /supportedHardforks$/, 'Should throw when calling paramByBlock() with an unsupported hardfork')

    st.end()
  })

  t.test('Parameter updates', function (st) {
    let c = new Common('mainnet')
    st.throws(function () { c.param('gasPrices', 'ecAdd', 'spuriousDragon') }, /value for ecAdd not found$/, 'Should throw for a value set on a later HF')

    st.equal(c.param('pow', 'minerReward', 'chainstart'), '', 'Should return correct value for chain start')
    st.equal(c.param('pow', 'minerReward', 'byzantium'), '', 'Should reflect HF update changes')
    st.equal(c.param('gasPrices', 'netSstoreNoopGas', 'constantinople'), , 'Should return updated sstore gas prices for constantinople')

    st.end()
  })

  t.test('Access by block number, paramByBlock()', function (st) {
    let c = new Common('mainnet', 'byzantium')

    st.equal(c.paramByBlock('pow', 'minerReward', ), '', 'Should correctly translate block numbers into HF states (updated value)')
    st.equal(c.paramByBlock('pow', 'minerReward', ), '', 'Should correctly translate block numbers into HF states (original value)')

    st.end()
  })
})

ethereumjs-common/tests/testnet.json

{
  "name": "testnet",
  "chainId": ,
  "networkId": ,
  "comment": "Private test network",
  "genesis": {
    "hash": "0xaa00000000000000000000000000000000000000000000000000000000000000",
    "timestamp": null,
    "gasLimit": ,
    "difficulty": ,
    "nonce": "0xbb00000000000000",
    "extraData": "0xcc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "stateRoot": "0xdd00000000000000000000000000000000000000000000000000000000000000"
  },
  "hardforks": [
    {
      "name": "chainstart",
      "block": ,
      "consensus": "poa",
      "finality": null
    },
    {
      "name": "homestead",
      "block": ,
      "consensus": "poa",
      "finality": null
    },
    {
      "name": "tangerineWhistle",
      "block": ,
      "consensus": "poa",
      "finality": null
    },
    {
      "name": "spuriousDragon",
      "block": ,
      "consensus": "poa",
      "finality": null
    },
    {
      "name": "byzantium",
      "block": ,
      "consensus": "poa",
      "finality": null
    }
  ],
  "bootstrapNodes": [
    {
      "ip": "10.0.0.1",
      "port": ,
      "id": "",
      "location": "",
      "comment": ""
    },
    {
      "ip": "10.0.0.2",
      "port": ,
      "id": "",
      "location": "",
      "comment": ""
    }
  ]
}