nimbus-eth1/nimbus/chain_config.nim

558 lines
22 KiB
Nim

# Nimbus
# Copyright (c) 2021 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import
std/[tables, strutils, options, times],
eth/[common, rlp, p2p], stint, stew/[byteutils],
json_serialization, chronicles,
json_serialization/std/options as jsoptions,
json_serialization/std/tables as jstable,
json_serialization/lexer,
"."/[forks, genesis_alloc]
{.push raises: [Defect].}
type
CliqueOptions = object
epoch : Option[int]
period: Option[int]
ChainOptions = object
chainId : ChainId
homesteadBlock : Option[BlockNumber]
daoForkBlock : Option[BlockNumber]
daoForkSupport : bool
eip150Block : Option[BlockNumber]
eip150Hash : Hash256
eip155Block : Option[BlockNumber]
eip158Block : Option[BlockNumber]
byzantiumBlock : Option[BlockNumber]
constantinopleBlock: Option[BlockNumber]
petersburgBlock : Option[BlockNumber]
istanbulBlock : Option[BlockNumber]
muirGlacierBlock : Option[BlockNumber]
berlinBlock : Option[BlockNumber]
londonBlock : Option[BlockNumber]
arrowGlacierBlock : Option[BlockNumber]
grayGlacierBlock : Option[BlockNumber]
mergeForkBlock : Option[BlockNumber]
shanghaiBlock : Option[BlockNumber]
cancunBlock : Option[BlockNumber]
clique : CliqueOptions
terminalTotalDifficulty*: Option[UInt256]
ChainConfig* = ref object
chainId* : ChainId
homesteadBlock* : BlockNumber
daoForkBlock* : BlockNumber
daoForkSupport* : bool
# EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
eip150Block* : BlockNumber
eip150Hash* : Hash256
eip155Block* : BlockNumber
eip158Block* : BlockNumber
byzantiumBlock* : BlockNumber
constantinopleBlock*: BlockNumber
petersburgBlock* : BlockNumber
istanbulBlock* : BlockNumber
muirGlacierBlock* : BlockNumber
berlinBlock* : BlockNumber
londonBlock* : BlockNumber
arrowGlacierBlock* : BlockNumber
grayGlacierBlock* : BlockNumber
mergeForkBlock* : BlockNumber # EIP-3675 (TheMerge) switch block
shanghaiBlock* : BlockNumber
cancunBlock* : BlockNumber
poaEngine* : bool
cliquePeriod* : int
cliqueEpoch* : int
terminalTotalDifficulty*: Option[UInt256]
Genesis* = ref object
nonce* : BlockNonce
timestamp* : EthTime
extraData* : seq[byte]
gasLimit* : GasInt
difficulty* : DifficultyInt
mixHash* : Hash256
coinbase* : EthAddress
alloc* : GenesisAlloc
number* : BlockNumber
gasUser* : GasInt
parentHash* : Hash256
baseFeePerGas*: Option[UInt256]
GenesisAlloc* = Table[EthAddress, GenesisAccount]
GenesisAccount* = object
code* : seq[byte]
storage*: Table[UInt256, UInt256]
balance*: UInt256
nonce* : AccountNonce
NetworkParams* = object
config* : ChainConfig
genesis*: Genesis
AddressBalance = object
address {.rlpCustomSerialization.}: EthAddress
account {.rlpCustomSerialization.}: GenesisAccount
CustomChain = object
config : ChainOptions
genesis: Genesis
GenesisFile* = object
config : ChainOptions
nonce* : BlockNonce
timestamp* : EthTime
extraData* : seq[byte]
gasLimit* : GasInt
difficulty* : DifficultyInt
mixHash* : Hash256
coinbase* : EthAddress
alloc* : GenesisAlloc
number* : BlockNumber
gasUser* : GasInt
parentHash* : Hash256
baseFeePerGas*: Option[UInt256]
const
CustomNet* = 0.NetworkId
# these are public network id
MainNet* = 1.NetworkId
# No longer used: MordenNet = 2
RopstenNet* = 3.NetworkId
RinkebyNet* = 4.NetworkId
GoerliNet* = 5.NetworkId
KovanNet* = 42.NetworkId
SepoliaNet* = 11155111.NetworkId
proc read(rlp: var Rlp, x: var AddressBalance, _: type EthAddress): EthAddress
{.gcsafe, raises: [Defect,RlpError].} =
let val = rlp.read(UInt256).toByteArrayBE()
result[0 .. ^1] = val.toOpenArray(12, val.high)
proc read(rlp: var Rlp, x: var AddressBalance, _: type GenesisAccount): GenesisAccount
{.gcsafe, raises: [Defect,RlpError].} =
GenesisAccount(balance: rlp.read(UInt256))
func decodePrealloc*(data: seq[byte]): GenesisAlloc
{.gcsafe, raises: [Defect,RlpError].} =
for tup in rlp.decode(data, seq[AddressBalance]):
result[tup.address] = tup.account
# borrowed from `lexer.hexCharValue()` :)
proc fromHex(c: char): int =
case c
of '0'..'9': ord(c) - ord('0')
of 'a'..'f': ord(c) - ord('a') + 10
of 'A'..'F': ord(c) - ord('A') + 10
else: -1
proc readValue(reader: var JsonReader, value: var UInt256)
{.gcsafe, raises: [Defect,CatchableError].} =
## Mixin for `Json.loadFile()`. Note that this driver applies the same
## to `BlockNumber` fields as well as generic `UInt265` fields like the
## account `balance`.
var (accu, ok) = (0.u256, true)
if reader.lexer.lazyTok == tkNumeric:
try:
reader.lexer.customIntValueIt:
accu = accu * 10 + it.u256
ok = reader.lexer.lazyTok == tkExInt # non-negative wanted
except:
ok = false
elif reader.lexer.lazyTok == tkQuoted:
try:
var (sLen, base) = (0, 10)
reader.lexer.customTextValueIt:
if ok:
var num = it.fromHex
if base <= num:
ok = false # cannot be larger than base
elif sLen < 2:
if 0 <= num:
accu = accu * base.u256 + num.u256
elif sLen == 1 and it in {'x', 'X'}:
base = 16 # handle "0x" prefix
else:
ok = false
sLen.inc
elif num < 0:
ok = false # not a hex digit
elif base == 10:
accu = accu * 10 + num.u256
else:
accu = accu * 16 + num.u256
except:
reader.raiseUnexpectedValue("numeric string parse error")
else:
reader.raiseUnexpectedValue("expect int or hex/int string")
if not ok:
reader.raiseUnexpectedValue("Uint256 parse error")
value = accu
reader.lexer.next()
proc readValue(reader: var JsonReader, value: var ChainId)
{.gcsafe, raises: [Defect,CatchableError].} =
value = reader.readValue(int).ChainId
proc readValue(reader: var JsonReader, value: var Hash256)
{.gcsafe, raises: [Defect,CatchableError].} =
value = Hash256.fromHex(reader.readValue(string))
proc readValue(reader: var JsonReader, value: var BlockNonce)
{.gcsafe, raises: [Defect,CatchableError].} =
value = fromHex[uint64](reader.readValue(string)).toBlockNonce
proc readValue(reader: var JsonReader, value: var EthTime)
{.gcsafe, raises: [Defect,CatchableError].} =
value = fromHex[int64](reader.readValue(string)).fromUnix
proc readValue(reader: var JsonReader, value: var seq[byte])
{.gcsafe, raises: [Defect,CatchableError].} =
value = hexToSeqByte(reader.readValue(string))
proc readValue(reader: var JsonReader, value: var GasInt)
{.gcsafe, raises: [Defect,CatchableError].} =
value = fromHex[GasInt](reader.readValue(string))
proc readValue(reader: var JsonReader, value: var EthAddress)
{.gcsafe, raises: [Defect,CatchableError].} =
value = parseAddress(reader.readValue(string))
proc readValue(reader: var JsonReader, value: var AccountNonce)
{.gcsafe, raises: [Defect,CatchableError].} =
value = fromHex[uint64](reader.readValue(string))
template to(a: string, b: type EthAddress): EthAddress =
# json_serialization decode table stuff
parseAddress(a)
template to(a: string, b: type UInt256): UInt256 =
# json_serialization decode table stuff
UInt256.fromHex(a)
proc loadNetworkParams*(cc: CustomChain, cg: var NetworkParams): bool =
if cc.genesis.isNil:
cg.genesis = Genesis()
warn "Loaded custom network configuration contains no 'genesis' data"
else:
cg.genesis = cc.genesis
cg.config = ChainConfig()
cg.config.chainId = cc.config.chainId
cg.config.daoForkSupport = cc.config.daoForkSupport
cg.config.eip150Hash = cc.config.eip150Hash
cg.config.poaEngine = false
if cc.config.clique.period.isSome or
cc.config.clique.epoch.isSome:
cg.config.poaEngine = true
# set default clique period to 1 second.
cg.config.cliquePeriod = cc.config.clique.period.get(1)
if cc.config.clique.epoch.isSome:
cg.config.cliqueEpoch = cc.config.clique.epoch.get()
cg.config.terminalTotalDifficulty = cc.config.terminalTotalDifficulty
template validateFork(forkName: untyped, nextBlock: untyped) =
let fork = astToStr(forkName)
cg.config.forkName = cc.config.forkName.get(nextBlock)
if cg.config.forkName > nextBlock:
error "Forks can't be assigned out of order", fork=fork
return false
# Process optional block numbers in non-increasing order (otherwise error.)
#
# See also the go-lang ref implementation:
# params/config.go:508: func (c *ChainConfig) CheckConfigForkOrder() error {
#
# The difference to the ref implementation is that we have no optional values
# everywhere for the block numbers but rather assign the next larger block.
validateFork(cancunBlock, high(BlockNumber))
validateFork(shanghaiBlock, cg.config.cancunBlock)
validateFork(mergeForkBlock, cg.config.shanghaiBlock)
validateFork(grayGlacierBlock, cg.config.mergeForkBlock)
validateFork(arrowGlacierBlock, cg.config.grayGlacierBlock)
validateFork(londonBlock, cg.config.arrowGlacierBlock)
validateFork(berlinBlock, cg.config.londonBlock)
validateFork(muirGlacierBlock, cg.config.berlinBlock)
validateFork(istanbulBlock, cg.config.muirGlacierBlock)
validateFork(petersburgBlock, cg.config.istanbulBlock)
validateFork(constantinopleBlock, cg.config.petersburgBlock)
validateFork(byzantiumBlock, cg.config.constantinopleBlock)
validateFork(eip158Block, cg.config.byzantiumBlock)
validateFork(eip155Block, cg.config.eip158Block)
validateFork(eip150Block, cg.config.eip155Block)
validateFork(daoForkBlock, cg.config.eip150Block)
validateFork(homesteadBlock, cg.config.daoForkBlock)
return true
proc loadNetworkParams*(fileName: string, cg: var NetworkParams):
bool {.raises: [Defect,SerializationError].} =
var cc: CustomChain
try:
cc = Json.loadFile(fileName, CustomChain, allowUnknownFields = true)
except IOError as e:
error "Network params I/O error", fileName, msg=e.msg
return false
except JsonReaderError as e:
error "Invalid network params file format", fileName, msg=e.formatMsg("")
return false
except Exception as e:
error "Error loading network params file",
fileName, exception = e.name, msg = e.msg
return false
loadNetworkParams(cc, cg)
proc decodeNetworkParams*(jsonString: string, cg: var NetworkParams): bool =
var cc: CustomChain
try:
cc = Json.decode(jsonString, CustomChain, allowUnknownFields = true)
except JsonReaderError as e:
error "Invalid network params format", msg=e.formatMsg("")
return false
except:
var msg = getCurrentExceptionMsg()
error "Error decoding network params", msg
return false
loadNetworkParams(cc, cg)
proc parseGenesisAlloc*(data: string, ga: var GenesisAlloc): bool
{.gcsafe, raises: [Defect,CatchableError].} =
try:
ga = Json.decode(data, GenesisAlloc, allowUnknownFields = true)
except JsonReaderError as e:
error "Invalid genesis config file format", msg=e.formatMsg("")
return false
return true
proc toFork*(c: ChainConfig, number: BlockNumber): Fork =
## Map to EVM fork, which doesn't include the DAO or Glacier forks.
if number >= c.cancunBlock: FkCancun
elif number >= c.shanghaiBlock: FkShanghai
elif number >= c.mergeForkBlock: FkParis
elif number >= c.londonBlock: FkLondon
elif number >= c.berlinBlock: FkBerlin
elif number >= c.istanbulBlock: FkIstanbul
elif number >= c.petersburgBlock: FkPetersburg
elif number >= c.constantinopleBlock: FkConstantinople
elif number >= c.byzantiumBlock: FkByzantium
elif number >= c.eip158Block: FkSpurious
elif number >= c.eip150Block: FkTangerine
elif number >= c.homesteadBlock: FkHomestead
else: FkFrontier
proc chainConfigForNetwork*(id: NetworkId): ChainConfig =
# For some public networks, NetworkId and ChainId value are identical
# but that is not always the case
result = case id
of MainNet:
const mainNetTTD = UInt256.fromHex("58750000000000000000000")
ChainConfig(
poaEngine: false,
chainId: MainNet.ChainId,
# Genesis (Frontier): # 2015-07-30 15:26:13 UTC
# Frontier Thawing: 200_000.toBlockNumber, # 2015-09-07 21:33:09 UTC
homesteadBlock: 1_150_000.toBlockNumber, # 2016-03-14 18:49:53 UTC
daoForkBlock: 1_920_000.toBlockNumber, # 2016-07-20 13:20:40 UTC
daoForkSupport: true,
eip150Block: 2_463_000.toBlockNumber, # 2016-10-18 13:19:31 UTC
eip150Hash: toDigest("2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
eip155Block: 2_675_000.toBlockNumber, # Same as EIP-158
eip158Block: 2_675_000.toBlockNumber, # 2016-11-22 16:15:44 UTC
byzantiumBlock: 4_370_000.toBlockNumber, # 2017-10-16 05:22:11 UTC
constantinopleBlock: 7_280_000.toBlockNumber, # Skipped on Mainnet
petersburgBlock: 7_280_000.toBlockNumber, # 2019-02-28 19:52:04 UTC
istanbulBlock: 9_069_000.toBlockNumber, # 2019-12-08 00:25:09 UTC
muirGlacierBlock: 9_200_000.toBlockNumber, # 2020-01-02 08:30:49 UTC
berlinBlock: 12_244_000.toBlockNumber, # 2021-04-15 10:07:03 UTC
londonBlock: 12_965_000.toBlockNumber, # 2021-08-05 12:33:42 UTC
arrowGlacierBlock: 13_773_000.toBlockNumber, # 2021-12-09 19:55:23 UTC
grayGlacierBlock: 15_050_000.toBlockNumber, # 2022-06-30 10:54:04 UTC
mergeForkBlock: high(BlockNumber),
shanghaiBlock: high(BlockNumber),
cancunBlock: high(BlockNumber),
terminalTotalDifficulty: some(mainNetTTD)
)
of RopstenNet:
ChainConfig(
poaEngine: false,
chainId: RopstenNet.ChainId,
# Genesis: # 2016-11-20 11:48:50 UTC
homesteadBlock: 0.toBlockNumber, # Included in genesis
daoForkSupport: false,
eip150Block: 0.toBlockNumber, # Included in genesis
eip150Hash: toDigest("41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"),
eip155Block: 10.toBlockNumber, # Same as EIP-158
eip158Block: 10.toBlockNumber, # 2016-11-20 11:50:44 UTC
byzantiumBlock: 1_700_000.toBlockNumber, # 2017-09-19 01:08:28 UTC
constantinopleBlock: 4_230_000.toBlockNumber, # 2018-10-13 17:19:06 UTC
petersburgBlock: 4_939_394.toBlockNumber, # 2019-02-02 07:39:08 UTC
istanbulBlock: 6_485_846.toBlockNumber, # 2019-09-30 03:38:06 UTC
muirGlacierBlock: 7_117_117.toBlockNumber, # 2020-01-13 06:37:37 UTC
berlinBlock: 9_812_189.toBlockNumber, # 2021-03-10 13:32:08 UTC
londonBlock: 10_499_401.toBlockNumber, # 2021-06-24 02:03:37 UTC
arrowGlacierBlock: high(BlockNumber), # No current plan
grayGlacierBlock: high(BlockNumber), # No current plan
mergeForkBlock: high(BlockNumber),
shanghaiBlock: high(BlockNumber),
cancunBlock: high(BlockNumber),
)
of RinkebyNet:
ChainConfig(
poaEngine: true,
chainId: RinkebyNet.ChainId,
# Genesis: # 2017-04-12 15:20:50 UTC
homesteadBlock: 1.toBlockNumber, # 2017-04-12 15:20:58 UTC
daoForkSupport: false,
eip150Block: 2.toBlockNumber, # 2017-04-12 15:21:14 UTC
eip150Hash: toDigest("9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"),
eip155Block: 3.toBlockNumber, # Same as EIP-158
eip158Block: 3.toBlockNumber, # 2017-04-12 15:21:29 UTC
byzantiumBlock: 1_035_301.toBlockNumber, # 2017-10-09 12:08:23 UTC
constantinopleBlock: 3_660_663.toBlockNumber, # 2019-01-09 13:00:55 UTC
petersburgBlock: 4_321_234.toBlockNumber, # 2019-05-04 05:32:45 UTC
istanbulBlock: 5_435_345.toBlockNumber, # 2019-11-13 18:21:53 UTC
muirGlacierBlock: 8_290_928.toBlockNumber, # Skipped on Rinkeby
berlinBlock: 8_290_928.toBlockNumber, # 2021-03-24 14:48:36 UTC
londonBlock: 8_897_988.toBlockNumber, # 2021-07-08 01:27:32 UTC
arrowGlacierBlock: high(BlockNumber), # No current plan
grayGlacierBlock: high(BlockNumber), # No current plan
mergeForkBlock: high(BlockNumber),
shanghaiBlock: high(BlockNumber),
cancunBlock: high(BlockNumber),
)
of GoerliNet:
ChainConfig(
poaEngine: true,
chainId: GoerliNet.ChainId,
# Genesis: # 2015-07-30 15:26:13 UTC
homesteadBlock: 0.toBlockNumber, # Included in genesis
daoForkSupport: false,
eip150Block: 0.toBlockNumber, # Included in genesis
eip150Hash: toDigest("0000000000000000000000000000000000000000000000000000000000000000"),
eip155Block: 0.toBlockNumber, # Included in genesis
eip158Block: 0.toBlockNumber, # Included in genesis
byzantiumBlock: 0.toBlockNumber, # Included in genesis
constantinopleBlock: 0.toBlockNumber, # Included in genesis
petersburgBlock: 0.toBlockNumber, # Included in genesis
istanbulBlock: 1_561_651.toBlockNumber, # 2019-10-30 13:53:05 UTC
muirGlacierBlock: 4_460_644.toBlockNumber, # Skipped in Goerli
berlinBlock: 4_460_644.toBlockNumber, # 2021-03-18 05:29:51 UTC
londonBlock: 5_062_605.toBlockNumber, # 2021-07-01 03:19:39 UTC
arrowGlacierBlock: high(BlockNumber), # No current plan
grayGlacierBlock: high(BlockNumber), # No current plan
mergeForkBlock: high(BlockNumber),
shanghaiBlock: high(BlockNumber),
cancunBlock: high(BlockNumber),
terminalTotalDifficulty: some(10790000.u256)
)
of SepoliaNet:
ChainConfig(
poaEngine: false,
chainId: SepoliaNet.ChainId,
arrowGlacierBlock: high(BlockNumber), # No current plan
grayGlacierBlock: high(BlockNumber), # No current plan
mergeForkBlock: high(BlockNumber),
shanghaiBlock: high(BlockNumber),
cancunBlock: high(BlockNumber),
)
else:
ChainConfig()
proc genesisBlockForNetwork(id: NetworkId): Genesis
{.gcsafe, raises: [Defect, ValueError, RlpError].} =
result = case id
of MainNet:
Genesis(
nonce: 66.toBlockNonce,
extraData: hexToSeqByte("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"),
gasLimit: 5000,
difficulty: 17179869184.u256,
alloc: decodePrealloc(mainnetAllocData)
)
of RopstenNet:
Genesis(
nonce: 66.toBlockNonce,
extraData: hexToSeqByte("0x3535353535353535353535353535353535353535353535353535353535353535"),
gasLimit: 16777216,
difficulty: 1048576.u256,
alloc: decodePrealloc(testnetAllocData)
)
of RinkebyNet:
Genesis(
nonce: 0.toBlockNonce,
timestamp: initTime(0x58ee40ba, 0),
extraData: hexToSeqByte("0x52657370656374206d7920617574686f7269746168207e452e436172746d616e42eb768f2244c8811c63729a21a3569731535f067ffc57839b00206d1ad20c69a1981b489f772031b279182d99e65703f0076e4812653aab85fca0f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
gasLimit: 4700000,
difficulty: 1.u256,
alloc: decodePrealloc(rinkebyAllocData)
)
of GoerliNet:
Genesis(
nonce: 0.toBlockNonce,
timestamp: initTime(0x5c51a607, 0),
extraData: hexToSeqByte("0x22466c6578692069732061207468696e6722202d204166726900000000000000e0a2bd4258d2768837baa26a28fe71dc079f84c70000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
gasLimit: 0xa00000,
difficulty: 1.u256,
alloc: decodePrealloc(goerliAllocData)
)
of SepoliaNet:
Genesis(
nonce: 0.toBlockNonce,
timestamp: initTime(0x6159af19, 0),
extraData: hexToSeqByte("0x5365706f6c69612c20417468656e732c204174746963612c2047726565636521"),
gasLimit: 0x1c9c380,
difficulty: 0x20000.u256,
alloc: decodePrealloc(sepoliaAllocData)
)
else:
Genesis()
proc networkParams*(id: NetworkId): NetworkParams
{.gcsafe, raises: [Defect, ValueError, RlpError].} =
result.genesis = genesisBlockForNetwork(id)
result.config = chainConfigForNetwork(id)
proc `==`*(a, b: ChainId): bool =
a.uint64 == b.uint64
proc `==`*(a, b: Genesis): bool =
if a.isNil and b.isNil: return true
if a.isNil and not b.isNil: return false
if not a.isNil and b.isNil: return false
a[] == b[]
proc `==`*(a, b: ChainConfig): bool =
if a.isNil and b.isNil: return true
if a.isNil and not b.isNil: return false
if not a.isNil and b.isNil: return false
a[] == b[]
proc isLondon*(c: ChainConfig, number: BlockNumber): bool {.inline.} =
number >= c.londonBlock