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