Documentation

Index

Constants

View Source
const (
	Wei   = 1
	GWei  = 1e9
	Ether = 1e18
)

    These are the multipliers for ether denominations. Example: To get the wei value of an amount in 'gwei', use

    new(big.Int).Mul(value, big.NewInt(params.GWei))
    
    View Source
    const (
    	// BloomBitsBlocks is the number of blocks a single bloom bit section vector
    	// contains on the server side.
    	BloomBitsBlocks uint64 = 4096
    
    	// BloomBitsBlocksClient is the number of blocks a single bloom bit section vector
    	// contains on the light client side
    	BloomBitsBlocksClient uint64 = 32768
    
    	// BloomConfirms is the number of confirmation blocks before a bloom section is
    	// considered probably final and its rotated bits are calculated.
    	BloomConfirms = 256
    
    	// CHTFrequency is the block frequency for creating CHTs
    	CHTFrequency = 32768
    
    	// BloomTrieFrequency is the block frequency for creating BloomTrie on both
    	// server/client sides.
    	BloomTrieFrequency = 32768
    
    	// HelperTrieConfirmations is the number of confirmations before a client is expected
    	// to have the given HelperTrie available.
    	HelperTrieConfirmations = 2048
    
    	// HelperTrieProcessConfirmations is the number of confirmations before a HelperTrie
    	// is generated
    	HelperTrieProcessConfirmations = 256
    
    	// CheckpointFrequency is the block frequency for creating checkpoint
    	CheckpointFrequency = 32768
    
    	// CheckpointProcessConfirmations is the number before a checkpoint is generated
    	CheckpointProcessConfirmations = 256
    
    	// ImmutabilityThreshold is the number of blocks after which a chain segment is
    	// considered immutable (i.e. soft finality). It is used by the downloader as a
    	// hard limit against deep ancestors, by the blockchain against deep reorgs, by
    	// the freezer as the cutoff treshold and by clique as the snapshot trust limit.
    	ImmutabilityThreshold = 90000
    )
    View Source
    const (
    	GasLimitBoundDivisor uint64 = 1024    // The bound divisor of the gas limit, used in update calculations.
    	MinGasLimit          uint64 = 5000    // Minimum the gas limit may ever be.
    	GenesisGasLimit      uint64 = 4712388 // Gas limit of the Genesis block.
    
    	MaximumExtraDataSize  uint64 = 32    // Maximum size extra data may be after Genesis.
    	ExpByteGas            uint64 = 10    // Times ceil(log256(exponent)) for the EXP instruction.
    	SloadGas              uint64 = 50    // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
    	CallValueTransferGas  uint64 = 9000  // Paid for CALL when the value transfer is non-zero.
    	CallNewAccountGas     uint64 = 25000 // Paid for CALL when the destination address didn't exist prior.
    	TxGas                 uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
    	TxGasContractCreation uint64 = 53000 // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
    	TxDataZeroGas         uint64 = 4     // Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.
    	QuadCoeffDiv          uint64 = 512   // Divisor for the quadratic particle of the memory cost equation.
    	LogDataGas            uint64 = 8     // Per byte in a LOG* operation's data.
    	CallStipend           uint64 = 2300  // Free gas given at beginning of call.
    
    	Sha3Gas     uint64 = 30 // Once per SHA3 operation.
    	Sha3WordGas uint64 = 6  // Once per word of the SHA3 operation's data.
    
    	SstoreSetGas    uint64 = 20000 // Once per SLOAD operation.
    	SstoreResetGas  uint64 = 5000  // Once per SSTORE operation if the zeroness changes from zero.
    	SstoreClearGas  uint64 = 5000  // Once per SSTORE operation if the zeroness doesn't change.
    	SstoreRefundGas uint64 = 15000 // Once per SSTORE operation if the zeroness changes to zero.
    
    	NetSstoreNoopGas  uint64 = 200   // Once per SSTORE operation if the value doesn't change.
    	NetSstoreInitGas  uint64 = 20000 // Once per SSTORE operation from clean zero.
    	NetSstoreCleanGas uint64 = 5000  // Once per SSTORE operation from clean non-zero.
    	NetSstoreDirtyGas uint64 = 200   // Once per SSTORE operation from dirty.
    
    	NetSstoreClearRefund      uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot
    	NetSstoreResetRefund      uint64 = 4800  // Once per SSTORE operation for resetting to the original non-zero value
    	NetSstoreResetClearRefund uint64 = 19800 // Once per SSTORE operation for resetting to the original zero value
    
    	SstoreSentryGasEIP2200   uint64 = 2300  // Minimum gas required to be present for an SSTORE call, not consumed
    	SstoreNoopGasEIP2200     uint64 = 800   // Once per SSTORE operation if the value doesn't change.
    	SstoreDirtyGasEIP2200    uint64 = 800   // Once per SSTORE operation if a dirty value is changed.
    	SstoreInitGasEIP2200     uint64 = 20000 // Once per SSTORE operation from clean zero to non-zero
    	SstoreInitRefundEIP2200  uint64 = 19200 // Once per SSTORE operation for resetting to the original zero value
    	SstoreCleanGasEIP2200    uint64 = 5000  // Once per SSTORE operation from clean non-zero to something else
    	SstoreCleanRefundEIP2200 uint64 = 4200  // Once per SSTORE operation for resetting to the original non-zero value
    	SstoreClearRefundEIP2200 uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot
    
    	JumpdestGas   uint64 = 1     // Once per JUMPDEST operation.
    	EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.
    
    	CreateDataGas            uint64 = 200   //
    	CallCreateDepth          uint64 = 1024  // Maximum depth of call/create stack.
    	ExpGas                   uint64 = 10    // Once per EXP instruction
    	LogGas                   uint64 = 375   // Per LOG* operation.
    	CopyGas                  uint64 = 3     //
    	StackLimit               uint64 = 1024  // Maximum size of VM stack allowed.
    	TierStepGas              uint64 = 0     // Once per operation, for a selection of them.
    	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                uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
    	Create2Gas               uint64 = 32000 // Once per CREATE2 operation
    	SelfdestructRefundGas    uint64 = 24000 // Refunded following a selfdestruct operation.
    	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.
    	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  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 = 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
    )
    View Source
    const (
    	VersionMajor = 1        // Major version component of the current release
    	VersionMinor = 9        // Minor version component of the current release
    	VersionPatch = 11       // Patch version component of the current release
    	VersionMeta  = "stable" // Version metadata to append to the version string
    )

    Variables

    View Source
    var (
    	MainnetGenesisHash = common.HexToHash("0x5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
    	TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
    	RinkebyGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177")
    	GoerliGenesisHash  = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a")
    )

      Genesis hashes to enforce below configs on.

      View Source
      var (
      	// MainnetChainConfig is the chain parameters to run a node on the main network.
      	MainnetChainConfig = &ChainConfig{
      		ChainID:             big.NewInt(3125659152),
      		HomesteadBlock:      big.NewInt(0),
      		DAOForkBlock:        nil,
      		DAOForkSupport:      true,
      		EIP150Block:         big.NewInt(0),
      		EIP150Hash:          common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
      		EIP155Block:         big.NewInt(0),
      		EIP158Block:         big.NewInt(0),
      		ByzantiumBlock:      nil,
      		ConstantinopleBlock: nil,
      		PetersburgBlock:     nil,
      		IstanbulBlock:       big.NewInt(9069000),
      		MuirGlacierBlock:    big.NewInt(9200000),
      		Ethash:              new(EthashConfig),
      	}
      
      	// MainnetTrustedCheckpoint contains the light client trusted checkpoint for the main network.
      	MainnetTrustedCheckpoint = &TrustedCheckpoint{
      		SectionIndex: 289,
      		SectionHead:  common.HexToHash("0x918da105270860fba90f96134b1ab3b27d2052a814d9cb9f4fbe69f42a20b07e"),
      		CHTRoot:      common.HexToHash("0x1c89c2e3e2fb3ea12c5e6ed755c7bc75f5f91d0275e1e59e70d91705098ed49f"),
      		BloomRoot:    common.HexToHash("0x64a5ac8e306cf5372bbe06049f0769d0a7364a0a42af215ba62dd8f2db60b2eb"),
      	}
      
      	// MainnetCheckpointOracle contains a set of configs for the main network oracle.
      	MainnetCheckpointOracle = &CheckpointOracleConfig{
      		Address: common.HexToAddress("0x9a9070028361F7AAbeB3f2F2Dc07F82C4a98A02a"),
      		Signers: []common.Address{
      			common.HexToAddress("0x1b2C260efc720BE89101890E4Db589b44E950527"),
      			common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"),
      			common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"),
      			common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"),
      			common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"),
      		},
      		Threshold: 2,
      	}
      
      	// TestnetChainConfig contains the chain parameters to run a node on the Ropsten test network.
      	TestnetChainConfig = &ChainConfig{
      		ChainID:             big.NewInt(3),
      		HomesteadBlock:      big.NewInt(0),
      		DAOForkBlock:        nil,
      		DAOForkSupport:      true,
      		EIP150Block:         big.NewInt(0),
      		EIP150Hash:          common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"),
      		EIP155Block:         big.NewInt(10),
      		EIP158Block:         big.NewInt(10),
      		ByzantiumBlock:      big.NewInt(1700000),
      		ConstantinopleBlock: big.NewInt(4230000),
      		PetersburgBlock:     big.NewInt(4939394),
      		IstanbulBlock:       big.NewInt(6485846),
      		MuirGlacierBlock:    big.NewInt(7117117),
      		Ethash:              new(EthashConfig),
      	}
      
      	// TestnetTrustedCheckpoint contains the light client trusted checkpoint for the Ropsten test network.
      	TestnetTrustedCheckpoint = &TrustedCheckpoint{
      		SectionIndex: 223,
      		SectionHead:  common.HexToHash("0x9aa51ca383f5075f816e0b8ce7125075cd562b918839ee286c03770722147661"),
      		CHTRoot:      common.HexToHash("0x755c6a5931b7bd36e55e47f3f1e81fa79c930ae15c55682d3a85931eedaf8cf2"),
      		BloomRoot:    common.HexToHash("0xabc37762d11b29dc7dde11b89846e2308ba681eeb015b6a202ef5e242bc107e8"),
      	}
      
      	// TestnetCheckpointOracle contains a set of configs for the Ropsten test network oracle.
      	TestnetCheckpointOracle = &CheckpointOracleConfig{
      		Address: common.HexToAddress("0xEF79475013f154E6A65b54cB2742867791bf0B84"),
      		Signers: []common.Address{
      			common.HexToAddress("0x32162F3581E88a5f62e8A61892B42C46E2c18f7b"),
      			common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"),
      			common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"),
      			common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"),
      			common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"),
      		},
      		Threshold: 2,
      	}
      
      	// RinkebyChainConfig contains the chain parameters to run a node on the Rinkeby test network.
      	RinkebyChainConfig = &ChainConfig{
      		ChainID:             big.NewInt(4),
      		HomesteadBlock:      big.NewInt(1),
      		DAOForkBlock:        nil,
      		DAOForkSupport:      true,
      		EIP150Block:         big.NewInt(2),
      		EIP150Hash:          common.HexToHash("0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"),
      		EIP155Block:         big.NewInt(3),
      		EIP158Block:         big.NewInt(3),
      		ByzantiumBlock:      big.NewInt(1035301),
      		ConstantinopleBlock: big.NewInt(3660663),
      		PetersburgBlock:     big.NewInt(4321234),
      		IstanbulBlock:       big.NewInt(5435345),
      		Clique: &CliqueConfig{
      			Period: 15,
      			Epoch:  30000,
      		},
      	}
      
      	// RinkebyTrustedCheckpoint contains the light client trusted checkpoint for the Rinkeby test network.
      	RinkebyTrustedCheckpoint = &TrustedCheckpoint{
      		SectionIndex: 181,
      		SectionHead:  common.HexToHash("0xdda275f3e9ecadf4834a6a682db1ca3db6945fa4014c82dadcad032fc5c1aefa"),
      		CHTRoot:      common.HexToHash("0x0fdfdbdb12e947e838fe26dd3ada4cc3092d6fa22aefec719b83f16004b5e596"),
      		BloomRoot:    common.HexToHash("0xfd8dc404a438eaa5cf93dd58dbaeed648aa49d563b511892262acff77c5db7db"),
      	}
      
      	// RinkebyCheckpointOracle contains a set of configs for the Rinkeby test network oracle.
      	RinkebyCheckpointOracle = &CheckpointOracleConfig{
      		Address: common.HexToAddress("0xebe8eFA441B9302A0d7eaECc277c09d20D684540"),
      		Signers: []common.Address{
      			common.HexToAddress("0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3"),
      			common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"),
      			common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"),
      			common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"),
      		},
      		Threshold: 2,
      	}
      
      	// GoerliChainConfig contains the chain parameters to run a node on the Görli test network.
      	GoerliChainConfig = &ChainConfig{
      		ChainID:             big.NewInt(5),
      		HomesteadBlock:      big.NewInt(0),
      		DAOForkBlock:        nil,
      		DAOForkSupport:      true,
      		EIP150Block:         big.NewInt(0),
      		EIP155Block:         big.NewInt(0),
      		EIP158Block:         big.NewInt(0),
      		ByzantiumBlock:      big.NewInt(0),
      		ConstantinopleBlock: big.NewInt(0),
      		PetersburgBlock:     big.NewInt(0),
      		IstanbulBlock:       big.NewInt(1561651),
      		Clique: &CliqueConfig{
      			Period: 15,
      			Epoch:  30000,
      		},
      	}
      
      	// GoerliTrustedCheckpoint contains the light client trusted checkpoint for the Görli test network.
      	GoerliTrustedCheckpoint = &TrustedCheckpoint{
      		SectionIndex: 66,
      		SectionHead:  common.HexToHash("0xeea3a7b2cb275956f3049dd27e6cdacd8a6ef86738d593d556efee5361019475"),
      		CHTRoot:      common.HexToHash("0x11712af50b4083dc5910e452ca69fbfc0f2940770b9846200a573f87a0af94e6"),
      		BloomRoot:    common.HexToHash("0x331b7a7b273e81daeac8cafb9952a16669d7facc7be3b0ebd3a792b4d8b95cc5"),
      	}
      
      	// GoerliCheckpointOracle contains a set of configs for the Goerli test network oracle.
      	GoerliCheckpointOracle = &CheckpointOracleConfig{
      		Address: common.HexToAddress("0x18CA0E045F0D772a851BC7e48357Bcaab0a0795D"),
      		Signers: []common.Address{
      			common.HexToAddress("0x4769bcaD07e3b938B7f43EB7D278Bc7Cb9efFb38"),
      			common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"),
      			common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"),
      			common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"),
      			common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"),
      		},
      		Threshold: 2,
      	}
      
      	// AllEthashProtocolChanges contains every protocol change (EIPs) introduced
      	// and accepted by the Ethereum core developers into the Ethash consensus.
      	//
      	// This configuration is intentionally not using keyed fields to force anyone
      	// adding flags to the config to also have to set these fields.
      	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), nil, nil, new(EthashConfig), nil}
      
      	// AllCliqueProtocolChanges contains every protocol change (EIPs) introduced
      	// and accepted by the Ethereum core developers into the Clique consensus.
      	//
      	// This configuration is intentionally not using keyed fields to force anyone
      	// adding flags to the config to also have to set these fields.
      	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), nil, nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
      
      	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), nil, nil, new(EthashConfig), nil}
      	TestRules       = TestChainConfig.Rules(new(big.Int))
      )
      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.
      	DurationLimithulk      = big.NewInt(8)      // The decision boundary on the blocktime duration used to determine whether difficulty should go up or not.
      	//TimeCapsuleBlock  = int64(2399820)
      	// block we will fork for the 51
      	TimeCapsuleBlock = int64(2403186)
      	// block we will fork for the 51
      	TimeCapsuleLength        = uint64(20)     // Threshold of blocks that can be delayed and the value is in Blocks
      	PirlGuardActivationBlock = int64(2442442) // Fork Block TODO change this to PirlGuardActivationBlock makes more sense
      	PirlGuardBlockLength     = uint64(20)     // Global Confirmation Time so everything is inside the PirlGuard limit. TODO change this to PirlGuardBlockLength
      	ForkBlockDoDo            = uint64(3605010)
      	ForkingDodoAddr          = "0xc2aaef63f4a9707debe5c05dfae2f65661ff4974"
      	CarbonVoteTopia          = uint64(3911500)
      )

        CheckpointOracles associates each known checkpoint oracles with the genesis hash of the chain it belongs to.

        View Source
        var DAOForkBlockExtra = common.FromHex("0x64616f2d686172642d666f726b")

          DAOForkBlockExtra is the block header extra-data field to set for the DAO fork point and a number of consecutive blocks to allow fast/light syncers to correctly pick the side they want ("dao-hard-fork").

          View Source
          var DAOForkExtraRange = big.NewInt(10)

            DAOForkExtraRange is the number of consecutive blocks from the DAO fork point to override the extra-data in to prevent no-fork attacks.

            View Source
            var DAORefundContract = common.HexToAddress("0xbf4ed7b27f1d666546e30d74d50d173d20bca754")

              DAORefundContract is the address of the refund contract to send DAO balances to.

              View Source
              var DiscoveryV5Bootnodes = []string{
              	"enode://06051a5573c81934c9554ef2898eb13b33a34b94cf36b202b69fde139ca17a85051979867720d4bdae4323d4943ddf9aeeb6643633aa656e0be843659795007a@35.177.226.168:30303",
              	"enode://0cc5f5ffb5d9098c8b8c62325f3797f56509bff942704687b6530992ac706e2cb946b90a34f1f19548cd3c7baccbcaea354531e5983c7d1bc0dee16ce4b6440b@40.118.3.223:30304",
              	"enode://1c7a64d76c0334b0418c004af2f67c50e36a3be60b5e4790bdac0439d21603469a85fad36f2473c9a80eb043ae60936df905fa28f1ff614c3e5dc34f15dcd2dc@40.118.3.223:30306",
              	"enode://85c85d7143ae8bb96924f2b54f1b3e70d8c4d367af305325d30a61385a432f247d2c75c45c6b4a60335060d072d7f5b35dd1d4c45f76941f62a4f83b6e75daaf@40.118.3.223:30307",
              }

                DiscoveryV5Bootnodes are the enode URLs of the P2P bootstrap nodes for the experimental RLPx v5 topic-discovery network.

                View Source
                var GoerliBootnodes = []string{
                
                	"enode://011f758e6552d105183b1761c5e2dea0111bc20fd5f6422bc7f91e0fabbec9a6595caf6239b37feb773dddd3f87240d99d859431891e4a642cf2a0a9e6cbb98a@51.141.78.53:30303",
                	"enode://176b9417f511d05b6b2cf3e34b756cf0a7096b3094572a8f6ef4cdcb9d1f9d00683bf0f83347eebdf3b81c3521c2332086d9592802230bf528eaf606a1d9677b@13.93.54.137:30303",
                	"enode://46add44b9f13965f7b9875ac6b85f016f341012d84f975377573800a863526f4da19ae2c620ec73d11591fa9510e992ecc03ad0751f53cc02f7c7ed6d55c7291@94.237.54.114:30313",
                	"enode://c1f8b7c2ac4453271fa07d8e9ecf9a2e8285aa0bd0c07df0131f47153306b0736fd3db8924e7a9bf0bed6b1d8d4f87362a71b033dc7c64547728d953e43e59b2@52.64.155.147:30303",
                	"enode://f4a9c6ee28586009fb5a96c8af13a58ed6d8315a9eee4772212c1d4d9cebe5a8b8a78ea4434f318726317d04a3f531a1ef0420cf9752605a562cfe858c46e263@213.186.16.82:30303",
                
                	"enode://a61215641fb8714a373c80edbfa0ea8878243193f57c96eeb44d0bc019ef295abd4e044fd619bfc4c59731a73fb79afe84e9ab6da0c743ceb479cbb6d263fa91@3.11.147.67:30303",
                }

                  GoerliBootnodes are the enode URLs of the P2P bootstrap nodes running on the Görli test network.

                  View Source
                  var KnownDNSNetworks = map[common.Hash]string{
                  	MainnetGenesisHash: dnsPrefix + "all.mainnet.ethdisco.net",
                  	TestnetGenesisHash: dnsPrefix + "all.ropsten.ethdisco.net",
                  	RinkebyGenesisHash: dnsPrefix + "all.rinkeby.ethdisco.net",
                  	GoerliGenesisHash:  dnsPrefix + "all.goerli.ethdisco.net",
                  }

                    These DNS names provide bootstrap connectivity for public testnets and the mainnet. See https://github.com/ethereum/discv4-dns-lists for more information.

                    View Source
                    var MainnetBootnodes = []string{
                    
                    	"enode://33992f6c62498272d677ae721cdf606a2fbfeb7b1ed2d89a1b432f7945078f4de60cb7e130e1d74b59148863089e52c9c1c7cd1c0ad2e2fa8e95df9e3b858a26@213.32.72.24:30303",
                    	"enode://a4cc2d78255f5eda16527c5566cbcb12f3bae7efe748c787206ad7c2028ad53690a634c9cc40067ad0c13547df721bea23862022817c330988f33fcba7ed03fe@139.59.244.73:30303",
                    	"enode://e28ce45258c481f04be8f84fb9b3ce3906bb54251b17ef957e18afb22a4ac4f784bf39adc5069deec1ca99ee41f02d59d0cb64677bbe661e1e6979da2b7c5276@137.74.31.30:30303",
                    	"enode://59ddbcb6ea8f59f99c5436dafd0560434fa835f3f835060fc1c1babbbf56be1527b1669b50bdb30cb611d085a4a5c6e16e4e72bf721e7da5253cf8e2769e9e94@54.39.181.185:30303",
                    	"enode://7744086e3ffa81f24b046c0d40de48f1b397174428f7e831aa66a3a7acb70cba9d27cb4fb490c002e576b64e21b202aa59179789b9af80183470af68dcd8f555@54.36.114.205:30303",
                    	"enode://7374c07c42eb2767b4da977ee8cc0d63a760be0311a218513e5f98b96df9cfd4c7b105e5a772f4d642617974437636637f3047a65869116ebf0bb15559afe5f3@51.75.193.83:30303",
                    	"enode://e3b014fef0914f599e7c8046068ef6f06aee457ee7ff94c4df3c395d9cc0f0469ec57d207a0a732d062e777604290652bd2753d2d32616a72f53418ad7acbd1f@51.75.169.35:30303",
                    	"enode://805290942d7d2abd761356624aac90914a180195a6877826ec1549f54880501227fab28ee8649ae7d0c5067ec0000d935a90065f0bdcb97a13499709afcbb7e1@51.75.62.167:30303",
                    	"enode://67572ef5994de853c57ff521146d24136412510b1fb9d4fd8b5c606d3acd326bab70251a352b6e5b4c05fccc964e41191ca6c1ac36eb7d0c2abc1cf83021a132@139.59.95.243:30303",
                    	"enode://095f192be56f68c11166f231fa270233599d7373df3ceadc578f09117d5f50bdbb13777bb52fb0392ddaadc1a889bc1003da52d2f2b8a6b0bce59dcdd23f2a13@139.59.244.73:30303",
                    }

                      MainnetBootnodes are the enode URLs of the P2P bootstrap nodes running on the main Ethereum network.

                      View Source
                      var RinkebyBootnodes = []string{
                      	"enode://a24ac7c5484ef4ed0c5eb2d36620ba4e4aa13b8c84684e1b4aab0cebea2ae45cb4d375b77eab56516d34bfbd3c1a833fc51296ff084b770b94fb9028c4d25ccf@52.169.42.101:30303",
                      	"enode://343149e4feefa15d882d9fe4ac7d88f885bd05ebb735e547f12e12080a9fa07c8014ca6fd7f373123488102fe5e34111f8509cf0b7de3f5b44339c9f25e87cb8@52.3.158.184:30303",
                      	"enode://b6b28890b006743680c52e64e0d16db57f28124885595fa03a562be1d2bf0f3a1da297d56b13da25fb992888fd556d4c1a27b1f39d531bde7de1921c90061cc6@159.89.28.211:30303",
                      }

                        RinkebyBootnodes are the enode URLs of the P2P bootstrap nodes running on the Rinkeby test network.

                        View Source
                        var TestnetBootnodes = []string{
                        	"enode://30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606@52.176.7.10:30303",
                        	"enode://865a63255b3bb68023b6bffd5095118fcc13e79dcf014fe4e47e065c350c7cc72af2e53eff895f11ba1bbb6a2b33271c1116ee870f266618eadfc2e78aa7349c@52.176.100.77:30303",
                        	"enode://6332792c4a00e3e4ee0926ed89e0d27ef985424d97b6a45bf0f23e51f0dcb5e66b875777506458aea7af6f9e4ffb69f43f3778ee73c81ed9d34c51c4b16b0b0f@52.232.243.152:30303",
                        	"enode://94c15d1b9e2fe7ce56e458b9a3b672ef11894ddedd0c6f247e0f1d3487f52b66208fb4aeb8179fce6e3a749ea93ed147c37976d67af557508d199d9594c35f09@192.81.208.223:30303",
                        }

                          TestnetBootnodes are the enode URLs of the P2P bootstrap nodes running on the Ropsten test network.

                            TrustedCheckpoints associates each known checkpoint with the genesis hash of the chain it belongs to.

                            View Source
                            var Version = func() string {
                            	return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
                            }()

                              Version holds the textual version string.

                              View Source
                              var VersionWithMeta = func() string {
                              	v := Version
                              	if VersionMeta != "" {
                              		v += "-" + VersionMeta
                              	}
                              	return v
                              }()

                                VersionWithMeta holds the textual version string including the metadata.

                                Functions

                                func ArchiveVersion

                                func ArchiveVersion(gitCommit string) string

                                  ArchiveVersion holds the textual version string used for Geth archives. e.g. "1.8.11-dea1ce05" for stable releases, or

                                  "1.8.13-unstable-21c059b6" for unstable releases
                                  

                                  func DAODrainList

                                  func DAODrainList() []common.Address

                                    DAODrainList is the list of accounts whose full balances will be moved into a refund contract at the beginning of the dao-fork block.

                                    func VersionWithCommit

                                    func VersionWithCommit(gitCommit, gitDate string) string

                                    Types

                                    type ChainConfig

                                    type ChainConfig struct {
                                    	ChainID *big.Int `json:"chainId"` // chainId identifies the current chain and is used for replay protection
                                    
                                    	HomesteadBlock *big.Int `json:"homesteadBlock,omitempty"` // Homestead switch block (nil = no fork, 0 = already homestead)
                                    
                                    	DAOForkBlock   *big.Int `json:"daoForkBlock,omitempty"`   // TheDAO hard-fork switch block (nil = no fork)
                                    	DAOForkSupport bool     `json:"daoForkSupport,omitempty"` // Whether the nodes supports or opposes the DAO hard-fork
                                    
                                    	// EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
                                    	EIP150Block *big.Int    `json:"eip150Block,omitempty"` // EIP150 HF block (nil = no fork)
                                    	EIP150Hash  common.Hash `json:"eip150Hash,omitempty"`  // EIP150 HF hash (needed for header only clients as only gas pricing changed)
                                    
                                    	EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block
                                    	EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block
                                    
                                    	ByzantiumBlock      *big.Int `json:"byzantiumBlock,omitempty"`      // Byzantium switch block (nil = no fork, 0 = already on byzantium)
                                    	ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated)
                                    	PetersburgBlock     *big.Int `json:"petersburgBlock,omitempty"`     // Petersburg switch block (nil = same as Constantinople)
                                    	IstanbulBlock       *big.Int `json:"istanbulBlock,omitempty"`       // Istanbul switch block (nil = no fork, 0 = already on istanbul)
                                    	MuirGlacierBlock    *big.Int `json:"muirGlacierBlock,omitempty"`    // Eip-2384 (bomb delay) switch block (nil = no fork, 0 = already activated)
                                    	EWASMBlock          *big.Int `json:"ewasmBlock,omitempty"`          // EWASM switch block (nil = no fork, 0 = already activated)
                                    
                                    	// Various consensus engines
                                    	Ethash *EthashConfig `json:"ethash,omitempty"`
                                    	Clique *CliqueConfig `json:"clique,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) CheckCompatible

                                      func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64) *ConfigCompatError

                                        CheckCompatible checks whether scheduled fork transitions have been imported with a mismatching chain configuration.

                                        func (*ChainConfig) CheckConfigForkOrder

                                        func (c *ChainConfig) CheckConfigForkOrder() error

                                          CheckConfigForkOrder checks that we don't "skip" any forks, geth isn't pluggable enough to guarantee that forks can be implemented in a different order than on official networks

                                          func (*ChainConfig) IsByzantium

                                          func (c *ChainConfig) IsByzantium(num *big.Int) bool

                                            IsByzantium returns whether num is either equal to the Byzantium fork block or greater.

                                            func (*ChainConfig) IsConstantinople

                                            func (c *ChainConfig) IsConstantinople(num *big.Int) bool

                                              IsConstantinople returns whether num is either equal to the Constantinople fork block or greater.

                                              func (*ChainConfig) IsDAOFork

                                              func (c *ChainConfig) IsDAOFork(num *big.Int) bool

                                                IsDAOFork returns whether num is either equal to the DAO fork block or greater.

                                                func (*ChainConfig) IsEIP150

                                                func (c *ChainConfig) IsEIP150(num *big.Int) bool

                                                  IsEIP150 returns whether num is either equal to the EIP150 fork block or greater.

                                                  func (*ChainConfig) IsEIP155

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

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

                                                    func (*ChainConfig) IsEIP158

                                                    func (c *ChainConfig) IsEIP158(num *big.Int) bool

                                                      IsEIP158 returns whether num is either equal to the EIP158 fork block or greater.

                                                      func (*ChainConfig) IsEWASM

                                                      func (c *ChainConfig) IsEWASM(num *big.Int) bool

                                                        IsEWASM returns whether num represents a block number after the EWASM fork

                                                        func (*ChainConfig) IsHomestead

                                                        func (c *ChainConfig) IsHomestead(num *big.Int) bool

                                                          IsHomestead returns whether num is either equal to the homestead block or greater.

                                                          func (*ChainConfig) IsIstanbul

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

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

                                                            func (*ChainConfig) IsMuirGlacier

                                                            func (c *ChainConfig) IsMuirGlacier(num *big.Int) bool

                                                              IsMuirGlacier returns whether num is either equal to the Muir Glacier (EIP-2384) fork block or greater.

                                                              func (*ChainConfig) IsPetersburg

                                                              func (c *ChainConfig) IsPetersburg(num *big.Int) bool

                                                                IsPetersburg returns whether num is either - equal to or greater than the PetersburgBlock fork block, - OR is nil, and Constantinople is active

                                                                func (*ChainConfig) Rules

                                                                func (c *ChainConfig) Rules(num *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 CheckpointOracleConfig

                                                                    type CheckpointOracleConfig struct {
                                                                    	Address   common.Address   `json:"address"`
                                                                    	Signers   []common.Address `json:"signers"`
                                                                    	Threshold uint64           `json:"threshold"`
                                                                    }

                                                                      CheckpointOracleConfig represents a set of checkpoint contract(which acts as an oracle) config which used for light client checkpoint syncing.

                                                                      type CliqueConfig

                                                                      type CliqueConfig struct {
                                                                      	Period uint64 `json:"period"` // Number of seconds between blocks to enforce
                                                                      	Epoch  uint64 `json:"epoch"`  // Epoch length to reset votes and checkpoint
                                                                      }

                                                                        CliqueConfig is the consensus engine configs for proof-of-authority based sealing.

                                                                        func (*CliqueConfig) String

                                                                        func (c *CliqueConfig) String() string

                                                                          String implements the stringer interface, returning the consensus engine details.

                                                                          type ConfigCompatError

                                                                          type ConfigCompatError struct {
                                                                          	What string
                                                                          	// block numbers of the stored and new configurations
                                                                          	StoredConfig, NewConfig *big.Int
                                                                          	// the block number to which the local chain must be rewound to correct the error
                                                                          	RewindTo uint64
                                                                          }

                                                                            ConfigCompatError is raised if the locally-stored blockchain is initialised with a ChainConfig that would alter the past.

                                                                            func (*ConfigCompatError) Error

                                                                            func (err *ConfigCompatError) Error() string

                                                                            type EthashConfig

                                                                            type EthashConfig struct{}

                                                                              EthashConfig is the consensus engine configs for proof-of-work based sealing.

                                                                              func (*EthashConfig) String

                                                                              func (c *EthashConfig) String() string

                                                                                String implements the stringer interface, returning the consensus engine details.

                                                                                type Rules

                                                                                type Rules struct {
                                                                                	ChainID                                                 *big.Int
                                                                                	IsHomestead, IsEIP150, IsEIP155, IsEIP158               bool
                                                                                	IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul 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 {
                                                                                  	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.

                                                                                    func (*TrustedCheckpoint) Empty

                                                                                    func (c *TrustedCheckpoint) Empty() bool

                                                                                      Empty returns an indicator whether the checkpoint is regarded as empty.

                                                                                      func (*TrustedCheckpoint) Hash

                                                                                      func (c *TrustedCheckpoint) Hash() common.Hash

                                                                                        Hash returns the hash of checkpoint's four key fields(index, sectionHead, chtRoot and bloomTrieRoot).

                                                                                        func (*TrustedCheckpoint) HashEqual

                                                                                        func (c *TrustedCheckpoint) HashEqual(hash common.Hash) bool

                                                                                          HashEqual returns an indicator comparing the itself hash with given one.