common

Documentation

Index

• Constants
• Variables
• func AssignShardForPubKeyWhenNotSpecified(pubKey []byte, numShards uint32) uint32
• func ExtractTokenIDAndNonceFromTokenStorageKey(tokenKey []byte) ([]byte, uint64)
• func GetClosedUnbufferedChannel() chan struct{}
• func IsContextDone(ctx context.Context) bool
• func LoadApiConfig(filepath string) (*config.ApiRoutesConfig, error)
• func LoadEconomicsConfig(filepath string) (*config.EconomicsConfig, error)
• func LoadEpochConfig(filepath string) (*config.EpochConfig, error)
• func LoadExternalConfig(filepath string) (*config.ExternalConfig, error)
• func LoadGasScheduleConfig(filepath string) (map[string]map[string]uint64, error)
• func LoadMainConfig(filepath string) (*config.Config, error)
• func LoadP2PConfig(filepath string) (*config.P2PConfig, error)
• func LoadPreferencesConfig(filepath string) (*config.Preferences, error)
• func LoadRatingsConfig(filepath string) (*config.RatingsConfig, error)
• func LoadRoundConfig(filePath string) (*config.RoundConfig, error)
• func LoadSystemSmartContractsConfig(filepath string) (*config.SystemSmartContractsConfig, error)
• func NewPidQueue() *pidQueue
• func NewTimeoutHandler(timeout time.Duration) (*timeoutHandler, error)
• func ProcessDestinationShardAsObserver(destinationShardIdAsObserver string) (uint32, error)
• type ApiOutputFormat
• type BlockInfo
• type DBWriteCacher
• type DelegationDataAPI
• type EpochStartDataAPI
• type GasScheduleNotifierAPI
• type GetProofResponse
• type InitialAccountAPI
• type Locker
• type MerkleProofVerifier
• type ModifiedHashes
  • func (mh ModifiedHashes) Clone() ModifiedHashes
• type NodeProcessingMode
• type NodeState
• type NonceGapApiResponse
• type NumNodesDTO
• type PeerType
• type PidQueueHandler
• type ProcessStatusHandler
• type ReceiptsHolder
• type RootHashHolder
• type SizeSyncStatisticsHandler
• type SnapshotDbHandler
• type SnapshotStatisticsHandler
• type StorageManager
• type Transaction
• type TransactionsPoolAPIResponse
• type TransactionsPoolForSenderApiResponse
• type TransactionsPoolNonceGapsForSenderApiResponse
• type Trie
• type TriesHolder

Constants

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// MetricBuiltInFunctionOnMetaEnableEpoch represents the epoch when the builtin functions on metachain are enabled
	MetricBuiltInFunctionOnMetaEnableEpoch = "erd_builtin_function_on_meta_enable_epoch"

	// MetricWaitingListFixEnableEpoch represents the epoch when the waiting list fix is enabled
	MetricWaitingListFixEnableEpoch = "erd_waiting_list_fix_enable_epoch"

	// MetricHeartbeatDisableEpoch represents the epoch when heartbeat v1 messages stop being sent and processed
	MetricHeartbeatDisableEpoch = "erd_heartbeat_disable_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"
)

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

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

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

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

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

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

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

const AdditionalScrForEachScCallOrSpecialTx = 3

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

const AsyncCallStepField = "AsyncCallStep"

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

const AsyncCallbackGasLockField = "AsyncCallbackGasLock"

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

const BaseOperationCost = "BaseOperationCost"

BaseOperationCost represents the field name for base operation costs

const BuiltInCost = "BuiltInCost"

BuiltInCost represents the field name for built in operation costs

const CombinedPeerType = "%s (%s)"

CombinedPeerType - represents the combination of two peerTypes

const CommitMaxTime = 3 * time.Second

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

const ConnectionTopic = "connection"

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

const ConsensusTopic = "consensus"

ConsensusTopic is the topic used in consensus algorithm

const DefaultDBPath = "db"

DefaultDBPath is the default path for nodes databases

const 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 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 ElrondAPICost = "ElrondAPICost"

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

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 GenesisTxSignatureString = "GENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISGENESISG"

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

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 HeartbeatV2Topic = "heartbeatV2"

HeartbeatV2Topic is the topic used for heartbeatV2 signaling

const HighestRoundFromBootStorage = "highestRoundFromBootStorage"

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

const ImportComplete = "importComplete"

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

const InvalidMessageBlacklistDuration = time.Second * 3600

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

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

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

const MaxIndexOfTxInMiniBlock = int32(29999)

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

const 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 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 MaxWaitingTimeToReceiveRequestedItem = 5 * time.Second

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

const MetaChainSystemSCsCost = "MetaChainSystemSCsCost"

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

const MetachainShardId = uint32(0xFFFFFFFF)

MetachainShardId will be used to identify a shard ID as metachain

const MetachainShardName = "metachain"

MetachainShardName is the string identifier of the metachain shard

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

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

const MetricAppVersion = "erd_app_version"

MetricAppVersion is the metric for the current app version

const MetricAreVMQueriesReady = "erd_are_vm_queries_ready"

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

const MetricChainId = "erd_chain_id"

MetricChainId is the metric that specifies current chain id

const MetricConnectedNodes = "erd_connected_nodes"

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

const MetricConsensusGroupSize = "erd_consensus_group_size"

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

const MetricConsensusRoundState = "erd_consensus_round_state"

MetricConsensusRoundState is the metric for consensus round state for a block

const MetricConsensusState = "erd_consensus_state"

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

const MetricCountAcceptedBlocks = "erd_count_accepted_blocks"

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

const MetricCountConsensus = "erd_count_consensus"

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

const MetricCountConsensusAcceptedBlocks = "erd_count_consensus_accepted_blocks"

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

const MetricCountLeader = "erd_count_leader"

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

const MetricCpuLoadPercent = "erd_cpu_load_percent"

MetricCpuLoadPercent is the metric for monitoring CPU load [%]

const MetricCreatedProposedBlock = "erd_consensus_created_proposed_block"

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

const MetricCrossCheckBlockHeight = "erd_cross_check_block_height"

MetricCrossCheckBlockHeight is the metric that store cross block height

const 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 MetricLatestTagSoftwareVersion = "erd_latest_tag_software_version"

MetricLatestTagSoftwareVersion is the metric that stores the latest tag software version

const MetricLeaderPercentage = "erd_leader_percentage"

MetricLeaderPercentage is the metric for leader rewards percentage

const MetricLiveValidatorNodes = "erd_live_validator_nodes"

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

const MetricMaxGasPerTransaction = "erd_max_gas_per_transaction"

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

const MetricMemHeapInUse = "erd_mem_heap_inuse"

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

const MetricMemLoadPercent = "erd_mem_load_percent"

MetricMemLoadPercent is the metric for monitoring memory load [%]

const MetricMemStackInUse = "erd_mem_stack_inuse"

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

const MetricMemTotal = "erd_mem_total"

MetricMemTotal is the metric for monitoring total memory bytes

const MetricMemUsedGolang = "erd_mem_used_golang"

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

const MetricMemUsedSystem = "erd_mem_used_sys"

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

const MetricMetaConsensusGroupSize = "erd_meta_consensus_group_size"

MetricMetaConsensusGroupSize is the metric for the metachain consensus group size

const MetricMinGasLimit = "erd_min_gas_limit"

MetricMinGasLimit is the metric that specifies the minimum gas limit

const MetricMinGasPrice = "erd_min_gas_price"

MetricMinGasPrice is the metric that specifies min gas price

const MetricMinTransactionVersion = "erd_min_transaction_version"

MetricMinTransactionVersion is the metric that specifies the minimum transaction version

const MetricMiniBlocksSize = "erd_mini_blocks_size"

MetricMiniBlocksSize is the metric that stores the current block size

const MetricNetworkRecvBps = "erd_network_recv_bps"

MetricNetworkRecvBps is the metric for monitoring network received bytes per second

const MetricNetworkRecvBpsPeak = "erd_network_recv_bps_peak"

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

const MetricNetworkRecvBytesInCurrentEpochPerHost = "erd_network_recv_bytes_in_epoch_per_host"

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

const MetricNetworkRecvPercent = "erd_network_recv_percent"

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

const MetricNetworkSendBytesInCurrentEpochPerHost = "erd_network_sent_bytes_in_epoch_per_host"

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

const MetricNetworkSentBps = "erd_network_sent_bps"

MetricNetworkSentBps is the metric for monitoring network sent bytes per second

const MetricNetworkSentBpsPeak = "erd_network_sent_bps_peak"

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

const MetricNetworkSentPercent = "erd_network_sent_percent"

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

const MetricNodeDisplayName = "erd_node_display_name"

MetricNodeDisplayName is the metric that stores the name of the node

const MetricNodeType = "erd_node_type"

MetricNodeType is the metric for monitoring the type of the node

const MetricNonce = "erd_nonce"

MetricNonce is the metric for monitoring the nonce of a node

const MetricNonceAtEpochStart = "erd_nonce_at_epoch_start"

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

const MetricNoncesPassedInCurrentEpoch = "erd_nonces_passed_in_current_epoch"

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

const MetricNumConnectedPeers = "erd_num_connected_peers"

MetricNumConnectedPeers is the metric for monitoring the number of connected peers

const MetricNumConnectedPeersClassification = "erd_num_connected_peers_classification"

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

const MetricNumIntraShardValidatorNodes = "erd_intra_shard_validator_nodes"

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

const MetricNumMetachainNodes = "erd_num_metachain_nodes"

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

const MetricNumMiniBlocks = "erd_num_mini_blocks"

MetricNumMiniBlocks is the metric for number of miniblocks in a block

const MetricNumNodesPerShard = "erd_num_nodes_in_shard"

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

const MetricNumProcessedTxs = "erd_num_transactions_processed"

MetricNumProcessedTxs is the metric that stores the number of transactions processed

const MetricNumShardHeadersFromPool = "erd_num_shard_headers_from_pool"

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

const MetricNumShardHeadersProcessed = "erd_num_shard_headers_processed"

MetricNumShardHeadersProcessed is the metric that stores number of shard header processed

const MetricNumShardsWithoutMetachain = "erd_num_shards_without_meta"

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

const MetricNumTimesInForkChoice = "erd_fork_choice_count"

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

const MetricNumTxInBlock = "erd_num_tx_block"

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

const MetricNumValidators = "erd_num_validators"

MetricNumValidators is the metric for the number of validators

const MetricP2PCrossShardObservers = "erd_p2p_cross_shard_observers"

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

const MetricP2PCrossShardValidators = "erd_p2p_cross_shard_validators"

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

const 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 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 specifies the moment in the round when the received block has reached the current node. The value is provided in percent (0 meaning it has been received just after the round started and 100 meaning that the block has been received in the last moment of the round)

const MetricRedundancyIsMainActive = "erd_redundancy_is_main_active"

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

const MetricRedundancyLevel = "erd_redundancy_level"

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

const MetricRewardsTopUpGradientPoint = "erd_rewards_top_up_gradient_point"

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

const MetricRoundAtEpochStart = "erd_round_at_epoch_start"

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

const MetricRoundDuration = "erd_round_duration"

MetricRoundDuration is the metric that specifies the round duration in milliseconds

const MetricRoundTime = "erd_round_time"

MetricRoundTime is the metric for round time in seconds

const MetricRoundsPassedInCurrentEpoch = "erd_rounds_passed_in_current_epoch"

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

const MetricRoundsPerEpoch = "erd_rounds_per_epoch"

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

const MetricShardConsensusGroupSize = "erd_shard_consensus_group_size"

MetricShardConsensusGroupSize is the metric for the shard consensus group size

const MetricShardId = "erd_shard_id"

MetricShardId is the metric for monitoring shard id of a node

const MetricStartTime = "erd_start_time"

MetricStartTime is the metric that specifies the genesis start time

const MetricSynchronizedRound = "erd_synchronized_round"

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

const MetricTopUpFactor = "erd_top_up_factor"

MetricTopUpFactor is the metric that specifies the top up factor

const MetricTopUpValue = "erd_total_top_up_value"

MetricTopUpValue holds the total top up value

const MetricTotalBaseStakedValue = "erd_total_base_staked_value"

MetricTotalBaseStakedValue holds the total base staked value

const MetricTotalFees = "erd_total_fees"

MetricTotalFees holds the total fees value for the last epoch

const MetricTotalSupply = "erd_total_supply"

MetricTotalSupply holds the total supply value for the last epoch

const MetricTxPoolLoad = "erd_tx_pool_load"

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

const MetricValueNA = "N/A"

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

const NodesCoordinatorRegistryKeyPrefix = "indexHashed_"

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

const NodesSetupJsonFileName = "nodesSetup.json"

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

const NotSetDestinationShardID = "disabled"

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

const 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 PeerAuthenticationTopic = "peerAuthentication"

PeerAuthenticationTopic is the topic used for peer authentication signaling

const PublicKeyBlacklistDuration = time.Second * 7200

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

const PutInStorerMaxTime = time.Second

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

const RetrialIntervalForOutportDriver = time.Second * 10

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

const ShuffledOut = "shuffledOut"

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

const 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 TimeToWaitForP2PBootstrap = 20 * time.Second

TimeToWaitForP2PBootstrap is the wait time for the P2P to bootstrap

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

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

const TimeoutGettingTrieNodesInHardfork = time.Minute * 10

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

const TriggerRegistryInitialKeyPrefix = "initial_value_epoch_"

TriggerRegistryInitialKeyPrefix is the key prefix to save initial data to storage

const TriggerRegistryKeyPrefix = "epochStartTrigger_"

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

const UnVersionedAppString = "undefined"

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

const 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

Variables

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

ErrInvalidTimeout signals that an invalid timeout period has been provided

var ErrNilArwenChangeLocker = errors.New("nil arwen change locker")

ErrNilArwenChangeLocker signals that a nil arwen 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 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 IsContextDone

func IsContextDone(ctx context.Context) bool

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

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) (*config.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

Types

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 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 DBWriteCacher

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

DBWriteCacher is used to cache changes made to the trie, and only write to the database when it's needed

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 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 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 Locker

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

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

type MerkleProofVerifier

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

MerkleProofVerifier is used to verify merkle proofs

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

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 NumNodesDTO

type NumNodesDTO struct {
	Leaves     int
	Extensions int
	Branches   int
	MaxLevel   int
}

NumNodesDTO represents the DTO structure that will hold the number of nodes split by category and other trie structure relevant data such as maximum number of trie levels including the roothash node and all leaves

type PeerType

type PeerType string

PeerType represents the type of a peer

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 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 {
	DBWriteCacher
	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 {
	AddSize(uint64)
	SnapshotFinished()
	NewSnapshotStarted()
	NewDataTrie()
	WaitForSnapshotsToFinish()
}

SnapshotStatisticsHandler is used to measure different statistics for the trie snapshot

type StorageManager

type StorageManager interface {
	Get(key []byte) ([]byte, error)
	GetFromCurrentEpoch(key []byte) ([]byte, error)
	Put(key []byte, val []byte) error
	PutInEpoch(key []byte, val []byte, epoch uint32) error
	PutInEpochWithoutCache(key []byte, val []byte, epoch uint32) error
	TakeSnapshot(rootHash []byte, mainTrieRootHash []byte, leavesChan chan core.KeyValueHolder, errChan chan error, stats SnapshotStatisticsHandler, epoch uint32)
	SetCheckpoint(rootHash []byte, mainTrieRootHash []byte, leavesChan chan core.KeyValueHolder, errChan chan error, stats SnapshotStatisticsHandler)
	GetLatestStorageEpoch() (uint32, error)
	IsPruningEnabled() bool
	IsPruningBlocked() bool
	EnterPruningBufferingMode()
	ExitPruningBufferingMode()
	AddDirtyCheckpointHashes([]byte, ModifiedHashes) bool
	Remove(hash []byte) error
	SetEpochForPutOperation(uint32)
	ShouldTakeSnapshot() bool
	GetBaseTrieStorageManager() StorageManager
	IsClosed() bool
	Close() error
	IsInterfaceNil() bool
}

StorageManager manages all trie storage operations

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, 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)
	GetNumNodes() NumNodesDTO
	GetAllLeavesOnChannel(leavesChannel chan core.KeyValueHolder, ctx context.Context, rootHash []byte) error
	GetAllHashes() ([][]byte, error)
	GetProof(key []byte) ([][]byte, []byte, error)
	VerifyProof(rootHash []byte, key []byte, proof [][]byte) (bool, error)
	GetStorageManager() StorageManager
	MarkStorerAsSyncedAndActive()
	Close() error
	IsInterfaceNil() bool
}

Trie is an interface for Merkle Trees implementations

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