params

package
v0.0.0-...-9aa8d79 Latest Latest
Warning

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

 Go to latest Published: Dec 29, 2020 License: GPL-3.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Marley         = 1
	Maher          = 1e9
	Fourtwentycoin = 1e18
)

These are the multipliers for 420coin denominations. Example: To get the marley value of an amount in 'mahers', use 

new(big.Int).Mul(value, big.NewInt(params.GMarley))
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

	// FullImmutabilityThreshold 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 threshold and by clique as the snapshot trust limit.
	FullImmutabilityThreshold = 90000

	// LightImmutabilityThreshold is the number of blocks after which a header chain
	// segment is considered immutable for light client(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 light pruner as the pruning validity guarantee.
	LightImmutabilityThreshold = 30000
)
View Source 
const (
	SmokeLimitBoundDivisor uint64 = 1024    // The bound divisor of the smoke limit, used in update calculations.
	MinSmokeLimit          uint64 = 5000    // Minimum the smoke limit may ever be.
	GenesisSmokeLimit      uint64 = 5000000 // Smoke limit of the Genesis block.

	MaximumExtraDataSize    uint64 = 32    // Maximum size extra data may be after Genesis.
	ExpByteSmoke            uint64 = 10    // Times ceil(log256(exponent)) for the EXP instruction.
	SloadSmoke              uint64 = 50    // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
	CallValueTransferSmoke  uint64 = 9000  // Paid for CALL when the value transfer is non-zero.
	CallNewAccountSmoke     uint64 = 25000 // Paid for CALL when the destination address didn't exist prior.
	TxSmoke                 uint64 = 20000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
	TxSmokeContractCreation uint64 = 50000 // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
	TxDataZeroSmoke         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.
	LogDataSmoke            uint64 = 8     // Per byte in a LOG* operation's data.
	CallStipend             uint64 = 2300  // Free smoke given at beginning of call.

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

	SstoreSetSmoke    uint64 = 20000 // Once per SLOAD operation.
	SstoreResetSmoke  uint64 = 5000  // Once per SSTORE operation if the zeroness changes from zero.
	SstoreClearSmoke  uint64 = 5000  // Once per SSTORE operation if the zeroness doesn't change.
	SstoreRefundSmoke uint64 = 15000 // Once per SSTORE operation if the zeroness changes to zero.

	NetSstoreNoopSmoke  uint64 = 200   // Once per SSTORE operation if the value doesn't change.
	NetSstoreInitSmoke  uint64 = 20000 // Once per SSTORE operation from clean zero.
	NetSstoreCleanSmoke uint64 = 5000  // Once per SSTORE operation from clean non-zero.
	NetSstoreDirtySmoke 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

	SstoreSentrySmokeEIP2200          uint64 = 2300  // Minimum smoke required to be present for an SSTORE call, not consumed
	SstoreSetSmokeEIP2200             uint64 = 20000 // Once per SSTORE operation from clean zero to non-zero
	SstoreResetSmokeEIP2200           uint64 = 5000  // Once per SSTORE operation from clean non-zero to something else
	SstoreClearsScheduleRefundEIP2200 uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot

	JumpdestSmoke uint64 = 1     // Once per JUMPDEST operation.
	EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.

	CreateDataSmoke            uint64 = 200   //
	CallCreateDepth            uint64 = 1024  // Maximum depth of call/create stack.
	ExpSmoke                   uint64 = 10    // Once per EXP instruction
	LogSmoke                   uint64 = 375   // Per LOG* operation.
	CopySmoke                  uint64 = 3     //
	StackLimit                 uint64 = 1024  // Maximum size of VM stack allowed.
	TierStepSmoke              uint64 = 0     // Once per operation, for a selection of them.
	LogTopicSmoke              uint64 = 375   // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicSmoke, LOG4 incurs 4 * c_txLogTopicSmoke.
	CreateSmoke                uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
	Create2Smoke               uint64 = 32000 // Once per CREATE2 operation
	SelfdestructRefundSmoke    uint64 = 24000 // Refunded following a selfdestruct operation.
	MemorySmoke                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.
	TxDataNonZeroSmokeFrontier 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.
	TxDataNonZeroSmokeEIP2028  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
	CallSmokeFrontier              uint64 = 40  // Once per CALL operation & message call transaction.
	CallSmokeEIP150                uint64 = 700 // Static portion of smoke for CALL-derivates after EIP 150 (Tangerine)
	BalanceSmokeFrontier           uint64 = 20  // The cost of a BALANCE operation
	BalanceSmokeEIP150             uint64 = 400 // The cost of a BALANCE operation after Tangerine
	BalanceSmokeEIP1884            uint64 = 700 // The cost of a BALANCE operation after EIP 1884 (part of Istanbul)
	ExtcodeSizeSmokeFrontier       uint64 = 20  // Cost of EXTCODESIZE before EIP 150 (Tangerine)
	ExtcodeSizeSmokeEIP150         uint64 = 700 // Cost of EXTCODESIZE after EIP 150 (Tangerine)
	SloadSmokeFrontier             uint64 = 50
	SloadSmokeEIP150               uint64 = 200
	SloadSmokeEIP1884              uint64 = 800  // Cost of SLOAD after EIP 1884 (part of Istanbul)
	SloadSmokeEIP2200              uint64 = 800  // Cost of SLOAD after EIP 2200 (part of Istanbul)
	ExtcodeHashSmokeConstantinople uint64 = 400  // Cost of EXTCODEHASH (introduced in Constantinople)
	ExtcodeHashSmokeEIP1884        uint64 = 700  // Cost of EXTCODEHASH after EIP 1884 (part in Istanbul)
	SelfdestructSmokeEIP150        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 smoke. It was changed during EIP 150 (Tangerine)
	ExtcodeCopyBaseFrontier uint64 = 20
	ExtcodeCopyBaseEIP150   uint64 = 700

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

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

	EcrecoverSmoke        uint64 = 3000 // Elliptic curve sender recovery smoke price
	Sha256BaseSmoke       uint64 = 60   // Base price for a SHA256 operation
	Sha256PerWordSmoke    uint64 = 12   // Per-word price for a SHA256 operation
	Ripemd160BaseSmoke    uint64 = 600  // Base price for a RIPEMD160 operation
	Ripemd160PerWordSmoke uint64 = 120  // Per-word price for a RIPEMD160 operation
	IdentityBaseSmoke     uint64 = 15   // Base price for a data copy operation
	IdentityPerWordSmoke  uint64 = 3    // Per-work price for a data copy operation

	Bn256AddSmokeByzantium             uint64 = 500    // Byzantium smoke needed for an elliptic curve addition
	Bn256AddSmokeIstanbul              uint64 = 150    // Smoke needed for an elliptic curve addition
	Bn256ScalarMulSmokeByzantium       uint64 = 40000  // Byzantium smoke needed for an elliptic curve scalar multiplication
	Bn256ScalarMulSmokeIstanbul        uint64 = 6000   // Smoke needed for an elliptic curve scalar multiplication
	Bn256PairingBaseSmokeByzantium     uint64 = 100000 // Byzantium base price for an elliptic curve pairing check
	Bn256PairingBaseSmokeIstanbul      uint64 = 45000  // Base price for an elliptic curve pairing check
	Bn256PairingPerPointSmokeByzantium uint64 = 80000  // Byzantium per-point price for an elliptic curve pairing check
	Bn256PairingPerPointSmokeIstanbul  uint64 = 34000  // Per-point price for an elliptic curve pairing check

	Bls12381G1AddSmoke          uint64 = 600    // Price for BLS12-381 elliptic curve G1 point addition
	Bls12381G1MulSmoke          uint64 = 12000  // Price for BLS12-381 elliptic curve G1 point scalar multiplication
	Bls12381G2AddSmoke          uint64 = 4500   // Price for BLS12-381 elliptic curve G2 point addition
	Bls12381G2MulSmoke          uint64 = 55000  // Price for BLS12-381 elliptic curve G2 point scalar multiplication
	Bls12381PairingBaseSmoke    uint64 = 115000 // Base smoke price for BLS12-381 elliptic curve pairing check
	Bls12381PairingPerPairSmoke uint64 = 23000  // Per-point pair smoke price for BLS12-381 elliptic curve pairing check
	Bls12381MapG1Smoke          uint64 = 5500   // Smoke price for BLS12-381 mapping field element to G1 operation
	Bls12381MapG2Smoke          uint64 = 110000 // Smoke price for BLS12-381 mapping field element to G2 operation
)
View Source 
const (
	VersionMajor = 1          // Major version component of the current release
	VersionMinor = 9          // Minor version component of the current release
	VersionPatch = 26         // Patch version component of the current release
	VersionMeta  = "unstable" // Version metadata to append to the version string
)

Variables

View Source 
var (
	MainnetGenesisHash   = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
	RuderalisGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
	// TODO: update with yolov2 values
	YoloV2GenesisHash = common.HexToHash("0x498a7239036dd2cd09e2bb8a80922b78632017958c332b42044c250d603a8a3e")
)

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(2020),
		HomesteadBlock:      big.NewInt(0),
		DAOForkBlock:        big.NewInt(0),
		DAOForkSupport:      true,
		EIP150Block:         big.NewInt(0),
		EIP150Hash:          common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
		EIP155Block:         big.NewInt(0),
		EIP158Block:         big.NewInt(0),
		ByzantiumBlock:      big.NewInt(0),
		ConstantinopleBlock: big.NewInt(1),
		PetersburgBlock:     big.NewInt(1),
		IstanbulBlock:       big.NewInt(1),
		MuirGlacierBlock:    big.NewInt(1),
		Ethash:              new(EthashConfig),
	}

	// MainnetTrustedCheckpoint contains the light client trusted checkpoint for the main network.
	MainnetTrustedCheckpoint = &TrustedCheckpoint{
		SectionIndex: 1,
		SectionHead:  common.HexToHash("0xd42b78902b6527a80337bf1bc372a3ccc3db97e9cc7cf421ca047ae9076c716b"),
		CHTRoot:      common.HexToHash("0xd97f3b30f7e0cb958e4c67c53ec27745e5a165e33e56821b86523dfee62b783a"),
		BloomRoot:    common.HexToHash("0xf3cbfd070fababfe2adc9b23fc02c731f6ca2cce6646b3ede4ef2db06092ccce"),
	}

	// 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,
	}

	// RuderalisChainConfig contains the chain parameters to run a node on the Ruderalis test network.
	RuderalisChainConfig = &ChainConfig{
		ChainID:             big.NewInt(2019),
		HomesteadBlock:      big.NewInt(0),
		DAOForkBlock:        nil,
		DAOForkSupport:      true,
		EIP150Block:         big.NewInt(0),
		EIP150Hash:          common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"),
		EIP155Block:         big.NewInt(0),
		EIP158Block:         big.NewInt(0),
		ByzantiumBlock:      big.NewInt(0),
		ConstantinopleBlock: big.NewInt(1),
		PetersburgBlock:     big.NewInt(1),
		IstanbulBlock:       big.NewInt(1),
		MuirGlacierBlock:    big.NewInt(1),
		Ethash:              new(EthashConfig),
	}

	// RuderalisTrustedCheckpoint contains the light client trusted checkpoint for the Ruderalis test network.
	RuderalisTrustedCheckpoint = &TrustedCheckpoint{
		SectionIndex: 1,
		SectionHead:  common.HexToHash("0x290a9eb65e65c64601d1b05522533ed502098a246736b348502a170818a33d64"),
		CHTRoot:      common.HexToHash("0x530ebac02264227277d0a16b0819ef96a2011a6e1e66523ebff8040f4a3437ca"),
		BloomRoot:    common.HexToHash("0x480cd5b3198a0767022902130546854a2e8867cce573c1cf0ce54e67a7bf5efb"),
	}

	// RuderalisCheckpointOracle contains a set of configs for the Ruderalis test network oracle.
	RuderalisCheckpointOracle = &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,
	}

	// YoloV2ChainConfig contains the chain parameters to run a node on the YOLOv2 test network.
	YoloV2ChainConfig = &ChainConfig{
		ChainID:             big.NewInt(13370),
		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(0),
		MuirGlacierBlock:    nil,
		YoloV2Block:         big.NewInt(0),
		Clique: &CliqueConfig{
			Period: 15,
			Epoch:  30000,
		},
	}

	// AllEthashProtocolChanges contains every protocol change (EIPs) introduced
	// and accepted by the 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, 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, nil, &CliqueConfig{Period: 0, Epoch: 30000}}

	TestChainConfig = &ChainConfig{big.NewInt(422), 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, 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(130130) // Difficulty of the Genesis block.
	MinimumDifficulty      = big.NewInt(130130) // The minimum that the difficulty may ever be.
	DurationLimit          = big.NewInt(8)      // The decision boundary on the blocktime duration used to determine if difficulty should go up or not.
	SlowStart              = big.NewInt(1000)   // SlowStart consists of 1000 blocks.
)
View Source 
var Bls12381MultiExpDiscountTable = [128]uint64{} /* 128 elements not displayed */

Smoke discount table for BLS12-381 G1 and G2 multi exponentiation operations

View Source 
var CheckpointOracles = map[common.Hash]*CheckpointOracleConfig{
	MainnetGenesisHash:   MainnetCheckpointOracle,
	RuderalisGenesisHash: RuderalisCheckpointOracle,
}

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 MainnetBootnodes = []string{

	"enode://d860a01f9722d78051619d1e2351aba3f43f943f6f00718d1b9baa4101932a1f5011f16bb2b1bb35db20d6fe28fa0bf09636d26a87d31de9ec6203eeedb1f666@18.138.108.67:13013",
}

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

View Source 
var RuderalisBootnodes = []string{
	"enode://30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606@52.176.7.10:13013",
}

RuderalisBootnodes are the enode URLs of the P2P bootstrap nodes running on the Ruderalis test network.

View Source 
var TrustedCheckpoints = map[common.Hash]*TrustedCheckpoint{
	MainnetGenesisHash:   MainnetTrustedCheckpoint,
	RuderalisGenesisHash: RuderalisTrustedCheckpoint,
}

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.

View Source 
var YoloV2Bootnodes = []string{
	"enode://9e1096aa59862a6f164994cb5cb16f5124d6c992cdbf4535ff7dea43ea1512afe5448dca9df1b7ab0726129603f1a3336b631e4d7a1a44c94daddd03241587f9@3.9.20.133:13013",
}

YoloV2Bootnodes are the enode URLs of the P2P bootstrap nodes running on the YOLOv2 ephemeral test network.

Functions

func ArchiveVersion 

func ArchiveVersion(gitCommit string) string

ArchiveVersion holds the textual version string used for G420 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 KnownDNSNetwork 

func KnownDNSNetwork(genesis common.Hash, protocol string) string

KnownDNSNetwork returns the address of a public DNS-based node list for the given genesis hash and protocol. See https://github.com/420coin/discv4-dns-lists for more information.

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)

	YoloV2Block *big.Int `json:"yoloV2Block,omitempty"` // YOLO v2: Gas repricings TODO @holiman add EIP references
	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, g420 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) IsYoloV2 

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

IsYoloV2 returns whether num is either equal to the YoloV1 fork block or greater.

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
	IsYoloV2                                                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.

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.