params

package
v1.3.1 Latest Latest
Warning

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

 Go to latest Published: Feb 13, 2020 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

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

	// CHTFrequencyClient is the block frequency for creating CHTs on the client side.
	CHTFrequencyClient = 32768

	// CHTFrequencyServer is the block frequency for creating CHTs on the server side.
	// Eventually this can be merged back with the client version, but that requires a
	// full database upgrade, so that should be left for a suitable moment.
	CHTFrequencyServer = 4096

	// 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
)
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.

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

	// 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
	// SuicideRefundGas ...
	SuicideRefundGas uint64 = 24000 // Refunded following a suicide 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 ...
	TxDataNonZeroGas 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.

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

	// EcrecoverGas ...
	EcrecoverGas uint64 = 3000 // Elliptic curve sender recovery gas price
	// Sha256BaseGas ...
	Sha256BaseGas uint64 = 60 // Base price for a SHA256 operation
	// Sha256PerWordGas ...
	Sha256PerWordGas uint64 = 12 // Per-word price for a SHA256 operation
	// Ripemd160BaseGas ...
	Ripemd160BaseGas uint64 = 600 // Base price for a RIPEMD160 operation
	// Ripemd160PerWordGas ...
	Ripemd160PerWordGas uint64 = 120 // Per-word price for a RIPEMD160 operation
	// IdentityBaseGas ...
	IdentityBaseGas uint64 = 15 // Base price for a data copy operation
	// IdentityPerWordGas ...
	IdentityPerWordGas uint64 = 3 // Per-work price for a data copy operation
	// ModExpQuadCoeffDiv ...
	ModExpQuadCoeffDiv uint64 = 20 // Divisor for the quadratic particle of the big int modular exponentiation
	// Bn256AddGas ...
	Bn256AddGas uint64 = 500 // Gas needed for an elliptic curve addition
	// Bn256ScalarMulGas ...
	Bn256ScalarMulGas uint64 = 40000 // Gas needed for an elliptic curve scalar multiplication
	// Bn256PairingBaseGas ...
	Bn256PairingBaseGas uint64 = 100000 // Base price for an elliptic curve pairing check
	// Bn256PairingPerPointGas ...
	Bn256PairingPerPointGas uint64 = 80000 // Per-point price for an elliptic curve pairing check
)

Variables

View Source 
var (
	MainnetChainID            = big.NewInt(1)
	TestnetChainID            = big.NewInt(2)
	PangaeaChainID            = big.NewInt(3)
	TestChainID               = big.NewInt(99)  // not a real network
	AllProtocolChangesChainID = big.NewInt(100) // 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,
		CrossTxEpoch:    big.NewInt(28),
		CrossLinkEpoch:  EpochTBD,
		StakingEpoch:    EpochTBD,
		PreStakingEpoch: EpochTBD,
		EIP155Epoch:     big.NewInt(28),
		S3Epoch:         big.NewInt(28),
	}

	// TestnetChainConfig contains the chain parameters to run a node on the harmony test network.
	TestnetChainConfig = &ChainConfig{
		ChainID:         TestnetChainID,
		CrossTxEpoch:    big.NewInt(0),
		CrossLinkEpoch:  big.NewInt(3),
		StakingEpoch:    big.NewInt(4),
		PreStakingEpoch: big.NewInt(2),
		EIP155Epoch:     big.NewInt(0),
		S3Epoch:         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,
		CrossTxEpoch:    big.NewInt(0),
		CrossLinkEpoch:  big.NewInt(2),
		StakingEpoch:    big.NewInt(3),
		PreStakingEpoch: big.NewInt(0),
		EIP155Epoch:     big.NewInt(0),
		S3Epoch:         big.NewInt(0),
	}

	// LocalnetChainConfig contains the chain parameters to run for local development.
	LocalnetChainConfig = &ChainConfig{
		ChainID:         TestnetChainID,
		CrossTxEpoch:    big.NewInt(0),
		CrossLinkEpoch:  big.NewInt(3),
		StakingEpoch:    big.NewInt(4),
		PreStakingEpoch: big.NewInt(2),
		EIP155Epoch:     big.NewInt(0),
		S3Epoch:         big.NewInt(0),
	}

	// 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,
		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,
		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 harmony phases.

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

This section is empty.

Types

type ChainConfig 

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

	// 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"`

	// 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"`

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

	// S3 epoch is the first epoch containing S3 mainnet and all ethereum update up to Constantinople
	S3Epoch *big.Int `json:"s3-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 added in v1.3.0 

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) 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) 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 added in v1.3.0 

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

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

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

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

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) IsPreStaking added in v1.3.0 

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

IsPreStaking determines whether staking transactions are allowed

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) IsStaking added in v1.3.0 

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

IsStaking determines whether it is staking epoch

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 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 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 harmony phases.

type Rules 

type Rules struct {
	ChainID                     *big.Int
	IsCrossLink, IsEIP155, IsS3 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.