params

package
v0.0.0-...-3a5d5d8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 13, 2024 License: LGPL-3.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// GasLimitBoundDivisor ...
	GasLimitBoundDivisor uint64 = 1024 // The bound divisor of the gas limit, used in update calculations.
	// MinGasLimit ...
	MinGasLimit uint64 = 5000 // Minimum the gas limit may ever be.
	// GenesisGasLimit ...
	GenesisGasLimit uint64 = 4712388 // Gas limit of the Genesis block.
	// TestGenesisGasLimit ..
	TestGenesisGasLimit uint64 = 80000000 // A Gas limit in testing of the Genesis block (set same as current asadal)
	// MaximumExtraDataSize ...
	MaximumExtraDataSize uint64 = 32 // Maximum size extra data may be after Genesis.
	// ExpByteGas ...
	ExpByteGas uint64 = 10 // Times ceil(log256(exponent)) for the EXP instruction.
	// SloadGas ...
	SloadGas uint64 = 50 // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
	// CallValueTransferGas ...
	CallValueTransferGas uint64 = 9000 // Paid for CALL when the value transfer is non-zero.
	// CallNewAccountGas ...
	CallNewAccountGas uint64 = 25000 // Paid for CALL when the destination address didn't exist prior.
	// TxGas ...
	TxGas uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
	// TxGasContractCreation ...
	TxGasContractCreation uint64 = 53000 // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
	// TxGasValidatorCreation ...
	TxGasValidatorCreation uint64 = 5300000 // Per transaction that creates a new validator. NOTE: Not payable on data of calls between transactions.
	// TxDataZeroGas ...
	TxDataZeroGas uint64 = 4 // Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.
	// QuadCoeffDiv ...
	QuadCoeffDiv uint64 = 512 // Divisor for the quadratic particle of the memory cost equation.
	// LogDataGas ...
	LogDataGas uint64 = 8 // Per byte in a LOG* operation's data.
	// CallStipend ...
	CallStipend uint64 = 2300 // Free gas given at beginning of call.

	// Sha3Gas ...
	Sha3Gas uint64 = 30 // Once per SHA3 operation.
	// Sha3WordGas ...
	Sha3WordGas uint64 = 6 // Once per word of the SHA3 operation's data.

	// SstoreSetGas ...
	SstoreSetGas uint64 = 20000 // Once per SLOAD operation.
	// SstoreResetGas ...
	SstoreResetGas uint64 = 5000 // Once per SSTORE operation if the zeroness changes from zero.
	// SstoreClearGas ...
	SstoreClearGas uint64 = 5000 // Once per SSTORE operation if the zeroness doesn't change.
	// SstoreRefundGas ...
	SstoreRefundGas uint64 = 15000 // Once per SSTORE operation if the zeroness changes to zero.

	// NetSstoreNoopGas ...
	NetSstoreNoopGas uint64 = 200 // Once per SSTORE operation if the value doesn't change.
	// NetSstoreInitGas ...
	NetSstoreInitGas uint64 = 20000 // Once per SSTORE operation from clean zero.
	// NetSstoreCleanGas ...
	NetSstoreCleanGas uint64 = 5000 // Once per SSTORE operation from clean non-zero.
	// NetSstoreDirtyGas ...
	NetSstoreDirtyGas uint64 = 200 // Once per SSTORE operation from dirty.

	// NetSstoreClearRefund ...
	NetSstoreClearRefund uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot
	// NetSstoreResetRefund ...
	NetSstoreResetRefund uint64 = 4800 // Once per SSTORE operation for resetting to the original non-zero value
	// NetSstoreResetClearRefund ...
	NetSstoreResetClearRefund uint64 = 19800 // Once per SSTORE operation for resetting to the original zero value

	// SstoreSentryGasEIP2200 ...
	SstoreSentryGasEIP2200 uint64 = 2300 // Minimum gas required to be present for an SSTORE call, not consumed
	// SstoreNoopGasEIP2200 ...
	SstoreNoopGasEIP2200 uint64 = 800 // Once per SSTORE operation if the value doesn't change.
	// SstoreDirtyGasEIP2200 ...
	SstoreDirtyGasEIP2200 uint64 = 800 // Once per SSTORE operation if a dirty value is changed.
	// SstoreInitGasEIP2200 ...
	SstoreInitGasEIP2200 uint64 = 20000 // Once per SSTORE operation from clean zero to non-zero
	// SstoreInitRefundEIP2200 ...
	SstoreInitRefundEIP2200 uint64 = 19200 // Once per SSTORE operation for resetting to the original zero value
	// SstoreCleanGasEIP2200 ...
	SstoreCleanGasEIP2200 uint64 = 5000 // Once per SSTORE operation from clean non-zero to something else
	// SstoreCleanRefundEIP2200 ...
	SstoreCleanRefundEIP2200 uint64 = 4200 // Once per SSTORE operation for resetting to the original non-zero value
	// SstoreClearRefundEIP2200 ...
	SstoreClearRefundEIP2200 uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot

	// JumpdestGas ...
	JumpdestGas uint64 = 1 // Refunded gas, once per SSTORE operation if the zeroness changes to zero.
	// EpochDuration ...
	EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.
	// CallGas ...
	CallGas uint64 = 40 // Once per CALL operation & message call transaction.
	// CreateDataGas ...
	CreateDataGas uint64 = 200 //
	// CallCreateDepth ...
	CallCreateDepth uint64 = 1024 // Maximum depth of call/create stack.
	// ExpGas ...
	ExpGas uint64 = 10 // Once per EXP instruction
	// LogGas ...
	LogGas uint64 = 375 // Per LOG* operation.
	// CopyGas ...
	CopyGas uint64 = 3 //
	// StackLimit ...
	StackLimit uint64 = 1024 // Maximum size of VM stack allowed.
	// TierStepGas ...
	TierStepGas uint64 = 0 // Once per operation, for a selection of them.
	// LogTopicGas ...
	LogTopicGas uint64 = 375 // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
	// CreateGas ...
	CreateGas uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
	// Create2Gas ...
	Create2Gas uint64 = 32000 // Once per CREATE2 operation
	// SelfdestructRefundGas ...
	SelfdestructRefundGas uint64 = 24000 // Refunded following a selfdestruct operation.
	// MemoryGas ...
	MemoryGas uint64 = 3 // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
	// TxDataNonZeroGas ...
	TxDataNonZeroGasFrontier uint64 = 68 // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
	// TxDataNonZeroGasEIP2028 ...
	TxDataNonZeroGasEIP2028 uint64 = 16 // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)

	// These have been changed during the course of the chain
	CallGasFrontier              uint64 = 40  // Once per CALL operation & message call transaction.
	CallGasEIP150                uint64 = 700 // Static portion of gas for CALL-derivates after EIP 150 (Tangerine)
	BalanceGasFrontier           uint64 = 20  // The cost of a BALANCE operation
	BalanceGasEIP150             uint64 = 400 // The cost of a BALANCE operation after Tangerine
	BalanceGasEIP1884            uint64 = 700 // The cost of a BALANCE operation after EIP 1884 (part of Istanbul)
	ExtcodeSizeGasFrontier       uint64 = 20  // Cost of EXTCODESIZE before EIP 150 (Tangerine)
	ExtcodeSizeGasEIP150         uint64 = 700 // Cost of EXTCODESIZE after EIP 150 (Tangerine)
	SloadGasFrontier             uint64 = 50
	SloadGasEIP150               uint64 = 200
	SloadGasEIP1884              uint64 = 800  // Cost of SLOAD after EIP 1884 (part of Istanbul)
	ExtcodeHashGasConstantinople uint64 = 400  // Cost of EXTCODEHASH (introduced in Constantinople)
	ExtcodeHashGasEIP1884        uint64 = 700  // Cost of EXTCODEHASH after EIP 1884 (part in Istanbul)
	SelfdestructGasEIP150        uint64 = 5000 // Cost of SELFDESTRUCT post EIP 150 (Tangerine)

	// EXP has a dynamic portion depending on the size of the exponent
	ExpByteFrontier uint64 = 10 // was set to 10 in Frontier
	ExpByteEIP158   uint64 = 50 // was raised to 50 during Eip158 (Spurious Dragon)

	// Extcodecopy has a dynamic AND a static cost. This represents only the
	// static portion of the gas. It was changed during EIP 150 (Tangerine)
	ExtcodeCopyBaseFrontier uint64 = 20
	ExtcodeCopyBaseEIP150   uint64 = 700

	// CreateBySelfdestructGas is used when the refunded account is one that does
	// not exist. This logic is similar to call.
	// Introduced in Tangerine Whistle (Eip 150)
	CreateBySelfdestructGas uint64 = 25000

	// MaxCodeSize ...
	MaxCodeSize = 24576 // Maximum bytecode to permit for a contract

	EcrecoverGas        uint64 = 3000 // Elliptic curve sender recovery gas price
	Sha256BaseGas       uint64 = 60   // Base price for a SHA256 operation
	Sha256PerWordGas    uint64 = 12   // Per-word price for a SHA256 operation
	Ripemd160BaseGas    uint64 = 600  // Base price for a RIPEMD160 operation
	Ripemd160PerWordGas uint64 = 120  // Per-word price for a RIPEMD160 operation
	IdentityBaseGas     uint64 = 15   // Base price for a data copy operation
	IdentityPerWordGas  uint64 = 3    // Per-work price for a data copy operation
	ModExpQuadCoeffDiv  uint64 = 20   // Divisor for the quadratic particle of the big int modular exponentiation

	Bn256AddGasByzantium             uint64 = 500    // Byzantium gas needed for an elliptic curve addition
	Bn256AddGasIstanbul              uint64 = 150    // Gas needed for an elliptic curve addition
	Bn256ScalarMulGasByzantium       uint64 = 40000  // Byzantium gas needed for an elliptic curve scalar multiplication
	Bn256ScalarMulGasIstanbul        uint64 = 6000   // Gas needed for an elliptic curve scalar multiplication
	Bn256PairingBaseGasByzantium     uint64 = 100000 // Byzantium base price for an elliptic curve pairing check
	Bn256PairingBaseGasIstanbul      uint64 = 45000  // Base price for an elliptic curve pairing check
	Bn256PairingPerPointGasByzantium uint64 = 80000  // Byzantium per-point price for an elliptic curve pairing check
	Bn256PairingPerPointGasIstanbul  uint64 = 34000  // Per-point price for an elliptic curve pairing check

	//SHA3-FIPS Precompiled contracts gas price esstimation as per ethereum yellow paper appendix G
	Sha3FipsGas     uint64 = 30 // Once per SHA3-256 operation.
	Sha3FipsWordGas uint64 = 6  // Once per word of the SHA3-256 operation's data.

)

nolint

Variables

View Source 
var (
	MainnetChainID            = big.NewInt(101)
	BabylonChainID            = big.NewInt(106)
	TestnetChainID            = big.NewInt(102)
	PangaeaChainID            = big.NewInt(103)
	PartnerChainID            = big.NewInt(104)
	StressnetChainID          = big.NewInt(105)
	TestChainID               = big.NewInt(199) // not a real network
	AllProtocolChangesChainID = big.NewInt(200) // not a real network

	// EthMainnetShard0ChainID to be reserved unique chain ID for eth compatible chains.
	EthMainnetShard0ChainID            = big.NewInt(1682841000)
	EthBabylonShard0ChainID            = big.NewInt(1682848000)
	EthTestnetShard0ChainID            = big.NewInt(1682842000)
	EthPangaeaShard0ChainID            = big.NewInt(1682843000)
	EthPartnerShard0ChainID            = big.NewInt(1682844000)
	EthStressnetShard0ChainID          = big.NewInt(1682845000)
	EthTestShard0ChainID               = big.NewInt(1682846000) // not a real network
	EthAllProtocolChangesShard0ChainID = big.NewInt(1682847000) // not a real network
)

Well-known chain IDs.

View Source 
var (
	// MainnetChainConfig is the chain parameters to run a node on the main network.
	MainnetChainConfig = &ChainConfig{
		ChainID:                    MainnetChainID,
		EthCompatibleChainID:       EthMainnetShard0ChainID,
		EthCompatibleShard0ChainID: EthMainnetShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(0),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(1),
		PreStakingEpoch:            big.NewInt(0),
		QuickUnlockEpoch:           big.NewInt(453),
		FiveSecondsEpoch:           big.NewInt(1),
		TwoSecondsEpoch:            EpochTBD,
		SixtyPercentEpoch:          big.NewInt(0),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(100),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(0),
	}

	// BabylonChainConfig is the chain parameters to run a node on the babylon network.
	BabylonChainConfig = &ChainConfig{
		ChainID:                    BabylonChainID,
		EthCompatibleChainID:       EthBabylonShard0ChainID,
		EthCompatibleShard0ChainID: EthBabylonShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(0),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(1),
		PreStakingEpoch:            big.NewInt(0),
		QuickUnlockEpoch:           EpochTBD,
		FiveSecondsEpoch:           EpochTBD,
		TwoSecondsEpoch:            EpochTBD,
		SixtyPercentEpoch:          big.NewInt(0),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(100),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(0),
	}

	// TestnetChainConfig contains the chain parameters to run a node on the feechain test network.
	TestnetChainConfig = &ChainConfig{
		ChainID:                    TestnetChainID,
		EthCompatibleChainID:       EthTestnetShard0ChainID,
		EthCompatibleShard0ChainID: EthTestnetShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(0),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(1),
		PreStakingEpoch:            big.NewInt(0),
		QuickUnlockEpoch:           big.NewInt(2840),
		FiveSecondsEpoch:           big.NewInt(2725),
		TwoSecondsEpoch:            EpochTBD,
		SixtyPercentEpoch:          big.NewInt(0),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(100),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(0),
	}

	// PangaeaChainConfig contains the chain parameters for the Pangaea network.
	// All features except for CrossLink are enabled at launch.
	PangaeaChainConfig = &ChainConfig{
		ChainID:                    PangaeaChainID,
		EthCompatibleChainID:       EthPangaeaShard0ChainID,
		EthCompatibleShard0ChainID: EthPangaeaShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(2),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(2),
		PreStakingEpoch:            big.NewInt(1),
		QuickUnlockEpoch:           EpochTBD,
		FiveSecondsEpoch:           big.NewInt(0),
		TwoSecondsEpoch:            big.NewInt(0),
		SixtyPercentEpoch:          big.NewInt(0),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(10),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(2),
	}

	// PartnerChainConfig contains the chain parameters for the Partner network.
	// All features except for CrossLink are enabled at launch.
	PartnerChainConfig = &ChainConfig{
		ChainID:                    PartnerChainID,
		EthCompatibleChainID:       EthPartnerShard0ChainID,
		EthCompatibleShard0ChainID: EthPartnerShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(2),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(2),
		PreStakingEpoch:            big.NewInt(1),
		QuickUnlockEpoch:           EpochTBD,
		FiveSecondsEpoch:           big.NewInt(0),
		TwoSecondsEpoch:            big.NewInt(0),
		SixtyPercentEpoch:          big.NewInt(4),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(10),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(2),
	}

	// StressnetChainConfig contains the chain parameters for the Stress test network.
	// All features except for CrossLink are enabled at launch.
	StressnetChainConfig = &ChainConfig{
		ChainID:                    StressnetChainID,
		EthCompatibleChainID:       EthStressnetShard0ChainID,
		EthCompatibleShard0ChainID: EthStressnetShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(2),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(2),
		PreStakingEpoch:            big.NewInt(1),
		QuickUnlockEpoch:           EpochTBD,
		FiveSecondsEpoch:           big.NewInt(0),
		TwoSecondsEpoch:            big.NewInt(0),
		SixtyPercentEpoch:          big.NewInt(10),
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(10),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              big.NewInt(0),
		StakingPrecompileEpoch:     big.NewInt(2),
	}

	// LocalnetChainConfig contains the chain parameters to run for local development.
	LocalnetChainConfig = &ChainConfig{
		ChainID:                    TestnetChainID,
		EthCompatibleChainID:       EthTestnetShard0ChainID,
		EthCompatibleShard0ChainID: EthTestnetShard0ChainID,
		EthCompatibleEpoch:         big.NewInt(0),
		CrossTxEpoch:               big.NewInt(0),
		CrossLinkEpoch:             big.NewInt(2),
		AggregatedRewardEpoch:      big.NewInt(3),
		StakingEpoch:               big.NewInt(2),
		PreStakingEpoch:            big.NewInt(0),
		QuickUnlockEpoch:           EpochTBD,
		FiveSecondsEpoch:           big.NewInt(0),
		TwoSecondsEpoch:            big.NewInt(3),
		SixtyPercentEpoch:          EpochTBD,
		RedelegationEpoch:          big.NewInt(0),
		NoEarlyUnlockEpoch:         big.NewInt(0),
		VRFEpoch:                   big.NewInt(0),
		PrevVRFEpoch:               big.NewInt(0),
		MinDelegation100Epoch:      big.NewInt(0),
		MinCommissionRateEpoch:     big.NewInt(0),
		MinCommissionPromoPeriod:   big.NewInt(10),
		EPoSBound35Epoch:           big.NewInt(0),
		EIP155Epoch:                big.NewInt(0),
		S3Epoch:                    big.NewInt(0),
		DataCopyFixEpoch:           big.NewInt(0),
		IstanbulEpoch:              big.NewInt(0),
		ReceiptLogEpoch:            big.NewInt(0),
		SHA3Epoch:                  big.NewInt(0),
		HIP6And8Epoch:              EpochTBD,
		StakingPrecompileEpoch:     big.NewInt(2),
	}

	// AllProtocolChanges ...
	// This configuration is intentionally not using keyed fields to force anyone
	// adding flags to the config to also have to set these fields.
	AllProtocolChanges = &ChainConfig{
		AllProtocolChangesChainID,
		EthAllProtocolChangesShard0ChainID,
		EthAllProtocolChangesShard0ChainID,
		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),
		big.NewInt(0),
		big.NewInt(0),
		big.NewInt(0),
		big.NewInt(10),
		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),
	}

	// TestChainConfig ...
	// This configuration is intentionally not using keyed fields to force anyone
	// adding flags to the config to also have to set these fields.
	TestChainConfig = &ChainConfig{
		TestChainID,
		EthTestShard0ChainID,
		EthTestShard0ChainID,
		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),
		big.NewInt(0),
		big.NewInt(0),
		big.NewInt(0),
		big.NewInt(10),
		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),
	}

	// TestRules ...
	TestRules = TestChainConfig.Rules(new(big.Int))
)
View Source 
var (
	// GasTableR3 contain the gas prices for
	// the r3 phase.
	GasTableR3 = GasTable{
		ExtcodeSize: 20,
		ExtcodeCopy: 20,
		Balance:     20,
		SLoad:       50,
		Calls:       40,
		Suicide:     0,
		ExpByte:     10,
	}
	// GasTableS3 contain the gas re-prices for
	// the s3 phase.
	GasTableS3 = GasTable{
		ExtcodeSize: 700,
		ExtcodeCopy: 700,
		ExtcodeHash: 400,
		Balance:     400,
		SLoad:       200,
		Calls:       700,
		Suicide:     5000,
		ExpByte:     50,

		CreateBySuicide: 25000,
	}
)

Variables containing gas prices for different feechain phases.

View Source 
var (
	DifficultyBoundDivisor = big.NewInt(2048)   // The bound divisor of the difficulty, used in the update calculations.
	GenesisDifficulty      = big.NewInt(131072) // Difficulty of the Genesis block.
	MinimumDifficulty      = big.NewInt(131072) // The minimum that the difficulty may ever be.
	DurationLimit          = big.NewInt(13)     // The decision boundary on the blocktime duration used to determine whether difficulty should go up or not.
)

nolint

View Source 
var EpochTBD = big.NewInt(10000000)

EpochTBD is a large, “not anytime soon” epoch. It used as a placeholder until the exact epoch is decided.

Functions

func IsEthCompatible 

func IsEthCompatible(chainID *big.Int) bool

IsEthCompatible returns whether the chainID is for ethereum compatible txn or not

func UpdateEthChainIDByShard 

func UpdateEthChainIDByShard(shardID uint32)

UpdateEthChainIDByShard update the ethChainID based on shard ID.

Types

type ChainConfig 

type ChainConfig struct {
	// ChainId identifies the current chain and is used for replay protection
	ChainID *big.Int `json:"chain-id"`

	// EthCompatibleChainID identifies the chain id used for ethereum compatible transactions
	EthCompatibleChainID *big.Int `json:"eth-compatible-chain-id"`

	// EthCompatibleShard0ChainID identifies the shard 0 chain id used for ethereum compatible transactions
	EthCompatibleShard0ChainID *big.Int `json:"eth-compatible-shard-0-chain-id"`

	// EthCompatibleEpoch is the epoch where ethereum-compatible transaction starts being
	// processed.
	EthCompatibleEpoch *big.Int `json:"eth-compatible-epoch,omitempty"`

	// CrossTxEpoch is the epoch where cross-shard transaction starts being
	// processed.
	CrossTxEpoch *big.Int `json:"cross-tx-epoch,omitempty"`

	// CrossLinkEpoch is the epoch where beaconchain starts containing
	// cross-shard links.
	CrossLinkEpoch *big.Int `json:"cross-link-epoch,omitempty"`

	// AggregatedRewardEpoch is the epoch when block rewards are distributed every 64 blocks
	AggregatedRewardEpoch *big.Int `json:"aggregated-reward-epoch,omitempty"`

	// StakingEpoch is the epoch when shard assign takes staking into account
	StakingEpoch *big.Int `json:"staking-epoch,omitempty"`

	// PreStakingEpoch is the epoch we allow staking transactions
	PreStakingEpoch *big.Int `json:"prestaking-epoch,omitempty"`

	// QuickUnlockEpoch is the epoch when undelegation will be unlocked at the current epoch
	QuickUnlockEpoch *big.Int `json:"quick-unlock-epoch,omitempty"`

	// FiveSecondsEpoch is the epoch when block time is reduced to 5 seconds
	// and block rewards adjusted to 17.5 ONE/block
	FiveSecondsEpoch *big.Int `json:"five-seconds-epoch,omitempty"`

	// TwoSecondsEpoch is the epoch when block time is reduced to 2 seconds
	// and block rewards adjusted to 7 ONE/block
	TwoSecondsEpoch *big.Int `json:"two-seconds-epoch,omitempty"`

	// SixtyPercentEpoch is the epoch when internal voting power reduced from 68% to 60%
	SixtyPercentEpoch *big.Int `json:"sixty-percent-epoch,omitempty"`

	// RedelegationEpoch is the epoch when redelegation is supported and undelegation locking time
	// is restored to 7 epoch
	RedelegationEpoch *big.Int `json:"redelegation-epoch,omitempty"`

	// NoEarlyUnlockEpoch is the epoch when the early unlock of undelegated token from validators who were elected for
	// more than 7 epochs is disabled
	NoEarlyUnlockEpoch *big.Int `json:"no-early-unlock-epoch,omitempty"`

	// VRFEpoch is the epoch when VRF randomness is enabled
	VRFEpoch *big.Int `json:"vrf-epoch,omitempty"`

	// PrevVRFEpoch is the epoch when previous VRF randomness can be fetched
	PrevVRFEpoch *big.Int `json:"prev-vrf-epoch,omitempty"`

	// MinDelegation100Epoch is the epoch when min delegation is reduced from 1000 ONE to 100 ONE
	MinDelegation100Epoch *big.Int `json:"min-delegation-100-epoch,omitempty"`

	// MinCommissionRateEpoch is the epoch when policy for minimum comission rate of 5% is started
	MinCommissionRateEpoch *big.Int `json:"min-commission-rate-epoch,omitempty"`

	// MinCommissionPromoPeriod is the number of epochs when newly elected validators can have 0% commission
	MinCommissionPromoPeriod *big.Int `json:"commission-promo-period,omitempty"`

	// EPoSBound35Epoch is the epoch when the EPoS bound parameter c is changed from 15% to 35%
	EPoSBound35Epoch *big.Int `json:"epos-bound-35-epoch,omitempty"`

	// EIP155 hard fork epoch (include EIP158 too)
	EIP155Epoch *big.Int `json:"eip155-epoch,omitempty"`

	// S3 epoch is the first epoch containing S3 asadal and all ethereum update up to Constantinople
	S3Epoch *big.Int `json:"s3-epoch,omitempty"`

	// DataCopyFix epoch is the first epoch containing fix for evm datacopy bug.
	DataCopyFixEpoch *big.Int `json:"data-copy-fix-epoch,omitempty"`

	// Istanbul epoch
	IstanbulEpoch *big.Int `json:"istanbul-epoch,omitempty"`

	// ReceiptLogEpoch is the first epoch support receiptlog
	ReceiptLogEpoch *big.Int `json:"receipt-log-epoch,omitempty"`

	// IsSHA3Epoch is the first epoch in supporting SHA3 FIPS-202 standard
	SHA3Epoch *big.Int `json:"sha3-epoch,omitempty"`

	// IsHIP6And8Epoch is the first epoch to support HIP-6 and HIP-8
	HIP6And8Epoch *big.Int `json:"hip6_8-epoch,omitempty"`

	// StakingPrecompileEpoch is the first epoch to support the staking precompiles
	StakingPrecompileEpoch *big.Int `json:"staking-precompile-epoch,omitempty"`
}

ChainConfig is the core config which determines the blockchain settings.

ChainConfig is stored in the database on a per block basis. This means that any network, identified by its genesis block, can have its own set of configuration options.

func (*ChainConfig) AcceptsCrossTx 

func (c *ChainConfig) AcceptsCrossTx(epoch *big.Int) bool

AcceptsCrossTx returns whether cross-shard transaction is accepted in the given epoch.

Note that this is different from comparing epoch against CrossTxEpoch. Cross-shard transaction is accepted from CrossTxEpoch+1 and on, in order to allow for all shards to roll into CrossTxEpoch and become able to handle ingress receipts. In other words, cross-shard transaction fields are introduced and ingress receipts are processed at CrossTxEpoch, but the shard does not accept cross-shard transactions from clients until CrossTxEpoch+1.

func (*ChainConfig) GasTable 

func (c *ChainConfig) GasTable(epoch *big.Int) GasTable

GasTable returns the gas table corresponding to the current phase (homestead or homestead reprice).

The returned GasTable's fields shouldn't, under any circumstances, be changed.

func (*ChainConfig) HasCrossTxFields 

func (c *ChainConfig) HasCrossTxFields(epoch *big.Int) bool

HasCrossTxFields returns whether blocks in the given epoch includes cross-shard transaction fields.

func (*ChainConfig) IsAggregatedRewardEpoch 

func (c *ChainConfig) IsAggregatedRewardEpoch(epoch *big.Int) bool

IsAggregatedRewardEpoch determines whether it is the epoch when rewards are distributed every 64 blocks 

func (c *ChainConfig) IsCrossLink(epoch *big.Int) bool

IsCrossLink returns whether epoch is either equal to the CrossLink fork epoch or greater.

func (*ChainConfig) IsDataCopyFixEpoch 

func (c *ChainConfig) IsDataCopyFixEpoch(epoch *big.Int) bool

IsDataCopyFixEpoch returns whether epoch has the fix for DataCopy evm bug.

func (*ChainConfig) IsEIP155 

func (c *ChainConfig) IsEIP155(epoch *big.Int) bool

IsEIP155 returns whether epoch is either equal to the EIP155 fork epoch or greater.

func (*ChainConfig) IsEPoSBound35 

func (c *ChainConfig) IsEPoSBound35(epoch *big.Int) bool

IsEPoSBound35 determines whether it is the epoch to extend the EPoS bound to 35%

func (*ChainConfig) IsEthCompatible 

func (c *ChainConfig) IsEthCompatible(epoch *big.Int) bool

IsEthCompatible determines whether it is ethereum compatible epoch

func (*ChainConfig) IsFiveSeconds 

func (c *ChainConfig) IsFiveSeconds(epoch *big.Int) bool

IsFiveSeconds determines whether it is the epoch to change to 5 seconds block time

func (*ChainConfig) IsHIP6And8Epoch 

func (c *ChainConfig) IsHIP6And8Epoch(epoch *big.Int) bool

IsHIP6And8Epoch determines whether it is the epoch to support HIP-6: reduce the internal voting power from 60% to 49% HIP-8: increase external nodes from 800 to 900

func (*ChainConfig) IsIstanbul 

func (c *ChainConfig) IsIstanbul(epoch *big.Int) bool

IsIstanbul returns whether epoch is either equal to the Istanbul fork epoch or greater.

func (*ChainConfig) IsMinCommissionRate 

func (c *ChainConfig) IsMinCommissionRate(epoch *big.Int) bool

IsMinCommissionRate determines whether it is the epoch to start the policy of 5% min commission

func (*ChainConfig) IsMinDelegation100 

func (c *ChainConfig) IsMinDelegation100(epoch *big.Int) bool

IsMinDelegation100 determines whether it is the epoch to reduce min delegation to 100

func (*ChainConfig) IsNoEarlyUnlock 

func (c *ChainConfig) IsNoEarlyUnlock(epoch *big.Int) bool

IsNoEarlyUnlock determines whether it is the epoch to stop early unlock

func (*ChainConfig) IsPreStaking 

func (c *ChainConfig) IsPreStaking(epoch *big.Int) bool

IsPreStaking determines whether staking transactions are allowed

func (*ChainConfig) IsPrevVRF 

func (c *ChainConfig) IsPrevVRF(epoch *big.Int) bool

IsPrevVRF determines whether it is the epoch to enable previous vrf

func (*ChainConfig) IsQuickUnlock 

func (c *ChainConfig) IsQuickUnlock(epoch *big.Int) bool

IsQuickUnlock determines whether it's the epoch when the undelegation should be unlocked at end of current epoch

func (*ChainConfig) IsReceiptLog 

func (c *ChainConfig) IsReceiptLog(epoch *big.Int) bool

IsReceiptLog returns whether epoch is either equal to the ReceiptLog fork epoch or greater.

func (*ChainConfig) IsRedelegation 

func (c *ChainConfig) IsRedelegation(epoch *big.Int) bool

IsRedelegation determines whether it is the epoch to support redelegation

func (*ChainConfig) IsS3 

func (c *ChainConfig) IsS3(epoch *big.Int) bool

IsS3 returns whether epoch is either equal to the S3 fork epoch or greater.

func (*ChainConfig) IsSHA3 

func (c *ChainConfig) IsSHA3(epoch *big.Int) bool

IsSHA3 returns whether epoch is either equal to the IsSHA3 fork epoch or greater.

func (*ChainConfig) IsSixtyPercent 

func (c *ChainConfig) IsSixtyPercent(epoch *big.Int) bool

IsSixtyPercent determines whether it is the epoch to reduce internal voting power to 60%

func (*ChainConfig) IsStaking 

func (c *ChainConfig) IsStaking(epoch *big.Int) bool

IsStaking determines whether it is staking epoch

func (*ChainConfig) IsStakingPrecompile 

func (c *ChainConfig) IsStakingPrecompile(epoch *big.Int) bool

IsStakingPrecompileEpoch determines whether staking precompiles are available in the EVM

func (*ChainConfig) IsTwoSeconds 

func (c *ChainConfig) IsTwoSeconds(epoch *big.Int) bool

IsTwoSeconds determines whether it is the epoch to change to 3 seconds block time

func (*ChainConfig) IsVRF 

func (c *ChainConfig) IsVRF(epoch *big.Int) bool

IsVRF determines whether it is the epoch to enable vrf

func (*ChainConfig) Rules 

func (c *ChainConfig) Rules(epoch *big.Int) Rules

Rules ensures c's ChainID is not nil.

func (*ChainConfig) String 

func (c *ChainConfig) String() string

String implements the fmt.Stringer interface.

type GasTable 

type GasTable struct {
	ExtcodeSize uint64
	ExtcodeCopy uint64
	ExtcodeHash uint64
	Balance     uint64
	SLoad       uint64
	Calls       uint64
	Suicide     uint64

	ExpByte uint64

	// CreateBySuicide occurs when the
	// refunded account is one that does
	// not exist. This logic is similar
	// to call. May be left nil. Nil means
	// not charged.
	CreateBySuicide uint64
}

GasTable organizes gas prices for different feechain phases.

type Rules 

type Rules struct {
	ChainID                                                                                              *big.Int
	EthChainID                                                                                           *big.Int
	IsCrossLink, IsEIP155, IsS3, IsReceiptLog, IsIstanbul, IsVRF, IsPrevVRF, IsSHA3, IsStakingPrecompile bool
}

Rules wraps ChainConfig and is merely syntactic sugar or can be used for functions that do not have or require information about the block.

Rules is a one time interface meaning that it shouldn't be used in between transition phases.

type TrustedCheckpoint 

type TrustedCheckpoint struct {
	Name         string      `json:"-"`
	SectionIndex uint64      `json:"sectionIndex"`
	SectionHead  common.Hash `json:"sectionHead"`
	CHTRoot      common.Hash `json:"chtRoot"`
	BloomRoot    common.Hash `json:"bloomRoot"`
}

TrustedCheckpoint represents a set of post-processed trie roots (CHT and BloomTrie) associated with the appropriate section index and head hash. It is used to start light syncing from this checkpoint and avoid downloading the entire header chain while still being able to securely access old headers/logs.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.