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(), 1, 'should return correct chain Id') //獲得chainId
    st.equal(c.networkId(), 1, '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(1) //也能夠使用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()[3]['block'], 2463000, 'should return correct hardfork data')//返回當前鏈的硬分叉數組中第四個分叉的'block'值
    st.equal(c.bootstrapNodes()[0].port, 30303, '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(), 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) {
    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'), 1700000, 'should return the correct HF change block for byzantium (provided)') //獲得byzantium分叉開始的區塊數

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkBlock(), 1700000, '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(1700000, 'byzantium'), true, 'should return true for HF change block for byzantium (provided)')
    st.equal(c.isHardforkBlock(1700001, 'byzantium'), false, 'should return false for another block for byzantium (provided)')

    c = new Common('ropsten', 'byzantium')
    st.equal(c.isHardforkBlock(1700000), true, 'should return true for HF change block for byzantium (set)')
    st.equal(c.isHardforkBlock(1700001), 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, 5, 'should return 5 active hardforks for Ropsten') //說明ropsten鏈中有5個活躍分叉類型
    st.equal(c.activeHardforks()[3]['name'], 'spuriousDragon', 'should return the correct HF data for Ropsten')
    st.equal(c.activeHardforks(9).length, 3, 'should return 3 active hardforks for Ropsten up to block 9')//即直到區塊9有的活躍分叉個數爲3
    st.equal(c.activeHardforks(10).length, 4, '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, 2, '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(10), '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', 1700000), true, 'Ropsten, byzantium (provided), 1700000 -> true')
    st.equal(c.hardforkIsActiveOnBlock('byzantium', 1700005), true, 'Ropsten, byzantium (provided), 1700005 -> true')
    st.equal(c.hardforkIsActiveOnBlock('byzantium', 1699999), false, 'Ropsten, byzantium (provided), 1699999 -> false')

    c = new Common('ropsten', 'byzantium')
    st.equal(c.hardforkIsActiveOnBlock(null, 1700000), true, 'Ropsten, byzantium (set), 1700000 -> true')
    st.equal(c.activeOnBlock(1700000), true, 'Ropsten, byzantium (set), 1700000 -> true (alias function)')
    st.equal(c.hardforkIsActiveOnBlock(null, 1700005), true, 'Ropsten, byzantium (set), 1700005 -> true')
    st.equal(c.hardforkIsActiveOnBlock(null, 1699999), 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'), 500, 'Should return correct value when HF directly provided')

    c.setHardfork('byzantium')
    st.equal(c.param('gasPrices', 'ecAdd'), 500, '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'), 500, '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', 0) }, /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'), '5000000000000000000', 'Should return correct value for chain start')
    st.equal(c.param('pow', 'minerReward', 'byzantium'), '3000000000000000000', 'Should reflect HF update changes')
    st.equal(c.param('gasPrices', 'netSstoreNoopGas', 'constantinople'), 200, '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', 4370000), '3000000000000000000', 'Should correctly translate block numbers into HF states (updated value)')
    st.equal(c.paramByBlock('pow', 'minerReward', 4369999), '5000000000000000000', 'Should correctly translate block numbers into HF states (original value)')

    st.end()
  })
})

 

ethereumjs-common/tests/testnet.json

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