ethereumjs/ethereumjs-common-2-API文档

https://github.com/ethereumjs/ethereumjs-common/blob/master/docs/index.md

 该API的调用的详细例子可见ethereumjs/ethereumjs-common-3-test

Common

Common class to access chain and hardfork parameters

访问链和硬分叉参数的Common类

Parameters输入参数

  • chain (String | Number | Dictionary) String ('mainnet') or Number (1) chain  可以使用字符串（如'mainnet'）或数字（如1）表示链
  • hardfork String String identifier ('byzantium') for hardfork (optional) （可选项）使用字符串标识('byzantium')表示
  • supportedHardforks Array Limit parameter returns to the given hardforks (optional) （可选项）返回给硬分叉的限制参数

 调用：

let c = new Common('mainnet')//使用的是mainnet链
let c = new Common('mainnet', 'byzantium')
let c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople'])

 

⚠️如果你连接的是自己私有的chain,初始化的方式是：

let chainParams = require('./testnet.json') //testnet.json中是具体的链描述信息
let c = new Common(chainParams, 'byzantium')

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": ""
    }
  ]
}

 

注意：

let chainParams = require('./testnet.json')
delete chainParams['hardforks'] //如果有任何内容的缺失，初始化时将报错
let c = new Common(chainParams, 'byzantium') //报错

 

 

 

setChain

Sets the chain 设置链

Parameters

  • chain (String | Number | Dictionary) String ('mainnet') or Number (1) chain representation. Or, a Dictionary of chain parameters for a private network. 可以使用字符串（如'mainnet'）或数字（如1）表示链。或者对于私有网络则使用链参数字典

调用：

let c = new Common('mainnet')
c.setChain('ropsten') //重新将链设置为ropsten

 

 

 

setHardfork

Sets the hardfork to get params for

设置硬叉以获取参数

Parameters

  • hardfork String String identifier ('byzantium')使用字符串标识('byzantium')表示

 调用：

let c = new Common('mainnet')
c.param('gasPrices', 'ecAdd', 'byzantium') //500

c.setHardfork('byzantium')
st.equal(c.param('gasPrices', 'ecAdd') //500

 

 

_chooseHardfork

Internal helper function to choose between hardfork set and hardfork provided as param

内部帮助函数，用于在硬分叉集中选择并提供其为参数

Parameters

  • hardfork String Hardfork given to function as a parameter 作为函数参数的硬分叉
  • onlySupported

Returns String Hardfork chosen to be used 返回选择使用的硬分叉

 

_getHardfork

Internal helper function, returns the params for the given hardfork for the chain set

内部帮助函数，返回链集的给定硬分叉的参数

Parameters

  • hardfork String Hardfork name 硬分叉名字

Returns Dictionary

 

_isSupportedHardfork

Internal helper function to check if a hardfork is set to be supported by the library

内部帮助函数，查看设置的硬分叉是否被库支持

Parameters

  • hardfork String Hardfork name 硬分叉的名字

Returns Boolean True if hardfork is supported 如果硬分叉被支持则返回true

 调用：

let c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople'])
c._isSupportedHardfork('byzantium') //返回true
c._isSupportedHardfork('spuriousDragon') //返回false

 

 

param

Returns the parameter corresponding to a hardfork

返回与硬分叉相关联的参数

Parameters

  • topic String Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow', 'casper', 'sharding') 参数主题(有'gasConfig', 'gasPrices', 'vm', 'pow', 'casper', 'sharding')
  • name String Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic) 参数名字 （比如'gasConfig' 主题中的 'minGasLimit' ）
  • hardfork String Hardfork name, optional if hardfork set 影分叉的名字，如果硬分叉集可选

 调用：

let c = new Common('mainnet')
c.param('gasPrices', 'ecAdd', 'byzantium') //500

c.setHardfork('byzantium')
st.equal(c.param('gasPrices', 'ecAdd') //500

 

 

paramByBlock

Returns a parameter for the hardfork active on block number

返回在区块数中活跃硬分叉的参数

Parameters

  • topic String Parameter topic 参数主体
  • name String Parameter name 参数名
  • blockNumber Number Block number 区块数

调用：

let c = new Common('mainnet', 'byzantium')
c.paramByBlock('pow', 'minerReward', 4370000) //'3000000000000000000'

 

 

hardforkIsActiveOnBlock

Checks if set or provided hardfork is active on block number

查看是否设置了或提供的硬分叉在区块数中是活跃的

Parameters

  • hardfork String Hardfork name or null (for HF set) 硬分叉名字或null
  • blockNumber Number 区块数
  • opts Array
    • opts.onlySupported Array.Boolean optional, only allow supported HFs (default: false) （可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Boolean

调用：

let c = new Common('ropsten')
c.hardforkIsActiveOnBlock('byzantium', 1700000) //返回true，等价于下面的
c.activeOnBlock(1700000) //返回true

c.hardforkIsActiveOnBlock('byzantium', 1700005)//返回true
c.hardforkIsActiveOnBlock('byzantium', 1699999) //返回false

 

c = new Common('ropsten', 'byzantium')
c.hardforkIsActiveOnBlock(null, 1700000) //true，因为上面已经设置链分叉为 'byzantium'，所以这里使用的是null
c.hardforkIsActiveOnBlock(null, 1700005) //true
c.hardforkIsActiveOnBlock(null, 1699999) //false

 

 

activeOnBlock

Alias to hardforkIsActiveOnBlock when hardfork is set

当硬分叉被设置时，其为hardforkIsActiveOnBlock的别名

Parameters

  • blockNumber Number区块数
  • opts Array
    • opts.onlySupported Array.Boolean optional, only allow supported HFs (default: false)（可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Boolean

 调用：

c = new Common('ropsten', 'byzantium')//当分叉已经设置时
c.hardforkIsActiveOnBlock(null, 1700000) //true，或使用
c.activeOnBlock(1700000)

 

 

 

hardforkGteHardfork

Sequence based check if given or set HF1 is greater than or equal HF2

基于序列的检查是否给定的或设置的硬分叉1强过或等同于硬分叉2时

Parameters

  • hardfork1 String Hardfork name or null (if set) 硬分叉名字或null
  • hardfork2 String Hardfork name 硬分叉名字
  • opts Array
    • opts.onlyActive Array.Boolean optional, only active HFs (default: false)（可选的）表示活跃HFs（默认为false）
    • opts.onlySupported Array.Boolean optional, only allow supported HFs (default: false)（可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Boolean

 调用：

let c = new Common('ropsten')
c.hardforkGteHardfork('constantinople', 'byzantium') //返回true，因为constantinople >= byzantium (provided)
c.hardforkGteHardfork('spuriousDragon', 'byzantium') //false

 

gteHardfork

Alias to hardforkGteHardfork when hardfork is set

当硬分叉被设置时其为hardforkGteHardfork别名

Parameters

  • hardfork String Hardfork name硬分叉名字
  • opts Array
    • opts.onlyActive Array.Boolean optional, only active HFs (default: false)（可选的）表示活跃HFs（默认为false）
    • opts.onlySupported Array.Boolean optional, only allow supported HFs (default: false)（可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Boolean

 调用：

c = new Common('ropsten', 'byzantium') //当分叉已经被设置时
c.hardforkGteHardfork(null, 'spuriousDragon') //返回true，或使用下面
c.gteHardfork('spuriousDragon') //true

 

hardforkIsActiveOnChain

Checks if given or set hardfork is active on the chain

检查是否给定的或设置的硬分叉在链上是活跃的

Parameters

  • hardfork String Hardfork name, optional if HF set 硬分叉名字
  • opts Array
    • opts.onlySupported Array.Boolean optional, only allow supported HFs (default: false) 可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Boolean

 调用：

let c = new Common('ropsten')
c.hardforkIsActiveOnChain('byzantium') //true
c.hardforkIsActiveOnChain('dao') //false
c.hardforkIsActiveOnChain('spuriousDragon', { onlySupported: true })//因为这里并没有设置，但是使用了onlySupported: true，所以会报出"spuriousDragon"为不支持的分叉的错误

c = new Common('ropsten', 'byzantium')
c.hardforkIsActiveOnChain() //true，即设置的'byzantium'在ropsten链中活跃

 

 

activeHardforks

Returns the active hardfork switches for the current chain

返回当前链的活跃硬分叉开关

Parameters

  • blockNumber Number up to block if provided, otherwise for the whole chain 如果提供则查询至该指定区块，否则为整条链
  • opts Array
    • opts.onlySupported Array.Boolean optional, limit results to supported HFs (default: false)（可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns Array Array with hardfork arrays 硬分叉数组

 调用：

let c = new Common('ropsten')
c.activeHardforks().length //返回5，说明ropsten链中有5个活跃分叉类型
c.activeHardforks()[3]['name'] //'spuriousDragon'
c.activeHardforks(9).length //返回3，即直到区块9有的活跃分叉个数为3

 

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

 

 

activeHardfork

Returns the latest active hardfork name for chain or block or throws if unavailable

返回链或区块最新的活跃硬分叉的名字，如果不可行则抛出错误

Parameters

  • blockNumber Number up to block if provided, otherwise for the whole chain如果提供则查询至该指定区块，否则为整条链
  • opts Array
    • opts.onlySupported Array.Boolean optional, limit results to supported HFs (default: false)（可选的）表示只支持HFs ，即初始化时自己设置的supportedHardforks（默认为false）

Returns String Hardfork name 硬分叉名

 调用：

let c = new Common('ropsten')
c.activeHardfork() //返回byzantium ，说明整条链最新的分叉为byzantium
c.activeHardfork(10) //返回spuriousDragon，即到区块10的最新分叉类型为spuriousDragon

 

c = new Common('ropsten', null, ['tangerineWhistle', 'spuriousDragon'])
c.activeHardfork(null, { onlySupported: true }) //返回'spuriousDragon'，因为supportedHardforks里最新的类型为它

 

hardforkBlock

Returns the hardfork change block for hardfork provided or set

为提供或设置的硬分叉返回硬分叉改变块

Parameters

  • hardfork String Hardfork name, optional if HF set 硬分叉名，如果硬分叉集设置则可选

Returns Number Block number 返回区块数

 例子：

let c = new Common('ropsten')
c.hardforkBlock('byzantium') //返回1700000，得到byzantium分叉开始的区块数

 

 

isHardforkBlock

True if block number provided is the hardfork (given or set) change block of the current chain

如果提供的区块数是目前链的硬分叉（给定或设置的）改变区块，则返回true

Parameters

  • blockNumber Number Number of the block to check 查看的区块数
  • hardfork String Hardfork name, optional if HF set 硬分叉名，如果硬分叉集设置则可选

Returns Boolean

 调用：

let c = new Common('ropsten')
c.isHardforkBlock(1700000) //返回true
c.isHardforkBlock(1700001) //返回false

 

 

consensus共识

Provide the consensus type for the hardfork set or provided as param

为设置或提供的硬分叉集提供共识类型作为参数

Parameters

  • hardfork String Hardfork name, optional if hardfork set 硬分叉名，如果硬分叉集设置则可选

Returns String Consensus type (e.g. 'pow', 'poa') 返回共识类型（如'pow', 'poa'）

 

let c = new Common('mainnet')
c.consensus('byzantium') //返回byzantium分叉共识为'pow'

 

 

finality

Provide the finality type for the hardfork set or provided as param

为设置或提供的硬分叉集提供结束类型作为参数

Parameters

  • hardfork String Hardfork name, optional if hardfork set 硬分叉名，如果硬分叉集设置则可选

Returns String Finality type (e.g. 'pos', null of no finality) 结束类型（如'pos'，没有则为null）

 调用：

let c = new Common('mainnet')
c.finality('byzantium') //null

 

 

genesis

Returns the Genesis parameters of current chain

返回当前链的初始状态参数

Returns Dictionary Genesis dict 初始字典

 如：

 "genesis": {
    "hash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
    "timestamp": null,
    "gasLimit": 5000,
    "difficulty": 17179869184,
    "nonce": "0x0000000000000042",
    "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
    "stateRoot": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
  }

调用：

let c = new Common('mainnet')
c.genesis().hash //返回"0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"

 

 

hardforks

Returns the hardforks for current chain返回当前链的硬分叉

Returns Array Array with arrays of hardforks 硬分叉的数组

 如：

 "hardforks": [
    {
      "name": "chainstart",
      "block": 0,
      "consensus": "pow",
      "finality": null
    },
    {
      "name": "homestead",
      "block": 1150000,
      "consensus": "pow",
      "finality": null
    }
]

调用：

let c = new Common('mainnet')
c.hardforks()[1]['block']//返回1150000

 

 

hardfork

Returns the hardfork set 返回硬分叉集

Returns String Hardfork name 硬分叉名字

调用：

let c = new Common('mainnet', 'byzantium') 
c.hardfork() //返回'byzantium'

 

 

bootstrapNodes

Returns bootstrap nodes for the current chain 返回当前链的bootstrap节点

Returns Dictionary Dict with bootstrap nodes  bootstrap节点字典

如：

  "bootstrapNodes": [
    {
      "ip": "13.93.211.84",
      "port": 30303,
      "id": "3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99",
      "location": "US-WEST",
      "comment": "Go Bootnode"
    },
    {
      "ip": "191.235.84.50",
      "port": 30303,
      "id": "78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d",
      "location": "BR",
      "comment": "Go Bootnode"
    }
]

调用：

let c = new Common('mainnet')
c.bootstrapNodes()[0].port //返回：30303

 

 

chainId

Returns the Id of current chain 返回当前链的ID

Returns Number chain Id

调用：

let c = new Common('mainnet')
c.chainId() //返回1

 

 

chainName

Returns the name of current chain 返回当前链的名字

Returns String chain name (lower case) （小写）

调用：

let c = new Common('mainnet')
c.chainName() //返回'mainnet'

 

 

networkId

Returns the Id of current network 返回当前网络的ID

Returns Number network Id

 调用：

let c = new Common('mainnet')
c.networkId() //返回1

 

posted @ 2018-12-12 10:24  慢行厚积  阅读(1021)  评论(0)  编辑  收藏  举报