common

package
v1.7.0 Latest Latest
Warning

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

 Go to latest Published: Jan 30, 2024 License: GPL-3.0 Imports: 19 Imported by: 10

Documentation

Index

Constants

View Source 
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"

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

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

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

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

	// MetricAdaptivity represents a boolean to determine if adaptivity will be enabled or not
	MetricAdaptivity = "erd_adaptivity"
)
View Source 
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"

	// 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"
)
View Source 
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
)
View Source 
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
)
View Source 
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"
)
View Source 
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"
	StakingQueueFlag                                   core.EnableEpochFlag = "StakingQueueFlag"
	StakingV4StartedFlag                               core.EnableEpochFlag = "StakingV4StartedFlag"
)

Enable epoch flags definitions

View Source 
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

View Source 
const AsyncCallStepField = "AsyncCallStep"

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

View Source 
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

View Source 
const BaseOperationCost = "BaseOperationCost"

BaseOperationCost represents the field name for base operation costs

View Source 
const BaseOpsAPICost = "BaseOpsAPICost"

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

View Source 
const BuiltInCost = "BuiltInCost"

BuiltInCost represents the field name for built-in operation costs

View Source 
const CombinedPeerType = "%s (%s)"

CombinedPeerType - represents the combination of two peerTypes

View Source 
const CommitMaxTime = 3 * time.Second

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

View Source 
const ConnectionTopic = "connection"

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

View Source 
const ConsensusTopic = "consensus"

ConsensusTopic is the topic used in consensus algorithm

View Source 
const DefaultDBPath = "db"

DefaultDBPath is the default path for nodes databases

View Source 
const DefaultInterceptorsIdentifier = "default interceptor"

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

View Source 
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

View Source 
const DefaultResolversIdentifier = "default resolver"

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

View Source 
const DefaultStatsPath = "stats"

DefaultStatsPath is the default path where the node stats are logged

View Source 
const DefaultUnstakedEpoch = math.MaxUint32

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

View Source 
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

View Source 
const EpochStartInterceptorsIdentifier = "epoch start interceptor"

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

View Source 
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

View Source 
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

View Source 
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

View Source 
const FullArchiveMetricSuffix = "_full_archive"

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

View Source 
const GenesisStorageSuffix = "_genesis"

GenesisStorageSuffix defines the storage suffix used for genesis altered data

View Source 
const GenesisTxSignatureString = "GENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISG"

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

View Source 
const HardforkInterceptorsIdentifier = "hardfork interceptor"

HardforkInterceptorsIdentifier represents the identifier that is used in the hardfork process

View Source 
const HardforkResolversIdentifier = "hardfork resolver"

HardforkResolversIdentifier represents the resolver that is used in the hardfork process

View Source 
const HeartbeatV2Topic = "heartbeatV2"

HeartbeatV2Topic is the topic used for heartbeatV2 signaling

View Source 
const HighestRoundFromBootStorage = "highestRoundFromBootStorage"

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

View Source 
const ImportComplete = "importComplete"

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

View Source 
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

View Source 
const InvalidSigningBlacklistDuration = time.Second * 7200

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

View Source 
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

View Source 
const MaxIndexOfTxInMiniBlock = int32(29999)

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

View Source 
const MaxPerTransaction = "MaxPerTransaction"

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

View Source 
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

View Source 
const MaxSoftwareVersionLengthInBytes = 10

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

View Source 
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.

View Source 
const MaxTxsToRequest = 1000

MaxTxsToRequest specifies the maximum number of txs to request

View Source 
const MaxWaitingTimeToReceiveRequestedItem = 5 * time.Second

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

View Source 
const MetaChainSystemSCsCost = "MetaChainSystemSCsCost"

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

View Source 
const MetachainShardId = uint32(0xFFFFFFFF)

MetachainShardId will be used to identify a shard ID as metachain

View Source 
const MetachainShardName = "metachain"

MetachainShardName is the string identifier of the metachain shard

View Source 
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

View Source 
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

View Source 
const MetricAccountsSnapshotNumNodes = "erd_accounts_snapshot_num_nodes"

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

View Source 
const MetricAppVersion = "erd_app_version"

MetricAppVersion is the metric for the current app version

View Source 
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

View Source 
const MetricChainId = "erd_chain_id"

MetricChainId is the metric that specifies current chain id

View Source 
const MetricConnectedNodes = "erd_connected_nodes"

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

View Source 
const MetricConsensusGroupSize = "erd_consensus_group_size"

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

View Source 
const MetricConsensusRoundState = "erd_consensus_round_state"

MetricConsensusRoundState is the metric for consensus round state for a block

View Source 
const MetricConsensusState = "erd_consensus_state"

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

View Source 
const MetricCountAcceptedBlocks = "erd_count_accepted_blocks"

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

View Source 
const MetricCountConsensus = "erd_count_consensus"

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

View Source 
const MetricCountConsensusAcceptedBlocks = "erd_count_consensus_accepted_blocks"

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

View Source 
const MetricCountLeader = "erd_count_leader"

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

View Source 
const MetricCpuLoadPercent = "erd_cpu_load_percent"

MetricCpuLoadPercent is the metric for monitoring CPU load [%]

View Source 
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)

View Source 
const MetricCrossCheckBlockHeight = "erd_cross_check_block_height"

MetricCrossCheckBlockHeight is the metric that store cross block height

View Source 
const MetricCrossCheckBlockHeightMeta = "erd_cross_check_block_height_meta"

MetricCrossCheckBlockHeightMeta is the metric that store metachain cross block height

View Source 
const MetricCurrentBlockHash = "erd_current_block_hash"

MetricCurrentBlockHash is the metric that stores the current block hash

View Source 
const MetricCurrentRound = "erd_current_round"

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

View Source 
const MetricCurrentRoundTimestamp = "erd_current_round_timestamp"

MetricCurrentRoundTimestamp is the metric that stores current round timestamp

View Source 
const MetricDenomination = "erd_denomination"

MetricDenomination is the metric for exposing the denomination

View Source 
const MetricDevRewardsInEpoch = "erd_dev_rewards"

MetricDevRewardsInEpoch holds the developers' rewards value for the last epoch

View Source 
const MetricEpochForEconomicsData = "erd_epoch_for_economics_data"

MetricEpochForEconomicsData holds the epoch for which economics data are computed

View Source 
const MetricEpochNumber = "erd_epoch_number"

MetricEpochNumber is the metric for the number of epoch

View Source 
const MetricExtraGasLimitGuardedTx = "erd_extra_gas_limit_guarded_tx"

MetricExtraGasLimitGuardedTx specifies the extra gas limit required for guarded transactions

View Source 
const MetricGasPerDataByte = "erd_gas_per_data_byte"

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

View Source 
const MetricGasPriceModifier = "erd_gas_price_modifier"

MetricGasPriceModifier is the metric that specifies the gas price modifier

View Source 
const MetricGatewayMetricsEndpoint = "erd_gateway_metrics_endpoint"

MetricGatewayMetricsEndpoint is the metric that specifies gateway endpoint

View Source 
const MetricHeaderSize = "erd_current_block_size"

MetricHeaderSize is the metric that stores the current block size

View Source 
const MetricHighestFinalBlock = "erd_highest_final_nonce"

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

View Source 
const MetricInflation = "erd_inflation"

MetricInflation holds the inflation value for the last epoch

View Source 
const MetricIsSyncing = "erd_is_syncing"

MetricIsSyncing is the metric for monitoring if a node is syncing

View Source 
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

View Source 
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

View Source 
const MetricLatestTagSoftwareVersion = "erd_latest_tag_software_version"

MetricLatestTagSoftwareVersion is the metric that stores the latest tag software version

View Source 
const MetricLeaderPercentage = "erd_leader_percentage"

MetricLeaderPercentage is the metric for leader rewards percentage

View Source 
const MetricLiveValidatorNodes = "erd_live_validator_nodes"

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

View Source 
const MetricMaxGasPerTransaction = "erd_max_gas_per_transaction"

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

View Source 
const MetricMemHeapInUse = "erd_mem_heap_inuse"

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

View Source 
const MetricMemLoadPercent = "erd_mem_load_percent"

MetricMemLoadPercent is the metric for monitoring memory load [%]

View Source 
const MetricMemStackInUse = "erd_mem_stack_inuse"

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

View Source 
const MetricMemTotal = "erd_mem_total"

MetricMemTotal is the metric for monitoring total memory bytes

View Source 
const MetricMemUsedGolang = "erd_mem_used_golang"

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

View Source 
const MetricMemUsedSystem = "erd_mem_used_sys"

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

View Source 
const MetricMetaConsensusGroupSize = "erd_meta_consensus_group_size"

MetricMetaConsensusGroupSize is the metric for the metachain consensus group size

View Source 
const MetricMinGasLimit = "erd_min_gas_limit"

MetricMinGasLimit is the metric that specifies the minimum gas limit

View Source 
const MetricMinGasPrice = "erd_min_gas_price"

MetricMinGasPrice is the metric that specifies min gas price

View Source 
const MetricMinTransactionVersion = "erd_min_transaction_version"

MetricMinTransactionVersion is the metric that specifies the minimum transaction version

View Source 
const MetricMiniBlocksSize = "erd_mini_blocks_size"

MetricMiniBlocksSize is the metric that stores the current block size

View Source 
const MetricNetworkRecvBps = "erd_network_recv_bps"

MetricNetworkRecvBps is the metric for monitoring network received bytes per second

View Source 
const MetricNetworkRecvBpsPeak = "erd_network_recv_bps_peak"

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

View Source 
const MetricNetworkRecvBytesInCurrentEpochPerHost = "erd_network_recv_bytes_in_epoch_per_host"

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

View Source 
const MetricNetworkRecvPercent = "erd_network_recv_percent"

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

View Source 
const MetricNetworkSendBytesInCurrentEpochPerHost = "erd_network_sent_bytes_in_epoch_per_host"

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

View Source 
const MetricNetworkSentBps = "erd_network_sent_bps"

MetricNetworkSentBps is the metric for monitoring network sent bytes per second

View Source 
const MetricNetworkSentBpsPeak = "erd_network_sent_bps_peak"

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

View Source 
const MetricNetworkSentPercent = "erd_network_sent_percent"

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

View Source 
const MetricNodeDisplayName = "erd_node_display_name"

MetricNodeDisplayName is the metric that stores the name of the node

View Source 
const MetricNodeType = "erd_node_type"

MetricNodeType is the metric for monitoring the type of the node

View Source 
const MetricNonce = "erd_nonce"

MetricNonce is the metric for monitoring the nonce of a node

View Source 
const MetricNonceAtEpochStart = "erd_nonce_at_epoch_start"

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

View Source 
const MetricNoncesPassedInCurrentEpoch = "erd_nonces_passed_in_current_epoch"

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

View Source 
const MetricNumConnectedPeers = "erd_num_connected_peers"

MetricNumConnectedPeers is the metric for monitoring the number of connected peers

View Source 
const MetricNumConnectedPeersClassification = "erd_num_connected_peers_classification"

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

View Source 
const MetricNumIntraShardValidatorNodes = "erd_intra_shard_validator_nodes"

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

View Source 
const MetricNumMetachainNodes = "erd_num_metachain_nodes"

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

View Source 
const MetricNumMiniBlocks = "erd_num_mini_blocks"

MetricNumMiniBlocks is the metric for number of miniblocks in a block

View Source 
const MetricNumNodesPerShard = "erd_num_nodes_in_shard"

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

View Source 
const MetricNumProcessedTxs = "erd_num_transactions_processed"

MetricNumProcessedTxs is the metric that stores the number of transactions processed

View Source 
const MetricNumShardHeadersFromPool = "erd_num_shard_headers_from_pool"

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

View Source 
const MetricNumShardHeadersProcessed = "erd_num_shard_headers_processed"

MetricNumShardHeadersProcessed is the metric that stores number of shard header processed

View Source 
const MetricNumShardsWithoutMetachain = "erd_num_shards_without_meta"

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

View Source 
const MetricNumTimesInForkChoice = "erd_fork_choice_count"

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

View Source 
const MetricNumTxInBlock = "erd_num_tx_block"

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

View Source 
const MetricNumValidators = "erd_num_validators"

MetricNumValidators is the metric for the number of validators

View Source 
const MetricP2PCrossShardObservers = "erd_p2p_cross_shard_observers"

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

View Source 
const MetricP2PCrossShardValidators = "erd_p2p_cross_shard_validators"

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

View Source 
const MetricP2PIntraShardObservers = "erd_p2p_intra_shard_observers"

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

View Source 
const MetricP2PIntraShardValidators = "erd_p2p_intra_shard_validators"

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

View Source 
const MetricP2PNumConnectedPeersClassification = "erd_p2p_num_connected_peers_classification"

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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
const MetricP2PPeerInfo = "erd_p2p_peer_info"

MetricP2PPeerInfo is the metric for the node's p2p info

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
const MetricP2PUnknownPeers = "erd_p2p_unknown_shard_peers"

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

View Source 
const MetricPeerSubType = "erd_peer_subtype"

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

View Source 
const MetricPeerType = "erd_peer_type"

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

View Source 
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

View Source 
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

View Source 
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)

View Source 
const MetricPublicKeyBlockSign = "erd_public_key_block_sign"

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

View Source 
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)

View Source 
const MetricRedundancyIsMainActive = "erd_redundancy_is_main_active"

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

View Source 
const MetricRedundancyLevel = "erd_redundancy_level"

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

View Source 
const MetricRedundancyStepInReason = "erd_redundancy_step_in_reason"

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

View Source 
const MetricRewardsTopUpGradientPoint = "erd_rewards_top_up_gradient_point"

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

View Source 
const MetricRoundAtEpochStart = "erd_round_at_epoch_start"

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

View Source 
const MetricRoundDuration = "erd_round_duration"

MetricRoundDuration is the metric that specifies the round duration in milliseconds

View Source 
const MetricRoundTime = "erd_round_time"

MetricRoundTime is the metric for round time in seconds

View Source 
const MetricRoundsPassedInCurrentEpoch = "erd_rounds_passed_in_current_epoch"

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

View Source 
const MetricRoundsPerEpoch = "erd_rounds_per_epoch"

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

View Source 
const MetricShardConsensusGroupSize = "erd_shard_consensus_group_size"

MetricShardConsensusGroupSize is the metric for the shard consensus group size

View Source 
const MetricShardId = "erd_shard_id"

MetricShardId is the metric for monitoring shard id of a node

View Source 
const MetricStartTime = "erd_start_time"

MetricStartTime is the metric that specifies the genesis start time

View Source 
const MetricSynchronizedRound = "erd_synchronized_round"

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

View Source 
const MetricTopUpFactor = "erd_top_up_factor"

MetricTopUpFactor is the metric that specifies the top-up factor

View Source 
const MetricTopUpValue = "erd_total_top_up_value"

MetricTopUpValue holds the total top up value

View Source 
const MetricTotalBaseStakedValue = "erd_total_base_staked_value"

MetricTotalBaseStakedValue holds the total base staked value

View Source 
const MetricTotalFees = "erd_total_fees"

MetricTotalFees holds the total fees value for the last epoch

View Source 
const MetricTotalSupply = "erd_total_supply"

MetricTotalSupply holds the total supply value for the last epoch

View Source 
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

View Source 
const MetricTrieSyncNumReceivedBytes = "erd_trie_sync_num_bytes_received"

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

View Source 
const MetricTxPoolLoad = "erd_tx_pool_load"

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

View Source 
const MetricValueNA = "N/A"

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

View Source 
const NodesCoordinatorRegistryKeyPrefix = "indexHashed_"

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

View Source 
const NodesSetupJsonFileName = "nodesSetup.json"

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

View Source 
const NotSetDestinationShardID = "disabled"

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

View Source 
const PeerAuthenticationTopic = "peerAuthentication"

PeerAuthenticationTopic is the topic used for peer authentication signaling

View Source 
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

View Source 
const PutInStorerMaxTime = time.Second

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

View Source 
const RetrialIntervalForOutportDriver = time.Second * 10

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

View Source 
const ShuffledOut = "shuffledOut"

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

View Source 
const TemporaryPath = "temp"

TemporaryPath is the default temporary path directory

View Source 
const TimeToWaitForP2PBootstrap = 20 * time.Second

TimeToWaitForP2PBootstrap is the wait time for the P2P to bootstrap

View Source 
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

View Source 
const TimeoutGettingTrieNodesInHardfork = time.Minute * 10

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

View Source 
const TriggerRegistryInitialKeyPrefix = "initial_value_epoch_"

TriggerRegistryInitialKeyPrefix is the key prefix to save initial data to storage

View Source 
const TriggerRegistryKeyPrefix = "epochStartTrigger_"

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

View Source 
const UnVersionedAppString = "undefined"

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

View Source 
const ValidatorInfoTopic = "validatorInfo"

ValidatorInfoTopic is the topic used for validatorInfo signaling

View Source 
const WrongConfiguration = "wrongConfiguration"

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

Variables

View Source 
var EmptyTrieHash = make([]byte, 32)

EmptyTrieHash returns the value with empty trie hash

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

ErrInvalidTimeout signals that an invalid timeout period has been provided

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

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

View Source 
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 added in v1.6.0 

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

func SuffixedMetric(metric string, suffix string) string

SuffixedMetric appends the suffix to the provided metric and returns it

func TrimSuffixFromValue added in v1.6.0 

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

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

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

type AuctionNode added in v1.7.0 

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

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

type BlockProcessingCutoffMode string

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

type BlockProcessingCutoffTrigger added in v1.6.0 

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

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

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

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

type ManagedPeersMonitor interface {
	GetManagedKeysCount() int
	GetManagedKeys() [][]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 added in v1.6.0 

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

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

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

type StateStatisticsHandler interface {
	Reset()
	ResetSnapshot()

	IncrCache()
	Cache() uint64
	IncrSnapshotCache()
	SnapshotCache() uint64

	IncrPersister(epoch uint32)
	Persister(epoch uint32) uint64
	IncrSnapshotPersister(epoch uint32)
	SnapshotPersister(epoch uint32) uint64

	IncrTrie()
	Trie() uint64

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

	IsInterfaceNil() bool
}

StateStatisticsHandler defines the behaviour of a storage statistics handler

type StateSyncNotifierSubscriber added in v1.6.0 

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

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(root []byte) (Trie, error)
	RecreateFromEpoch(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 added in v1.6.0 

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

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

TrieStorageInteractor defines the methods used for interacting with the trie storage

type TrieType added in v1.6.0 

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

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

Source Files

View all Source files

Directories

Path Synopsis
disabled
machine
osLevel
softwareVersion
softwareVersion/factory

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.