common

Documentation

Index

• Constants
• Variables
• func AssignShardForPubKeyWhenNotSpecified(pubKey []byte, numShards uint32) uint32
• func CloseKeyValueHolderChan(ch chan core.KeyValueHolder)
• func ExtractTokenIDAndNonceFromTokenStorageKey(tokenKey []byte) ([]byte, uint64)
• func GetClosedUnbufferedChannel() chan struct{}
• func GetSkBytesFromP2pKey(p2pKeyFilename string) ([]byte, error)
• func IsContextDone(ctx context.Context) bool
• func IsEmptyTrie(root []byte) bool
• func LoadApiConfig(filepath string) (*config.ApiRoutesConfig, error)
• func LoadEconomicsConfig(filepath string) (*config.EconomicsConfig, error)
• func LoadEpochConfig(filepath string) (*config.EpochConfig, error)
• func LoadExternalConfig(filepath string) (*config.ExternalConfig, error)
• func LoadGasScheduleConfig(filepath string) (map[string]map[string]uint64, error)
• func LoadMainConfig(filepath string) (*config.Config, error)
• func LoadP2PConfig(filepath string) (*p2pConfig.P2PConfig, error)
• func LoadPreferencesConfig(filepath string) (*config.Preferences, error)
• func LoadRatingsConfig(filepath string) (*config.RatingsConfig, error)
• func LoadRoundConfig(filePath string) (*config.RoundConfig, error)
• func LoadSystemSmartContractsConfig(filepath string) (*config.SystemSmartContractsConfig, error)
• func NewPidQueue() *pidQueue
• func NewTimeoutHandler(timeout time.Duration) (*timeoutHandler, error)
• func ProcessDestinationShardAsObserver(destinationShardIdAsObserver string) (uint32, error)
• func SuffixedMetric(metric string, suffix string) string
• func TrimSuffixFromValue(value []byte, suffixLength int) ([]byte, error)
• type AlteredAccountsForBlockAPIResponse
• type ApiOutputFormat
• type AuctionListValidatorAPIResponse
• type AuctionNode
• type BaseStorer
• type BlockInfo
• type BlockProcessingCutoffMode
• type BlockProcessingCutoffTrigger
• type BufferedErrChan
• type DataTrieHandler
• type DelegationDataAPI
• type EnableEpochsHandler
• type EpochStartDataAPI
• type ExecutionOrderGetter
• type GasScheduleNotifierAPI
• type GetProofResponse
• type InitialAccountAPI
• type KeyBuilder
• type Locker
• type ManagedPeersHolder
• type ManagedPeersMonitor
• type MerkleProofVerifier
• type MissingTrieNodesNotifier
• type ModifiedHashes
  • func (mh ModifiedHashes) Clone() ModifiedHashes
• type NodeOperation
• type NodeProcessingMode
  • func GetNodeProcessingMode(importDbConfig *config.ImportDbConfig) NodeProcessingMode
• type NodeState
• type NonceGapApiResponse
• type PeerType
• type PidQueueHandler
• type ProcessStatusHandler
• type ReceiptsHolder
• type RootHashHolder
• type SizeSyncStatisticsHandler
• type SnapshotDbHandler
• type SnapshotStatisticsHandler
• type StateStatisticsHandler
• type StateSyncNotifierSubscriber
• type StorageManager
• type StorageMarker
• type Transaction
• type TransactionsPoolAPIResponse
• type TransactionsPoolForSenderApiResponse
• type TransactionsPoolNonceGapsForSenderApiResponse
• type Trie
• type TrieIteratorChannels
• type TrieLeafParser
• type TrieStatisticsHandler
• type TrieStats
• type TrieStorageInteractor
• type TrieType
• type TriesHolder
• type TriesStatisticsCollector
• type TxExecutionOrderHandler

Constants

const (
	// MetricScDeployEnableEpoch represents the epoch when the deployment of smart contracts is enabled
	MetricScDeployEnableEpoch = "erd_smart_contract_deploy_enable_epoch"

	// MetricBuiltInFunctionsEnableEpoch represents the epoch when the built-in functions is enabled
	MetricBuiltInFunctionsEnableEpoch = "erd_built_in_functions_enable_epoch"

	// MetricRelayedTransactionsEnableEpoch represents the epoch when the relayed transactions is enabled
	MetricRelayedTransactionsEnableEpoch = "erd_relayed_transactions_enable_epoch"

	// MetricPenalizedTooMuchGasEnableEpoch represents the epoch when the penalization for using too much gas is enabled
	MetricPenalizedTooMuchGasEnableEpoch = "erd_penalized_too_much_gas_enable_epoch"

	// MetricSwitchJailWaitingEnableEpoch represents the epoch when the system smart contract processing at end of epoch is enabled
	MetricSwitchJailWaitingEnableEpoch = "erd_switch_jail_waiting_enable_epoch"

	// MetricSwitchHysteresisForMinNodesEnableEpoch represents the epoch when the system smart contract changes its config to consider
	// also (minimum) hysteresis nodes for the minimum number of nodes
	MetricSwitchHysteresisForMinNodesEnableEpoch = "erd_switch_hysteresis_for_min_nodes_enable_epoch"

	// MetricBelowSignedThresholdEnableEpoch represents the epoch when the change for computing rating for validators below signed rating is enabled
	MetricBelowSignedThresholdEnableEpoch = "erd_below_signed_threshold_enable_epoch"

	// MetricTransactionSignedWithTxHashEnableEpoch represents the epoch when the node will also accept transactions that are
	// signed with the hash of transaction
	MetricTransactionSignedWithTxHashEnableEpoch = "erd_transaction_signed_with_txhash_enable_epoch"

	// MetricMetaProtectionEnableEpoch represents the epoch when the transactions to the metachain are checked to have enough gas
	MetricMetaProtectionEnableEpoch = "erd_meta_protection_enable_epoch"

	// MetricAheadOfTimeGasUsageEnableEpoch represents the epoch when the cost of smart contract prepare changes from compiler
	// per byte to ahead of time prepare per byte
	MetricAheadOfTimeGasUsageEnableEpoch = "erd_ahead_of_time_gas_usage_enable_epoch"

	// MetricGasPriceModifierEnableEpoch represents the epoch when the gas price modifier in fee computation is enabled
	MetricGasPriceModifierEnableEpoch = "erd_gas_price_modifier_enable_epoch"

	// MetricRepairCallbackEnableEpoch represents the epoch when the callback repair is activated for smart contract results
	MetricRepairCallbackEnableEpoch = "erd_repair_callback_enable_epoch"

	// MetricBlockGasAndFreeRecheckEnableEpoch represents the epoch when gas and fees used in each created or processed block are re-checked
	MetricBlockGasAndFreeRecheckEnableEpoch = "erd_block_gas_and_fee_recheck_enable_epoch"

	// MetricStakingV2EnableEpoch represents the epoch when staking v2 is enabled
	MetricStakingV2EnableEpoch = "erd_staking_v2_enable_epoch"

	// MetricStakeEnableEpoch represents the epoch when staking is enabled
	MetricStakeEnableEpoch = "erd_stake_enable_epoch"

	// MetricDoubleKeyProtectionEnableEpoch represents the epoch when double key protection is enabled
	MetricDoubleKeyProtectionEnableEpoch = "erd_double_key_protection_enable_epoch"

	// MetricEsdtEnableEpoch represents the epoch when ESDT is enabled
	MetricEsdtEnableEpoch = "erd_esdt_enable_epoch"

	// MetricGovernanceEnableEpoch  represents the epoch when governance is enabled
	MetricGovernanceEnableEpoch = "erd_governance_enable_epoch"

	// MetricDelegationManagerEnableEpoch represents the epoch when the delegation manager is enabled
	MetricDelegationManagerEnableEpoch = "erd_delegation_manager_enable_epoch"

	// MetricDelegationSmartContractEnableEpoch represents the epoch when delegation smart contract is enabled
	MetricDelegationSmartContractEnableEpoch = "erd_delegation_smart_contract_enable_epoch"

	// MetricCorrectLastUnjailedEnableEpoch represents the epoch when the correction on the last unjailed node is applied
	MetricCorrectLastUnjailedEnableEpoch = "erd_correct_last_unjailed_enable_epoch"

	// MetricBalanceWaitingListsEnableEpoch represents the epoch when the balance waiting lists on shards fix is applied
	MetricBalanceWaitingListsEnableEpoch = "erd_balance_waiting_lists_enable_epoch"

	// MetricReturnDataToLastTransferEnableEpoch represents the epoch when the return data to last transfer is applied
	MetricReturnDataToLastTransferEnableEpoch = "erd_return_data_to_last_transfer_enable_epoch"

	// MetricSenderInOutTransferEnableEpoch represents the epoch when the sender in out transfer is applied
	MetricSenderInOutTransferEnableEpoch = "erd_sender_in_out_transfer_enable_epoch"

	// MetricRelayedTransactionsV2EnableEpoch represents the epoch when the relayed transactions v2 is enabled
	MetricRelayedTransactionsV2EnableEpoch = "erd_relayed_transactions_v2_enable_epoch"

	// MetricFixRelayedBaseCostEnableEpoch represents the epoch when the fix for relayed base cost is enabled
	MetricFixRelayedBaseCostEnableEpoch = "erd_fix_relayed_base_cost_enable_epoch"

	// MetricUnbondTokensV2EnableEpoch represents the epoch when the unbond tokens v2 is applied
	MetricUnbondTokensV2EnableEpoch = "erd_unbond_tokens_v2_enable_epoch"

	// MetricSaveJailedAlwaysEnableEpoch represents the epoch the save jailed fix is applied
	MetricSaveJailedAlwaysEnableEpoch = "erd_save_jailed_always_enable_epoch"

	// MetricValidatorToDelegationEnableEpoch represents the epoch when the validator to delegation feature (staking v3.5) is enabled
	MetricValidatorToDelegationEnableEpoch = "erd_validator_to_delegation_enable_epoch"

	// MetricReDelegateBelowMinCheckEnableEpoch represents the epoch when the re-delegation below minimum value fix is applied
	MetricReDelegateBelowMinCheckEnableEpoch = "erd_redelegate_below_min_check_enable_epoch"

	// MetricIncrementSCRNonceInMultiTransferEnableEpoch represents the epoch when the fix for multi transfer SCR is enabled
	MetricIncrementSCRNonceInMultiTransferEnableEpoch = "erd_increment_scr_nonce_in_multi_transfer_enable_epoch"

	// MetricScheduledMiniBlocksEnableEpoch represents the epoch when the scheduled miniblocks feature is enabled
	MetricScheduledMiniBlocksEnableEpoch = "erd_scheduled_miniblocks_enable_epoch"

	// MetricESDTMultiTransferEnableEpoch represents the epoch when the ESDT multi transfer feature is enabled
	MetricESDTMultiTransferEnableEpoch = "erd_esdt_multi_transfer_enable_epoch"

	// MetricGlobalMintBurnDisableEpoch represents the epoch when the global mint and burn feature is disabled
	MetricGlobalMintBurnDisableEpoch = "erd_global_mint_burn_disable_epoch"

	// MetricESDTTransferRoleEnableEpoch represents the epoch when the ESDT transfer role feature is enabled
	MetricESDTTransferRoleEnableEpoch = "erd_esdt_transfer_role_enable_epoch"

	// MetricComputeRewardCheckpointEnableEpoch represents the epoch when compute reward checkpoint feature is enabled
	MetricComputeRewardCheckpointEnableEpoch = "erd_compute_reward_checkpoint_enable_epoch"

	// MetricSCRSizeInvariantCheckEnableEpoch represents the epoch when scr size invariant check is enabled
	MetricSCRSizeInvariantCheckEnableEpoch = "erd_scr_size_invariant_check_enable_epoch"

	// MetricBackwardCompSaveKeyValueEnableEpoch represents the epoch when backward compatibility save key valu is enabled
	MetricBackwardCompSaveKeyValueEnableEpoch = "erd_backward_comp_save_keyvalue_enable_epoch"

	// MetricESDTNFTCreateOnMultiShardEnableEpoch represents the epoch when esdt nft create on multi shard is enabled
	MetricESDTNFTCreateOnMultiShardEnableEpoch = "erd_esdt_nft_create_on_multi_shard_enable_epoch"

	// MetricMetaESDTSetEnableEpoch represents the epoch when meta esdt set is enabled
	MetricMetaESDTSetEnableEpoch = "erd_meta_esdt_set_enable_epoch"

	// MetricAddTokensToDelegationEnableEpoch represents the epoch when add tokens to delegation
	MetricAddTokensToDelegationEnableEpoch = "erd_add_tokens_to_delegation_enable_epoch"

	// MetricMultiESDTTransferFixOnCallBackOnEnableEpoch represents the epoch when multi esdt transfer fix on callback on is enabled
	MetricMultiESDTTransferFixOnCallBackOnEnableEpoch = "erd_multi_esdt_transfer_fix_on_callback_enable_epoch"

	// MetricOptimizeGasUsedInCrossMiniBlocksEnableEpoch represents the epoch when optimize gas used in cross miniblocks is enabled
	MetricOptimizeGasUsedInCrossMiniBlocksEnableEpoch = "erd_optimize_gas_used_in_cross_miniblocks_enable_epoch"
	// MetricCorrectFirstQueuedEpoch represents the epoch when correct first queued fix is enabled
	MetricCorrectFirstQueuedEpoch = "erd_correct_first_queued_enable_epoch"

	// MetricCorrectJailedNotUnstakedEmptyQueueEpoch represents the epoch when correct jailed not unstacked meptry queue fix is enabled
	MetricCorrectJailedNotUnstakedEmptyQueueEpoch = "erd_correct_jailed_not_unstaked_empty_queue_enable_epoch"

	// MetricFixOOGReturnCodeEnableEpoch represents the epoch when OOG return code fix is enabled
	MetricFixOOGReturnCodeEnableEpoch = "erd_fix_oog_return_code_enable_epoch"

	// MetricRemoveNonUpdatedStorageEnableEpoch represents the epoch when remove non updated storage fix is enabled
	MetricRemoveNonUpdatedStorageEnableEpoch = "erd_remove_non_updated_storage_enable_epoch"

	// MetricDeleteDelegatorAfterClaimRewardsEnableEpoch represents the epoch when delete delegator after claim rewards fix is enabled
	MetricDeleteDelegatorAfterClaimRewardsEnableEpoch = "erd_delete_delegator_after_claim_rewards_enable_epoch"

	// MetricOptimizeNFTStoreEnableEpoch represents the epoch when optimize nft store feature is enabled
	MetricOptimizeNFTStoreEnableEpoch = "erd_optimize_nft_store_enable_epoch"

	// MetricCreateNFTThroughExecByCallerEnableEpoch represents the epoch when create nft through exec by caller functionality is enabled
	MetricCreateNFTThroughExecByCallerEnableEpoch = "erd_create_nft_through_exec_by_caller_enable_epoch"

	// MetricStopDecreasingValidatorRatingWhenStuckEnableEpoch represents the epoch when stop decreaing validator rating when stuck functionality is enabled
	MetricStopDecreasingValidatorRatingWhenStuckEnableEpoch = "erd_stop_decreasing_validator_rating_when_stuck_enable_epoch"

	// MetricFrontRunningProtectionEnableEpoch represents the epoch when front running protection feature is enabled
	MetricFrontRunningProtectionEnableEpoch = "erd_front_running_protection_enable_epoch"

	// MetricIsPayableBySCEnableEpoch represents the epoch when is payable by SC feature is enabled
	MetricIsPayableBySCEnableEpoch = "erd_is_payable_by_sc_enable_epoch"

	// MetricCleanUpInformativeSCRsEnableEpoch represents the epoch when cleanup informative scrs functionality is enabled
	MetricCleanUpInformativeSCRsEnableEpoch = "erd_cleanup_informative_scrs_enable_epoch"

	// MetricStorageAPICostOptimizationEnableEpoch represents the epoch when storage api cost optimization feature is enabled
	MetricStorageAPICostOptimizationEnableEpoch = "erd_storage_api_cost_optimization_enable_epoch"

	// MetricTransformToMultiShardCreateEnableEpoch represents the epoch when transform to multi shard create functionality is enabled
	MetricTransformToMultiShardCreateEnableEpoch = "erd_transform_to_multi_shard_create_enable_epoch"

	// MetricESDTRegisterAndSetAllRolesEnableEpoch represents the epoch when esdt register and set all roles functionality is enabled
	MetricESDTRegisterAndSetAllRolesEnableEpoch = "erd_esdt_register_and_set_all_roles_enable_epoch"

	// MetricDoNotReturnOldBlockInBlockchainHookEnableEpoch represents the epoch when do not return old block in blockchain hook fix is enabled
	MetricDoNotReturnOldBlockInBlockchainHookEnableEpoch = "erd_do_not_returns_old_block_in_blockchain_hook_enable_epoch"

	// MetricAddFailedRelayedTxToInvalidMBsDisableEpoch represents the epoch when add failed relayed tx to invalid miniblocks functionality is enabled
	MetricAddFailedRelayedTxToInvalidMBsDisableEpoch = "erd_add_failed_relayed_tx_to_invalid_mbs_enable_epoch"

	// MetricSCRSizeInvariantOnBuiltInResultEnableEpoch represents the epoch when scr size invariant on builtin result functionality is enabled
	MetricSCRSizeInvariantOnBuiltInResultEnableEpoch = "erd_scr_size_invariant_on_builtin_result_enable_epoch"

	// MetricCheckCorrectTokenIDForTransferRoleEnableEpoch represents the epoch when check correct tokenID for transfer role fix is enabled
	MetricCheckCorrectTokenIDForTransferRoleEnableEpoch = "erd_check_correct_tokenid_for_transfer_role_enable_epoch"

	// MetricDisableExecByCallerEnableEpoch represents the epoch when disable exec by caller functionality is enabled
	MetricDisableExecByCallerEnableEpoch = "erd_disable_exec_by_caller_enable_epoch"

	// MetricFailExecutionOnEveryAPIErrorEnableEpoch represents the epoch when fail execution on every api error functionality is enabled
	MetricFailExecutionOnEveryAPIErrorEnableEpoch = "erd_fail_execution_on_every_api_error_enable_epoch"

	// MetricManagedCryptoAPIsEnableEpoch represents the epoch when managed cypto apis functionality is enabled
	MetricManagedCryptoAPIsEnableEpoch = "erd_managed_crypto_apis_enable_epoch"

	// MetricRefactorContextEnableEpoch represents the epoch when refactor context functionality is enabled
	MetricRefactorContextEnableEpoch = "erd_refactor_context_enable_epoch"

	// MetricCheckFunctionArgumentEnableEpoch represents the epoch when check function argument functionality is enabled
	MetricCheckFunctionArgumentEnableEpoch = "erd_check_function_argument_enable_epoch"

	// MetricCheckExecuteOnReadOnlyEnableEpoch represents the epoch when check execute on read only fix is enabled
	MetricCheckExecuteOnReadOnlyEnableEpoch = "erd_check_execute_on_readonly_enable_epoch"

	// MetricMiniBlockPartialExecutionEnableEpoch represents the epoch when miniblock partial execution feature is enabled
	MetricMiniBlockPartialExecutionEnableEpoch = "erd_miniblock_partial_execution_enable_epoch"

	// MetricESDTMetadataContinuousCleanupEnableEpoch represents the epoch when esdt metadata continuous clenaup functionality is enabled
	MetricESDTMetadataContinuousCleanupEnableEpoch = "erd_esdt_metadata_continuous_cleanup_enable_epoch"

	// MetricFixAsyncCallBackArgsListEnableEpoch represents the epoch when fix async callback args list is enabled
	MetricFixAsyncCallBackArgsListEnableEpoch = "erd_fix_async_callback_args_list_enable_epoch"

	// MetricFixOldTokenLiquidityEnableEpoch represents the epoch when fix old token liquidity is enabled
	MetricFixOldTokenLiquidityEnableEpoch = "erd_fix_old_token_liquidity_enable_epoch"

	// MetricRuntimeMemStoreLimitEnableEpoch represents the epoch when runtime mem store limit functionality is enabled
	MetricRuntimeMemStoreLimitEnableEpoch = "erd_runtime_mem_store_limit_enable_epoch"

	// MetricRuntimeCodeSizeFixEnableEpoch represents the epoch when runtime code size fix is enabled
	MetricRuntimeCodeSizeFixEnableEpoch = "erd_runtime_code_size_fix_enable_epoch"

	// MetricSetSenderInEeiOutputTransferEnableEpoch represents the epoch when set sender in eei output transfer functionality is enabled
	MetricSetSenderInEeiOutputTransferEnableEpoch = "erd_set_sender_in_eei_output_transfer_enable_epoch"

	// MetricRefactorPeersMiniBlocksEnableEpoch represents the epoch when refactor peers miniblock feature is enabled
	MetricRefactorPeersMiniBlocksEnableEpoch = "erd_refactor_peers_miniblocks_enable_epoch"

	// MetricSCProcessorV2EnableEpoch represents the epoch when SC processor V2 feature is enabled
	MetricSCProcessorV2EnableEpoch = "erd_sc_processorv2_enable_epoch"

	// MetricMaxBlockchainHookCountersEnableEpoch represents the epoch when max blockchain hook counters functionality is enabled
	MetricMaxBlockchainHookCountersEnableEpoch = "erd_max_blockchain_hook_counters_enable_epoch"

	// MetricWipeSingleNFTLiquidityDecreaseEnableEpoch represents the epoch when wipe single NFT liquidity decrease functionality is enabled
	MetricWipeSingleNFTLiquidityDecreaseEnableEpoch = "erd_wipe_single_nft_liquidity_decrease_enable_epoch"

	// MetricAlwaysSaveTokenMetaDataEnableEpoch represents the epoch when always save token metadata functionality is enabled
	MetricAlwaysSaveTokenMetaDataEnableEpoch = "erd_always_save_token_metadata_enable_epoch"

	// MetricSetGuardianEnableEpoch represents the epoch when the guardian feature is enabled
	MetricSetGuardianEnableEpoch = "erd_set_guardian_feature_enable_epoch"

	// MetricSetScToScLogEventEnableEpoch represents the epoch when the sc to sc log event feature is enabled
	MetricSetScToScLogEventEnableEpoch = "erd_set_sc_to_sc_log_event_enable_epoch"

	// MetricRelayedNonceFixEnableEpoch represents the epoch when relayed nonce fix is enabled
	MetricRelayedNonceFixEnableEpoch = "erd_relayed_nonce_fix_enable_epoch"

	// MetricDeterministicSortOnValidatorsInfoEnableEpoch represents the epoch when deterministic sort on validators info functionality is enabled
	MetricDeterministicSortOnValidatorsInfoEnableEpoch = "erd_deterministic_sort_on_validators_info_enable_epoch"

	// MetricKeepExecOrderOnCreatedSCRsEnableEpoch represents the epoch when keep exec order on created scs fix is enabled
	MetricKeepExecOrderOnCreatedSCRsEnableEpoch = "erd_keep_exec_order_on_created_scrs_enable_epoch"

	// MetricMultiClaimOnDelegationEnableEpoch represents the epoch when multi claim on delegation functionality is enabled
	MetricMultiClaimOnDelegationEnableEpoch = "erd_multi_claim_on_delegation_enable_epoch"

	// MetricChangeUsernameEnableEpoch represents the epoch when change username functionality is enabled
	MetricChangeUsernameEnableEpoch = "erd_change_username_enable_epoch"

	// MetricAutoBalanceDataTriesEnableEpoch represents the epoch when auto balance data tries feature is enabled
	MetricAutoBalanceDataTriesEnableEpoch = "erd_auto_balance_data_tries_enable_epoch"

	// MetricMigrateDataTrieEnableEpoch represents the epoch when migrate data trie feature is enabled
	MetricMigrateDataTrieEnableEpoch = "erd_migrate_datatrie_enable_epoch"

	// MetricConsistentTokensValuesLengthCheckEnableEpoch represents the epoch when consistent tokens values length check is enabled
	MetricConsistentTokensValuesLengthCheckEnableEpoch = "erd_consistent_tokens_values_length_check_enable_epoch"

	// MetricFixDelegationChangeOwnerOnAccountEnableEpoch represents the epoch when fix delegation change owner on account is enabled
	MetricFixDelegationChangeOwnerOnAccountEnableEpoch = "erd_fix_delegation_change_owner_on_account_enable_epoch"

	// MetricDynamicGasCostForDataTrieStorageLoadEnableEpoch represents the epoch when dynamic gas cost for data tries storage load functionality is enabled
	MetricDynamicGasCostForDataTrieStorageLoadEnableEpoch = "erd_dynamic_gas_cost_for_datatrie_storage_load_enable_epoch"

	// MetricNFTStopCreateEnableEpoch represents the epoch when NFT stop create functionality is enabled
	MetricNFTStopCreateEnableEpoch = "erd_nft_stop_create_enable_epoch"

	// MetricChangeOwnerAddressCrossShardThroughSCEnableEpoch represents the epoch when change owner address cross shard through SC functionality is enabled
	MetricChangeOwnerAddressCrossShardThroughSCEnableEpoch = "erd_change_owner_address_cross_shard_through_sc_enable_epoch"

	// MetricFixGasRemainingForSaveKeyValueBuiltinFunctionEnableEpoch represents the epoch when fix gas remaining for save key value builin function is enabled
	MetricFixGasRemainingForSaveKeyValueBuiltinFunctionEnableEpoch = "erd_fix_gas_remainig_for_save_keyvalue_builtin_function_enable_epoch"

	// MetricCurrentRandomnessOnSortingEnableEpoch represents the epoch when current randomness on sorting functionality is enabled
	MetricCurrentRandomnessOnSortingEnableEpoch = "erd_current_randomness_on_sorting_enable_epoch"

	// MetricStakeLimitsEnableEpoch represents the epoch when stake limits functionality is enabled
	MetricStakeLimitsEnableEpoch = "erd_stake_limits_enable_epoch"

	// MetricStakingV4Step1EnableEpoch represents the epoch when staking v4 step 1 feature is enabled
	MetricStakingV4Step1EnableEpoch = "erd_staking_v4_step1_enable_epoch"

	// MetricStakingV4Step2EnableEpoch represents the epoch when staking v4 step 2 feature is enabled
	MetricStakingV4Step2EnableEpoch = "erd_staking_v4_step2_enable_epoch"

	// MetricStakingV4Step3EnableEpoch represents the epoch when staking v4 step 3 feature is enabled
	MetricStakingV4Step3EnableEpoch = "erd_staking_v4_step3_enable_epoch"

	// MetricCleanupAuctionOnLowWaitingListEnableEpoch represents the epoch when cleanup auction on low waiting list fix is enabled
	MetricCleanupAuctionOnLowWaitingListEnableEpoch = "erd_cleanup_auction_on_low_waiting_list_enable_epoch"

	// MetricAlwaysMergeContextsInEEIEnableEpoch represents the epoch when always merge contexts in EEI fix is enabled
	MetricAlwaysMergeContextsInEEIEnableEpoch = "erd_always_merge_contexts_in_eei_enable_epoch"

	// MetricDynamicESDTEnableEpoch represents the epoch when dynamic ESDT feature is enabled
	MetricDynamicESDTEnableEpoch = "erd_dynamic_esdt_enable_epoch"

	// MetricEGLDInMultiTransferEnableEpoch represents the epoch when EGLD in multi transfer feature is enabled
	MetricEGLDInMultiTransferEnableEpoch = "erd_egld_in_multi_transfer_enable_epoch"

	// MetricCryptoOpcodesV2EnableEpoch represents the epoch when crypto opcodes v2 feature is enabled
	MetricCryptoOpcodesV2EnableEpoch = "erd_crypto_opcodes_v2_enable_epoch"

	// MetricMultiESDTNFTTransferAndExecuteByUserEnableEpoch represents the epoch when enshrined sovereign opcodes are enabled
	MetricMultiESDTNFTTransferAndExecuteByUserEnableEpoch = "erd_multi_esdt_transfer_execute_by_user_enable_epoch"

	// MetricFixRelayedMoveBalanceToNonPayableSCEnableEpoch represents the epoch when the fix for relayed move balance to non-payable sc is enabled
	MetricFixRelayedMoveBalanceToNonPayableSCEnableEpoch = "erd_fix_relayed_move_balance_to_non_payable_sc_enable_epoch"

	// MetricMaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch
	MetricMaxNodesChangeEnableEpoch = "erd_max_nodes_change_enable_epoch"

	// MetricEpochEnable represents the epoch when the max nodes change configuration is applied
	MetricEpochEnable = "erd_epoch_enable"

	// EpochEnableSuffix represents the suffix for EpochEnable item in MaxNodesChangeEnableEpoch list
	EpochEnableSuffix = "_epoch_enable"

	// MetricMaxNumNodes represents the maximum number of nodes than can be enabled in a max nodes change configuration setup
	MetricMaxNumNodes = "erd_max_num_nodes"

	// MaxNumNodesSuffix represents the suffix for MaxNumNodes item in MaxNodesChangeEnableEpoch list
	MaxNumNodesSuffix = "_max_num_nodes"

	// MetricNodesToShufflePerShard represents the nodes to be shuffled per shard
	MetricNodesToShufflePerShard = "erd_nodes_to_shuffle_per_shard"

	// NodesToShufflePerShardSuffix represents the suffix for NodesToShufflePerShard item in MaxNodesChangeEnableEpoch list
	NodesToShufflePerShardSuffix = "_nodes_to_shuffle_per_shard"
)

const (
	// MetricRatingsGeneralStartRating represents the starting rating used by the rater
	MetricRatingsGeneralStartRating = "erd_ratings_general_start_rating"

	// MetricRatingsGeneralMaxRating represents the maximum rating limit
	MetricRatingsGeneralMaxRating = "erd_ratings_general_max_rating"

	// MetricRatingsGeneralMinRating represents the minimum rating limit
	MetricRatingsGeneralMinRating = "erd_ratings_general_min_rating"

	// MetricRatingsGeneralSignedBlocksThreshold represents the signed blocks threshold
	MetricRatingsGeneralSignedBlocksThreshold = "erd_ratings_general_signed_blocks_threshold"

	// MetricRatingsGeneralSelectionChances represents the selection chances thresholds
	MetricRatingsGeneralSelectionChances = "erd_ratings_general_selection_chances"

	// MetricSelectionChancesMaxThreshold represents the max threshold for a selection chances item
	MetricSelectionChancesMaxThreshold = "erd_max_threshold"

	// SelectionChancesMaxThresholdSuffix represents the SelectionChances suffix for MaxThreshold
	SelectionChancesMaxThresholdSuffix = "_max_threshold"

	// MetricSelectionChancesChancePercent represents the chance percentage for a selection chances metric
	MetricSelectionChancesChancePercent = "erd_chance_percent"

	// SelectionChancesChancePercentSuffix represents the SelectionChances suffix for ChancePercent
	SelectionChancesChancePercentSuffix = "_chance_percent"

	// MetricRatingsShardChainHoursToMaxRatingFromStartRating represents the hours to max rating from start rating
	MetricRatingsShardChainHoursToMaxRatingFromStartRating = "erd_ratings_shardchain_hours_to_max_rating_from_start_rating"

	// MetricRatingsShardChainProposerValidatorImportance represents the proposer validator importance index
	MetricRatingsShardChainProposerValidatorImportance = "erd_ratings_shardchain_proposer_validator_importance"

	// MetricRatingsShardChainProposerDecreaseFactor represents the proposer decrease factor
	MetricRatingsShardChainProposerDecreaseFactor = "erd_ratings_shardchain_proposer_decrease_factor"

	// MetricRatingsShardChainValidatorDecreaseFactor represents the validator decrease factor
	MetricRatingsShardChainValidatorDecreaseFactor = "erd_ratings_shardchain_validator_decrease_factor"

	// MetricRatingsShardChainConsecutiveMissedBlocksPenalty represents the consecutive missed block penalty
	MetricRatingsShardChainConsecutiveMissedBlocksPenalty = "erd_ratings_shardchain_consecutive_missed_blocks_penalty"

	// MetricRatingsMetaChainHoursToMaxRatingFromStartRating represents the hours to max rating from start rating
	MetricRatingsMetaChainHoursToMaxRatingFromStartRating = "erd_ratings_metachain_hours_to_max_rating_from_start_rating"

	// MetricRatingsMetaChainProposerValidatorImportance represents the proposer validator importance index
	MetricRatingsMetaChainProposerValidatorImportance = "erd_ratings_metachain_proposer_validator_importance"

	// MetricRatingsMetaChainProposerDecreaseFactor represents the proposer decrease factor
	MetricRatingsMetaChainProposerDecreaseFactor = "erd_ratings_metachain_proposer_decrease_factor"

	// MetricRatingsMetaChainValidatorDecreaseFactor represents the validator decrease factor
	MetricRatingsMetaChainValidatorDecreaseFactor = "erd_ratings_metachain_validator_decrease_factor"

	// MetricRatingsMetaChainConsecutiveMissedBlocksPenalty represents the consecutive missed blocks penalty
	MetricRatingsMetaChainConsecutiveMissedBlocksPenalty = "erd_ratings_metachain_consecutive_missed_blocks_penalty"

	// MetricRatingsPeerHonestyDecayCoefficient represents the peer honesty decay coefficient
	MetricRatingsPeerHonestyDecayCoefficient = "erd_ratings_peerhonesty_decay_coefficient"

	// MetricRatingsPeerHonestyDecayUpdateIntervalInSeconds represents the decat update interval in seconds
	MetricRatingsPeerHonestyDecayUpdateIntervalInSeconds = "erd_ratings_peerhonesty_decay_update_interval_inseconds"

	// MetricRatingsPeerHonestyMaxScore represents the peer honesty max score allowed
	MetricRatingsPeerHonestyMaxScore = "erd_ratings_peerhonesty_max_score"

	// MetricRatingsPeerHonestyMinScore represents the peer honesty min score
	MetricRatingsPeerHonestyMinScore = "erd_ratings_peerhonesty_min_score"

	// MetricRatingsPeerHonestyBadPeerThreshold represents the peer honesty bad peer threshold
	MetricRatingsPeerHonestyBadPeerThreshold = "erd_ratings_peerhonesty_bad_peer_threshold"

	// MetricRatingsPeerHonestyUnitValue represents the peer honesty unit value
	MetricRatingsPeerHonestyUnitValue = "erd_ratings_peerhonesty_unit_value"

	// MetricHysteresis represents the hysteresis threshold
	MetricHysteresis = "erd_hysteresis"

	// MetricAdaptivity represents a boolean to determine if adaptivity will be enabled or not
	MetricAdaptivity = "erd_adaptivity"
)

const (
	// StorerOrder defines the order of storers to be notified of a start of epoch event
	StorerOrder = iota
	// NodesCoordinatorOrder defines the order in which NodesCoordinator is notified of a start of epoch event
	NodesCoordinatorOrder
	// ConsensusOrder defines the order in which Consensus is notified of a start of epoch event
	ConsensusOrder
	// NetworkShardingOrder defines the order in which the network sharding subsystem is notified of a start of epoch event
	NetworkShardingOrder
	// IndexerOrder defines the order in which indexer is notified of a start of epoch event
	IndexerOrder
	// NetStatisticsOrder defines the order in which netStatistic component is notified of a start of epoch event
	NetStatisticsOrder
	// OldDatabaseCleanOrder defines the order in which oldDatabaseCleaner component is notified of a start of epoch event
	OldDatabaseCleanOrder
)

const (
	// ActiveDBKey is the key at which ActiveDBVal will be saved
	ActiveDBKey = "activeDB"

	// ActiveDBVal is the value that will be saved at ActiveDBKey
	ActiveDBVal = "yes"

	// TrieSyncedKey is the key at which TrieSyncedVal will be saved
	TrieSyncedKey = "synced"

	// TrieSyncedVal is the value that will be saved at TrieSyncedKey
	TrieSyncedVal = "yes"

	// TrieLeavesChannelDefaultCapacity represents the default value to be used as capacity for getting all trie leaves on
	// a channel
	TrieLeavesChannelDefaultCapacity = 100

	// TrieLeavesChannelSyncCapacity represents the value to be used as capacity for getting main trie
	// leaf nodes for trie sync
	TrieLeavesChannelSyncCapacity = 1000
)

const (
	// BlockProcessingCutoffModePause represents the mode where the node will pause the processing at the given coordinates
	BlockProcessingCutoffModePause = "pause"
	// BlockProcessingCutoffModeProcessError represents the mode where the node will reprocess with error the block at the given coordinates
	BlockProcessingCutoffModeProcessError = "process-error"
)

const (
	SCDeployFlag                                       core.EnableEpochFlag = "SCDeployFlag"
	BuiltInFunctionsFlag                               core.EnableEpochFlag = "BuiltInFunctionsFlag"
	RelayedTransactionsFlag                            core.EnableEpochFlag = "RelayedTransactionsFlag"
	PenalizedTooMuchGasFlag                            core.EnableEpochFlag = "PenalizedTooMuchGasFlag"
	SwitchJailWaitingFlag                              core.EnableEpochFlag = "SwitchJailWaitingFlag"
	BelowSignedThresholdFlag                           core.EnableEpochFlag = "BelowSignedThresholdFlag"
	SwitchHysteresisForMinNodesFlagInSpecificEpochOnly core.EnableEpochFlag = "SwitchHysteresisForMinNodesFlagInSpecificEpochOnly"
	TransactionSignedWithTxHashFlag                    core.EnableEpochFlag = "TransactionSignedWithTxHashFlag"
	MetaProtectionFlag                                 core.EnableEpochFlag = "MetaProtectionFlag"
	AheadOfTimeGasUsageFlag                            core.EnableEpochFlag = "AheadOfTimeGasUsageFlag"
	GasPriceModifierFlag                               core.EnableEpochFlag = "GasPriceModifierFlag"
	RepairCallbackFlag                                 core.EnableEpochFlag = "RepairCallbackFlag"
	ReturnDataToLastTransferFlagAfterEpoch             core.EnableEpochFlag = "ReturnDataToLastTransferFlagAfterEpoch"
	SenderInOutTransferFlag                            core.EnableEpochFlag = "SenderInOutTransferFlag"
	StakeFlag                                          core.EnableEpochFlag = "StakeFlag"
	StakingV2Flag                                      core.EnableEpochFlag = "StakingV2Flag"
	StakingV2OwnerFlagInSpecificEpochOnly              core.EnableEpochFlag = "StakingV2OwnerFlagInSpecificEpochOnly"
	StakingV2FlagAfterEpoch                            core.EnableEpochFlag = "StakingV2FlagAfterEpoch"
	DoubleKeyProtectionFlag                            core.EnableEpochFlag = "DoubleKeyProtectionFlag"
	ESDTFlag                                           core.EnableEpochFlag = "ESDTFlag"
	ESDTFlagInSpecificEpochOnly                        core.EnableEpochFlag = "ESDTFlagInSpecificEpochOnly"
	GovernanceFlag                                     core.EnableEpochFlag = "GovernanceFlag"
	GovernanceFlagInSpecificEpochOnly                  core.EnableEpochFlag = "GovernanceFlagInSpecificEpochOnly"
	DelegationManagerFlag                              core.EnableEpochFlag = "DelegationManagerFlag"
	DelegationSmartContractFlag                        core.EnableEpochFlag = "DelegationSmartContractFlag"
	DelegationSmartContractFlagInSpecificEpochOnly     core.EnableEpochFlag = "DelegationSmartContractFlagInSpecificEpochOnly"
	CorrectLastUnJailedFlag                            core.EnableEpochFlag = "CorrectLastUnJailedFlag"
	CorrectLastUnJailedFlagInSpecificEpochOnly         core.EnableEpochFlag = "CorrectLastUnJailedFlagInSpecificEpochOnly"
	RelayedTransactionsV2Flag                          core.EnableEpochFlag = "RelayedTransactionsV2Flag"
	UnBondTokensV2Flag                                 core.EnableEpochFlag = "UnBondTokensV2Flag"
	SaveJailedAlwaysFlag                               core.EnableEpochFlag = "SaveJailedAlwaysFlag"
	ReDelegateBelowMinCheckFlag                        core.EnableEpochFlag = "ReDelegateBelowMinCheckFlag"
	ValidatorToDelegationFlag                          core.EnableEpochFlag = "ValidatorToDelegationFlag"
	IncrementSCRNonceInMultiTransferFlag               core.EnableEpochFlag = "IncrementSCRNonceInMultiTransferFlag"
	ESDTMultiTransferFlag                              core.EnableEpochFlag = "ESDTMultiTransferFlag"
	GlobalMintBurnFlag                                 core.EnableEpochFlag = "GlobalMintBurnFlag"
	ESDTTransferRoleFlag                               core.EnableEpochFlag = "ESDTTransferRoleFlag"
	ComputeRewardCheckpointFlag                        core.EnableEpochFlag = "ComputeRewardCheckpointFlag"
	SCRSizeInvariantCheckFlag                          core.EnableEpochFlag = "SCRSizeInvariantCheckFlag"
	BackwardCompSaveKeyValueFlag                       core.EnableEpochFlag = "BackwardCompSaveKeyValueFlag"
	ESDTNFTCreateOnMultiShardFlag                      core.EnableEpochFlag = "ESDTNFTCreateOnMultiShardFlag"
	MetaESDTSetFlag                                    core.EnableEpochFlag = "MetaESDTSetFlag"
	AddTokensToDelegationFlag                          core.EnableEpochFlag = "AddTokensToDelegationFlag"
	MultiESDTTransferFixOnCallBackFlag                 core.EnableEpochFlag = "MultiESDTTransferFixOnCallBackFlag"
	OptimizeGasUsedInCrossMiniBlocksFlag               core.EnableEpochFlag = "OptimizeGasUsedInCrossMiniBlocksFlag"
	CorrectFirstQueuedFlag                             core.EnableEpochFlag = "CorrectFirstQueuedFlag"
	DeleteDelegatorAfterClaimRewardsFlag               core.EnableEpochFlag = "DeleteDelegatorAfterClaimRewardsFlag"
	RemoveNonUpdatedStorageFlag                        core.EnableEpochFlag = "RemoveNonUpdatedStorageFlag"
	OptimizeNFTStoreFlag                               core.EnableEpochFlag = "OptimizeNFTStoreFlag"
	CreateNFTThroughExecByCallerFlag                   core.EnableEpochFlag = "CreateNFTThroughExecByCallerFlag"
	StopDecreasingValidatorRatingWhenStuckFlag         core.EnableEpochFlag = "StopDecreasingValidatorRatingWhenStuckFlag"
	FrontRunningProtectionFlag                         core.EnableEpochFlag = "FrontRunningProtectionFlag"
	PayableBySCFlag                                    core.EnableEpochFlag = "PayableBySCFlag"
	CleanUpInformativeSCRsFlag                         core.EnableEpochFlag = "CleanUpInformativeSCRsFlag"
	StorageAPICostOptimizationFlag                     core.EnableEpochFlag = "StorageAPICostOptimizationFlag"
	ESDTRegisterAndSetAllRolesFlag                     core.EnableEpochFlag = "ESDTRegisterAndSetAllRolesFlag"
	ScheduledMiniBlocksFlag                            core.EnableEpochFlag = "ScheduledMiniBlocksFlag"
	CorrectJailedNotUnStakedEmptyQueueFlag             core.EnableEpochFlag = "CorrectJailedNotUnStakedEmptyQueueFlag"
	DoNotReturnOldBlockInBlockchainHookFlag            core.EnableEpochFlag = "DoNotReturnOldBlockInBlockchainHookFlag"
	AddFailedRelayedTxToInvalidMBsFlag                 core.EnableEpochFlag = "AddFailedRelayedTxToInvalidMBsFlag"
	SCRSizeInvariantOnBuiltInResultFlag                core.EnableEpochFlag = "SCRSizeInvariantOnBuiltInResultFlag"
	CheckCorrectTokenIDForTransferRoleFlag             core.EnableEpochFlag = "CheckCorrectTokenIDForTransferRoleFlag"
	FailExecutionOnEveryAPIErrorFlag                   core.EnableEpochFlag = "FailExecutionOnEveryAPIErrorFlag"
	MiniBlockPartialExecutionFlag                      core.EnableEpochFlag = "MiniBlockPartialExecutionFlag"
	ManagedCryptoAPIsFlag                              core.EnableEpochFlag = "ManagedCryptoAPIsFlag"
	ESDTMetadataContinuousCleanupFlag                  core.EnableEpochFlag = "ESDTMetadataContinuousCleanupFlag"
	DisableExecByCallerFlag                            core.EnableEpochFlag = "DisableExecByCallerFlag"
	RefactorContextFlag                                core.EnableEpochFlag = "RefactorContextFlag"
	CheckFunctionArgumentFlag                          core.EnableEpochFlag = "CheckFunctionArgumentFlag"
	CheckExecuteOnReadOnlyFlag                         core.EnableEpochFlag = "CheckExecuteOnReadOnlyFlag"
	SetSenderInEeiOutputTransferFlag                   core.EnableEpochFlag = "SetSenderInEeiOutputTransferFlag"
	FixAsyncCallbackCheckFlag                          core.EnableEpochFlag = "FixAsyncCallbackCheckFlag"
	SaveToSystemAccountFlag                            core.EnableEpochFlag = "SaveToSystemAccountFlag"
	CheckFrozenCollectionFlag                          core.EnableEpochFlag = "CheckFrozenCollectionFlag"
	SendAlwaysFlag                                     core.EnableEpochFlag = "SendAlwaysFlag"
	ValueLengthCheckFlag                               core.EnableEpochFlag = "ValueLengthCheckFlag"
	CheckTransferFlag                                  core.EnableEpochFlag = "CheckTransferFlag"
	ESDTNFTImprovementV1Flag                           core.EnableEpochFlag = "ESDTNFTImprovementV1Flag"
	ChangeDelegationOwnerFlag                          core.EnableEpochFlag = "ChangeDelegationOwnerFlag"
	RefactorPeersMiniBlocksFlag                        core.EnableEpochFlag = "RefactorPeersMiniBlocksFlag"
	SCProcessorV2Flag                                  core.EnableEpochFlag = "SCProcessorV2Flag"
	FixAsyncCallBackArgsListFlag                       core.EnableEpochFlag = "FixAsyncCallBackArgsListFlag"
	FixOldTokenLiquidityFlag                           core.EnableEpochFlag = "FixOldTokenLiquidityFlag"
	RuntimeMemStoreLimitFlag                           core.EnableEpochFlag = "RuntimeMemStoreLimitFlag"
	RuntimeCodeSizeFixFlag                             core.EnableEpochFlag = "RuntimeCodeSizeFixFlag"
	MaxBlockchainHookCountersFlag                      core.EnableEpochFlag = "MaxBlockchainHookCountersFlag"
	WipeSingleNFTLiquidityDecreaseFlag                 core.EnableEpochFlag = "WipeSingleNFTLiquidityDecreaseFlag"
	AlwaysSaveTokenMetaDataFlag                        core.EnableEpochFlag = "AlwaysSaveTokenMetaDataFlag"
	SetGuardianFlag                                    core.EnableEpochFlag = "SetGuardianFlag"
	RelayedNonceFixFlag                                core.EnableEpochFlag = "RelayedNonceFixFlag"
	ConsistentTokensValuesLengthCheckFlag              core.EnableEpochFlag = "ConsistentTokensValuesLengthCheckFlag"
	KeepExecOrderOnCreatedSCRsFlag                     core.EnableEpochFlag = "KeepExecOrderOnCreatedSCRsFlag"
	MultiClaimOnDelegationFlag                         core.EnableEpochFlag = "MultiClaimOnDelegationFlag"
	ChangeUsernameFlag                                 core.EnableEpochFlag = "ChangeUsernameFlag"
	AutoBalanceDataTriesFlag                           core.EnableEpochFlag = "AutoBalanceDataTriesFlag"
	MigrateDataTrieFlag                                core.EnableEpochFlag = "MigrateDataTrieFlag"
	FixDelegationChangeOwnerOnAccountFlag              core.EnableEpochFlag = "FixDelegationChangeOwnerOnAccountFlag"
	FixOOGReturnCodeFlag                               core.EnableEpochFlag = "FixOOGReturnCodeFlag"
	DeterministicSortOnValidatorsInfoFixFlag           core.EnableEpochFlag = "DeterministicSortOnValidatorsInfoFixFlag"
	DynamicGasCostForDataTrieStorageLoadFlag           core.EnableEpochFlag = "DynamicGasCostForDataTrieStorageLoadFlag"
	ScToScLogEventFlag                                 core.EnableEpochFlag = "ScToScLogEventFlag"
	BlockGasAndFeesReCheckFlag                         core.EnableEpochFlag = "BlockGasAndFeesReCheckFlag"
	BalanceWaitingListsFlag                            core.EnableEpochFlag = "BalanceWaitingListsFlag"
	NFTStopCreateFlag                                  core.EnableEpochFlag = "NFTStopCreateFlag"
	FixGasRemainingForSaveKeyValueFlag                 core.EnableEpochFlag = "FixGasRemainingForSaveKeyValueFlag"
	IsChangeOwnerAddressCrossShardThroughSCFlag        core.EnableEpochFlag = "IsChangeOwnerAddressCrossShardThroughSCFlag"
	CurrentRandomnessOnSortingFlag                     core.EnableEpochFlag = "CurrentRandomnessOnSortingFlag"
	StakeLimitsFlag                                    core.EnableEpochFlag = "StakeLimitsFlag"
	StakingV4Step1Flag                                 core.EnableEpochFlag = "StakingV4Step1Flag"
	StakingV4Step2Flag                                 core.EnableEpochFlag = "StakingV4Step2Flag"
	StakingV4Step3Flag                                 core.EnableEpochFlag = "StakingV4Step3Flag"
	CleanupAuctionOnLowWaitingListFlag                 core.EnableEpochFlag = "CleanupAuctionOnLowWaitingListFlag"
	StakingV4StartedFlag                               core.EnableEpochFlag = "StakingV4StartedFlag"
	AlwaysMergeContextsInEEIFlag                       core.EnableEpochFlag = "AlwaysMergeContextsInEEIFlag"
	UseGasBoundedShouldFailExecutionFlag               core.EnableEpochFlag = "UseGasBoundedShouldFailExecutionFlag"
	DynamicESDTFlag                                    core.EnableEpochFlag = "DynamicEsdtFlag"
	EGLDInESDTMultiTransferFlag                        core.EnableEpochFlag = "EGLDInESDTMultiTransferFlag"
	CryptoOpcodesV2Flag                                core.EnableEpochFlag = "CryptoOpcodesV2Flag"
	UnJailCleanupFlag                                  core.EnableEpochFlag = "UnJailCleanupFlag"
	FixRelayedBaseCostFlag                             core.EnableEpochFlag = "FixRelayedBaseCostFlag"
	MultiESDTNFTTransferAndExecuteByUserFlag           core.EnableEpochFlag = "MultiESDTNFTTransferAndExecuteByUserFlag"
	FixRelayedMoveBalanceToNonPayableSCFlag            core.EnableEpochFlag = "FixRelayedMoveBalanceToNonPayableSCFlag"
)

Enable epoch flags definitions

const AdditionalScrForEachScCallOrSpecialTx = 3

AdditionalScrForEachScCallOrSpecialTx specifies the additional number of smart contract results which should be considered by a node, when it includes sc calls or special txs in a miniblock. Ex.: normal txs -> aprox. 27000, sc calls or special txs -> aprox. 6250 = 27000 / (AdditionalScrForEachScCallOrSpecialTx + 1), considering that constant below is set to 3

const AsyncCallStepField = "AsyncCallStep"

AsyncCallStepField is the field name for the gas cost for any of the two steps required to execute an async call

const AsyncCallbackGasLockField = "AsyncCallbackGasLock"

AsyncCallbackGasLockField is the field name for the gas amount to be locked before executing the destination async call, to be put aside for the async callback

const BaseOperationCost = "BaseOperationCost"

BaseOperationCost represents the field name for base operation costs

const BaseOpsAPICost = "BaseOpsAPICost"

BaseOpsAPICost represents the field name of the SC API (EEI) gas costs

const BuiltInCost = "BuiltInCost"

BuiltInCost represents the field name for built-in operation costs

const CombinedPeerType = "%s (%s)"

CombinedPeerType - represents the combination of two peerTypes

const CommitMaxTime = 3 * time.Second

CommitMaxTime represents max time accepted for a commit action, after which a warn message is displayed

const ConnectionTopic = "connection"

ConnectionTopic represents the topic used when sending the new connection message data

const ConsensusTopic = "consensus"

ConsensusTopic is the topic used in consensus algorithm

const DefaultDBPath = "db"

DefaultDBPath is the default path for nodes databases

const DefaultInterceptorsIdentifier = "default interceptor"

DefaultInterceptorsIdentifier represents the identifier that is used in conjunction with regular interceptors (that makes the node run properly)

const DefaultLogProfileIdentifier = "[default log profile]"

DefaultLogProfileIdentifier represents the default log profile used when the logviewer/termui applications do not need to change the current logging profile

const DefaultResolversIdentifier = "default resolver"

DefaultResolversIdentifier represents the identifier that is used in conjunction with regular resolvers (that makes the node run properly)

const DefaultStatsPath = "stats"

DefaultStatsPath is the default path where the node stats are logged

const DefaultUnstakedEpoch = math.MaxUint32

DefaultUnstakedEpoch represents the default epoch that is set for a validator that has not unstaked yet

const DisabledShardIDAsObserver = uint32(0xFFFFFFFF) - 7

DisabledShardIDAsObserver defines the uint32 identifier which tells that the node hasn't configured any preferred shard to start in as observer

const EpochStartInterceptorsIdentifier = "epoch start interceptor"

EpochStartInterceptorsIdentifier represents the identifier that is used in the start-in-epoch process

const ExtraDelayBetweenBroadcastMbsAndTxs = 1 * time.Second

ExtraDelayBetweenBroadcastMbsAndTxs represents the number of seconds to wait since miniblocks have been broadcast and the moment when theirs transactions would be broadcast too

const ExtraDelayForBroadcastBlockInfo = 1 * time.Second

ExtraDelayForBroadcastBlockInfo represents the number of seconds to wait since a block has been broadcast and the moment when its components, like mini blocks and transactions, would be broadcast too

const ExtraDelayForRequestBlockInfo = ExtraDelayForBroadcastBlockInfo + ExtraDelayBetweenBroadcastMbsAndTxs + time.Second

ExtraDelayForRequestBlockInfo represents the number of seconds to wait since a block has been received and the moment when its components, like mini blocks and transactions, would be requested too if they are still missing

const FullArchiveMetricSuffix = "_full_archive"

FullArchiveMetricSuffix is the suffix added to metrics specific for full archive network

const GenesisStorageSuffix = "_genesis"

GenesisStorageSuffix defines the storage suffix used for genesis altered data

const GenesisTxSignatureString = "GENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISG"

GenesisTxSignatureString is the string used to generate genesis transaction signature as 128 hex characters

const HardforkInterceptorsIdentifier = "hardfork interceptor"

HardforkInterceptorsIdentifier represents the identifier that is used in the hardfork process

const HardforkResolversIdentifier = "hardfork resolver"

HardforkResolversIdentifier represents the resolver that is used in the hardfork process

const HeartbeatV2Topic = "heartbeatV2"

HeartbeatV2Topic is the topic used for heartbeatV2 signaling

const HighestRoundFromBootStorage = "highestRoundFromBootStorage"

HighestRoundFromBootStorage is the key for the highest round that is saved in storage

const ImportComplete = "importComplete"

ImportComplete signals that a node restart will be done because the import did complete

const InvalidMessageBlacklistDuration = time.Second * 3600

InvalidMessageBlacklistDuration represents the time to keep a peer in the black list if it sends a message that does not follow the protocol: example not useing the same marshaler as the other peers

const InvalidSigningBlacklistDuration = time.Second * 7200

InvalidSigningBlacklistDuration defines the time to keep a peer id in blacklist if it signs a message with invalid signature

const MaxBulkTransactionSize = 1 << 18 // 256KB bulks

MaxBulkTransactionSize specifies the maximum size of one bulk with txs which can be send over the network TODO convert this const into a var and read it from config when this code moves to another binary

const MaxIndexOfTxInMiniBlock = int32(29999)

MaxIndexOfTxInMiniBlock defines the maximum index of a tx inside one mini block

const MaxPerTransaction = "MaxPerTransaction"

MaxPerTransaction represents the field name of max counts per transaction in block chain hook

const MaxRoundsWithoutCommittedStartInEpochBlock = 50

MaxRoundsWithoutCommittedStartInEpochBlock defines the maximum rounds to wait for start in epoch block to be committed, before a special action to be applied

const MaxSoftwareVersionLengthInBytes = 10

MaxSoftwareVersionLengthInBytes represents the maximum length for the software version to be saved in block header

const MaxTxNonceDeltaAllowed = 100

MaxTxNonceDeltaAllowed specifies the maximum difference between an account's nonce and a received transaction's nonce in order to mark the transaction as valid.

const MaxTxsToRequest = 1000

MaxTxsToRequest specifies the maximum number of txs to request

const MaxWaitingTimeToReceiveRequestedItem = 5 * time.Second

MaxWaitingTimeToReceiveRequestedItem represents the maximum waiting time in seconds needed to receive the requested items

const MetaChainSystemSCsCost = "MetaChainSystemSCsCost"

MetaChainSystemSCsCost represents the field name for metachain system smart contract operation costs

const MetachainShardId = uint32(0xFFFFFFFF)

MetachainShardId will be used to identify a shard ID as metachain

const MetachainShardName = "metachain"

MetachainShardName is the string identifier of the metachain shard

const MetachainTopicIdentifier = "META" // TODO - move this to mx-chain-core-go and change wherever we use the string value

MetachainTopicIdentifier is the identifier used in topics to define the metachain shard ID

const MetricAccountsSnapshotInProgress = "erd_accounts_snapshot_in_progress"

MetricAccountsSnapshotInProgress is the metric that outputs the status of the accounts' snapshot, if it's in progress or not

const MetricAccountsSnapshotNumNodes = "erd_accounts_snapshot_num_nodes"

MetricAccountsSnapshotNumNodes is the metric that outputs the number of trie nodes written for accounts after snapshot

const MetricAppVersion = "erd_app_version"

MetricAppVersion is the metric for the current app version

const MetricAreVMQueriesReady = "erd_are_vm_queries_ready"

MetricAreVMQueriesReady will hold the string representation of the boolean that indicated if the node is ready to process VM queries

const MetricBlockTimestamp = "erd_block_timestamp"

MetricBlockTimestamp is the metric for monitoring the timestamp of the last synchronized block

const MetricChainId = "erd_chain_id"

MetricChainId is the metric that specifies current chain id

const MetricConnectedNodes = "erd_connected_nodes"

MetricConnectedNodes is the metric for monitoring total connected nodes on the network

const MetricConsensusGroupSize = "erd_consensus_group_size"

MetricConsensusGroupSize is the metric for consensus group size for the current shard/meta

const MetricConsensusRoundState = "erd_consensus_round_state"

MetricConsensusRoundState is the metric for consensus round state for a block

const MetricConsensusState = "erd_consensus_state"

MetricConsensusState is the metric for consensus state of node proposer,participant or not consensus group

const MetricCountAcceptedBlocks = "erd_count_accepted_blocks"

MetricCountAcceptedBlocks is the metric for monitoring number of blocks that was accepted proposed by a node

const MetricCountConsensus = "erd_count_consensus"

MetricCountConsensus is the metric for monitoring number of rounds when a node was in consensus group

const MetricCountConsensusAcceptedBlocks = "erd_count_consensus_accepted_blocks"

MetricCountConsensusAcceptedBlocks is the metric for monitoring number of blocks accepted when the node was in consensus group

const MetricCountLeader = "erd_count_leader"

MetricCountLeader is the metric for monitoring number of rounds when a node was leader

const MetricCpuLoadPercent = "erd_cpu_load_percent"

MetricCpuLoadPercent is the metric for monitoring CPU load [%]

const MetricCreatedProposedBlock = "erd_consensus_created_proposed_block"

MetricCreatedProposedBlock is the metric that specifies the percent of the block subround used for header and body creation (0 meaning that the block was created in no-time and 100 meaning that the block creation used all the subround spare duration)

const MetricCrossCheckBlockHeight = "erd_cross_check_block_height"

MetricCrossCheckBlockHeight is the metric that store cross block height

const MetricCrossCheckBlockHeightMeta = "erd_cross_check_block_height_meta"

MetricCrossCheckBlockHeightMeta is the metric that store metachain cross block height

const MetricCurrentBlockHash = "erd_current_block_hash"

MetricCurrentBlockHash is the metric that stores the current block hash

const MetricCurrentRound = "erd_current_round"

MetricCurrentRound is the metric for monitoring the current round of a node

const MetricCurrentRoundTimestamp = "erd_current_round_timestamp"

MetricCurrentRoundTimestamp is the metric that stores current round timestamp

const MetricDenomination = "erd_denomination"

MetricDenomination is the metric for exposing the denomination

const MetricDevRewardsInEpoch = "erd_dev_rewards"

MetricDevRewardsInEpoch holds the developers' rewards value for the last epoch

const MetricEpochForEconomicsData = "erd_epoch_for_economics_data"

MetricEpochForEconomicsData holds the epoch for which economics data are computed

const MetricEpochNumber = "erd_epoch_number"

MetricEpochNumber is the metric for the number of epoch

const MetricExtraGasLimitGuardedTx = "erd_extra_gas_limit_guarded_tx"

MetricExtraGasLimitGuardedTx specifies the extra gas limit required for guarded transactions

const MetricGasPerDataByte = "erd_gas_per_data_byte"

MetricGasPerDataByte is the metric that specifies the required gas for a data byte

const MetricGasPriceModifier = "erd_gas_price_modifier"

MetricGasPriceModifier is the metric that specifies the gas price modifier

const MetricGatewayMetricsEndpoint = "erd_gateway_metrics_endpoint"

MetricGatewayMetricsEndpoint is the metric that specifies gateway endpoint

const MetricHeaderSize = "erd_current_block_size"

MetricHeaderSize is the metric that stores the current block size

const MetricHighestFinalBlock = "erd_highest_final_nonce"

MetricHighestFinalBlock is the metric for the nonce of the highest final block

const MetricInflation = "erd_inflation"

MetricInflation holds the inflation value for the last epoch

const MetricIsSyncing = "erd_is_syncing"

MetricIsSyncing is the metric for monitoring if a node is syncing

const MetricLastAccountsSnapshotDurationSec = "erd_accounts_snapshot_last_duration_in_seconds"

MetricLastAccountsSnapshotDurationSec is the metric that outputs the duration in seconds of the last accounts db snapshot. If snapshot is in progress it will be set to 0

const MetricLastPeersSnapshotDurationSec = "erd_peers_snapshot_last_duration_in_seconds"

MetricLastPeersSnapshotDurationSec is the metric that outputs the duration in seconds of the last peers db snapshot. If snapshot is in progress it will be set to 0

const MetricLatestTagSoftwareVersion = "erd_latest_tag_software_version"

MetricLatestTagSoftwareVersion is the metric that stores the latest tag software version

const MetricLeaderPercentage = "erd_leader_percentage"

MetricLeaderPercentage is the metric for leader rewards percentage

const MetricLiveValidatorNodes = "erd_live_validator_nodes"

MetricLiveValidatorNodes is the metric for the number of live validators on the network

const MetricMaxGasPerTransaction = "erd_max_gas_per_transaction"

MetricMaxGasPerTransaction is the metric that specifies the maximum gas limit for a transaction

const MetricMemHeapInUse = "erd_mem_heap_inuse"

MetricMemHeapInUse is a metric for monitoring the memory ("heap in use")

const MetricMemLoadPercent = "erd_mem_load_percent"

MetricMemLoadPercent is the metric for monitoring memory load [%]

const MetricMemStackInUse = "erd_mem_stack_inuse"

MetricMemStackInUse is a metric for monitoring the memory ("stack in use")

const MetricMemTotal = "erd_mem_total"

MetricMemTotal is the metric for monitoring total memory bytes

const MetricMemUsedGolang = "erd_mem_used_golang"

MetricMemUsedGolang is a metric for monitoring the memory ("total")

const MetricMemUsedSystem = "erd_mem_used_sys"

MetricMemUsedSystem is a metric for monitoring the memory ("sys mem")

const MetricMetaConsensusGroupSize = "erd_meta_consensus_group_size"

MetricMetaConsensusGroupSize is the metric for the metachain consensus group size

const MetricMinGasLimit = "erd_min_gas_limit"

MetricMinGasLimit is the metric that specifies the minimum gas limit

const MetricMinGasPrice = "erd_min_gas_price"

MetricMinGasPrice is the metric that specifies min gas price

const MetricMinTransactionVersion = "erd_min_transaction_version"

MetricMinTransactionVersion is the metric that specifies the minimum transaction version

const MetricMiniBlocksSize = "erd_mini_blocks_size"

MetricMiniBlocksSize is the metric that stores the current block size

const MetricNetworkRecvBps = "erd_network_recv_bps"

MetricNetworkRecvBps is the metric for monitoring network received bytes per second

const MetricNetworkRecvBpsPeak = "erd_network_recv_bps_peak"

MetricNetworkRecvBpsPeak is the metric for monitoring network received peak bytes per second

const MetricNetworkRecvBytesInCurrentEpochPerHost = "erd_network_recv_bytes_in_epoch_per_host"

MetricNetworkRecvBytesInCurrentEpochPerHost is the metric for monitoring network received bytes in current epoch per host

const MetricNetworkRecvPercent = "erd_network_recv_percent"

MetricNetworkRecvPercent is the metric for monitoring network receive load [%]

const MetricNetworkSendBytesInCurrentEpochPerHost = "erd_network_sent_bytes_in_epoch_per_host"

MetricNetworkSendBytesInCurrentEpochPerHost is the metric for monitoring network send bytes in current epoch per host

const MetricNetworkSentBps = "erd_network_sent_bps"

MetricNetworkSentBps is the metric for monitoring network sent bytes per second

const MetricNetworkSentBpsPeak = "erd_network_sent_bps_peak"

MetricNetworkSentBpsPeak is the metric for monitoring network sent peak bytes per second

const MetricNetworkSentPercent = "erd_network_sent_percent"

MetricNetworkSentPercent is the metric for monitoring network sent load [%]

const MetricNodeDisplayName = "erd_node_display_name"

MetricNodeDisplayName is the metric that stores the name of the node

const MetricNodeType = "erd_node_type"

MetricNodeType is the metric for monitoring the type of the node

const MetricNonce = "erd_nonce"

MetricNonce is the metric for monitoring the nonce of a node

const MetricNonceAtEpochStart = "erd_nonce_at_epoch_start"

MetricNonceAtEpochStart is the metric for storing the first nonce of the current epoch

const MetricNoncesPassedInCurrentEpoch = "erd_nonces_passed_in_current_epoch"

MetricNoncesPassedInCurrentEpoch is the metric that tells the number of nonces passed in current epoch

const MetricNumConnectedPeers = "erd_num_connected_peers"

MetricNumConnectedPeers is the metric for monitoring the number of connected peers

const MetricNumConnectedPeersClassification = "erd_num_connected_peers_classification"

MetricNumConnectedPeersClassification is the metric for monitoring the number of connected peers split on the connection type

const MetricNumIntraShardValidatorNodes = "erd_intra_shard_validator_nodes"

MetricNumIntraShardValidatorNodes is the metric for the number of intra-shard validators

const MetricNumMetachainNodes = "erd_num_metachain_nodes"

MetricNumMetachainNodes is the metric which holds the number of nodes in metachain

const MetricNumMiniBlocks = "erd_num_mini_blocks"

MetricNumMiniBlocks is the metric for number of miniblocks in a block

const MetricNumNodesPerShard = "erd_num_nodes_in_shard"

MetricNumNodesPerShard is the metric which holds the number of nodes in a shard

const MetricNumProcessedTxs = "erd_num_transactions_processed"

MetricNumProcessedTxs is the metric that stores the number of transactions processed

const MetricNumShardHeadersFromPool = "erd_num_shard_headers_from_pool"

MetricNumShardHeadersFromPool is the metric that stores number of shard header from pool

const MetricNumShardHeadersProcessed = "erd_num_shard_headers_processed"

MetricNumShardHeadersProcessed is the metric that stores number of shard header processed

const MetricNumShardsWithoutMetachain = "erd_num_shards_without_meta"

MetricNumShardsWithoutMetachain is the metric for monitoring the number of shards (excluding meta)

const MetricNumTimesInForkChoice = "erd_fork_choice_count"

MetricNumTimesInForkChoice is the metric that counts how many times a node was in fork choice

const MetricNumTxInBlock = "erd_num_tx_block"

MetricNumTxInBlock is the metric for the number of transactions in the proposed block

const MetricNumValidators = "erd_num_validators"

MetricNumValidators is the metric for the number of validators

const MetricP2PCrossShardObservers = "erd_p2p_cross_shard_observers"

MetricP2PCrossShardObservers is the metric that outputs the cross-shard connected observers

const MetricP2PCrossShardValidators = "erd_p2p_cross_shard_validators"

MetricP2PCrossShardValidators is the metric that outputs the cross-shard connected validators

const MetricP2PIntraShardObservers = "erd_p2p_intra_shard_observers"

MetricP2PIntraShardObservers is the metric that outputs the intra-shard connected observers

const MetricP2PIntraShardValidators = "erd_p2p_intra_shard_validators"

MetricP2PIntraShardValidators is the metric that outputs the intra-shard connected validators

const MetricP2PNumConnectedPeersClassification = "erd_p2p_num_connected_peers_classification"

MetricP2PNumConnectedPeersClassification is the metric for monitoring the number of connected peers split on the connection type

const MetricP2PNumReceiverPeers = "erd_p2p_num_receiver_peers"

MetricP2PNumReceiverPeers represents the number of connected peer sent messages to the current peer (and have been received by the current peer) in the amount of time

const MetricP2PPeakNumReceiverPeers = "erd_p2p_peak_num_receiver_peers"

MetricP2PPeakNumReceiverPeers represents the peak number of connected peer sent messages to the current peer (and have been received by the current peer) in the amount of time

const MetricP2PPeakPeerNumProcessedMessages = "erd_p2p_peak_peer_num_processed_messages"

MetricP2PPeakPeerNumProcessedMessages represents the peak maximum number of processed messages in the amount of time counted on a connected peer

const MetricP2PPeakPeerNumReceivedMessages = "erd_p2p_peak_peer_num_received_messages"

MetricP2PPeakPeerNumReceivedMessages represents the peak maximum number of received messages in the amount of time counted on a connected peer

const MetricP2PPeakPeerSizeProcessedMessages = "erd_p2p_peak_peer_size_processed_messages"

MetricP2PPeakPeerSizeProcessedMessages represents the peak maximum size of processed data (sum of all messages) in the amount of time counted on a connected peer

const MetricP2PPeakPeerSizeReceivedMessages = "erd_p2p_peak_peer_size_received_messages"

MetricP2PPeakPeerSizeReceivedMessages represents the peak maximum size of received data (sum of all messages) in the amount of time counted on a connected peer

const MetricP2PPeerInfo = "erd_p2p_peer_info"

MetricP2PPeerInfo is the metric for the node's p2p info

const MetricP2PPeerNumProcessedMessages = "erd_p2p_peer_num_processed_messages"

MetricP2PPeerNumProcessedMessages represents the current maximum number of processed messages in the amount of time counted on a connected peer

const MetricP2PPeerNumReceivedMessages = "erd_p2p_peer_num_received_messages"

MetricP2PPeerNumReceivedMessages represents the current maximum number of received messages in the amount of time counted on a connected peer

const MetricP2PPeerSizeProcessedMessages = "erd_p2p_peer_size_processed_messages"

MetricP2PPeerSizeProcessedMessages represents the current maximum size of processed data (sum of all messages) in the amount of time counted on a connected peer

const MetricP2PPeerSizeReceivedMessages = "erd_p2p_peer_size_received_messages"

MetricP2PPeerSizeReceivedMessages represents the current maximum size of received data (sum of all messages) in the amount of time counted on a connected peer

const MetricP2PUnknownPeers = "erd_p2p_unknown_shard_peers"

MetricP2PUnknownPeers is the metric that outputs the unknown-shard connected peers

const MetricPeerSubType = "erd_peer_subtype"

MetricPeerSubType is the metric which tells the peer's subtype (regular observer or full history observer)

const MetricPeerType = "erd_peer_type"

MetricPeerType is the metric which tells the peer's type (in eligible list, in waiting list, or observer)

const MetricPeersSnapshotInProgress = "erd_peers_snapshot_in_progress"

MetricPeersSnapshotInProgress is the metric that outputs the status of the peers' snapshot, if it's in progress or not

const MetricProbableHighestNonce = "erd_probable_highest_nonce"

MetricProbableHighestNonce is the metric for monitoring the max speculative nonce received by the node by listening on the network

const MetricProcessedProposedBlock = "erd_consensus_processed_proposed_block"

MetricProcessedProposedBlock is the metric that specify the percent of the block subround used for header and body processing (0 meaning that the block was processed in no-time and 100 meaning that the block processing used all the subround spare duration)

const MetricPublicKeyBlockSign = "erd_public_key_block_sign"

MetricPublicKeyBlockSign is the metric for monitoring public key of a node used in block signing

const MetricReceivedProposedBlock = "erd_consensus_received_proposed_block"

MetricReceivedProposedBlock is the metric that specifies the moment in the round when the received block has reached the current node. The value is provided in percent (0 meaning it has been received just after the round started and 100 meaning that the block has been received in the last moment of the round)

const MetricRedundancyIsMainActive = "erd_redundancy_is_main_active"

MetricRedundancyIsMainActive is the metric that specifies data about the redundancy main machine

const MetricRedundancyLevel = "erd_redundancy_level"

MetricRedundancyLevel is the metric that specifies the redundancy level of the current node

const MetricRedundancyStepInReason = "erd_redundancy_step_in_reason"

MetricRedundancyStepInReason is the metric that specifies why the back-up machine stepped in

const MetricRewardsTopUpGradientPoint = "erd_rewards_top_up_gradient_point"

MetricRewardsTopUpGradientPoint is the metric that specifies the rewards top up gradient point

const MetricRoundAtEpochStart = "erd_round_at_epoch_start"

MetricRoundAtEpochStart is the metric for storing the first round of the current epoch

const MetricRoundDuration = "erd_round_duration"

MetricRoundDuration is the metric that specifies the round duration in milliseconds

const MetricRoundTime = "erd_round_time"

MetricRoundTime is the metric for round time in seconds

const MetricRoundsPassedInCurrentEpoch = "erd_rounds_passed_in_current_epoch"

MetricRoundsPassedInCurrentEpoch is the metric that tells the number of rounds passed in current epoch

const MetricRoundsPerEpoch = "erd_rounds_per_epoch"

MetricRoundsPerEpoch is the metric that tells the number of rounds in an epoch

const MetricShardConsensusGroupSize = "erd_shard_consensus_group_size"

MetricShardConsensusGroupSize is the metric for the shard consensus group size

const MetricShardId = "erd_shard_id"

MetricShardId is the metric for monitoring shard id of a node

const MetricStartTime = "erd_start_time"

MetricStartTime is the metric that specifies the genesis start time

const MetricSynchronizedRound = "erd_synchronized_round"

MetricSynchronizedRound is the metric for monitoring the synchronized round of a node

const MetricTopUpFactor = "erd_top_up_factor"

MetricTopUpFactor is the metric that specifies the top-up factor

const MetricTopUpValue = "erd_total_top_up_value"

MetricTopUpValue holds the total top up value

const MetricTotalBaseStakedValue = "erd_total_base_staked_value"

MetricTotalBaseStakedValue holds the total base staked value

const MetricTotalFees = "erd_total_fees"

MetricTotalFees holds the total fees value for the last epoch

const MetricTotalSupply = "erd_total_supply"

MetricTotalSupply holds the total supply value for the last epoch

const MetricTrieSyncNumProcessedNodes = "erd_trie_sync_num_nodes_processed"

MetricTrieSyncNumProcessedNodes is the metric that outputs the number of trie nodes processed for accounts during trie sync

const MetricTrieSyncNumReceivedBytes = "erd_trie_sync_num_bytes_received"

MetricTrieSyncNumReceivedBytes is the metric that outputs the number of bytes received for accounts during trie sync

const MetricTxPoolLoad = "erd_tx_pool_load"

MetricTxPoolLoad is the metric for monitoring number of transactions from pool of a node

const MetricValueNA = "N/A"

MetricValueNA represents the value to be used when a metric is not available/applicable

const NodesCoordinatorRegistryKeyPrefix = "indexHashed_"

NodesCoordinatorRegistryKeyPrefix is the key prefix to save epoch start registry to storage

const NodesSetupJsonFileName = "nodesSetup.json"

NodesSetupJsonFileName specifies the name of the json file which contains the setup of the nodes

const NotSetDestinationShardID = "disabled"

NotSetDestinationShardID represents the shardIdString when the destinationShardId is not set in the prefs

const PeerAuthenticationTopic = "peerAuthentication"

PeerAuthenticationTopic is the topic used for peer authentication signaling

const PublicKeyBlacklistDuration = time.Second * 7200

PublicKeyBlacklistDuration represents the time to keep a public key in the black list if it will degrade its rating to a minimum threshold due to improper messages

const PutInStorerMaxTime = time.Second

PutInStorerMaxTime represents max time accepted for a put action, after which a warn message is displayed

const RetrialIntervalForOutportDriver = time.Second * 10

RetrialIntervalForOutportDriver is the interval in which the outport driver should try to call the driver again

const ShuffledOut = "shuffledOut"

ShuffledOut signals that a restart is pending because the node was shuffled out

const TemporaryPath = "temp"

TemporaryPath is the default temporary path directory

const TimeToWaitForP2PBootstrap = 20 * time.Second

TimeToWaitForP2PBootstrap is the wait time for the P2P to bootstrap

const TimeoutGettingTrieNodes = 2 * time.Minute // to consider syncing a very large trie node of 64MB at ~1MB/s

TimeoutGettingTrieNodes defines the timeout in trie sync operation if no node is received

const TimeoutGettingTrieNodesInHardfork = time.Minute * 10

TimeoutGettingTrieNodesInHardfork represents the maximum time allowed between 2 nodes fetches (and commits) during the hardfork process

const TriggerRegistryInitialKeyPrefix = "initial_value_epoch_"

TriggerRegistryInitialKeyPrefix is the key prefix to save initial data to storage

const TriggerRegistryKeyPrefix = "epochStartTrigger_"

TriggerRegistryKeyPrefix is the key prefix to save epoch start registry to storage

const UnVersionedAppString = "undefined"

UnVersionedAppString represents the default app version that indicate that the binary wasn't build by setting the appVersion flag

const ValidatorInfoTopic = "validatorInfo"

ValidatorInfoTopic is the topic used for validatorInfo signaling

const WrongConfiguration = "wrongConfiguration"

WrongConfiguration signals that the node has a malformed configuration and cannot continue processing

Variables

var EmptyTrieHash = make([]byte, 32)

EmptyTrieHash returns the value with empty trie hash

var ErrInvalidTimeout = errors.New("invalid timeout value")

ErrInvalidTimeout signals that an invalid timeout period has been provided

var ErrNilStateSyncNotifierSubscriber = errors.New("nil state sync notifier subscriber")

ErrNilStateSyncNotifierSubscriber signals that a nil state sync notifier subscriber has been provided

var ErrNilWasmChangeLocker = errors.New("nil wasm change locker")

ErrNilWasmChangeLocker signals that a nil wasm change locker has been provided

Functions

func AssignShardForPubKeyWhenNotSpecified

func AssignShardForPubKeyWhenNotSpecified(pubKey []byte, numShards uint32) uint32

AssignShardForPubKeyWhenNotSpecified will return the same shard ID when it is called with the same parameters This function fetched the last byte of the public key and based on a modulo operation it will return a shard ID

func CloseKeyValueHolderChan

func CloseKeyValueHolderChan(ch chan core.KeyValueHolder)

CloseKeyValueHolderChan will close the channel if not nil

func ExtractTokenIDAndNonceFromTokenStorageKey

func ExtractTokenIDAndNonceFromTokenStorageKey(tokenKey []byte) ([]byte, uint64)

ExtractTokenIDAndNonceFromTokenStorageKey will parse the token's storage key and extract the identifier and the nonce

func GetClosedUnbufferedChannel

func GetClosedUnbufferedChannel() chan struct{}

GetClosedUnbufferedChannel returns an instance of a 'chan struct{}' that is already closed

func GetSkBytesFromP2pKey

func GetSkBytesFromP2pKey(p2pKeyFilename string) ([]byte, error)

GetSkBytesFromP2pKey will read key file based on provided path. If no valid filename it will return an empty byte array, otherwise it will try to fetch the private key and return the decoded byte array.

func IsContextDone

func IsContextDone(ctx context.Context) bool

IsContextDone will return true if the provided context signals it is done

func IsEmptyTrie

func IsEmptyTrie(root []byte) bool

IsEmptyTrie returns true if the given root is for an empty trie

func LoadApiConfig

func LoadApiConfig(filepath string) (*config.ApiRoutesConfig, error)

LoadApiConfig returns a ApiRoutesConfig by reading the config file provided

func LoadEconomicsConfig

func LoadEconomicsConfig(filepath string) (*config.EconomicsConfig, error)

LoadEconomicsConfig returns a EconomicsConfig by reading the config file provided

func LoadEpochConfig

func LoadEpochConfig(filepath string) (*config.EpochConfig, error)

LoadEpochConfig returns an EpochConfig by reading from the provided config file

func LoadExternalConfig

func LoadExternalConfig(filepath string) (*config.ExternalConfig, error)

LoadExternalConfig returns a ExternalConfig by reading the config file provided

func LoadGasScheduleConfig

func LoadGasScheduleConfig(filepath string) (map[string]map[string]uint64, error)

LoadGasScheduleConfig returns a map[string]uint64 of gas costs read from the provided config file

func LoadMainConfig

func LoadMainConfig(filepath string) (*config.Config, error)

LoadMainConfig returns a Config by reading the config file provided

func LoadP2PConfig

func LoadP2PConfig(filepath string) (*p2pConfig.P2PConfig, error)

LoadP2PConfig returns a P2PConfig by reading the config file provided

func LoadPreferencesConfig

func LoadPreferencesConfig(filepath string) (*config.Preferences, error)

LoadPreferencesConfig returns a Preferences by reading the config file provided

func LoadRatingsConfig

func LoadRatingsConfig(filepath string) (*config.RatingsConfig, error)

LoadRatingsConfig returns a RatingsConfig by reading the config file provided

func LoadRoundConfig

func LoadRoundConfig(filePath string) (*config.RoundConfig, error)

LoadRoundConfig returns a RoundConfig by reading from provided config file

func LoadSystemSmartContractsConfig

func LoadSystemSmartContractsConfig(filepath string) (*config.SystemSmartContractsConfig, error)

LoadSystemSmartContractsConfig returns a SystemSmartContractsConfig by reading the config file provided

func NewPidQueue

func NewPidQueue() *pidQueue

NewPidQueue returns a new instance of pid queue

func NewTimeoutHandler

func NewTimeoutHandler(timeout time.Duration) (*timeoutHandler, error)

NewTimeoutHandler returns a new instance of the timeout handler

func ProcessDestinationShardAsObserver

func ProcessDestinationShardAsObserver(destinationShardIdAsObserver string) (uint32, error)

ProcessDestinationShardAsObserver returns the shardID given the destination as observer string

func SuffixedMetric

func SuffixedMetric(metric string, suffix string) string

SuffixedMetric appends the suffix to the provided metric and returns it

func TrimSuffixFromValue

func TrimSuffixFromValue(value []byte, suffixLength int) ([]byte, error)

TrimSuffixFromValue returns the value without the suffix

Types

type AlteredAccountsForBlockAPIResponse

type AlteredAccountsForBlockAPIResponse struct {
	Accounts []*alteredAccount.AlteredAccount `json:"accounts"`
}

AlteredAccountsForBlockAPIResponse holds the altered accounts for a certain block

type ApiOutputFormat

type ApiOutputFormat uint8

ApiOutputFormat represents the format type returned by api

const (
	// ApiOutputFormatJSON outport format returns struct directly, will be serialized into JSON by gin
	ApiOutputFormatJSON ApiOutputFormat = 0

	// ApiOutputFormatProto outport format returns the bytes of the proto object
	ApiOutputFormatProto ApiOutputFormat = 1
)

type AuctionListValidatorAPIResponse

type AuctionListValidatorAPIResponse struct {
	Owner          string         `json:"owner"`
	NumStakedNodes int64          `json:"numStakedNodes"`
	TotalTopUp     string         `json:"totalTopUp"`
	TopUpPerNode   string         `json:"topUpPerNode"`
	QualifiedTopUp string         `json:"qualifiedTopUp"`
	Nodes          []*AuctionNode `json:"nodes"`
}

AuctionListValidatorAPIResponse holds the data needed for an auction node validator for responding to API calls

type AuctionNode

type AuctionNode struct {
	BlsKey    string `json:"blsKey"`
	Qualified bool   `json:"qualified"`
}

AuctionNode holds data needed for a node in auction to respond to API calls

type BaseStorer

type BaseStorer interface {
	Put(key, val []byte) error
	Get(key []byte) ([]byte, error)
	Remove(key []byte) error
	Close() error
	IsInterfaceNil() bool
}

BaseStorer define the base methods needed for a storer

type BlockInfo

type BlockInfo interface {
	GetNonce() uint64
	GetHash() []byte
	GetRootHash() []byte
	Equal(blockInfo BlockInfo) bool
	IsInterfaceNil() bool
}

BlockInfo provides a block information such as nonce, hash, roothash and so on

type BlockProcessingCutoffMode

type BlockProcessingCutoffMode string

BlockProcessingCutoffMode represents the type to be used to identify the mode of the block processing cutoff

type BlockProcessingCutoffTrigger

type BlockProcessingCutoffTrigger string

BlockProcessingCutoffTrigger represents the trigger of the cutoff potentially used in block processing

const (
	// BlockProcessingCutoffByNonce represents the cutoff by nonce
	BlockProcessingCutoffByNonce BlockProcessingCutoffTrigger = "nonce"
	// BlockProcessingCutoffByRound represents the cutoff by round
	BlockProcessingCutoffByRound BlockProcessingCutoffTrigger = "round"
	// BlockProcessingCutoffByEpoch represents the cutoff by epoch
	BlockProcessingCutoffByEpoch BlockProcessingCutoffTrigger = "epoch"
)

type BufferedErrChan

type BufferedErrChan interface {
	WriteInChanNonBlocking(err error)
	ReadFromChanNonBlocking() error
	Close()
	IsInterfaceNil() bool
}

BufferedErrChan is an interface that defines the methods for a buffered error channel

type DataTrieHandler

type DataTrieHandler interface {
	RootHash() ([]byte, error)
	GetAllLeavesOnChannel(leavesChannels *TrieIteratorChannels, ctx context.Context, rootHash []byte, keyBuilder KeyBuilder, trieLeafParser TrieLeafParser) error
	IsMigratedToLatestVersion() (bool, error)
	IsInterfaceNil() bool
}

DataTrieHandler is an interface that declares the methods used for dataTries

type DelegationDataAPI

type DelegationDataAPI struct {
	Address string `json:"address"`
	Value   string `json:"value"`
}

DelegationDataAPI will be used when requesting the genesis balances from API

type EnableEpochsHandler

type EnableEpochsHandler interface {
	GetCurrentEpoch() uint32
	IsFlagDefined(flag core.EnableEpochFlag) bool
	IsFlagEnabled(flag core.EnableEpochFlag) bool
	IsFlagEnabledInEpoch(flag core.EnableEpochFlag, epoch uint32) bool
	GetActivationEpoch(flag core.EnableEpochFlag) uint32

	IsInterfaceNil() bool
}

EnableEpochsHandler is used to verify which flags are set in a specific epoch based on EnableEpochs config

type EpochStartDataAPI

type EpochStartDataAPI struct {
	Nonce             uint64 `json:"nonce"`
	Round             uint64 `json:"round"`
	Timestamp         int64  `json:"timestamp"`
	Epoch             uint32 `json:"epoch"`
	Shard             uint32 `json:"shard"`
	PrevBlockHash     string `json:"prevBlockHash"`
	StateRootHash     string `json:"stateRootHash"`
	ScheduledRootHash string `json:"scheduledRootHash"`
	AccumulatedFees   string `json:"accumulatedFees,omitempty"`
	DeveloperFees     string `json:"developerFees,omitempty"`
}

EpochStartDataAPI holds fields from the first block in a given epoch

type ExecutionOrderGetter

type ExecutionOrderGetter interface {
	GetItemAtIndex(index uint32) ([]byte, error)
	GetOrder(txHash []byte) (int, error)
	GetItems() [][]byte
	Contains(txHash []byte) bool
	Len() int
	IsInterfaceNil() bool
}

ExecutionOrderGetter defines the functionality of a component that can return the execution order of a block transactions

type GasScheduleNotifierAPI

type GasScheduleNotifierAPI interface {
	core.GasScheduleNotifier
	LatestGasScheduleCopy() map[string]map[string]uint64
}

GasScheduleNotifierAPI defines the behavior of the gas schedule notifier components that is used for api

type GetProofResponse

type GetProofResponse struct {
	Proof    [][]byte
	Value    []byte
	RootHash string
}

GetProofResponse is a struct that stores the response of a GetProof API request

type InitialAccountAPI

type InitialAccountAPI struct {
	Address      string            `json:"address"`
	Supply       string            `json:"supply"`
	Balance      string            `json:"balance"`
	StakingValue string            `json:"stakingvalue"`
	Delegation   DelegationDataAPI `json:"delegation"`
}

InitialAccountAPI represents the structure to be returned when requesting the genesis balances from API

type KeyBuilder

type KeyBuilder interface {
	BuildKey(keyPart []byte)
	GetKey() ([]byte, error)
	Clone() KeyBuilder
	IsInterfaceNil() bool
}

KeyBuilder is used for building trie keys as you traverse the trie

type Locker

type Locker interface {
	Lock()
	Unlock()
	RLock()
	RUnlock()
}

Locker defines the operations used to lock different critical areas. Implemented by the RWMutex.

type ManagedPeersHolder

type ManagedPeersHolder interface {
	AddManagedPeer(privateKeyBytes []byte) error
	GetPrivateKey(pkBytes []byte) (crypto.PrivateKey, error)
	GetP2PIdentity(pkBytes []byte) ([]byte, core.PeerID, error)
	GetMachineID(pkBytes []byte) (string, error)
	GetNameAndIdentity(pkBytes []byte) (string, string, error)
	IncrementRoundsWithoutReceivedMessages(pkBytes []byte)
	ResetRoundsWithoutReceivedMessages(pkBytes []byte, pid core.PeerID)
	GetManagedKeysByCurrentNode() map[string]crypto.PrivateKey
	GetLoadedKeysByCurrentNode() [][]byte
	IsKeyManagedByCurrentNode(pkBytes []byte) bool
	IsKeyRegistered(pkBytes []byte) bool
	IsPidManagedByCurrentNode(pid core.PeerID) bool
	IsKeyValidator(pkBytes []byte) bool
	SetValidatorState(pkBytes []byte, state bool)
	GetNextPeerAuthenticationTime(pkBytes []byte) (time.Time, error)
	SetNextPeerAuthenticationTime(pkBytes []byte, nextTime time.Time)
	IsMultiKeyMode() bool
	GetRedundancyStepInReason() string
	IsInterfaceNil() bool
}

ManagedPeersHolder defines the operations of an entity that holds managed identities for a node

type ManagedPeersMonitor

type ManagedPeersMonitor interface {
	GetManagedKeysCount() int
	GetManagedKeys() [][]byte
	GetLoadedKeys() [][]byte
	GetEligibleManagedKeys() ([][]byte, error)
	GetWaitingManagedKeys() ([][]byte, error)
	IsInterfaceNil() bool
}

ManagedPeersMonitor defines the operations of an entity that monitors the managed peers holder

type MerkleProofVerifier

type MerkleProofVerifier interface {
	VerifyProof(rootHash []byte, key []byte, proof [][]byte) (bool, error)
}

MerkleProofVerifier is used to verify merkle proofs

type MissingTrieNodesNotifier

type MissingTrieNodesNotifier interface {
	RegisterHandler(handler StateSyncNotifierSubscriber) error
	AsyncNotifyMissingTrieNode(hash []byte)
	IsInterfaceNil() bool
}

MissingTrieNodesNotifier defines the operations of an entity that notifies about missing trie nodes

type ModifiedHashes

type ModifiedHashes map[string]struct{}

ModifiedHashes is used to memorize all old hashes and new hashes from when a trie is committed

func (ModifiedHashes) Clone

func (mh ModifiedHashes) Clone() ModifiedHashes

Clone is used to create a clone of the map

type NodeOperation

type NodeOperation string

NodeOperation defines the p2p node operation

const FullArchiveMode NodeOperation = "full archive mode"

FullArchiveMode defines the node operation as a full archive mode

const NormalOperation NodeOperation = "normal operation"

NormalOperation defines the normal mode operation: either seeder, observer or validator

type NodeProcessingMode

type NodeProcessingMode int

NodeProcessingMode represents the processing mode in which the node was started

const (
	// Normal means that the node has started in the normal processing mode
	Normal NodeProcessingMode = iota

	// ImportDb means that the node has started in the import-db mode
	ImportDb
)

func GetNodeProcessingMode

func GetNodeProcessingMode(importDbConfig *config.ImportDbConfig) NodeProcessingMode

GetNodeProcessingMode returns the node processing mode based on the provided config

type NodeState

type NodeState int

NodeState specifies what type of state a node could have

const (
	// NsSynchronized defines ID of a state of synchronized
	NsSynchronized NodeState = iota
	// NsNotSynchronized defines ID of a state of not synchronized
	NsNotSynchronized
	// NsNotCalculated defines ID of a state which is not calculated
	NsNotCalculated
)

type NonceGapApiResponse

type NonceGapApiResponse struct {
	From uint64 `json:"from"`
	To   uint64 `json:"to"`
}

NonceGapApiResponse is a struct that holds a nonce gap from transactions pool From - first unknown nonce To - last unknown nonce

type PeerType

type PeerType string

PeerType represents the type of peer

const AuctionList PeerType = "auction"

AuctionList represents the list of peers which don't participate in consensus yet, but will be selected based on their top up stake

const EligibleList PeerType = "eligible"

EligibleList represents the list of peers who participate in consensus inside a shard

const InactiveList PeerType = "inactive"

InactiveList represents the list of peers who were taken out because they were leaving

const JailedList PeerType = "jailed"

JailedList represents the list of peers who have stake but are in jail

const LeavingList PeerType = "leaving"

LeavingList represents the list of peers who were taken out of eligible and waiting because of rating

const NewList PeerType = "new"

NewList represents the list of peers who have stake and are pending to become eligible

const ObserverList PeerType = "observer"

ObserverList represents the list of peers who don't participate in consensus but will join the next epoch

const SelectedFromAuctionList PeerType = "selectedFromAuction"

SelectedFromAuctionList represents the list of peers which have been selected from AuctionList based on their top up to be distributed on the WaitingList in the next epoch

const WaitingList PeerType = "waiting"

WaitingList represents the list of peers who don't participate in consensus but will join the next epoch

type PidQueueHandler

type PidQueueHandler interface {
	Push(pid core.PeerID)
	Pop() core.PeerID
	IndexOf(pid core.PeerID) int
	Promote(idx int)
	Remove(pid core.PeerID)
	DataSizeInBytes() int
	Get(idx int) core.PeerID
	Len() int
	IsInterfaceNil() bool
}

PidQueueHandler defines the behavior of a queue of pids

type ProcessStatusHandler

type ProcessStatusHandler interface {
	SetBusy(reason string)
	SetIdle()
	IsIdle() bool
	IsInterfaceNil() bool
}

ProcessStatusHandler defines the behavior of a component able to hold the current status of the node and able to tell if the node is idle or processing/committing a block

type ReceiptsHolder

type ReceiptsHolder interface {
	GetMiniblocks() []*block.MiniBlock
	IsInterfaceNil() bool
}

ReceiptsHolder holds receipts content (e.g. miniblocks)

type RootHashHolder

type RootHashHolder interface {
	GetRootHash() []byte
	GetEpoch() core.OptionalUint32
	String() string
	IsInterfaceNil() bool
}

RootHashHolder holds a rootHash and the corresponding epoch

type SizeSyncStatisticsHandler

type SizeSyncStatisticsHandler interface {
	data.SyncStatisticsHandler
	AddNumBytesReceived(bytes uint64)
	NumBytesReceived() uint64
	NumTries() int
	AddProcessingTime(duration time.Duration)
	IncrementIteration()
	ProcessingTime() time.Duration
	NumIterations() int
}

SizeSyncStatisticsHandler extends the SyncStatisticsHandler interface by allowing setting up the trie node size

type SnapshotDbHandler

type SnapshotDbHandler interface {
	BaseStorer
	IsInUse() bool
	DecreaseNumReferences()
	IncreaseNumReferences()
	MarkForRemoval()
	MarkForDisconnection()
	SetPath(string)
}

SnapshotDbHandler is used to keep track of how many references a snapshot db has

type SnapshotStatisticsHandler

type SnapshotStatisticsHandler interface {
	SnapshotFinished()
	NewSnapshotStarted()
	WaitForSnapshotsToFinish()
	AddTrieStats(handler TrieStatisticsHandler, trieType TrieType)
	GetSnapshotDuration() int64
	GetSnapshotNumNodes() uint64
	IsInterfaceNil() bool
}

SnapshotStatisticsHandler is used to measure different statistics for the trie snapshot

type StateStatisticsHandler

type StateStatisticsHandler interface {
	Reset()
	ResetSnapshot()

	IncrementCache()
	Cache() uint64
	IncrementSnapshotCache()
	SnapshotCache() uint64

	IncrementPersister(epoch uint32)
	Persister(epoch uint32) uint64
	IncrementSnapshotPersister(epoch uint32)
	SnapshotPersister(epoch uint32) uint64

	IncrementTrie()
	Trie() uint64

	ProcessingStats() []string
	SnapshotStats() []string

	IsInterfaceNil() bool
}

StateStatisticsHandler defines the behaviour of a storage statistics handler

type StateSyncNotifierSubscriber

type StateSyncNotifierSubscriber interface {
	MissingDataTrieNodeFound(hash []byte)
	IsInterfaceNil() bool
}

StateSyncNotifierSubscriber defines the operations of an entity that subscribes to a missing trie nodes notifier

type StorageManager

type StorageManager interface {
	TrieStorageInteractor
	GetFromCurrentEpoch(key []byte) ([]byte, error)
	PutInEpoch(key []byte, val []byte, epoch uint32) error
	PutInEpochWithoutCache(key []byte, val []byte, epoch uint32) error
	TakeSnapshot(address string, rootHash []byte, mainTrieRootHash []byte, iteratorChannels *TrieIteratorChannels, missingNodesChan chan []byte, stats SnapshotStatisticsHandler, epoch uint32)
	GetLatestStorageEpoch() (uint32, error)
	IsPruningEnabled() bool
	IsPruningBlocked() bool
	EnterPruningBufferingMode()
	ExitPruningBufferingMode()
	RemoveFromAllActiveEpochs(hash []byte) error
	SetEpochForPutOperation(uint32)
	ShouldTakeSnapshot() bool
	IsSnapshotSupported() bool
	GetBaseTrieStorageManager() StorageManager
	IsClosed() bool
	Close() error
	IsInterfaceNil() bool
}

StorageManager manages all trie storage operations

type StorageMarker

type StorageMarker interface {
	MarkStorerAsSyncedAndActive(storer StorageManager)
	IsInterfaceNil() bool
}

StorageMarker is used to mark the given storer as synced and active

type Transaction

type Transaction struct {
	TxFields map[string]interface{} `json:"txFields"`
}

Transaction is a struct that holds transaction fields to be returned when getting the transactions from pool

type TransactionsPoolAPIResponse

type TransactionsPoolAPIResponse struct {
	RegularTransactions  []Transaction `json:"regularTransactions"`
	SmartContractResults []Transaction `json:"smartContractResults"`
	Rewards              []Transaction `json:"rewards"`
}

TransactionsPoolAPIResponse is a struct that holds the data to be returned when getting the transaction pool from an API call

type TransactionsPoolForSenderApiResponse

type TransactionsPoolForSenderApiResponse struct {
	Transactions []Transaction `json:"transactions"`
}

TransactionsPoolForSenderApiResponse is a struct that holds the data to be returned when getting the transactions for a sender from an API call

type TransactionsPoolNonceGapsForSenderApiResponse

type TransactionsPoolNonceGapsForSenderApiResponse struct {
	Sender string                `json:"sender"`
	Gaps   []NonceGapApiResponse `json:"gaps"`
}

TransactionsPoolNonceGapsForSenderApiResponse is a struct that holds the data to be returned when getting the nonce gaps from transactions pool for a sender from an API call

type Trie

type Trie interface {
	Get(key []byte) ([]byte, uint32, error)
	Update(key, value []byte) error
	Delete(key []byte) error
	RootHash() ([]byte, error)
	Commit() error
	Recreate(options RootHashHolder) (Trie, error)
	String() string
	GetObsoleteHashes() [][]byte
	GetDirtyHashes() (ModifiedHashes, error)
	GetOldRoot() []byte
	GetSerializedNodes([]byte, uint64) ([][]byte, uint64, error)
	GetSerializedNode([]byte) ([]byte, error)
	GetAllLeavesOnChannel(allLeavesChan *TrieIteratorChannels, ctx context.Context, rootHash []byte, keyBuilder KeyBuilder, trieLeafParser TrieLeafParser) error
	GetAllHashes() ([][]byte, error)
	GetProof(key []byte) ([][]byte, []byte, error)
	VerifyProof(rootHash []byte, key []byte, proof [][]byte) (bool, error)
	GetStorageManager() StorageManager
	IsMigratedToLatestVersion() (bool, error)
	Close() error
	IsInterfaceNil() bool
}

Trie is an interface for Merkle Trees implementations

type TrieIteratorChannels

type TrieIteratorChannels struct {
	LeavesChan chan core.KeyValueHolder
	ErrChan    BufferedErrChan
}

TrieIteratorChannels defines the channels that are being used when iterating the trie nodes

type TrieLeafParser

type TrieLeafParser interface {
	ParseLeaf(key []byte, val []byte, version core.TrieNodeVersion) (core.KeyValueHolder, error)
	IsInterfaceNil() bool
}

TrieLeafParser is used to parse trie leaves

type TrieStatisticsHandler

type TrieStatisticsHandler interface {
	AddBranchNode(level int, size uint64)
	AddExtensionNode(level int, size uint64)
	AddLeafNode(level int, size uint64, version core.TrieNodeVersion)
	AddAccountInfo(address string, rootHash []byte)

	GetTotalNodesSize() uint64
	GetTotalNumNodes() uint64
	GetMaxTrieDepth() uint32
	GetBranchNodesSize() uint64
	GetNumBranchNodes() uint64
	GetExtensionNodesSize() uint64
	GetNumExtensionNodes() uint64
	GetLeafNodesSize() uint64
	GetNumLeafNodes() uint64
	GetLeavesMigrationStats() map[core.TrieNodeVersion]uint64

	MergeTriesStatistics(statsToBeMerged TrieStatisticsHandler)
	ToString() []string
	IsInterfaceNil() bool
}

TrieStatisticsHandler is used to collect different statistics about a single trie

type TrieStats

type TrieStats interface {
	GetTrieStats(address string, rootHash []byte) (TrieStatisticsHandler, error)
}

TrieStats is used to collect the trie statistics for the given rootHash

type TrieStorageInteractor

type TrieStorageInteractor interface {
	BaseStorer
	GetIdentifier() string
	GetStateStatsHandler() StateStatisticsHandler
}

TrieStorageInteractor defines the methods used for interacting with the trie storage

type TrieType

type TrieType string

TrieType defines the type of the trie

const (
	// MainTrie represents the main trie in which all the accounts and SC code are stored
	MainTrie TrieType = "mainTrie"

	// DataTrie represents a data trie in which all the data related to an account is stored
	DataTrie TrieType = "dataTrie"
)

type TriesHolder

type TriesHolder interface {
	Put([]byte, Trie)
	Replace(key []byte, tr Trie)
	Get([]byte) Trie
	GetAll() []Trie
	Reset()
	IsInterfaceNil() bool
}

TriesHolder is used to store multiple tries

type TriesStatisticsCollector

type TriesStatisticsCollector interface {
	Add(trieStats TrieStatisticsHandler, trieType TrieType)
	Print()
	GetNumNodes() uint64
}

TriesStatisticsCollector is used to merge the statistics for multiple tries

type TxExecutionOrderHandler

type TxExecutionOrderHandler interface {
	Add(txHash []byte)
	GetItemAtIndex(index uint32) ([]byte, error)
	GetOrder(txHash []byte) (int, error)
	Remove(txHash []byte)
	RemoveMultiple(txHashes [][]byte)
	GetItems() [][]byte
	Contains(txHash []byte) bool
	Clear()
	Len() int
	IsInterfaceNil() bool
}

TxExecutionOrderHandler is used to collect and provide the order of transactions execution