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