config.go 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339
  1. // Copyright 2016 The go-ethereum Authors
  2. // This file is part of the go-ethereum library.
  3. //
  4. // The go-ethereum library is free software: you can redistribute it and/or modify
  5. // it under the terms of the GNU Lesser General Public License as published by
  6. // the Free Software Foundation, either version 3 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // The go-ethereum library is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. // GNU Lesser General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU Lesser General Public License
  15. // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
  16. package params
  17. import (
  18. "fmt"
  19. "math/big"
  20. "github.com/ethereum/go-ethereum/common"
  21. )
  22. var (
  23. MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") // Mainnet genesis hash to enforce below configs on
  24. TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") // Testnet genesis hash to enforce below configs on
  25. )
  26. var (
  27. // MainnetChainConfig is the chain parameters to run a node on the main network.
  28. MainnetChainConfig = &ChainConfig{
  29. ChainId: big.NewInt(1),
  30. HomesteadBlock: big.NewInt(1150000),
  31. DAOForkBlock: big.NewInt(1920000),
  32. DAOForkSupport: true,
  33. EIP150Block: big.NewInt(2463000),
  34. EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
  35. EIP155Block: big.NewInt(2675000),
  36. EIP158Block: big.NewInt(2675000),
  37. ByzantiumBlock: big.NewInt(4370000),
  38. ConstantinopleBlock: nil,
  39. Ethash: new(EthashConfig),
  40. }
  41. // TestnetChainConfig contains the chain parameters to run a node on the Ropsten test network.
  42. TestnetChainConfig = &ChainConfig{
  43. ChainId: big.NewInt(3),
  44. HomesteadBlock: big.NewInt(0),
  45. DAOForkBlock: nil,
  46. DAOForkSupport: true,
  47. EIP150Block: big.NewInt(0),
  48. EIP150Hash: common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"),
  49. EIP155Block: big.NewInt(10),
  50. EIP158Block: big.NewInt(10),
  51. ByzantiumBlock: big.NewInt(1700000),
  52. ConstantinopleBlock: nil,
  53. Ethash: new(EthashConfig),
  54. }
  55. // RinkebyChainConfig contains the chain parameters to run a node on the Rinkeby test network.
  56. RinkebyChainConfig = &ChainConfig{
  57. ChainId: big.NewInt(4),
  58. HomesteadBlock: big.NewInt(1),
  59. DAOForkBlock: nil,
  60. DAOForkSupport: true,
  61. EIP150Block: big.NewInt(2),
  62. EIP150Hash: common.HexToHash("0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"),
  63. EIP155Block: big.NewInt(3),
  64. EIP158Block: big.NewInt(3),
  65. ByzantiumBlock: big.NewInt(1035301),
  66. ConstantinopleBlock: nil,
  67. Clique: &CliqueConfig{
  68. Period: 15,
  69. Epoch: 30000,
  70. },
  71. }
  72. // AllEthashProtocolChanges contains every protocol change (EIPs) introduced
  73. // and accepted by the Ethereum core developers into the Ethash consensus.
  74. //
  75. // This configuration is intentionally not using keyed fields to force anyone
  76. // adding flags to the config to also have to set these fields.
  77. AllEthashProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(EthashConfig), nil}
  78. // AllCliqueProtocolChanges contains every protocol change (EIPs) introduced
  79. // and accepted by the Ethereum core developers into the Clique consensus.
  80. //
  81. // This configuration is intentionally not using keyed fields to force anyone
  82. // adding flags to the config to also have to set these fields.
  83. AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
  84. TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(EthashConfig), nil}
  85. TestRules = TestChainConfig.Rules(new(big.Int))
  86. )
  87. // ChainConfig is the core config which determines the blockchain settings.
  88. //
  89. // ChainConfig is stored in the database on a per block basis. This means
  90. // that any network, identified by its genesis block, can have its own
  91. // set of configuration options.
  92. type ChainConfig struct {
  93. ChainId *big.Int `json:"chainId"` // Chain id identifies the current chain and is used for replay protection
  94. HomesteadBlock *big.Int `json:"homesteadBlock,omitempty"` // Homestead switch block (nil = no fork, 0 = already homestead)
  95. DAOForkBlock *big.Int `json:"daoForkBlock,omitempty"` // TheDAO hard-fork switch block (nil = no fork)
  96. DAOForkSupport bool `json:"daoForkSupport,omitempty"` // Whether the nodes supports or opposes the DAO hard-fork
  97. // EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
  98. EIP150Block *big.Int `json:"eip150Block,omitempty"` // EIP150 HF block (nil = no fork)
  99. EIP150Hash common.Hash `json:"eip150Hash,omitempty"` // EIP150 HF hash (needed for header only clients as only gas pricing changed)
  100. EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block
  101. EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block
  102. ByzantiumBlock *big.Int `json:"byzantiumBlock,omitempty"` // Byzantium switch block (nil = no fork, 0 = already on byzantium)
  103. ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated)
  104. // Various consensus engines
  105. Ethash *EthashConfig `json:"ethash,omitempty"`
  106. Clique *CliqueConfig `json:"clique,omitempty"`
  107. }
  108. // EthashConfig is the consensus engine configs for proof-of-work based sealing.
  109. type EthashConfig struct{}
  110. // String implements the stringer interface, returning the consensus engine details.
  111. func (c *EthashConfig) String() string {
  112. return "ethash"
  113. }
  114. // CliqueConfig is the consensus engine configs for proof-of-authority based sealing.
  115. type CliqueConfig struct {
  116. Period uint64 `json:"period"` // Number of seconds between blocks to enforce
  117. Epoch uint64 `json:"epoch"` // Epoch length to reset votes and checkpoint
  118. }
  119. // String implements the stringer interface, returning the consensus engine details.
  120. func (c *CliqueConfig) String() string {
  121. return "clique"
  122. }
  123. // String implements the fmt.Stringer interface.
  124. func (c *ChainConfig) String() string {
  125. var engine interface{}
  126. switch {
  127. case c.Ethash != nil:
  128. engine = c.Ethash
  129. case c.Clique != nil:
  130. engine = c.Clique
  131. default:
  132. engine = "unknown"
  133. }
  134. return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Engine: %v}",
  135. c.ChainId,
  136. c.HomesteadBlock,
  137. c.DAOForkBlock,
  138. c.DAOForkSupport,
  139. c.EIP150Block,
  140. c.EIP155Block,
  141. c.EIP158Block,
  142. c.ByzantiumBlock,
  143. c.ConstantinopleBlock,
  144. engine,
  145. )
  146. }
  147. // IsHomestead returns whether num is either equal to the homestead block or greater.
  148. func (c *ChainConfig) IsHomestead(num *big.Int) bool {
  149. return isForked(c.HomesteadBlock, num)
  150. }
  151. // IsDAO returns whether num is either equal to the DAO fork block or greater.
  152. func (c *ChainConfig) IsDAOFork(num *big.Int) bool {
  153. return isForked(c.DAOForkBlock, num)
  154. }
  155. func (c *ChainConfig) IsEIP150(num *big.Int) bool {
  156. return isForked(c.EIP150Block, num)
  157. }
  158. func (c *ChainConfig) IsEIP155(num *big.Int) bool {
  159. return isForked(c.EIP155Block, num)
  160. }
  161. func (c *ChainConfig) IsEIP158(num *big.Int) bool {
  162. return isForked(c.EIP158Block, num)
  163. }
  164. func (c *ChainConfig) IsByzantium(num *big.Int) bool {
  165. return isForked(c.ByzantiumBlock, num)
  166. }
  167. func (c *ChainConfig) IsConstantinople(num *big.Int) bool {
  168. return isForked(c.ConstantinopleBlock, num)
  169. }
  170. // GasTable returns the gas table corresponding to the current phase (homestead or homestead reprice).
  171. //
  172. // The returned GasTable's fields shouldn't, under any circumstances, be changed.
  173. func (c *ChainConfig) GasTable(num *big.Int) GasTable {
  174. if num == nil {
  175. return GasTableHomestead
  176. }
  177. switch {
  178. case c.IsEIP158(num):
  179. return GasTableEIP158
  180. case c.IsEIP150(num):
  181. return GasTableEIP150
  182. default:
  183. return GasTableHomestead
  184. }
  185. }
  186. // CheckCompatible checks whether scheduled fork transitions have been imported
  187. // with a mismatching chain configuration.
  188. func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64) *ConfigCompatError {
  189. bhead := new(big.Int).SetUint64(height)
  190. // Iterate checkCompatible to find the lowest conflict.
  191. var lasterr *ConfigCompatError
  192. for {
  193. err := c.checkCompatible(newcfg, bhead)
  194. if err == nil || (lasterr != nil && err.RewindTo == lasterr.RewindTo) {
  195. break
  196. }
  197. lasterr = err
  198. bhead.SetUint64(err.RewindTo)
  199. }
  200. return lasterr
  201. }
  202. func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, head *big.Int) *ConfigCompatError {
  203. if isForkIncompatible(c.HomesteadBlock, newcfg.HomesteadBlock, head) {
  204. return newCompatError("Homestead fork block", c.HomesteadBlock, newcfg.HomesteadBlock)
  205. }
  206. if isForkIncompatible(c.DAOForkBlock, newcfg.DAOForkBlock, head) {
  207. return newCompatError("DAO fork block", c.DAOForkBlock, newcfg.DAOForkBlock)
  208. }
  209. if c.IsDAOFork(head) && c.DAOForkSupport != newcfg.DAOForkSupport {
  210. return newCompatError("DAO fork support flag", c.DAOForkBlock, newcfg.DAOForkBlock)
  211. }
  212. if isForkIncompatible(c.EIP150Block, newcfg.EIP150Block, head) {
  213. return newCompatError("EIP150 fork block", c.EIP150Block, newcfg.EIP150Block)
  214. }
  215. if isForkIncompatible(c.EIP155Block, newcfg.EIP155Block, head) {
  216. return newCompatError("EIP155 fork block", c.EIP155Block, newcfg.EIP155Block)
  217. }
  218. if isForkIncompatible(c.EIP158Block, newcfg.EIP158Block, head) {
  219. return newCompatError("EIP158 fork block", c.EIP158Block, newcfg.EIP158Block)
  220. }
  221. if c.IsEIP158(head) && !configNumEqual(c.ChainId, newcfg.ChainId) {
  222. return newCompatError("EIP158 chain ID", c.EIP158Block, newcfg.EIP158Block)
  223. }
  224. if isForkIncompatible(c.ByzantiumBlock, newcfg.ByzantiumBlock, head) {
  225. return newCompatError("Byzantium fork block", c.ByzantiumBlock, newcfg.ByzantiumBlock)
  226. }
  227. if isForkIncompatible(c.ConstantinopleBlock, newcfg.ConstantinopleBlock, head) {
  228. return newCompatError("Constantinople fork block", c.ConstantinopleBlock, newcfg.ConstantinopleBlock)
  229. }
  230. return nil
  231. }
  232. // isForkIncompatible returns true if a fork scheduled at s1 cannot be rescheduled to
  233. // block s2 because head is already past the fork.
  234. func isForkIncompatible(s1, s2, head *big.Int) bool {
  235. return (isForked(s1, head) || isForked(s2, head)) && !configNumEqual(s1, s2)
  236. }
  237. // isForked returns whether a fork scheduled at block s is active at the given head block.
  238. func isForked(s, head *big.Int) bool {
  239. if s == nil || head == nil {
  240. return false
  241. }
  242. return s.Cmp(head) <= 0
  243. }
  244. func configNumEqual(x, y *big.Int) bool {
  245. if x == nil {
  246. return y == nil
  247. }
  248. if y == nil {
  249. return x == nil
  250. }
  251. return x.Cmp(y) == 0
  252. }
  253. // ConfigCompatError is raised if the locally-stored blockchain is initialised with a
  254. // ChainConfig that would alter the past.
  255. type ConfigCompatError struct {
  256. What string
  257. // block numbers of the stored and new configurations
  258. StoredConfig, NewConfig *big.Int
  259. // the block number to which the local chain must be rewound to correct the error
  260. RewindTo uint64
  261. }
  262. func newCompatError(what string, storedblock, newblock *big.Int) *ConfigCompatError {
  263. var rew *big.Int
  264. switch {
  265. case storedblock == nil:
  266. rew = newblock
  267. case newblock == nil || storedblock.Cmp(newblock) < 0:
  268. rew = storedblock
  269. default:
  270. rew = newblock
  271. }
  272. err := &ConfigCompatError{what, storedblock, newblock, 0}
  273. if rew != nil && rew.Sign() > 0 {
  274. err.RewindTo = rew.Uint64() - 1
  275. }
  276. return err
  277. }
  278. func (err *ConfigCompatError) Error() string {
  279. return fmt.Sprintf("mismatching %s in database (have %d, want %d, rewindto %d)", err.What, err.StoredConfig, err.NewConfig, err.RewindTo)
  280. }
  281. // Rules wraps ChainConfig and is merely syntatic sugar or can be used for functions
  282. // that do not have or require information about the block.
  283. //
  284. // Rules is a one time interface meaning that it shouldn't be used in between transition
  285. // phases.
  286. type Rules struct {
  287. ChainId *big.Int
  288. IsHomestead, IsEIP150, IsEIP155, IsEIP158 bool
  289. IsByzantium bool
  290. }
  291. func (c *ChainConfig) Rules(num *big.Int) Rules {
  292. chainId := c.ChainId
  293. if chainId == nil {
  294. chainId = new(big.Int)
  295. }
  296. return Rules{ChainId: new(big.Int).Set(chainId), IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), IsEIP155: c.IsEIP155(num), IsEIP158: c.IsEIP158(num), IsByzantium: c.IsByzantium(num)}
  297. }