ethereumjs/ethereumjs-common-2-API文档

时间：2023-03-09 05:24:48
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') //

_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') //

c.setHardfork('byzantium')

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

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', ) //'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', ) //返回true，等价于下面的

c.activeOnBlock() //返回true

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

c.hardforkIsActiveOnBlock('byzantium', ) //返回false
c = new Common('ropsten', 'byzantium')

c.hardforkIsActiveOnBlock(null, ) //true，因为上面已经设置链分叉为 'byzantium'，所以这里使用的是null

c.hardforkIsActiveOnBlock(null, ) //true

c.hardforkIsActiveOnBlock(null, ) //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, ) //true，或使用

c.activeOnBlock()

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()[]['name'] //'spuriousDragon'

c.activeHardforks().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() //返回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() //返回true

c.isHardforkBlock() //返回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": ,

    "difficulty": ,

    "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": ,

      "consensus": "pow",

      "finality": null

    },

    {

      "name": "homestead",

      "block": ,

      "consensus": "pow",

      "finality": null

    }

]

调用：

let c = new Common('mainnet')

c.hardforks()[]['block']//返回

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": ,

      "id": "3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99",

      "location": "US-WEST",

      "comment": "Go Bootnode"

    },

    {

      "ip": "191.235.84.50",

      "port": ,

      "id": "78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d",

      "location": "BR",

      "comment": "Go Bootnode"

    }

]

调用：

let c = new Common('mainnet')

c.bootstrapNodes()[].port //返回：

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

相关文章