github.com/codysnider/go-ethereum@v1.10.18-0.20220420071915-14f4ae99222a/params/config.go (about) 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 17 package params 18 19 import ( 20 "encoding/binary" 21 "fmt" 22 "math/big" 23 24 "github.com/ethereum/go-ethereum/common" 25 "golang.org/x/crypto/sha3" 26 ) 27 28 // Genesis hashes to enforce below configs on. 29 var ( 30 MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") 31 RopstenGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") 32 SepoliaGenesisHash = common.HexToHash("0x25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9") 33 RinkebyGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177") 34 GoerliGenesisHash = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a") 35 KilnGenesisHash = common.HexToHash("0x51c7fe41be669f69c45c33a56982cbde405313342d9e2b00d7c91a7b284dd4f8") 36 ) 37 38 // TrustedCheckpoints associates each known checkpoint with the genesis hash of 39 // the chain it belongs to. 40 var TrustedCheckpoints = map[common.Hash]*TrustedCheckpoint{ 41 MainnetGenesisHash: MainnetTrustedCheckpoint, 42 RopstenGenesisHash: RopstenTrustedCheckpoint, 43 SepoliaGenesisHash: SepoliaTrustedCheckpoint, 44 RinkebyGenesisHash: RinkebyTrustedCheckpoint, 45 GoerliGenesisHash: GoerliTrustedCheckpoint, 46 } 47 48 // CheckpointOracles associates each known checkpoint oracles with the genesis hash of 49 // the chain it belongs to. 50 var CheckpointOracles = map[common.Hash]*CheckpointOracleConfig{ 51 MainnetGenesisHash: MainnetCheckpointOracle, 52 RopstenGenesisHash: RopstenCheckpointOracle, 53 RinkebyGenesisHash: RinkebyCheckpointOracle, 54 GoerliGenesisHash: GoerliCheckpointOracle, 55 } 56 57 var ( 58 // MainnetChainConfig is the chain parameters to run a node on the main network. 59 MainnetChainConfig = &ChainConfig{ 60 ChainID: big.NewInt(1), 61 HomesteadBlock: big.NewInt(1_150_000), 62 DAOForkBlock: big.NewInt(1_920_000), 63 DAOForkSupport: true, 64 EIP150Block: big.NewInt(2_463_000), 65 EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"), 66 EIP155Block: big.NewInt(2_675_000), 67 EIP158Block: big.NewInt(2_675_000), 68 ByzantiumBlock: big.NewInt(4_370_000), 69 ConstantinopleBlock: big.NewInt(7_280_000), 70 PetersburgBlock: big.NewInt(7_280_000), 71 IstanbulBlock: big.NewInt(9_069_000), 72 MuirGlacierBlock: big.NewInt(9_200_000), 73 BerlinBlock: big.NewInt(12_244_000), 74 LondonBlock: big.NewInt(12_965_000), 75 ArrowGlacierBlock: big.NewInt(13_773_000), 76 Ethash: new(EthashConfig), 77 } 78 79 // MainnetTrustedCheckpoint contains the light client trusted checkpoint for the main network. 80 MainnetTrustedCheckpoint = &TrustedCheckpoint{ 81 SectionIndex: 413, 82 SectionHead: common.HexToHash("0x8aa8e64ceadcdc5f23bc41d2acb7295a261a5cf680bb00a34f0e01af08200083"), 83 CHTRoot: common.HexToHash("0x008af584d385a2610706c5a439d39f15ddd4b691c5d42603f65ae576f703f477"), 84 BloomRoot: common.HexToHash("0x5a081af71a588f4d90bced242545b08904ad4fb92f7effff2ceb6e50e6dec157"), 85 } 86 87 // MainnetCheckpointOracle contains a set of configs for the main network oracle. 88 MainnetCheckpointOracle = &CheckpointOracleConfig{ 89 Address: common.HexToAddress("0x9a9070028361F7AAbeB3f2F2Dc07F82C4a98A02a"), 90 Signers: []common.Address{ 91 common.HexToAddress("0x1b2C260efc720BE89101890E4Db589b44E950527"), // Peter 92 common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"), // Martin 93 common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"), // Zsolt 94 common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"), // Gary 95 common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"), // Guillaume 96 }, 97 Threshold: 2, 98 } 99 100 // RopstenChainConfig contains the chain parameters to run a node on the Ropsten test network. 101 RopstenChainConfig = &ChainConfig{ 102 ChainID: big.NewInt(3), 103 HomesteadBlock: big.NewInt(0), 104 DAOForkBlock: nil, 105 DAOForkSupport: true, 106 EIP150Block: big.NewInt(0), 107 EIP150Hash: common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"), 108 EIP155Block: big.NewInt(10), 109 EIP158Block: big.NewInt(10), 110 ByzantiumBlock: big.NewInt(1_700_000), 111 ConstantinopleBlock: big.NewInt(4_230_000), 112 PetersburgBlock: big.NewInt(4_939_394), 113 IstanbulBlock: big.NewInt(6_485_846), 114 MuirGlacierBlock: big.NewInt(7_117_117), 115 BerlinBlock: big.NewInt(9_812_189), 116 LondonBlock: big.NewInt(10_499_401), 117 Ethash: new(EthashConfig), 118 } 119 120 // RopstenTrustedCheckpoint contains the light client trusted checkpoint for the Ropsten test network. 121 RopstenTrustedCheckpoint = &TrustedCheckpoint{ 122 SectionIndex: 346, 123 SectionHead: common.HexToHash("0xafa0384ebd13a751fb7475aaa7fc08ac308925c8b2e2195bca2d4ab1878a7a84"), 124 CHTRoot: common.HexToHash("0x522ae1f334bfa36033b2315d0b9954052780700b69448ecea8d5877e0f7ee477"), 125 BloomRoot: common.HexToHash("0x4093fd53b0d2cc50181dca353fe66f03ae113e7cb65f869a4dfb5905de6a0493"), 126 } 127 128 // RopstenCheckpointOracle contains a set of configs for the Ropsten test network oracle. 129 RopstenCheckpointOracle = &CheckpointOracleConfig{ 130 Address: common.HexToAddress("0xEF79475013f154E6A65b54cB2742867791bf0B84"), 131 Signers: []common.Address{ 132 common.HexToAddress("0x32162F3581E88a5f62e8A61892B42C46E2c18f7b"), // Peter 133 common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"), // Martin 134 common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"), // Zsolt 135 common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"), // Gary 136 common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"), // Guillaume 137 }, 138 Threshold: 2, 139 } 140 141 // SepoliaChainConfig contains the chain parameters to run a node on the Sepolia test network. 142 SepoliaChainConfig = &ChainConfig{ 143 ChainID: big.NewInt(11155111), 144 HomesteadBlock: big.NewInt(0), 145 DAOForkBlock: nil, 146 DAOForkSupport: true, 147 EIP150Block: big.NewInt(0), 148 EIP155Block: big.NewInt(0), 149 EIP158Block: big.NewInt(0), 150 ByzantiumBlock: big.NewInt(0), 151 ConstantinopleBlock: big.NewInt(0), 152 PetersburgBlock: big.NewInt(0), 153 IstanbulBlock: big.NewInt(0), 154 MuirGlacierBlock: big.NewInt(0), 155 BerlinBlock: big.NewInt(0), 156 LondonBlock: big.NewInt(0), 157 Ethash: new(EthashConfig), 158 } 159 160 // SepoliaTrustedCheckpoint contains the light client trusted checkpoint for the Sepolia test network. 161 SepoliaTrustedCheckpoint = &TrustedCheckpoint{ 162 SectionIndex: 1, 163 SectionHead: common.HexToHash("0x5dde65e28745b10ff9e9b86499c3a3edc03587b27a06564a4342baf3a37de869"), 164 CHTRoot: common.HexToHash("0x042a0d914f7baa4f28f14d12291e5f346e88c5b9d95127bf5422a8afeacd27e8"), 165 BloomRoot: common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"), 166 } 167 168 // RinkebyChainConfig contains the chain parameters to run a node on the Rinkeby test network. 169 RinkebyChainConfig = &ChainConfig{ 170 ChainID: big.NewInt(4), 171 HomesteadBlock: big.NewInt(1), 172 DAOForkBlock: nil, 173 DAOForkSupport: true, 174 EIP150Block: big.NewInt(2), 175 EIP150Hash: common.HexToHash("0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"), 176 EIP155Block: big.NewInt(3), 177 EIP158Block: big.NewInt(3), 178 ByzantiumBlock: big.NewInt(1_035_301), 179 ConstantinopleBlock: big.NewInt(3_660_663), 180 PetersburgBlock: big.NewInt(4_321_234), 181 IstanbulBlock: big.NewInt(5_435_345), 182 MuirGlacierBlock: nil, 183 BerlinBlock: big.NewInt(8_290_928), 184 LondonBlock: big.NewInt(8_897_988), 185 ArrowGlacierBlock: nil, 186 Clique: &CliqueConfig{ 187 Period: 15, 188 Epoch: 30000, 189 }, 190 } 191 192 // RinkebyTrustedCheckpoint contains the light client trusted checkpoint for the Rinkeby test network. 193 RinkebyTrustedCheckpoint = &TrustedCheckpoint{ 194 SectionIndex: 292, 195 SectionHead: common.HexToHash("0x4185c2f1bb85ecaa04409d1008ff0761092ea2e94e8a71d64b1a5abc37b81414"), 196 CHTRoot: common.HexToHash("0x03b0191e6140effe0b88bb7c97bfb794a275d3543cb3190662fb72d9beea423c"), 197 BloomRoot: common.HexToHash("0x3d5f6edccc87536dcbc0dd3aae97a318205c617dd3957b4261470c71481629e2"), 198 } 199 200 // RinkebyCheckpointOracle contains a set of configs for the Rinkeby test network oracle. 201 RinkebyCheckpointOracle = &CheckpointOracleConfig{ 202 Address: common.HexToAddress("0xebe8eFA441B9302A0d7eaECc277c09d20D684540"), 203 Signers: []common.Address{ 204 common.HexToAddress("0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3"), // Peter 205 common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"), // Martin 206 common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"), // Zsolt 207 common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"), // Gary 208 }, 209 Threshold: 2, 210 } 211 212 // GoerliChainConfig contains the chain parameters to run a node on the Görli test network. 213 GoerliChainConfig = &ChainConfig{ 214 ChainID: big.NewInt(5), 215 HomesteadBlock: big.NewInt(0), 216 DAOForkBlock: nil, 217 DAOForkSupport: true, 218 EIP150Block: big.NewInt(0), 219 EIP155Block: big.NewInt(0), 220 EIP158Block: big.NewInt(0), 221 ByzantiumBlock: big.NewInt(0), 222 ConstantinopleBlock: big.NewInt(0), 223 PetersburgBlock: big.NewInt(0), 224 IstanbulBlock: big.NewInt(1_561_651), 225 MuirGlacierBlock: nil, 226 BerlinBlock: big.NewInt(4_460_644), 227 LondonBlock: big.NewInt(5_062_605), 228 ArrowGlacierBlock: nil, 229 Clique: &CliqueConfig{ 230 Period: 15, 231 Epoch: 30000, 232 }, 233 } 234 235 // GoerliTrustedCheckpoint contains the light client trusted checkpoint for the Görli test network. 236 GoerliTrustedCheckpoint = &TrustedCheckpoint{ 237 SectionIndex: 176, 238 SectionHead: common.HexToHash("0x2de018858528434f93adb40b1f03f2304a86d31b4ef2b1f930da0134f5c32427"), 239 CHTRoot: common.HexToHash("0x8c17e497d38088321c147abe4acbdfb3c0cab7d7a2b97e07404540f04d12747e"), 240 BloomRoot: common.HexToHash("0x02a41b6606bd3f741bd6ae88792d75b1ad8cf0ea5e28fbaa03bc8b95cbd20034"), 241 } 242 243 // GoerliCheckpointOracle contains a set of configs for the Goerli test network oracle. 244 GoerliCheckpointOracle = &CheckpointOracleConfig{ 245 Address: common.HexToAddress("0x18CA0E045F0D772a851BC7e48357Bcaab0a0795D"), 246 Signers: []common.Address{ 247 common.HexToAddress("0x4769bcaD07e3b938B7f43EB7D278Bc7Cb9efFb38"), // Peter 248 common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"), // Martin 249 common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"), // Zsolt 250 common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"), // Gary 251 common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"), // Guillaume 252 }, 253 Threshold: 2, 254 } 255 256 // AllEthashProtocolChanges contains every protocol change (EIPs) introduced 257 // and accepted by the Ethereum core developers into the Ethash consensus. 258 // 259 // This configuration is intentionally not using keyed fields to force anyone 260 // adding flags to the config to also have to set these fields. 261 AllEthashProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, new(EthashConfig), nil} 262 263 // AllCliqueProtocolChanges contains every protocol change (EIPs) introduced 264 // and accepted by the Ethereum core developers into the Clique consensus. 265 // 266 // This configuration is intentionally not using keyed fields to force anyone 267 // adding flags to the config to also have to set these fields. 268 AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}} 269 270 TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, new(EthashConfig), nil} 271 TestRules = TestChainConfig.Rules(new(big.Int), false) 272 ) 273 274 // TrustedCheckpoint represents a set of post-processed trie roots (CHT and 275 // BloomTrie) associated with the appropriate section index and head hash. It is 276 // used to start light syncing from this checkpoint and avoid downloading the 277 // entire header chain while still being able to securely access old headers/logs. 278 type TrustedCheckpoint struct { 279 SectionIndex uint64 `json:"sectionIndex"` 280 SectionHead common.Hash `json:"sectionHead"` 281 CHTRoot common.Hash `json:"chtRoot"` 282 BloomRoot common.Hash `json:"bloomRoot"` 283 } 284 285 // HashEqual returns an indicator comparing the itself hash with given one. 286 func (c *TrustedCheckpoint) HashEqual(hash common.Hash) bool { 287 if c.Empty() { 288 return hash == common.Hash{} 289 } 290 return c.Hash() == hash 291 } 292 293 // Hash returns the hash of checkpoint's four key fields(index, sectionHead, chtRoot and bloomTrieRoot). 294 func (c *TrustedCheckpoint) Hash() common.Hash { 295 var sectionIndex [8]byte 296 binary.BigEndian.PutUint64(sectionIndex[:], c.SectionIndex) 297 298 w := sha3.NewLegacyKeccak256() 299 w.Write(sectionIndex[:]) 300 w.Write(c.SectionHead[:]) 301 w.Write(c.CHTRoot[:]) 302 w.Write(c.BloomRoot[:]) 303 304 var h common.Hash 305 w.Sum(h[:0]) 306 return h 307 } 308 309 // Empty returns an indicator whether the checkpoint is regarded as empty. 310 func (c *TrustedCheckpoint) Empty() bool { 311 return c.SectionHead == (common.Hash{}) || c.CHTRoot == (common.Hash{}) || c.BloomRoot == (common.Hash{}) 312 } 313 314 // CheckpointOracleConfig represents a set of checkpoint contract(which acts as an oracle) 315 // config which used for light client checkpoint syncing. 316 type CheckpointOracleConfig struct { 317 Address common.Address `json:"address"` 318 Signers []common.Address `json:"signers"` 319 Threshold uint64 `json:"threshold"` 320 } 321 322 // ChainConfig is the core config which determines the blockchain settings. 323 // 324 // ChainConfig is stored in the database on a per block basis. This means 325 // that any network, identified by its genesis block, can have its own 326 // set of configuration options. 327 type ChainConfig struct { 328 ChainID *big.Int `json:"chainId"` // chainId identifies the current chain and is used for replay protection 329 330 HomesteadBlock *big.Int `json:"homesteadBlock,omitempty"` // Homestead switch block (nil = no fork, 0 = already homestead) 331 332 DAOForkBlock *big.Int `json:"daoForkBlock,omitempty"` // TheDAO hard-fork switch block (nil = no fork) 333 DAOForkSupport bool `json:"daoForkSupport,omitempty"` // Whether the nodes supports or opposes the DAO hard-fork 334 335 // EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) 336 EIP150Block *big.Int `json:"eip150Block,omitempty"` // EIP150 HF block (nil = no fork) 337 EIP150Hash common.Hash `json:"eip150Hash,omitempty"` // EIP150 HF hash (needed for header only clients as only gas pricing changed) 338 339 EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block 340 EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block 341 342 ByzantiumBlock *big.Int `json:"byzantiumBlock,omitempty"` // Byzantium switch block (nil = no fork, 0 = already on byzantium) 343 ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated) 344 PetersburgBlock *big.Int `json:"petersburgBlock,omitempty"` // Petersburg switch block (nil = same as Constantinople) 345 IstanbulBlock *big.Int `json:"istanbulBlock,omitempty"` // Istanbul switch block (nil = no fork, 0 = already on istanbul) 346 MuirGlacierBlock *big.Int `json:"muirGlacierBlock,omitempty"` // Eip-2384 (bomb delay) switch block (nil = no fork, 0 = already activated) 347 BerlinBlock *big.Int `json:"berlinBlock,omitempty"` // Berlin switch block (nil = no fork, 0 = already on berlin) 348 LondonBlock *big.Int `json:"londonBlock,omitempty"` // London switch block (nil = no fork, 0 = already on london) 349 ArrowGlacierBlock *big.Int `json:"arrowGlacierBlock,omitempty"` // Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) 350 MergeForkBlock *big.Int `json:"mergeForkBlock,omitempty"` // EIP-3675 (TheMerge) switch block (nil = no fork, 0 = already in merge proceedings) 351 352 // TerminalTotalDifficulty is the amount of total difficulty reached by 353 // the network that triggers the consensus upgrade. 354 TerminalTotalDifficulty *big.Int `json:"terminalTotalDifficulty,omitempty"` 355 356 // Various consensus engines 357 Ethash *EthashConfig `json:"ethash,omitempty"` 358 Clique *CliqueConfig `json:"clique,omitempty"` 359 } 360 361 // EthashConfig is the consensus engine configs for proof-of-work based sealing. 362 type EthashConfig struct{} 363 364 // String implements the stringer interface, returning the consensus engine details. 365 func (c *EthashConfig) String() string { 366 return "ethash" 367 } 368 369 // CliqueConfig is the consensus engine configs for proof-of-authority based sealing. 370 type CliqueConfig struct { 371 Period uint64 `json:"period"` // Number of seconds between blocks to enforce 372 Epoch uint64 `json:"epoch"` // Epoch length to reset votes and checkpoint 373 } 374 375 // String implements the stringer interface, returning the consensus engine details. 376 func (c *CliqueConfig) String() string { 377 return "clique" 378 } 379 380 // String implements the fmt.Stringer interface. 381 func (c *ChainConfig) String() string { 382 var engine interface{} 383 switch { 384 case c.Ethash != nil: 385 engine = c.Ethash 386 case c.Clique != nil: 387 engine = c.Clique 388 default: 389 engine = "unknown" 390 } 391 return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Berlin: %v, London: %v, Arrow Glacier: %v, MergeFork: %v, Terminal TD: %v, Engine: %v}", 392 c.ChainID, 393 c.HomesteadBlock, 394 c.DAOForkBlock, 395 c.DAOForkSupport, 396 c.EIP150Block, 397 c.EIP155Block, 398 c.EIP158Block, 399 c.ByzantiumBlock, 400 c.ConstantinopleBlock, 401 c.PetersburgBlock, 402 c.IstanbulBlock, 403 c.MuirGlacierBlock, 404 c.BerlinBlock, 405 c.LondonBlock, 406 c.ArrowGlacierBlock, 407 c.MergeForkBlock, 408 c.TerminalTotalDifficulty, 409 engine, 410 ) 411 } 412 413 // IsHomestead returns whether num is either equal to the homestead block or greater. 414 func (c *ChainConfig) IsHomestead(num *big.Int) bool { 415 return isForked(c.HomesteadBlock, num) 416 } 417 418 // IsDAOFork returns whether num is either equal to the DAO fork block or greater. 419 func (c *ChainConfig) IsDAOFork(num *big.Int) bool { 420 return isForked(c.DAOForkBlock, num) 421 } 422 423 // IsEIP150 returns whether num is either equal to the EIP150 fork block or greater. 424 func (c *ChainConfig) IsEIP150(num *big.Int) bool { 425 return isForked(c.EIP150Block, num) 426 } 427 428 // IsEIP155 returns whether num is either equal to the EIP155 fork block or greater. 429 func (c *ChainConfig) IsEIP155(num *big.Int) bool { 430 return isForked(c.EIP155Block, num) 431 } 432 433 // IsEIP158 returns whether num is either equal to the EIP158 fork block or greater. 434 func (c *ChainConfig) IsEIP158(num *big.Int) bool { 435 return isForked(c.EIP158Block, num) 436 } 437 438 // IsByzantium returns whether num is either equal to the Byzantium fork block or greater. 439 func (c *ChainConfig) IsByzantium(num *big.Int) bool { 440 return isForked(c.ByzantiumBlock, num) 441 } 442 443 // IsConstantinople returns whether num is either equal to the Constantinople fork block or greater. 444 func (c *ChainConfig) IsConstantinople(num *big.Int) bool { 445 return isForked(c.ConstantinopleBlock, num) 446 } 447 448 // IsMuirGlacier returns whether num is either equal to the Muir Glacier (EIP-2384) fork block or greater. 449 func (c *ChainConfig) IsMuirGlacier(num *big.Int) bool { 450 return isForked(c.MuirGlacierBlock, num) 451 } 452 453 // IsPetersburg returns whether num is either 454 // - equal to or greater than the PetersburgBlock fork block, 455 // - OR is nil, and Constantinople is active 456 func (c *ChainConfig) IsPetersburg(num *big.Int) bool { 457 return isForked(c.PetersburgBlock, num) || c.PetersburgBlock == nil && isForked(c.ConstantinopleBlock, num) 458 } 459 460 // IsIstanbul returns whether num is either equal to the Istanbul fork block or greater. 461 func (c *ChainConfig) IsIstanbul(num *big.Int) bool { 462 return isForked(c.IstanbulBlock, num) 463 } 464 465 // IsBerlin returns whether num is either equal to the Berlin fork block or greater. 466 func (c *ChainConfig) IsBerlin(num *big.Int) bool { 467 return isForked(c.BerlinBlock, num) 468 } 469 470 // IsLondon returns whether num is either equal to the London fork block or greater. 471 func (c *ChainConfig) IsLondon(num *big.Int) bool { 472 return isForked(c.LondonBlock, num) 473 } 474 475 // IsArrowGlacier returns whether num is either equal to the Arrow Glacier (EIP-4345) fork block or greater. 476 func (c *ChainConfig) IsArrowGlacier(num *big.Int) bool { 477 return isForked(c.ArrowGlacierBlock, num) 478 } 479 480 // IsTerminalPoWBlock returns whether the given block is the last block of PoW stage. 481 func (c *ChainConfig) IsTerminalPoWBlock(parentTotalDiff *big.Int, totalDiff *big.Int) bool { 482 if c.TerminalTotalDifficulty == nil { 483 return false 484 } 485 return parentTotalDiff.Cmp(c.TerminalTotalDifficulty) < 0 && totalDiff.Cmp(c.TerminalTotalDifficulty) >= 0 486 } 487 488 // CheckCompatible checks whether scheduled fork transitions have been imported 489 // with a mismatching chain configuration. 490 func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64) *ConfigCompatError { 491 bhead := new(big.Int).SetUint64(height) 492 493 // Iterate checkCompatible to find the lowest conflict. 494 var lasterr *ConfigCompatError 495 for { 496 err := c.checkCompatible(newcfg, bhead) 497 if err == nil || (lasterr != nil && err.RewindTo == lasterr.RewindTo) { 498 break 499 } 500 lasterr = err 501 bhead.SetUint64(err.RewindTo) 502 } 503 return lasterr 504 } 505 506 // CheckConfigForkOrder checks that we don't "skip" any forks, geth isn't pluggable enough 507 // to guarantee that forks can be implemented in a different order than on official networks 508 func (c *ChainConfig) CheckConfigForkOrder() error { 509 type fork struct { 510 name string 511 block *big.Int 512 optional bool // if true, the fork may be nil and next fork is still allowed 513 } 514 var lastFork fork 515 for _, cur := range []fork{ 516 {name: "homesteadBlock", block: c.HomesteadBlock}, 517 {name: "daoForkBlock", block: c.DAOForkBlock, optional: true}, 518 {name: "eip150Block", block: c.EIP150Block}, 519 {name: "eip155Block", block: c.EIP155Block}, 520 {name: "eip158Block", block: c.EIP158Block}, 521 {name: "byzantiumBlock", block: c.ByzantiumBlock}, 522 {name: "constantinopleBlock", block: c.ConstantinopleBlock}, 523 {name: "petersburgBlock", block: c.PetersburgBlock}, 524 {name: "istanbulBlock", block: c.IstanbulBlock}, 525 {name: "muirGlacierBlock", block: c.MuirGlacierBlock, optional: true}, 526 {name: "berlinBlock", block: c.BerlinBlock}, 527 {name: "londonBlock", block: c.LondonBlock}, 528 {name: "arrowGlacierBlock", block: c.ArrowGlacierBlock, optional: true}, 529 {name: "mergeStartBlock", block: c.MergeForkBlock, optional: true}, 530 } { 531 if lastFork.name != "" { 532 // Next one must be higher number 533 if lastFork.block == nil && cur.block != nil { 534 return fmt.Errorf("unsupported fork ordering: %v not enabled, but %v enabled at %v", 535 lastFork.name, cur.name, cur.block) 536 } 537 if lastFork.block != nil && cur.block != nil { 538 if lastFork.block.Cmp(cur.block) > 0 { 539 return fmt.Errorf("unsupported fork ordering: %v enabled at %v, but %v enabled at %v", 540 lastFork.name, lastFork.block, cur.name, cur.block) 541 } 542 } 543 } 544 // If it was optional and not set, then ignore it 545 if !cur.optional || cur.block != nil { 546 lastFork = cur 547 } 548 } 549 return nil 550 } 551 552 func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, head *big.Int) *ConfigCompatError { 553 if isForkIncompatible(c.HomesteadBlock, newcfg.HomesteadBlock, head) { 554 return newCompatError("Homestead fork block", c.HomesteadBlock, newcfg.HomesteadBlock) 555 } 556 if isForkIncompatible(c.DAOForkBlock, newcfg.DAOForkBlock, head) { 557 return newCompatError("DAO fork block", c.DAOForkBlock, newcfg.DAOForkBlock) 558 } 559 if c.IsDAOFork(head) && c.DAOForkSupport != newcfg.DAOForkSupport { 560 return newCompatError("DAO fork support flag", c.DAOForkBlock, newcfg.DAOForkBlock) 561 } 562 if isForkIncompatible(c.EIP150Block, newcfg.EIP150Block, head) { 563 return newCompatError("EIP150 fork block", c.EIP150Block, newcfg.EIP150Block) 564 } 565 if isForkIncompatible(c.EIP155Block, newcfg.EIP155Block, head) { 566 return newCompatError("EIP155 fork block", c.EIP155Block, newcfg.EIP155Block) 567 } 568 if isForkIncompatible(c.EIP158Block, newcfg.EIP158Block, head) { 569 return newCompatError("EIP158 fork block", c.EIP158Block, newcfg.EIP158Block) 570 } 571 if c.IsEIP158(head) && !configNumEqual(c.ChainID, newcfg.ChainID) { 572 return newCompatError("EIP158 chain ID", c.EIP158Block, newcfg.EIP158Block) 573 } 574 if isForkIncompatible(c.ByzantiumBlock, newcfg.ByzantiumBlock, head) { 575 return newCompatError("Byzantium fork block", c.ByzantiumBlock, newcfg.ByzantiumBlock) 576 } 577 if isForkIncompatible(c.ConstantinopleBlock, newcfg.ConstantinopleBlock, head) { 578 return newCompatError("Constantinople fork block", c.ConstantinopleBlock, newcfg.ConstantinopleBlock) 579 } 580 if isForkIncompatible(c.PetersburgBlock, newcfg.PetersburgBlock, head) { 581 // the only case where we allow Petersburg to be set in the past is if it is equal to Constantinople 582 // mainly to satisfy fork ordering requirements which state that Petersburg fork be set if Constantinople fork is set 583 if isForkIncompatible(c.ConstantinopleBlock, newcfg.PetersburgBlock, head) { 584 return newCompatError("Petersburg fork block", c.PetersburgBlock, newcfg.PetersburgBlock) 585 } 586 } 587 if isForkIncompatible(c.IstanbulBlock, newcfg.IstanbulBlock, head) { 588 return newCompatError("Istanbul fork block", c.IstanbulBlock, newcfg.IstanbulBlock) 589 } 590 if isForkIncompatible(c.MuirGlacierBlock, newcfg.MuirGlacierBlock, head) { 591 return newCompatError("Muir Glacier fork block", c.MuirGlacierBlock, newcfg.MuirGlacierBlock) 592 } 593 if isForkIncompatible(c.BerlinBlock, newcfg.BerlinBlock, head) { 594 return newCompatError("Berlin fork block", c.BerlinBlock, newcfg.BerlinBlock) 595 } 596 if isForkIncompatible(c.LondonBlock, newcfg.LondonBlock, head) { 597 return newCompatError("London fork block", c.LondonBlock, newcfg.LondonBlock) 598 } 599 if isForkIncompatible(c.ArrowGlacierBlock, newcfg.ArrowGlacierBlock, head) { 600 return newCompatError("Arrow Glacier fork block", c.ArrowGlacierBlock, newcfg.ArrowGlacierBlock) 601 } 602 if isForkIncompatible(c.MergeForkBlock, newcfg.MergeForkBlock, head) { 603 return newCompatError("Merge Start fork block", c.MergeForkBlock, newcfg.MergeForkBlock) 604 } 605 return nil 606 } 607 608 // isForkIncompatible returns true if a fork scheduled at s1 cannot be rescheduled to 609 // block s2 because head is already past the fork. 610 func isForkIncompatible(s1, s2, head *big.Int) bool { 611 return (isForked(s1, head) || isForked(s2, head)) && !configNumEqual(s1, s2) 612 } 613 614 // isForked returns whether a fork scheduled at block s is active at the given head block. 615 func isForked(s, head *big.Int) bool { 616 if s == nil || head == nil { 617 return false 618 } 619 return s.Cmp(head) <= 0 620 } 621 622 func configNumEqual(x, y *big.Int) bool { 623 if x == nil { 624 return y == nil 625 } 626 if y == nil { 627 return x == nil 628 } 629 return x.Cmp(y) == 0 630 } 631 632 // ConfigCompatError is raised if the locally-stored blockchain is initialised with a 633 // ChainConfig that would alter the past. 634 type ConfigCompatError struct { 635 What string 636 // block numbers of the stored and new configurations 637 StoredConfig, NewConfig *big.Int 638 // the block number to which the local chain must be rewound to correct the error 639 RewindTo uint64 640 } 641 642 func newCompatError(what string, storedblock, newblock *big.Int) *ConfigCompatError { 643 var rew *big.Int 644 switch { 645 case storedblock == nil: 646 rew = newblock 647 case newblock == nil || storedblock.Cmp(newblock) < 0: 648 rew = storedblock 649 default: 650 rew = newblock 651 } 652 err := &ConfigCompatError{what, storedblock, newblock, 0} 653 if rew != nil && rew.Sign() > 0 { 654 err.RewindTo = rew.Uint64() - 1 655 } 656 return err 657 } 658 659 func (err *ConfigCompatError) Error() string { 660 return fmt.Sprintf("mismatching %s in database (have %d, want %d, rewindto %d)", err.What, err.StoredConfig, err.NewConfig, err.RewindTo) 661 } 662 663 // Rules wraps ChainConfig and is merely syntactic sugar or can be used for functions 664 // that do not have or require information about the block. 665 // 666 // Rules is a one time interface meaning that it shouldn't be used in between transition 667 // phases. 668 type Rules struct { 669 ChainID *big.Int 670 IsHomestead, IsEIP150, IsEIP155, IsEIP158 bool 671 IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool 672 IsBerlin, IsLondon bool 673 IsMerge bool 674 } 675 676 // Rules ensures c's ChainID is not nil. 677 func (c *ChainConfig) Rules(num *big.Int, isMerge bool) Rules { 678 chainID := c.ChainID 679 if chainID == nil { 680 chainID = new(big.Int) 681 } 682 return Rules{ 683 ChainID: new(big.Int).Set(chainID), 684 IsHomestead: c.IsHomestead(num), 685 IsEIP150: c.IsEIP150(num), 686 IsEIP155: c.IsEIP155(num), 687 IsEIP158: c.IsEIP158(num), 688 IsByzantium: c.IsByzantium(num), 689 IsConstantinople: c.IsConstantinople(num), 690 IsPetersburg: c.IsPetersburg(num), 691 IsIstanbul: c.IsIstanbul(num), 692 IsBerlin: c.IsBerlin(num), 693 IsLondon: c.IsLondon(num), 694 IsMerge: isMerge, 695 } 696 }