params

package
v0.0.0-...-119215d Latest Latest
Warning

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

 Go to latest Published: Jul 16, 2019 License: GPL-3.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// These are the multipliers for ether denominations.
	// Example: To get the wei value of an amount in 'douglas', use
	//
	//    new(big.Int).Mul(value, big.NewInt(params.Douglas))
	//
	Wei     = 1
	Ada     = 1e3
	Babbage = 1e6
	Shannon = 1e9
	//Shannon  = 1e8
	Szabo    = 1e12
	Finney   = 1e15
	Tnb      = 1e18
	Einstein = 1e21
	Douglas  = 1e42
)
View Source 
const (
	GasLimitBoundDivisor uint64 = 2048    // 1024The bound divisor of the gas limit, used in update calculations.
	MinGasLimit          uint64 = 10000   // 5000Minimum the gas limit may ever be.
	GenesisGasLimit      uint64 = 9424776 // 4712388Gas 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 = 18000  // 9000Paid for CALL when the value transfer is non-zero.
	CallNewAccountGas     uint64 = 50000  // 25000Paid for CALL when the destination address didn't exist prior.
	TxGas                 uint64 = 42000  // 21000Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
	TxGasContractCreation uint64 = 106000 // 53000Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
	TxDataZeroGas         uint64 = 8      // 4Per 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.
	SstoreSetGas          uint64 = 40000  // 20000Once per SLOAD operation.
	LogDataGas            uint64 = 16     // 8Per byte in a LOG* operation's data.
	CallStipend           uint64 = 2300   // Free gas given at beginning of call.

	Sha3Gas          uint64 = 60    // 30Once per SHA3 operation.
	Sha3WordGas      uint64 = 12    // 6Once per word of the SHA3 operation's data.
	SstoreResetGas   uint64 = 10000 // 5000Once per SSTORE operation if the zeroness changes from zero.
	SstoreClearGas   uint64 = 10000 // 5000Once per SSTORE operation if the zeroness doesn't change.
	SstoreRefundGas  uint64 = 30000 // 15000Once per SSTORE operation if the zeroness changes to zero.
	JumpdestGas      uint64 = 2     // 1Refunded gas, once per SSTORE operation if the zeroness changes to zero.
	EpochDuration    uint64 = 30000 // Duration between proof-of-work epochs.
	CallGas          uint64 = 40    // Once per CALL operation & message call transaction.
	CreateDataGas    uint64 = 400   // 200
	CallCreateDepth  uint64 = 1024  // Maximum depth of call/create stack.
	ExpGas           uint64 = 10    // Once per EXP instruction
	LogGas           uint64 = 750   // 375Per LOG* operation.
	CopyGas          uint64 = 6     // 3
	StackLimit       uint64 = 1024  // Maximum size of VM stack allowed.
	TierStepGas      uint64 = 0     // Once per operation, for a selection of them.
	LogTopicGas      uint64 = 750   // 375Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
	CreateGas        uint64 = 64000 // 32000Once per CREATE operation & contract-creation transaction.
	SuicideRefundGas uint64 = 48000 // 24000Refunded following a suicide operation.
	MemoryGas        uint64 = 6     // 3Times 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 uint64 = 136   // 68Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.

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

	EcrecoverGas            uint64 = 6000   // 3000Elliptic curve sender recovery gas price
	Sha256BaseGas           uint64 = 120    // 60Base price for a SHA256 operation
	Sha256PerWordGas        uint64 = 24     // 12Per-word price for a SHA256 operation
	Ripemd160BaseGas        uint64 = 1200   // 600Base price for a RIPEMD160 operation
	Ripemd160PerWordGas     uint64 = 240    // 120Per-word price for a RIPEMD160 operation
	IdentityBaseGas         uint64 = 30     // 15Base price for a data copy operation
	IdentityPerWordGas      uint64 = 6      // 3Per-work price for a data copy operation
	ModExpQuadCoeffDiv      uint64 = 20     // Divisor for the quadratic particle of the big int modular exponentiation
	Bn256AddGas             uint64 = 1000   // 500Gas needed for an elliptic curve addition
	Bn256ScalarMulGas       uint64 = 80000  // 40000Gas needed for an elliptic curve scalar multiplication
	Bn256PairingBaseGas     uint64 = 200000 // 100000Base price for an elliptic curve pairing check
	Bn256PairingPerPointGas uint64 = 160000 // 80000Per-point price for an elliptic curve pairing check
)
View Source 
const (
	VersionMajor = 1          // Major version component of the current release
	VersionMinor = 8          // Minor version component of the current release
	VersionPatch = 8          // Patch version component of the current release
	VersionMeta  = "unstable" // Version metadata to append to the version string
)
View Source 
const (
	// BloomBitsBlocks is the number of blocks a single bloom bit section vector
	// contains.
	BloomBitsBlocks uint64 = 4096
)

Variables

View Source 
var (
	//MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") // Mainnet genesis hash to enforce below configs on
	MainnetGenesisHash = common.HexToHash("0x0")
	//TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") // Testnet genesis hash to enforce below configs on
	TestnetGenesisHash = common.HexToHash("0x0")
)
View Source 
var (
	// MainnetChainConfig is the chain parameters to run a node on the main network.
	MainnetChainConfig = &ChainConfig{
		ChainId:             big.NewInt(1),
		HomesteadBlock:      big.NewInt(1),
		DAOForkBlock:        big.NewInt(1),
		DAOForkSupport:      false,
		EIP150Block:         big.NewInt(2),
		EIP150Hash:          common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
		EIP155Block:         big.NewInt(3),
		EIP158Block:         big.NewInt(3),
		ByzantiumBlock:      big.NewInt(4),
		ConstantinopleBlock: nil,
		Mithash:             new(MithashConfig),
	}

	// TestnetChainConfig contains the chain parameters to run a node on the Ropsten test network.
	TestnetChainConfig = &ChainConfig{
		ChainId:        big.NewInt(666),
		HomesteadBlock: big.NewInt(1),
		DAOForkBlock:   nil,
		DAOForkSupport: false,
		EIP150Block:    big.NewInt(2),

		EIP150Hash:          common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
		EIP155Block:         big.NewInt(3),
		EIP158Block:         big.NewInt(3),
		ByzantiumBlock:      big.NewInt(4),
		ConstantinopleBlock: nil,
		Mithash:             new(MithashConfig),

		Clique: &CliqueConfig{
			Period: 15,
			Epoch:  30000,
		},
	}

	// 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: nil,
		Clique: &CliqueConfig{
			Period: 15,
			Epoch:  30000,
		},
	}

	// AllMithashProtocolChanges contains every protocol change (EIPs) introduced
	// and accepted by the Mit core developers into the Mithash consensus.
	//
	// This configuration is intentionally not using keyed fields to force anyone
	// adding flags to the config to also have to set these fields.
	AllMithashProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(MithashConfig), nil}

	// AllCliqueProtocolChanges contains every protocol change (EIPs) introduced
	// and accepted by the Mit 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), 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), nil, new(MithashConfig), nil}
	TestRules       = TestChainConfig.Rules(new(big.Int))
)
View Source 
var (
	// GasTableHomestead contain the gas prices for
	// the homestead phase.
	GasTableHomestead = GasTable{
		ExtcodeSize: 20,
		ExtcodeCopy: 20,
		Balance:     20,
		SLoad:       50,
		Calls:       40,
		Suicide:     0,
		ExpByte:     10,
	}

	// GasTableHomestead contain the gas re-prices for
	// the homestead phase.
	GasTableEIP150 = GasTable{
		ExtcodeSize: 700,
		ExtcodeCopy: 700,
		Balance:     400,
		SLoad:       200,
		Calls:       700,
		Suicide:     5000,
		ExpByte:     10,

		CreateBySuicide: 25000,
	}

	GasTableEIP158 = GasTable{
		ExtcodeSize: 700,
		ExtcodeCopy: 700,
		Balance:     400,
		SLoad:       200,
		Calls:       700,
		Suicide:     5000,
		ExpByte:     50,

		CreateBySuicide: 25000,
	}
)
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.
)
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{}

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

View Source 
var MainnetBootnodes = []string{

	"enode://2a1fa5fb68c68536e0ed9c20eabd64b749264bcb12be24130861139e02cbd6aeb2dadec34b201e803586c042c5807e82951b0d7a14c9cafe9626a7fca68f6183@106.2.11.139:9999",
	"enode://880da7bfc175239d34d1a5b576e9cd54f24559ef4e9b35cd275942707fa77e0e109e5cc43f24e61e93fe8c392cdf9660389c5877c139183a836343d57b5b7379@103.242.67.59:9999",
}

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

View Source 
var RinkebyBootnodes = []string{}
View Source 
var (
	TargetGasLimit uint64 = GenesisGasLimit // The artificial target
)
View Source 
var TestnetBootnodes = []string{
	"enode://819656a6f60cda49fab06e04ac47f148fcb3a48cefec41e8e61795366c3771a514b1f267d62ae36230a96e665995530e34d639b0d27e1ff33ba5fa89e83a7549@103.242.67.65:9999",
	"enode://bbf4ba9aeea72dd1235d83828cc21a498db9dd2f4c2de93da9f607fffb2ee9bba540606ff0b576212cc0aef7024ce92bed0f38b153be65ba81bfdf21a2a3f0ef@103.242.67.72:9999",
	"enode://9ba2930e537939a981a5d908d96b45d8a7fb2c7364a3d0a7dc57686fa3c7d2ff5392eb015043f03e4e9d5a5b7f6e36cebf961fdd1072fc06473e6a11c779c6d9@103.242.67.72:9998",
}

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

View Source 
var Version = func() string {
	v := fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
	if VersionMeta != "" {
		v += "-" + VersionMeta
	}
	return v
}()

Version holds the textual version string.

Functions

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 string) string

Types

type ChainConfig 

type ChainConfig struct {
	ChainId *big.Int `json:"chainId"` // Chain id 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/fanxiong/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)

	// Various consensus engines
	Mithash *MithashConfig `json:"mithash,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) GasTable 

func (c *ChainConfig) GasTable(num *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) IsByzantium 

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

func (*ChainConfig) IsConstantinople 

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

func (*ChainConfig) IsDAOFork 

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

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

func (*ChainConfig) IsEIP150 

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

func (*ChainConfig) IsEIP155 

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

func (*ChainConfig) IsEIP158 

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

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) Rules 

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

func (*ChainConfig) String 

func (c *ChainConfig) String() string

String implements the fmt.Stringer interface.

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 GasTable 

type GasTable struct {
	ExtcodeSize uint64
	ExtcodeCopy 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
}

type MithashConfig 

type MithashConfig struct{}

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

func (*MithashConfig) String 

func (c *MithashConfig) 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                               bool
}

Rules wraps ChainConfig and is merely syntatic 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.

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.