core

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

	//MetricBuiltInFunctionsEnableEpoch represents the epoch when the built in functions will be enabled
	MetricBuiltInFunctionsEnableEpoch = "erd_built_in_functions_enable_epoch"

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

	//MetricPenalizedTooMuchGasEnableEpoch represents the epoch when the penalization for using too much gas will be 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 scrs
	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 epoch should not be 0
	MetricDelegationManagerEnableEpoch = "erd_delegation_manager_enable_epoch"

	//MetricDelegationSmartContractEnableEpoch represents the epoch when delegation smart contract is enabled epoch should not be 0
	MetricDelegationSmartContractEnableEpoch = "erd_delegation_smart_contract_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"
)

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 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 AllShardId = uint32(0xFFFFFFF0)

AllShardId will be used to identify that a message is for all shards

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 BuiltInCost = "BuiltInCost"

BuiltInCost represents the field name for built in operation costs

const BuiltInFunctionChangeOwnerAddress = "ChangeOwnerAddress"

BuiltInFunctionChangeOwnerAddress is the key for the change owner built in function built-in function

const BuiltInFunctionClaimDeveloperRewards = "ClaimDeveloperRewards"

BuiltInFunctionClaimDeveloperRewards is the key for the claim developer rewards built-in function

const BuiltInFunctionESDTBurn = "ESDTBurn"

BuiltInFunctionESDTBurn is the key for the elrond standard digital token burn built-in function

const BuiltInFunctionESDTFreeze = "ESDTFreeze"

BuiltInFunctionESDTFreeze is the key for the elrond standard digital token freeze built-in function

const BuiltInFunctionESDTLocalBurn = "ESDTLocalBurn"

BuiltInFunctionESDTLocalBurn is the key for the elrond standard digital token local burn built-in function

const BuiltInFunctionESDTLocalMint = "ESDTLocalMint"

BuiltInFunctionESDTLocalMint is the key for the elrond standard digital token local mint built-in function

const BuiltInFunctionESDTNFTAddQuantity = "ESDTNFTAddQuantity"

BuiltInFunctionESDTNFTAddQuantity is the key for the elrond standard digital token NFT add quantity built-in function

const BuiltInFunctionESDTNFTBurn = "ESDTNFTBurn"

BuiltInFunctionESDTNFTBurn is the key for the elrond standard digital token NFT burn built-in function

const BuiltInFunctionESDTNFTCreate = "ESDTNFTCreate"

BuiltInFunctionESDTNFTCreate is the key for the elrond standard digital token NFT create built-in function

const BuiltInFunctionESDTNFTCreateRoleTransfer = "ESDTNFTCreateRoleTransfer"

BuiltInFunctionESDTNFTCreateRoleTransfer is the key for the elrond standard digital token create role transfer function

const BuiltInFunctionESDTNFTTransfer = "ESDTNFTTransfer"

BuiltInFunctionESDTNFTTransfer is the key for the elrond standard digital token NFT transfer built-in function

const BuiltInFunctionESDTPause = "ESDTPause"

BuiltInFunctionESDTPause is the key for the elrond standard digital token pause built-in function

const BuiltInFunctionESDTTransfer = "ESDTTransfer"

BuiltInFunctionESDTTransfer is the key for the elrond standard digital token transfer built-in function

const BuiltInFunctionESDTUnFreeze = "ESDTUnFreeze"

BuiltInFunctionESDTUnFreeze is the key for the elrond standard digital token unfreeze built-in function

const BuiltInFunctionESDTUnPause = "ESDTUnPause"

BuiltInFunctionESDTUnPause is the key for the elrond standard digital token unpause built-in function

const BuiltInFunctionESDTWipe = "ESDTWipe"

BuiltInFunctionESDTWipe is the key for the elrond standard digital token wipe built-in function

const BuiltInFunctionSaveKeyValue = "SaveKeyValue"

BuiltInFunctionSaveKeyValue is the key for the save key value built-in function

const BuiltInFunctionSetESDTRole = "ESDTSetRole"

BuiltInFunctionSetESDTRole is the key for the elrond standard digital token set built-in function

const BuiltInFunctionSetUserName = "SetUserName"

BuiltInFunctionSetUserName is the key for the set user name built-in function

const BuiltInFunctionUnSetESDTRole = "ESDTUnSetRole"

BuiltInFunctionUnSetESDTRole is the key for the elrond standard digital token unset built-in function

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 ConsensusTopic = "consensus"

ConsensusTopic is the topic used in consensus algorithm

const DefaultDBPath = "db"

DefaultDBPath is the default path for nodes databases

const DefaultEpochString = "Epoch"

DefaultEpochString is the default folder root name for node per epoch 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 DefaultShardString = "Shard"

DefaultShardString is the default folder root name for per shard databases

const DefaultStaticDbString = "Static"

DefaultStaticDbString is the default name for the static databases (not changing with epoch)

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 DelegationSystemSCKey = "delegation"

DelegationSystemSCKey is the key under which there is data in case of system delegation smart contracts

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 ESDTKeyIdentifier = "esdt"

ESDTKeyIdentifier is the key prefix for esdt tokens

const ESDTNFTLatestNonceIdentifier = "nonce"

ESDTNFTLatestNonceIdentifier is the key prefix for esdt latest nonce identifier

const ESDTRoleIdentifier = "role"

ESDTRoleIdentifier is the key prefix for esdt role identifier

const ESDTRoleLocalBurn = "ESDTRoleLocalBurn"

ESDTRoleLocalBurn is the constant string for the local role of burn for ESDT tokens

const ESDTRoleLocalMint = "ESDTRoleLocalMint"

ESDTRoleLocalMint is the constant string for the local role of mint for ESDT tokens

const ESDTRoleNFTAddQuantity = "ESDTRoleNFTAddQuantity"

ESDTRoleNFTAddQuantity is the constant string for the local role of adding quantity for existing ESDT NFT tokens

const ESDTRoleNFTBurn = "ESDTRoleNFTBurn"

ESDTRoleNFTBurn is the constant string for the local role of burn for ESDT NFT tokens

const ESDTRoleNFTCreate = "ESDTRoleNFTCreate"

ESDTRoleNFTCreate is the constant string for the local role of create for ESDT NFT tokens

const ElrondAPICost = "ElrondAPICost"

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

const ElrondProtectedKeyPrefix = "ELROND"

ElrondProtectedKeyPrefix is the key prefix which is protected from writing in the trie - only for special builtin functions

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 FileModeUserReadWrite = 0600

FileModeUserReadWrite represents the permission for a file which allows the user for reading and writing

const FungibleESDT = "FungibleESDT"

FungibleESDT defines the string for the token type of fungible ESDT

const GetNodeFromDBErrorString = "getNodeFromDB error"

GetNodeFromDBErrorString represents the string which is returned when a getting node from DB returns an error

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 HeartbeatTopic = "heartbeat"

HeartbeatTopic is the topic used for heartbeat 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 LastNonceKeyMetricsStorage = "lastNonce"

LastNonceKeyMetricsStorage holds the key used for storing the last nonce for stored metrics

const MaxBufferSizeToSendTrieNodes = 1 << 18 //256KB

MaxBufferSizeToSendTrieNodes represents max buffer size to send in bytes used when resolving trie nodes Every trie node that has a greater size than this constant is considered a large trie node and should be split in smaller chunks

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 MaxLeafSize = uint64(1 << 26) //64MB

MaxLeafSize represents maximum amount of data which can be saved under one leaf

const MaxLenForESDTIssueMint = 100

MaxLenForESDTIssueMint defines the maximum length in bytes for the issued/minted balance

const MaxNumShards = 256

MaxNumShards represents the maximum number of shards possible in the system

const MaxRetriesToCreateDB = 10

MaxRetriesToCreateDB represents the maximum number of times to try to create DB if it failed

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 MaxRoyalty = uint32(10000)

MaxRoyalty defines 100% as uint32

const MaxSoftwareVersionLengthInBytes = 10

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

const MaxTxNonceDeltaAllowed = 30000

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 MaxUserNameLength = 32

MaxUserNameLength represents the maximum number of bytes a UserName can have

const MaxWaitingTimeToReceiveRequestedItem = 5 * time.Second

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

const MeasurementsLoggerFormat = "%.4fs"

MeasurementsLoggerFormat contains the formatting string to output elapsed time in seconds in a consistent way

const MegabyteSize = 1024 * 1024

MegabyteSize represents the size in bytes of a megabyte

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 MetricAppVersion = "erd_app_version"

MetricAppVersion is the metric for the current app version

const MetricAverageBlockTxCount = "erd_average_block_tx_count"

MetricAverageBlockTxCount holds the average count of transactions in a 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 specify 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 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 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 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 MetricLastBlockTxCount = "erd_last_block_tx_count"

MetricLastBlockTxCount holds the number of transactions in the last block

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 monitoring live validators on the network

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 MetricNonceForTPS = "erd_nonce_for_tps"

MetricNonceForTPS is the metric for monitoring the nonce of a node used in TPS benchmarks

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 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 MetricNumProcessedTxsTPSBenchmark = "erd_num_transactions_processed_tps_benchmark"

MetricNumProcessedTxsTPSBenchmark is the metric that stores the number of transactions processed for tps benchmark

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 time 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 MetricP2PFullHistoryObservers = "erd_p2p_full_history_observers"

MetricP2PFullHistoryObservers is the metric that outputs the full-history connected observers

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 MetricPeakTPS = "erd_peak_tps"

MetricPeakTPS holds the peak transactions per second

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 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 specify 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 MetricRewardsTopUpGradientPoint = "erd_rewards_top_up_gradient_point"

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

const MetricRewardsValue = "erd_rewards_value"

MetricRewardsValue is the metric that stores rewards value

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 MetricTxPoolLoad = "erd_tx_pool_load"

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

const MinLenArgumentsESDTNFTTransfer = 4

MinLenArgumentsESDTNFTTransfer defines the minimum length for esdt nft transfer

const MinLenArgumentsESDTTransfer = 2

MinLenArgumentsESDTTransfer defines the min length of arguments for the ESDT transfer

const MinMetaTxExtraGasCost = uint64(1_000_000)

MinMetaTxExtraGasCost is the constant defined for minimum gas value to be sent in meta transaction

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 NonFungibleESDT = "NonFungibleESDT"

NonFungibleESDT defines the string for the token type of non fungible ESDT

const NotSetDestinationShardID = "disabled"

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

const NumInitCharactersForScAddress = 10

NumInitCharactersForScAddress numbers of characters for smart contract address identifier

const PathEpochPlaceholder = "[E]"

PathEpochPlaceholder represents the placeholder for the epoch number in paths

const PathIdentifierPlaceholder = "[I]"

PathIdentifierPlaceholder represents the placeholder for the identifier in paths

const PathShardPlaceholder = "[S]"

PathShardPlaceholder represents the placeholder for the shard ID in paths

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 RelayedTransaction = "relayedTx"

RelayedTransaction is the key for the elrond meta/gassless/relayed transaction standard

const RelayedTransactionV2 = "relayedTxV2"

RelayedTransactionV2 is the key for the optimized elrond meta/gassless/relayed transaction standard

const SCDeployInitFunctionName = "_init"

SCDeployInitFunctionName is the key for the function which is called at smart contract deploy time

const SecondsToWaitForP2PBootstrap = 20

SecondsToWaitForP2PBootstrap is the wait time for the P2P to bootstrap

const SemiFungibleESDT = "SemiFungibleESDT"

SemiFungibleESDT defines the string for the token type of semi fungible ESDT

const ShardIdentiferLen = 2

ShardIdentiferLen number of characters for shard identifier in an address

const ShuffledOut = "shuffledOut"

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

const SleepTimeBetweenCreateDBRetries = 5 * time.Second

SleepTimeBetweenCreateDBRetries represents the number of seconds to sleep between DB creates

const TemporaryPath = "temp"

TemporaryPath is the default temporary path directory

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 VMTypeLen = 2

VMTypeLen number of characters with VMType identifier in an address, these are the last 2 characters from the initial identifier

const WrongConfiguration = "wrongConfiguration"

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

const WrongP2PMessageBlacklistDuration = time.Second * 7200

WrongP2PMessageBlacklistDuration represents the time to keep a peer id in the blacklist if it sends a message that do not follow this protocol