ethereumjs/ethereumjs-common-2-API文档

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
```
相关阅读:
Python标准库：内置函数dict(**kwarg)
如何把 excel 的数据导入到数据库里面去
 正在载入数据中效果
 站点公司亚马逊砸了10亿也没能做成智能手机，技术是须要沉淀和积累的
 零积分下载，2014年辛星mysql教程秋季版第一本已经完工，期待您的支持
 【C语言】在两个数成对出现的数组中找到一个单独的数。
3.跟我学solr---使用solrj加入索引
 使用CAShapeLayer的path属性与UIBezierPath画出扫描框
 UI设计四要素
 swift 工作日志
原文地址：https://www.cnblogs.com/wanghui-garcia/p/10087836.html

ethereumjs/ethereumjs-common-2-API文档

Common

调用：

setChain

setHardfork

调用：

_chooseHardfork

_getHardfork

_isSupportedHardfork

param

调用：

paramByBlock

调用：

hardforkIsActiveOnBlock

调用：

activeOnBlock

调用：

hardforkGteHardfork

调用：

gteHardfork

调用：

hardforkIsActiveOnChain

调用：

activeHardforks

调用：

activeHardfork

调用：

hardforkBlock

例子：

isHardforkBlock

调用：

consensus共识

finality

调用：

genesis

hardforks

hardfork

bootstrapNodes

chainId

chainName

networkId