params

const (
	Von  = 1
	GVon = 1e9
	LAT  = 1e18
)

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

	// PlatON is instantly immutability
	// 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
)

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 * 2        // Gas limit of the Genesis block.
	DefaultMinerGasCeil  uint64 = 21000 * 8000 * 1.2 // 201600000
	MaxGasCeil           uint64 = 300000000

	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.
	// todo: pre value: 53000
	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.
	TxDataZeroWasmDeployGas uint64 = 1     // Per byte of data attached to a transaction that equals zero for wasm deploying. 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.

	Keccak256Gas     uint64 = 30 // Once per KECCAK256 operation.
	Keccak256WordGas uint64 = 6  // Once per word of the KECCAK256 operation's data.
	InitCodeWordGas  uint64 = 2  // Once per word of the init code when creating a contract.

	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
	SstoreSetGasEIP2200               uint64 = 20000 // Once per SSTORE operation from clean zero to non-zero
	SstoreResetGasEIP2200             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

	ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
	ColdSloadCostEIP2929         = uint64(2100) // COLD_SLOAD_COST
	WarmStorageReadCostEIP2929   = uint64(100)  // WARM_STORAGE_READ_COST

	// In EIP-2200: SstoreResetGas was 5000.
	// In EIP-2929: SstoreResetGas was changed to '5000 - COLD_SLOAD_COST'.
	// In EIP-3529: SSTORE_CLEARS_SCHEDULE is defined as SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST
	// Which becomes: 5000 - 2100 + 1900 = 4800
	SstoreClearsScheduleRefundEIP3529        = SstoreResetGasEIP2200 - ColdSloadCostEIP2929 + TxAccessListStorageKeyGas
	JumpdestGas                       uint64 = 1     // Once per JUMPDEST operation.
	EpochDuration                     uint64 = 30000 // Duration between proof-of-work epochs.

	CreateDataGas              uint64 = 200 //
	CreateWasmDataGas          uint64 = 4
	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
	SuicideRefundGas           uint64 = 24000 // Refunded following a suicide 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.
	TxDataNonZeroGas           uint64 = 16    // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)
	TxDataNonZeroWasmDeployGas uint64 = 4     // Per byte of data attached to a transaction that is not equal to zero for wasm deploying. 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)
	TxAccessListAddressGas     uint64 = 2400  // Per address specified in EIP 2930 access list
	TxAccessListStorageKeyGas  uint64 = 1900  // Per storage key specified in EIP 2930 access list

	// 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
	SloadGasEIP2200              uint64 = 800  // Cost of SLOAD after EIP 2200 (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

	DefaultBaseFeeChangeDenominator = 8 // Bounds the amount the base fee can change between blocks.
	DefaultElasticityMultiplier     = 2 // Bounds the maximum gas limit an EIP-1559 block may have.
	InitialBaseFee                  = 0 // Initial base fee for EIP-1559 blocks.

	MaxCodeSize     = 524288          // Maximum bytecode to permit for a contract
	MaxInitCodeSize = 2 * MaxCodeSize // Maximum initcode to permit in a creation transaction and create instructions

	// Precompiled contract gas prices
	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
	Bn256AddGas             uint64 = 150   // Gas needed for an elliptic curve addition
	Bn256ScalarMulGas       uint64 = 6000  // Gas needed for an elliptic curve scalar multiplication
	Bn256PairingBaseGas     uint64 = 45000 // Base price for an elliptic curve pairing check
	Bn256PairingPerPointGas uint64 = 34000 // Per-point price for an elliptic curve pairing check

	Bls12381G1AddGas          uint64 = 600    // Price for BLS12-381 elliptic curve G1 point addition
	Bls12381G1MulGas          uint64 = 12000  // Price for BLS12-381 elliptic curve G1 point scalar multiplication
	Bls12381G2AddGas          uint64 = 4500   // Price for BLS12-381 elliptic curve G2 point addition
	Bls12381G2MulGas          uint64 = 55000  // Price for BLS12-381 elliptic curve G2 point scalar multiplication
	Bls12381PairingBaseGas    uint64 = 115000 // Base gas price for BLS12-381 elliptic curve pairing check
	Bls12381PairingPerPairGas uint64 = 23000  // Per-point pair gas price for BLS12-381 elliptic curve pairing check
	Bls12381MapG1Gas          uint64 = 5500   // Gas price for BLS12-381 mapping field element to G1 operation
	Bls12381MapG2Gas          uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation

	BlsVerifyGas uint64 = 21000 // Gas price for BLS12-381 mapping field element to G2 operation

	// The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529,
	// up to half the consumed gas could be refunded. Redefined as 1/5th in EIP-3529
	RefundQuotient        uint64 = 2
	RefundQuotientEIP3529 uint64 = 5

	// PlatONPrecompiled contract gas
	StakingGas            uint64 = 6000  // Gas needed for precompiled contract: stakingContract
	CreateStakeGas        uint64 = 32000 // Gas needed for createStaking
	EditCandidateGas      uint64 = 12000 // Gas needed for editCandidate
	IncStakeGas           uint64 = 20000 // Gas needed for increaseStaking
	WithdrewStakeGas      uint64 = 20000 // Gas needed for withdrewStaking
	DelegateGas           uint64 = 16000 // Gas needed for delegate
	WithdrewDelegationGas uint64 = 8000  // Gas needed for withdrewDelegate
	RedeemDelegationGas   uint64 = 6000  // Gas needed for RedeemDelegation

	GovGas                   uint64 = 9000   // Gas needed for precompiled contract: govContract
	SubmitTextProposalGas    uint64 = 320000 // Gas needed for submitText
	SubmitVersionProposalGas uint64 = 450000 // Gas needed for submitVersion
	SubmitCancelProposalGas  uint64 = 500000 // Gas needed for submitCancel
	SubmitParamProposalGas   uint64 = 500000 // Gas needed for submitParam
	VoteGas                  uint64 = 2000   // Gas needed for vote
	DeclareVersionGas        uint64 = 3000   // Gas needed for declareVersion

	SlashingGas              uint64 = 21000 // Gas needed for precompiled contract: slashingContract
	ReportDuplicateSignGas   uint64 = 21000 // Gas needed for reportDuplicateSign
	DuplicateEvidencesGas    uint64 = 21000 // When reporting, each duplicate sign of evidence requires gas to be consumed
	RestrictingPlanGas       uint64 = 18000 // Gas needed for precompiled contract: restrictingPlanContract
	CreateRestrictingPlanGas uint64 = 8000  // Gas needed for createRestrictingPlan
	ReleasePlanGas           uint64 = 21000 // Gas consumed every time the von of the restrictPlan is released

	DelegateRewardGas         uint64 = 3000 // Gas needed for  delegate reward
	WithdrawDelegateRewardGas uint64 = 8000 // Gas needed for withdraw  delegate reward
	WithdrawDelegateNodeGas   uint64 = 1000 // Gas needed for withdraw  delegate reward Node Count
	WithdrawDelegateEpochGas  uint64 = 100  // Gas needed for withdraw  delegate reward epoch Count
)

const (
	//These versions are meaning the current code version.
	VersionMajor = 1          // Major version component of the current release
	VersionMinor = 5          // Minor version component of the current release
	VersionPatch = 1          // Patch version component of the current release
	VersionMeta  = "unstable" // Version metadata to append to the version string

	//CAUTION: DO NOT MODIFY THIS ONCE THE CHAIN HAS BEEN INITIALIZED!!!
	//nolint:staticcheck
	GenesisVersion = uint32(1<<16 | 0<<8 | 0)
)

const (
	FORKVERSION_0_11_0 = uint32(0<<16 | 11<<8 | 0)
	FORKVERSION_1_1_0  = uint32(1<<16 | 1<<8 | 0)
	FORKVERSION_1_2_0  = uint32(1<<16 | 2<<8 | 0)
	FORKVERSION_1_3_0  = uint32(1<<16 | 3<<8 | 0)
	FORKVERSION_1_4_0  = uint32(1<<16 | 4<<8 | 0)
	FORKVERSION_1_5_0  = uint32(1<<16 | 5<<8 | 0)
	FORKVERSION_1_6_0  = uint32(1<<16 | 6<<8 | 0)
)

const (
	DefualtRule = iota
	StakingRule
	SlashingRule
	RestrictingRule
	RewardRule
	GovernanceRule
	CollectDeclareVersionRule
)

const (
	Zero                      = 0
	Eighty                    = 80
	Hundred                   = 100
	TenThousand               = 10000
	CeilBlocksReward          = 50000
	CeilMaxValidators         = 10000
	FloorMaxConsensusVals     = 4
	CeilMaxConsensusVals      = 43
	PositiveInfinity          = "+∞"
	CeilUnStakeFreezeDuration = 168 * 2
	CeilMaxEvidenceAge        = CeilUnStakeFreezeDuration - 1
	// The maximum time range for the cumulative number of zero blocks (No more than 64)
	MaxZeroProduceCumulativeTime uint16 = 50

	RewardPerMaxChangeRangeUpperLimit = 2000
	RewardPerMaxChangeRangeLowerLimit = 1
	RewardPerChangeIntervalUpperLimit = 28
	RewardPerChangeIntervalLowerLimit = 2
	IncreaseIssuanceRatioUpperLimit   = 2000
	IncreaseIssuanceRatioLowerLimit   = 0

	// When electing consensus nodes, it is used to calculate the P value of the binomial distribution
	ElectionBase = 30

	ElectionBasePIP3 = 43

	MainNetECHash = "0x259176769541cdb61bc19806cbf5a3f3489f4829b6b69f804f45f947a0c9c3e9"

	MaxValidatorsForVersion150 = 225
)

const (
	DefaultMainNet     = iota // PlatON default main net flag
	DefaultTestNet            // PlatON default test net flag
	DefaultUnitTestNet        // PlatON default unit test
)