core

Documentation

Index

• Constants
• Variables
• func CalculateHash(marshalizer marshal.Marshalizer, hasher hashing.Hasher, object interface{}) ([]byte, error)
• func ConvertBytes(bytes uint64) string
• func CreateFile(prefix string, subfolder string, fileExtension string) (*os.File, error)
• func GetTrimmedPk(pk string) string
• func GetVMType(rcvAddress []byte) []byte
• func IsMetachainIdentifier(identifier []byte) bool
• func IsSmartContractAddress(rcvAddress []byte) bool
• func IsSmartContractOnMetachain(identifier []byte, rcvAddress []byte) bool
• func LoadGasScheduleConfig(filepath string) (map[string]map[string]uint64, error)
• func LoadJsonFile(dest interface{}, relativePath string) error
• func LoadP2PConfig(filepath string) (*config.P2PConfig, error)
• func LoadServersPConfig(filepath string) (*config.ServersConfig, error)
• func LoadSkFromPemFile(relativePath string, skIndex int) ([]byte, error)
• func LoadTomlFile(dest interface{}, relativePath string) error
• func LoadTomlFileToMap(relativePath string) (map[string]interface{}, error)
• func MaxInt32(a int32, b int32) int32
• func MaxUint32(a uint32, b uint32) uint32
• func MaxUint64(a uint64, b uint64) uint64
• func MinInt32(a int32, b int32) int32
• func MinUint32(a uint32, b uint32) uint32
• func MinUint64(a uint64, b uint64) uint64
• func OpenFile(relativePath string) (*os.File, error)
• func SaveSkToPemFile(file *os.File, identifier string, skBytes []byte) error
• func SecondsToHourMinSec(input int) string
• func ToB64(buff []byte) string
• func ToHex(buff []byte) string
• type AppStatusHandler
• type ConnectedAddressesHandler
• type NodeType

Constants

const ConsensusTopic = "consensus"

ConsensusTopic is the topic used in consensus algorithm

const GenesisBlockNonce = 0

GenesisBlockNonce is the nonce of the genesis block

const MaxBulkTransactionSize = 2 << 17 //128KB 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 MaxMiniBlocksInBlock = 100

MaxMiniBlocksInBlock specifies the max number of mini blocks which can be added in one block

const MetricAppVersion = "erd_app_version"

MetricAppVersion is the metric for the current app version

const MetricCommunityPercentage = "erd_metric_community_percentage"

MetricCommunityPercentage is the metric for community rewards percentage

const MetricConnectedNodes = "erd_connected_nodes"

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

const MetricConsensusGroupSize = "erd_metric_consensus_group_size"

MetricConsensusGroupSize is the metric for consensus group size

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 MetricCrossCheckBlockHeight = "erd_metric_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 MetricDenominationCoefficient = "erc_metric_denomination_coefficient"

MetricDenominationCoefficient is the metric for denomination coefficient that is used in views

const MetricHeaderSize = "erd_current_block_size"

MetricHeaderSize is the metric that stores the current block size

const MetricHighestFinalBlockInShard = "erd_highest_notarized_block_by_metachain_for_current_shard"

MetricHighestFinalBlockInShard is the metric that stores the highest nonce block notarized by metachain for current shard

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_metric_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 MetricMemLoadPercent = "erd_mem_load_percent"

MetricMemLoadPercent is the metric for monitoring memory load [%]

const MetricMemTotal = "erd_mem_total"

MetricMemTotal is the metric for monitoring total memory bytes

const MetricMemUsedGolang = "erd_mem_used_golang"

MetricMemUsedGolang is the metric that stores the total memory used by golang in bytes

const MetricMemUsedSystem = "erd_mem_used_sys"

MetricMemUsedSystem is the metric that stores the total memory used by the system in bytes

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 MetricNetworkRecvPercent = "erd_network_recv_percent"

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

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 MetricNumConnectedPeers = "erd_num_connected_peers"

MetricNumConnectedPeers is the metric for monitoring the number of connected peers

const MetricNumMiniBlocks = "erd_num_mini_blocks"

MetricNumMiniBlocks is the metric for number of miniblocks in a block

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

MetricNumValidators is the metric for the number of validators

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 MetricPublicKeyBlockSign = "erd_public_key_block_sign"

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

const MetricPublicKeyTxSign = "erd_public_key_tx_sign"

MetricPublicKeyTxSign is the metric for monitoring public key of a node used in tx signing (balance account held by the node)

const MetricRewardsValue = "erd_rewards_value"

MetricRewardsValue is the metric that stores rewards value

const MetricRoundTime = "erd_round_time"

MetricRoundTime is the metric for round time in seconds

const MetricShardId = "erd_shard_id"

MetricShardId is the metric for monitoring shard id of a node

const MetricSynchronizedRound = "erd_synchronized_round"

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

const MetricTxPoolLoad = "erd_tx_pool_load"

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

const NumInitCharactersForScAddress = 10

NumInitCharactersForScAddress numbers of characters for smart contract address identifier

const ShardIdentiferLen = 2

ShardIdentiferLen number of characters for shard identifier in an address

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

Variables

var ErrEmptyFile = errors.New("empty file provided")

ErrEmptyFile signals that a empty file has been provided

var ErrInvalidIndex = errors.New("invalid private key index")

ErrInvalidIndex signals that an invalid private key index has been provided

var ErrInvalidValue = errors.New("invalid value provided")

ErrInvalidValue signals that a nil value has been provided

var ErrNilAppStatusHandler = errors.New("appStatusHandler is nil")

ErrNilAppStatusHandler signals that a nil status handler has been provided

var ErrNilCoordinator = errors.New("nil coordinator provided")

ErrNilCoordinator signals that a nil shardCoordinator has been provided

var ErrNilFile = errors.New("nil file provided")

ErrNilFile signals that a nil file has been provided

var ErrNilHasher = errors.New("nil hasher provided")

ErrNilHasher signals that a nil hasher has been provided

var ErrNilInputData = errors.New("nil input data")

ErrNilInputData signals that a nil data has been provided

var ErrNilLogger = errors.New("nil logger provided")

ErrNilLogger signals that a nil logger has been provided

var ErrNilMarshalizer = errors.New("nil marshalizer provided")

ErrNilMarshalizer signals that a nil marshalizer has been provided

var ErrNilUrl = errors.New("url is empty")

ErrNilUrl signals that the provided url is empty

var ErrNotPositiveValue = errors.New("the provided value is not positive")

ErrNotPositiveValue signals that a 0 or negative value has been provided

var ErrPemFileIsInvalid = errors.New("pem file is invalid")

ErrPemFileIsInvalid signals that a pem file is invalid

var ErrWrongTypeAssertion = errors.New("wrong type assertion")

ErrWrongTypeAssertion signals that an type assertion failed

Functions

func CalculateHash

func CalculateHash(
	marshalizer marshal.Marshalizer,
	hasher hashing.Hasher,
	object interface{},
) ([]byte, error)

CalculateHash marshalizes the interface and calculates its hash

func ConvertBytes

func ConvertBytes(bytes uint64) string

ConvertBytes converts the input bytes in a readable string using multipliers (k, M, G)

func CreateFile

func CreateFile(prefix string, subfolder string, fileExtension string) (*os.File, error)

CreateFile opens or creates a file relative to the default path

func GetTrimmedPk

func GetTrimmedPk(pk string) string

GetTrimmedPk returns a trimmed string to the pkPrefixSize value

func GetVMType

func GetVMType(rcvAddress []byte) []byte

GetVMType

func IsMetachainIdentifier

func IsMetachainIdentifier(identifier []byte) bool

IsMetachainIdentifier verifies if the identifier is of type metachain

func IsSmartContractAddress

func IsSmartContractAddress(rcvAddress []byte) bool

IsSmartContractAddress verifies if a set address is of type smart contract

func IsSmartContractOnMetachain

func IsSmartContractOnMetachain(identifier []byte, rcvAddress []byte) bool

IsSmartContractOnMetachain verifies if an address is smart contract on metachain

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 LoadJsonFile

func LoadJsonFile(dest interface{}, relativePath string) error

LoadJsonFile method to open and decode json file

func LoadP2PConfig

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

LoadP2PConfig returns a P2PConfig by reading the config file provided

func LoadServersPConfig

func LoadServersPConfig(filepath string) (*config.ServersConfig, error)

LoadServersPConfig returns a ServersConfig by reading the config file provided

func LoadSkFromPemFile

func LoadSkFromPemFile(relativePath string, skIndex int) ([]byte, error)

LoadSkFromPemFile loads the secret key bytes stored in the file

func LoadTomlFile

func LoadTomlFile(dest interface{}, relativePath string) error

LoadTomlFile method to open and decode toml file

func LoadTomlFileToMap

func LoadTomlFileToMap(relativePath string) (map[string]interface{}, error)

LoadTomlFileToMap opens and decodes a toml file as a map[string]interface{}

func MaxInt32

func MaxInt32(a int32, b int32) int32

MaxInt32 returns the maximum of two given numbers

func MaxUint32

func MaxUint32(a uint32, b uint32) uint32

MaxUint32 returns the maximum of two given numbers

func MaxUint64

func MaxUint64(a uint64, b uint64) uint64

MaxUint64 returns the maximum of two given numbers

func MinInt32

func MinInt32(a int32, b int32) int32

MinInt32 returns the minimum of two given numbers

func MinUint32

func MinUint32(a uint32, b uint32) uint32

MinUint32 returns the minimum of two given numbers

func MinUint64

func MinUint64(a uint64, b uint64) uint64

MinUint64 returns the minimum of two given numbers

func OpenFile

func OpenFile(relativePath string) (*os.File, error)

OpenFile method opens the file from given path - does not close the file

func SaveSkToPemFile

func SaveSkToPemFile(file *os.File, identifier string, skBytes []byte) error

SaveSkToPemFile saves secret key bytes in the file

func SecondsToHourMinSec

func SecondsToHourMinSec(input int) string

SecondsToHourMinSec transform seconds input in a human friendly format

func ToB64

func ToB64(buff []byte) string

ToB64 encodes the given buff to base64

func ToHex

func ToHex(buff []byte) string

ToHex encodes the given buff to hex

Types

type AppStatusHandler

type AppStatusHandler interface {
	IsInterfaceNil() bool
	Increment(key string)
	AddUint64(key string, val uint64)
	Decrement(key string)
	SetInt64Value(key string, value int64)
	SetUInt64Value(key string, value uint64)
	SetStringValue(key string, value string)
	Close()
}

AppStatusHandler interface will handle different implementations of monitoring tools, such as Prometheus of term-ui

type ConnectedAddressesHandler

type ConnectedAddressesHandler interface {
	ConnectedAddresses() []string
}

ConnectedAddressesHandler interface will be used for passing the network component to AppStatusPolling

type NodeType

type NodeType string

NodeType represents the node's role in the network

const NodeTypeObserver NodeType = "observer"

NodeTypeObserver signals that a node is running as observer node

const NodeTypeValidator NodeType = "validator"

NodeTypeValidator signals that a node is running as validator node