process

package

Go to main page

Versions in this module

v0

v0.0.2

Oct 31, 2023

Changes in this version

+ const MaxHeadersToWhitelistInAdvance

+ const MaxNumPendingMiniBlocksPerShard

+ const MinShardHeadersFromSameShardInOneMetaBlock

+ var ErrAccountNotPayable = errors.New("sending value to non payable contract")

+ var ErrBuiltInFunctionsAreDisabled = errors.New("built in functions are disabled")

+ var ErrNilHistoryRepository = errors.New("history repository is nil")

+ var ErrNilIndexer = errors.New("indexer is nil")

+ var ErrNilProtocolSustainabilityAddress = errors.New("nil protocol sustainability address")

+ var ErrNilTpsBenchmark = errors.New("tps benchmark object is nil")

+ var ErrRelayedTxDisabled = errors.New("relayed tx is disabled")

+ var ErrReservedFieldNotSupportedYet = errors.New("reserved field not supported yet")

+ var ErrSmartContractDeploymentIsDisabled = errors.New("smart Contract deployment is disabled")

+ var ErrUpgradeNotAllowed = errors.New("upgrade is allowed only for owner")

type BlockChainHookHandler

+ IsInterfaceNil func() bool

+ IsPayable func(address []byte) (bool, error)

type BlockTracker

+ CheckBlockAgainstWhitelist func(interceptedData InterceptedData) bool

type EpochStartRewardsCreator

+ GetProtocolSustainabilityRewards func() *big.Int

type RewardsHandler

+ ProtocolSustainabilityAddress func() string

+ ProtocolSustainabilityPercentage func() float64

type SmartContractProcessor

+ IsPayable func(address []byte) (bool, error)

type ValidityAttester

+ CheckBlockAgainstWhitelist func(interceptedData InterceptedData) bool

v0.0.1

Oct 30, 2023

Changes in this version

+ const BlockFinality

+ const EpochChangeGracePeriod

+ const MaxHeaderRequestsAllowed

+ const MaxHeadersToRequestInAdvance

+ const MaxMetaHeadersAllowedInOneShardBlock

+ const MaxMetaNoncesBehind

+ const MaxNumOfTxsToSelect

+ const MaxNumPendingMiniBlocks

+ const MaxRoundsToKeepUnprocessedMiniBlocks

+ const MaxRoundsToKeepUnprocessedTransactions

+ const MaxRoundsWithoutCommittedBlock

+ const MaxRoundsWithoutNewBlockReceived

+ const MaxShardHeadersAllowedInOneMetaBlock

+ const MaxShardNoncesBehind

+ const MaxSyncWithErrorsAllowed

+ const MetaBlockValidity

+ const MinForkRound

+ const NonceDifferenceWhenSynced

+ const NumTxPerSenderBatchForFillingMiniblock

+ const RoundModulusTrigger

+ const RoundModulusTriggerWhenSyncIsStuck

+ var ErrAccountNotFound = errors.New("account not found")

+ var ErrAccountStateDirty = errors.New("accountState was dirty before starting to change")

+ var ErrAccumulatedFeesDoNotMatch = errors.New("accumulated fees do not match")

+ var ErrAccumulatedFeesInEpochDoNotMatch = errors.New("accumulated fees in epoch do not match")

+ var ErrBlockBodyHashMismatch = errors.New("block bodies does not match")

+ var ErrBlockHashDoesNotMatch = errors.New("block hash does not match")

+ var ErrBlockProposerSignatureMissing = errors.New("block proposer signature is missing")

+ var ErrBuiltInFunctionCalledWithValue = errors.New("built in function called with tx value is not allowed")

+ var ErrCallerIsNotTheDNSAddress = errors.New("not a dns address")

+ var ErrConsecutiveMissedBlocksPenaltyLowerThanOne = errors.New("consecutive missed blocks penalty lower than 1")

+ var ErrContainerKeyAlreadyExists = errors.New("provided key already exists in container")

+ var ErrCrossShardMBWithoutConfirmationFromMeta = errors.New(...)

+ var ErrDecreaseRatingsStepMoreThanMinusOne = errors.New("decrease rating step has a value greater than -1")

+ var ErrDestinationNotInSelfShard = errors.New("destination is not in self shard")

+ var ErrDevFeesInEpochDoNotMatch = errors.New("developer fees in epoch do not match")

+ var ErrDeveloperFeesDoNotMatch = errors.New("developer fees do not match")

+ var ErrDuplicateThreshold = errors.New("two thresholds are the same")

+ var ErrEmptyFloodPreventerList = errors.New("empty flood preventer provided")

+ var ErrEmptyFunctionName = errors.New("empty function name")

+ var ErrEmptySoftwareVersion = errors.New("empty software version")

+ var ErrEmptyTopic = errors.New("empty topic")

+ var ErrEpochDoesNotMatch = errors.New("epoch does not match")

+ var ErrEpochStartDataDoesNotMatch = errors.New("epoch start data does not match")

+ var ErrFailedTransaction = errors.New("failed transaction, gas consumed")

+ var ErrGettingShardDataFromEpochStartData = errors.New("could not find shard data from previous epoch start metablock")

+ var ErrHeaderBodyMismatch = errors.New("body cannot be validated from header data")

+ var ErrHeaderIsBlackListed = errors.New("header is black listed")

+ var ErrHeaderNotFinal = errors.New("header in metablock is not final")

+ var ErrHeaderShardDataMismatch = errors.New("shard header does not match shard info")

+ var ErrHigherGasLimitRequiredInTx = errors.New("higher gas limit required in tx")

+ var ErrHigherNonceInBlock = errors.New("higher nonce in block")

+ var ErrHigherNonceInTransaction = errors.New("higher nonce in transaction")

+ var ErrHigherRoundInBlock = errors.New("higher round in block")

+ var ErrHoursToMaxRatingFromStartRatingZero = errors.New("hours to reach max rating is zero")

+ var ErrIncreaseStepLowerThanOne = errors.New("increase step is lower than one")

+ var ErrInsufficientFee = errors.New("insufficient balance for fees")

+ var ErrInsufficientFunds = errors.New("insufficient funds")

+ var ErrInsufficientGasLimitInTx = errors.New("insufficient gas limit in tx")

+ var ErrInsufficientGasPriceInTx = errors.New("insufficient gas price in tx")

+ var ErrInterceptedDataNotForCurrentShard = errors.New("intercepted data not for current shard")

+ var ErrInvalidAddressLength = errors.New("invalid address length")

+ var ErrInvalidArguments = errors.New("invalid arguments to process built-in function")

+ var ErrInvalidAuctionEnableNonce = errors.New("invalid auction enable nonce")

+ var ErrInvalidBadPeerThreshold = errors.New("invalid bad peer threshold")

+ var ErrInvalidBody = errors.New("invalid body")

+ var ErrInvalidCacheRefreshIntervalInSec = errors.New("invalid cacheRefreshIntervalInSec")

+ var ErrInvalidChainID = errors.New("invalid chain ID")

+ var ErrInvalidContainerKey = errors.New("element does not exist in container")

+ var ErrInvalidDecayCoefficient = errors.New("decay coefficient is invalid")

+ var ErrInvalidDecayIntervalInSeconds = errors.New("invalid decay interval in seconds")

+ var ErrInvalidGasPerDataByte = errors.New("invalid gas per data byte")

+ var ErrInvalidGenesisTotalSupply = errors.New("invalid genesis total supply")

+ var ErrInvalidInflationPercentages = errors.New("invalid inflation percentages")

+ var ErrInvalidMaxGasLimitPerBlock = errors.New("invalid max gas limit per block")

+ var ErrInvalidMaxScore = errors.New("invalid maximum score")

+ var ErrInvalidMetaHeader = errors.New("invalid header provided, expected MetaBlock")

+ var ErrInvalidMetaTransaction = errors.New("meta transaction is invalid")

+ var ErrInvalidMinScore = errors.New("invalid minimum score")

+ var ErrInvalidMinStepValue = errors.New("invalid min step value")

+ var ErrInvalidMiniBlockType = errors.New("invalid miniblock type")

+ var ErrInvalidMinimumGasLimitForTx = errors.New("invalid minimum gas limit for transactions")

+ var ErrInvalidMinimumGasPrice = errors.New("invalid minimum gas price")

+ var ErrInvalidNonceRequest = errors.New("invalid nonce request")

+ var ErrInvalidPeerAccount = errors.New("invalid peer account")

+ var ErrInvalidRewardsPercentages = errors.New("invalid rewards percentages")

+ var ErrInvalidRewardsValue = errors.New("invalid rewards value")

+ var ErrInvalidShardCacherIdentifier = errors.New("invalid identifier for shard cacher")

+ var ErrInvalidShardId = errors.New("invalid shard id")

+ var ErrInvalidStakingEnableNonce = errors.New("invalid staking enable nonce")

+ var ErrInvalidTransactionVersion = errors.New("invalid transaction version")

+ var ErrInvalidTxInPool = errors.New("invalid transaction in the transactions pool")

+ var ErrInvalidUnBondPeriod = errors.New("invalid unbond period")

+ var ErrInvalidUnJailPrice = errors.New("invalid unjail price")

+ var ErrInvalidUnitValue = errors.New("invalid unit value")

+ var ErrInvalidUserNameLength = errors.New("invalid user name length")

+ var ErrInvalidVMType = errors.New("invalid VM type")

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

+ var ErrLenMismatch = errors.New("lengths mismatch")

+ var ErrLogNotFound = errors.New("no logs for queried transaction")

+ var ErrLowerNonceInBlock = errors.New("lower nonce in block")

+ var ErrLowerNonceInTransaction = errors.New("lower nonce in transaction")

+ var ErrLowerRoundInBlock = errors.New("header round is lower than last committed")

+ var ErrMarshalWithoutSuccess = errors.New("marshal without success")

+ var ErrMaxBlockSizeReached = errors.New("max block size has been reached")

+ var ErrMaxGasLimitPerBlockInSelfShardIsReached = errors.New("max gas limit per block in self shard is reached")

+ var ErrMaxGasLimitPerMiniBlockInReceiverShardIsReached = errors.New("max gas limit per mini block in receiver shard is reached")

+ var ErrMaxGasLimitPerMiniBlockInSenderShardIsReached = errors.New("max gas limit per mini block in sender shard is reached")

+ var ErrMaxRatingIsSmallerThanMinRating = errors.New("max rating is smaller than min rating")

+ var ErrMaxRatingZero = errors.New("max rating is zero")

+ var ErrMinRatingSmallerThanOne = errors.New("min rating is smaller than one")

+ var ErrMiniBlockHashMismatch = errors.New("miniblocks does not match")

+ var ErrMiniBlockNumMissMatch = errors.New("num miniblocks does not match")

+ var ErrMiniBlocksInWrongOrder = errors.New("miniblocks in wrong order, should have been only from me")

+ var ErrMissingBody = errors.New("missing body")

+ var ErrMissingHashForHeaderNonce = errors.New("missing hash for header nonce")

+ var ErrMissingHeader = errors.New("missing header")

+ var ErrMissingPreProcessor = errors.New("pre processor is missing")

+ var ErrMissingTransaction = errors.New("missing transaction")

+ var ErrNegativeValue = errors.New("negative value")

+ var ErrNilAccountsAdapter = errors.New("nil AccountsAdapter")

+ var ErrNilAddressContainer = errors.New("nil AddressContainer")

+ var ErrNilAntifloodHandler = errors.New("nil antiflood handler")

+ var ErrNilAppStatusHandler = errors.New("nil AppStatusHandler")

+ var ErrNilArgumentParser = errors.New("argument parser is nil")

+ var ErrNilArgumentStruct = errors.New("nil argument struct")

+ var ErrNilBadTxHandler = errors.New("nil bad tx handler")

+ var ErrNilBalanceComputationHandler = errors.New("nil balance computation handler")

+ var ErrNilBlackListCacher = errors.New("nil black list cacher")

+ var ErrNilBlackListedPkCache = errors.New("nil black listed public key cache")

+ var ErrNilBlockBody = errors.New("nil block body")

+ var ErrNilBlockChain = errors.New("nil block chain")

+ var ErrNilBlockChainHook = errors.New("nil blockchain hook")

+ var ErrNilBlockHeader = errors.New("nil block header")

+ var ErrNilBlockProcessor = errors.New("nil block processor")

+ var ErrNilBlockSizeComputationHandler = errors.New("nil block size computation handler")

+ var ErrNilBlockSizeThrottler = errors.New("block size throttler is nil")

+ var ErrNilBlockTracker = errors.New("nil block tracker")

+ var ErrNilBootStorer = errors.New("nil boot storer")

+ var ErrNilBuffer = errors.New("provided byte buffer is nil")

+ var ErrNilBuiltInFunction = errors.New("built in function is nil")

+ var ErrNilCacher = errors.New("nil cacher")

+ var ErrNilCommunityAddress = errors.New("nil community address")

+ var ErrNilContainerElement = errors.New("element cannot be nil")

+ var ErrNilDataPoolHolder = errors.New("nil data pool holder")

+ var ErrNilDataToProcess = errors.New("nil data to process")

+ var ErrNilDebugger = errors.New("nil debug handler")

+ var ErrNilDnsAddresses = errors.New("nil dns addresses map")

+ var ErrNilEconomicsData = errors.New("nil economics data")

+ var ErrNilEconomicsFeeHandler = errors.New("nil economics fee handler")

+ var ErrNilEpochEconomics = errors.New("nil epoch economics")

+ var ErrNilEpochHandler = errors.New("nil epoch handler")

+ var ErrNilEpochStartDataCreator = errors.New("nil epoch start data creator")

+ var ErrNilEpochStartNotifier = errors.New("nil epochStartNotifier")

+ var ErrNilEpochStartRewardsCreator = errors.New("nil epoch start rewards creator")

+ var ErrNilEpochStartTrigger = errors.New("nil start of epoch trigger")

+ var ErrNilEpochStartValidatorInfoCreator = errors.New("nil epoch start validator info creator")

+ var ErrNilForkDetector = errors.New("nil fork detector")

+ var ErrNilGasHandler = errors.New("nil gas handler")

+ var ErrNilGasSchedule = errors.New("nil GasSchedule")

+ var ErrNilHasher = errors.New("nil Hasher")

+ var ErrNilHaveTimeHandler = errors.New("nil have time handler")

+ var ErrNilHdrValidator = errors.New("nil header validator")

+ var ErrNilHeaderHandler = errors.New("nil header handler")

+ var ErrNilHeaderIntegrityVerifier = errors.New("nil header integrity verifier")

+ var ErrNilHeaderSigVerifier = errors.New("nil header sig verifier")

+ var ErrNilHeaderValidator = errors.New("nil header validator")

+ var ErrNilHeadersDataPool = errors.New("nil headers data pool")

+ var ErrNilHeadersNonceHashStorage = errors.New("nil headers nonce hash storage")

+ var ErrNilHeadersStorage = errors.New("nil headers storage")

+ var ErrNilInterceptedDataFactory = errors.New("nil intercepted data factory")

+ var ErrNilInterceptedDataProcessor = errors.New("nil intercepted data processor")

+ var ErrNilInterceptorContainer = errors.New("nil interceptor container")

+ var ErrNilInterceptorThrottler = errors.New("nil interceptor throttler")

+ var ErrNilIntermediateProcessorContainer = errors.New("intermediate processor container is nil")

+ var ErrNilIntermediateTransactionHandler = errors.New("intermediate transaction handler is nil")

+ var ErrNilKeyGen = errors.New("nil key generator")

+ var ErrNilMarshalizer = errors.New("nil Marshalizer")

+ var ErrNilMessage = errors.New("nil message")

+ var ErrNilMessenger = errors.New("nil Messenger")

+ var ErrNilMetaBlockHeader = errors.New("nil metablock header")

+ var ErrNilMetaBlocksPool = errors.New("nil meta blocks pool")

+ var ErrNilMinChanceIfZero = errors.New("no min chance ")

+ var ErrNilMiniBlock = errors.New("nil mini block")

+ var ErrNilMiniBlockPool = errors.New("nil mini block pool")

+ var ErrNilMiniBlocks = errors.New("nil mini blocks")

+ var ErrNilMiniBlocksProvider = errors.New("nil miniblocks provider")

+ var ErrNilMultiSigVerifier = errors.New("nil multi-signature verifier")

+ var ErrNilNetworkWatcher = errors.New("nil network watcher")

+ var ErrNilNodesConfigProvider = errors.New("nil nodes config provider")

+ var ErrNilNodesCoordinator = errors.New("nil nodes coordinator")

+ var ErrNilNodesSetup = errors.New("nil nodes setup")

+ var ErrNilPeerAccountsAdapter = errors.New("nil peer accounts database")

+ var ErrNilPeerShardMapper = errors.New("nil peer shard mapper")

+ var ErrNilPeerValidatorMapper = errors.New("nil peer validator mapper")

+ var ErrNilPendingMiniBlocksHandler = errors.New("nil pending miniblocks handler")

+ var ErrNilPoolsHolder = errors.New("nil pools holder")

+ var ErrNilPreProcessor = errors.New("preprocessor is nil")

+ var ErrNilPreProcessorsContainer = errors.New("preprocessors container is nil")

+ var ErrNilPrevRandSeed = errors.New("provided previous rand seed is nil")

+ var ErrNilPreviousBlockHash = errors.New("nil previous block header hash")

+ var ErrNilPubKeysBitmap = errors.New("nil public keys bitmap")

+ var ErrNilPubkeyConverter = errors.New("nil pubkey converter")

+ var ErrNilQuotaStatusHandler = errors.New("nil quota status handler")

+ var ErrNilRandSeed = errors.New("provided rand seed is nil")

+ var ErrNilRater = errors.New("nil rater")

+ var ErrNilRatingsInfoHandler = errors.New("nil ratings info handler")

+ var ErrNilRcvAddr = errors.New("nil receiver address")

+ var ErrNilReceiptHandler = errors.New("nil receipt handler")

+ var ErrNilRequestHandler = errors.New("nil request handler")

+ var ErrNilRewardTransaction = errors.New("reward transaction is nil")

+ var ErrNilRewardTxDataPool = errors.New("reward transactions pool is nil")

+ var ErrNilRewardsHandler = errors.New("rewards handler is nil")

+ var ErrNilRewardsTxProcessor = errors.New("nil rewards transaction processor")

+ var ErrNilRootHash = errors.New("root hash is nil")

+ var ErrNilRounder = errors.New("nil Rounder")

+ var ErrNilSCDataGetter = errors.New("nil sc data getter")

+ var ErrNilSCDestAccount = errors.New("nil destination SC account")

+ var ErrNilSCToProtocol = errors.New("nil sc to protocol")

+ var ErrNilScAddress = errors.New("nil SC address")

+ var ErrNilShardCoordinator = errors.New("nil shard coordinator")

+ var ErrNilShardedDataCacherNotifier = errors.New("nil sharded data cacher notifier")

+ var ErrNilSignature = errors.New("nil signature")

+ var ErrNilSingleSigner = errors.New("nil single signer")

+ var ErrNilSmartContractProcessor = errors.New("smart contract processor is nil")

+ var ErrNilSmartContractResult = errors.New("smart contract result is nil")

+ var ErrNilSmartContractResultProcessor = errors.New("nil smart contract result processor")

+ var ErrNilSndAddr = errors.New("nil sender address")

+ var ErrNilStorage = errors.New("nil storage")

+ var ErrNilStore = errors.New("nil data storage service")

+ var ErrNilSystemSCConfig = errors.New("nil system sc config")

+ var ErrNilTemporaryAccountsHandler = errors.New("temporary accounts handler is nil")

+ var ErrNilTopicFloodPreventer = errors.New("nil topic flood preventer")

+ var ErrNilTransaction = errors.New("nil transaction")

+ var ErrNilTransactionCoordinator = errors.New("transaction coordinator is nil")

+ var ErrNilTransactionPool = errors.New("nil transaction pool")

+ var ErrNilTxBlockBody = errors.New("nil tx block body")

+ var ErrNilTxDataPool = errors.New("nil transaction data pool")

+ var ErrNilTxForCurrentBlockHandler = errors.New("nil tx for current block handler")

+ var ErrNilTxHash = errors.New("nil transaction hash")

+ var ErrNilTxLogsProcessor = errors.New("nil transaction logs processor")

+ var ErrNilTxProcessor = errors.New("nil transactions processor")

+ var ErrNilTxStorage = errors.New("nil transaction storage")

+ var ErrNilTxTypeHandler = errors.New("nil tx type handler")

+ var ErrNilTxValidator = errors.New("nil transaction validator")

+ var ErrNilUTxDataPool = errors.New("unsigned transactions pool is nil")

+ var ErrNilUTxStorage = errors.New("unsigned transactions storage is nil")

+ var ErrNilUint64Converter = errors.New("unit64converter is nil")

+ var ErrNilUnsignedTxDataPool = errors.New("unsigned transactions pool is nil")

+ var ErrNilUnsignedTxHandler = errors.New("nil unsigned tx handler")

+ var ErrNilVMOutput = errors.New("nil vm output")

+ var ErrNilValidatorInfos = errors.New("nil validator infos")

+ var ErrNilValidatorStatistics = errors.New("nil validator statistics")

+ var ErrNilValidityAttester = errors.New("nil validity attester")

+ var ErrNilValue = errors.New("nil value")

+ var ErrNilValueFromRewardTransaction = errors.New("transferred value is nil in reward transaction")

+ var ErrNilVmInput = errors.New("nil vm input")

+ var ErrNilWhiteListHandler = errors.New("nil whitelist handler")

+ var ErrNoChancesForMaxThreshold = errors.New("max threshold has no chances")

+ var ErrNoChancesProvided = errors.New("no chances are provided")

+ var ErrNoDataInMessage = errors.New("no data found in received message")

+ var ErrNoVM = errors.New("no VM (hook not set)")

+ var ErrNotEnoughGas = errors.New("not enough gas was sent in the transaction")

+ var ErrNotEnoughValidBlocksInStorage = errors.New("not enough valid blocks to start from storage")

+ var ErrNotEpochStartBlock = errors.New("not epoch start block")

+ var ErrNotarizedHeadersSliceForShardIsNil = errors.New("notarized headers slice for shard is nil")

+ var ErrNotarizedHeadersSliceIsNil = errors.New("notarized headers slice is nil")

+ var ErrOnlyValidatorsCanUseThisTopic = errors.New("only validators can use this topic")

+ var ErrOperationNotPermitted = errors.New("operation in account not permitted")

+ var ErrOriginatorIsBlacklisted = errors.New("originator is blacklisted")

+ var ErrOverallBalanceChangeFromSC = errors.New("SC output balance updates are wrong")

+ var ErrOverflow = errors.New("type overflow occured")

+ var ErrRandSeedDoesNotMatch = errors.New("random seed do not match")

+ var ErrReceiptsHashMissmatch = errors.New("receipts hash missmatch")

+ var ErrRecursiveRelayedTxIsNotAllowed = errors.New("recursive relayed tx is not allowed")

+ var ErrRelayedTxBeneficiaryDoesNotMatchReceiver = errors.New("invalid address in relayed tx")

+ var ErrRelayedTxValueHigherThenUserTxValue = errors.New("relayed tx value is higher than user tx value")

+ var ErrRewardMiniBlockNotFromMeta = errors.New("rewards miniblocks should come only from meta")

+ var ErrRootStateDoesNotMatch = errors.New("root state does not match")

+ var ErrSCDeployFromSCRIsNotPermitted = errors.New(...)

+ var ErrShardIdMissmatch = errors.New("shard ID missmatch")

+ var ErrShardIsStuck = errors.New("shard is stuck")

+ var ErrSignedBlocksThresholdNotBetweenZeroAndOne = errors.New("signed blocks threshold is not between 0 and 1")

+ var ErrStartRatingNotBetweenMinAndMax = errors.New("start rating is not between min and max rating")

+ var ErrSystemBusy = errors.New("system busy")

+ var ErrTimeIsOut = errors.New("time is out")

+ var ErrTooManyReceiptsMiniBlocks = errors.New("too many receipts miniblocks")

+ var ErrTransactionIsNotWhitelisted = errors.New("transaction is not whitelisted")

+ var ErrTxNotFound = errors.New("transaction not found")

+ var ErrTxValueOutOfBounds = errors.New("tx value is out of bounds")

+ var ErrTxValueTooBig = errors.New("tx value is too big")

+ var ErrUnknownBlockType = errors.New("block type is unknown")

+ var ErrUnmarshalWithoutSuccess = errors.New("unmarshal without success")

+ var ErrUserNameChangeIsDisabled = errors.New("user name change is disabled")

+ var ErrUserNameDoesNotMatch = errors.New("user name does not match")

+ var ErrUserNameDoesNotMatchInCrossShardTx = errors.New("user name does not match in destination shard")

+ var ErrValidatorInfoMiniBlockNotFromMeta = errors.New("validatorInfo miniblocks should come only from meta")

+ var ErrValidatorStatsRootHashDoesNotMatch = errors.New("root hash for validator statistics does not match")

+ var ErrWrongNonceInBlock = errors.New("wrong nonce in block")

+ var ErrWrongNonceInVMOutput = errors.New("nonce invalid from SC run")

+ var ErrWrongTransaction = errors.New("invalid transaction")

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

+ var ErrWrongTypeInContainer = errors.New("wrong type of object inside container")

+ var ErrWrongTypeInMiniBlock = errors.New("type in miniblock is not correct for processing")

+ var ErrZeroMaxComputableRounds = errors.New("max computable rounds is zero")

+ func AddHeaderToBlackList(blackListHandler TimeCacher, hash []byte)

+ func DisplayProcessTxDetails(message string, accountHandler state.AccountHandler, ...)

+ func GetHeaderFromStorageWithNonce(nonce uint64, shardId uint32, storageService dataRetriever.StorageService, ...) (data.HeaderHandler, []byte, error)

+ func GetMarshalizedHeaderFromStorage(blockUnit dataRetriever.UnitType, hash []byte, marshalizer marshal.Marshalizer, ...) ([]byte, error)

+ func GetMetaHeader(hash []byte, headersCacher dataRetriever.HeadersPool, ...) (*block.MetaBlock, error)

+ func GetMetaHeaderFromPool(hash []byte, headersCacher dataRetriever.HeadersPool) (*block.MetaBlock, error)

+ func GetMetaHeaderFromPoolWithNonce(nonce uint64, headersCacher dataRetriever.HeadersPool) (*block.MetaBlock, []byte, error)

+ func GetMetaHeaderFromStorage(hash []byte, marshalizer marshal.Marshalizer, ...) (*block.MetaBlock, error)

+ func GetMetaHeaderFromStorageWithNonce(nonce uint64, storageService dataRetriever.StorageService, ...) (*block.MetaBlock, []byte, error)

+ func GetMetaHeaderWithNonce(nonce uint64, headersCacher dataRetriever.HeadersPool, ...) (*block.MetaBlock, []byte, error)

+ func GetShardHeader(hash []byte, headersCacher dataRetriever.HeadersPool, ...) (*block.Header, error)

+ func GetShardHeaderFromPool(hash []byte, headersCacher dataRetriever.HeadersPool) (*block.Header, error)

+ func GetShardHeaderFromPoolWithNonce(nonce uint64, shardId uint32, headersCacher dataRetriever.HeadersPool) (*block.Header, []byte, error)

+ func GetShardHeaderFromStorage(hash []byte, marshalizer marshal.Marshalizer, ...) (*block.Header, error)

+ func GetShardHeaderFromStorageWithNonce(nonce uint64, shardId uint32, storageService dataRetriever.StorageService, ...) (*block.Header, []byte, error)

+ func GetShardHeaderWithNonce(nonce uint64, shardId uint32, headersCacher dataRetriever.HeadersPool, ...) (*block.Header, []byte, error)

+ func GetTransactionHandler(senderShardID uint32, destShardID uint32, txHash []byte, ...) (data.TransactionHandler, error)

+ func GetTransactionHandlerFromPool(senderShardID uint32, destShardID uint32, txHash []byte, ...) (data.TransactionHandler, error)

+ func GetTransactionHandlerFromStorage(txHash []byte, storageService dataRetriever.StorageService, ...) (data.TransactionHandler, error)

+ func IsAllowedToSaveUnderKey(key []byte) bool

+ func IsInProperRound(index int64) bool

+ func IsShardCacherIdentifierForSourceMe(cacheID string, shardID uint32) bool

+ func ParseShardCacherIdentifier(cacheID string) (uint32, uint32, error)

+ func ShardCacherIdentifier(senderShardID uint32, destinationShardID uint32) string

+ func SortHeadersByNonce(headers []data.HeaderHandler)

+ type AntifloodDebugger interface

+ AddData func(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, ...)

+ Close func() error

+ IsInterfaceNil func() bool

+ type ArgumentsParser interface

+ CreateDataFromStorageUpdate func(storageUpdates []*vmcommon.StorageUpdate) string

+ GetStorageUpdates func(data string) ([]*vmcommon.StorageUpdate, error)

+ IsInterfaceNil func() bool

+ ParseCallData func(data string) (string, [][]byte, error)

+ ParseDeployData func(data string) (*parsers.DeployArgs, error)

+ type BlockChainHookHandler interface

+ GetBuiltInFunctions func() BuiltInFunctionContainer

+ NewAddress func(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)

+ SetCurrentHeader func(hdr data.HeaderHandler)

+ type BlockHeaderState int

+ const BHNotarized

+ const BHProcessed

+ const BHProposed

+ const BHReceived

+ const BHReceivedTooLate

+ type BlockProcessor interface

+ ApplyProcessedMiniBlocks func(processedMiniBlocks *processedMb.ProcessedMiniBlockTracker)

+ CommitBlock func(header data.HeaderHandler, body data.BodyHandler) error

+ CreateBlock func(initialHdr data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)

+ CreateNewHeader func(round uint64, nonce uint64) data.HeaderHandler

+ DecodeBlockBody func(dta []byte) data.BodyHandler

+ DecodeBlockHeader func(dta []byte) data.HeaderHandler

+ IsInterfaceNil func() bool

+ MarshalizedDataToBroadcast func(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error)

+ ProcessBlock func(header data.HeaderHandler, body data.BodyHandler, ...) error

+ PruneStateOnRollback func(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)

+ RestoreBlockIntoPools func(header data.HeaderHandler, body data.BodyHandler) error

+ RevertAccountState func(header data.HeaderHandler)

+ RevertStateToBlock func(header data.HeaderHandler) error

+ SetNumProcessedObj func(numObj uint64)

+ type BlockSizeThrottler interface

+ Add func(round uint64, size uint32)

+ ComputeCurrentMaxSize func()

+ GetCurrentMaxSize func() uint32

+ IsInterfaceNil func() bool

+ Succeed func(round uint64)

+ type BlockTracker interface

+ AddCrossNotarizedHeader func(shradID uint32, crossNotarizedHeader data.HeaderHandler, ...)

+ AddSelfNotarizedHeader func(shardID uint32, selfNotarizedHeader data.HeaderHandler, ...)

+ AddTrackedHeader func(header data.HeaderHandler, hash []byte)

+ CheckBlockAgainstFinal func(headerHandler data.HeaderHandler) error

+ CheckBlockAgainstRounder func(headerHandler data.HeaderHandler) error

+ CleanupHeadersBehindNonce func(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)

+ CleanupInvalidCrossHeaders func(metaNewEpoch uint32, metaRoundAttestingEpoch uint64)

+ ComputeLongestChain func(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)

+ ComputeLongestMetaChainFromLastNotarized func() ([]data.HeaderHandler, [][]byte, error)

+ ComputeLongestShardsChainsFromLastNotarized func() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)

+ DisplayTrackedHeaders func()

+ GetCrossNotarizedHeader func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)

+ GetLastCrossNotarizedHeader func(shardID uint32) (data.HeaderHandler, []byte, error)

+ GetLastCrossNotarizedHeadersForAllShards func() (map[uint32]data.HeaderHandler, error)

+ GetLastSelfNotarizedHeader func(shardID uint32) (data.HeaderHandler, []byte, error)

+ GetSelfNotarizedHeader func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)

+ GetTrackedHeaders func(shardID uint32) ([]data.HeaderHandler, [][]byte)

+ GetTrackedHeadersForAllShards func() map[uint32][]data.HeaderHandler

+ GetTrackedHeadersWithNonce func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)

+ IsInterfaceNil func() bool

+ IsShardStuck func(shardID uint32) bool

+ RegisterCrossNotarizedHeadersHandler func(func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

+ RegisterSelfNotarizedHeadersHandler func(func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

+ RemoveLastNotarizedHeaders func()

+ RestoreToGenesis func()

+ ShouldAddHeader func(headerHandler data.HeaderHandler) bool

+ type BootStorer interface

+ Get func(round int64) (bootstrapStorage.BootstrapData, error)

+ GetHighestRound func() int64

+ IsInterfaceNil func() bool

+ Put func(round int64, bootData bootstrapStorage.BootstrapData) error

+ SaveLastRound func(round int64) error

+ type Bootstrapper interface

+ AddSyncStateListener func(func(isSyncing bool))

+ Close func() error

+ GetNodeState func() core.NodeState

+ IsInterfaceNil func() bool

+ SetStatusHandler func(handler core.AppStatusHandler) error

+ StartSyncingBlocks func()

+ type BootstrapperFromStorage interface

+ GetHighestBlockNonce func() uint64

+ IsInterfaceNil func() bool

+ LoadFromStorage func() error

+ type BuiltInFunctionContainer interface

+ Add func(key string, function BuiltinFunction) error

+ Get func(key string) (BuiltinFunction, error)

+ IsInterfaceNil func() bool

+ Keys func() map[string]struct{}

+ Len func() int

+ Remove func(key string)

+ Replace func(key string, function BuiltinFunction) error

+ type BuiltinFunction interface

+ IsInterfaceNil func() bool

+ ProcessBuiltinFunction func(acntSnd, acntDst state.UserAccountHandler, vmInput *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)

+ type CallArgumentsParser interface

+ IsInterfaceNil func() bool

+ ParseData func(data string) (string, [][]byte, error)

+ type Checker interface

+ Integrity func(coordinator sharding.Coordinator) error

+ IntegrityAndValidity func(coordinator sharding.Coordinator) error

+ IsInterfaceNil func() bool

+ type DataMarshalizer interface

+ CreateMarshalizedData func(txHashes [][]byte) ([][]byte, error)

+ type DataPacker interface

+ IsInterfaceNil func() bool

+ PackDataInChunks func(data [][]byte, limit int) ([][]byte, error)

+ type DeployArgumentsParser interface

+ IsInterfaceNil func() bool

+ ParseData func(data string) (*parsers.DeployArgs, error)

+ type EconomicsAddressesHandler interface

+ BurnAddress func() string

+ CommunityAddress func() string

+ IsInterfaceNil func() bool

+ type EndOfEpochEconomics interface

+ ComputeEndOfEpochEconomics func(metaBlock *block.MetaBlock) (*block.Economics, error)

+ IsInterfaceNil func() bool

+ VerifyRewardsPerBlock func(metaBlock *block.MetaBlock) error

+ type EpochBootstrapper interface

+ IsInterfaceNil func() bool

+ SetCurrentEpochStartRound func(round uint64)

+ type EpochHandler interface

+ IsInterfaceNil func() bool

+ MetaEpoch func() uint32

+ type EpochStartDataCreator interface

+ CreateEpochStartData func() (*block.EpochStart, error)

+ IsInterfaceNil func() bool

+ VerifyEpochStartDataForMetablock func(metaBlock *block.MetaBlock) error

+ type EpochStartEventNotifier interface

+ IsInterfaceNil func() bool

+ RegisterHandler func(handler epochStart.ActionHandler)

+ UnregisterHandler func(handler epochStart.ActionHandler)

+ type EpochStartRewardsCreator interface

+ CreateMarshalizedData func(body *block.Body) map[string][][]byte

+ CreateRewardsMiniBlocks func(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo) (block.MiniBlockSlice, error)

+ DeleteTxsFromStorage func(metaBlock *block.MetaBlock, body *block.Body)

+ GetRewardsTxs func(body *block.Body) map[string]data.TransactionHandler

+ IsInterfaceNil func() bool

+ RemoveBlockDataFromPools func(metaBlock *block.MetaBlock, body *block.Body)

+ SaveTxBlockToStorage func(metaBlock *block.MetaBlock, body *block.Body)

+ VerifyRewardsMiniBlocks func(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo) error

+ type EpochStartTriggerHandler interface

+ Epoch func() uint32

+ EpochFinalityAttestingRound func() uint64

+ EpochStartMetaHdrHash func() []byte

+ EpochStartRound func() uint64

+ GetSavedStateKey func() []byte

+ IsEpochStart func() bool

+ IsInterfaceNil func() bool

+ LoadState func(key []byte) error

+ MetaEpoch func() uint32

+ RequestEpochStartIfNeeded func(interceptedHeader data.HeaderHandler)

+ RevertStateToBlock func(header data.HeaderHandler) error

+ SetFinalityAttestingRound func(round uint64)

+ SetProcessed func(header data.HeaderHandler, body data.BodyHandler)

+ Update func(round uint64, nonce uint64)

+ type EpochStartValidatorInfoCreator interface

+ CreateValidatorInfoMiniBlocks func(validatorInfo map[uint32][]*state.ValidatorInfo) (block.MiniBlockSlice, error)

+ DeleteValidatorInfoBlocksFromStorage func(metaBlock *block.MetaBlock)

+ IsInterfaceNil func() bool

+ RemoveBlockDataFromPools func(metaBlock *block.MetaBlock, body *block.Body)

+ SaveValidatorInfoBlocksToStorage func(metaBlock *block.MetaBlock, body *block.Body)

+ VerifyValidatorInfoMiniBlocks func(miniblocks []*block.MiniBlock, ...) error

+ type FeeHandler interface

+ CheckValidityTxValues func(tx TransactionWithFeeHandler) error

+ ComputeFee func(tx TransactionWithFeeHandler) *big.Int

+ ComputeGasLimit func(tx TransactionWithFeeHandler) uint64

+ DeveloperPercentage func() float64

+ IsInterfaceNil func() bool

+ MaxGasLimitPerBlock func(shardID uint32) uint64

+ MinGasPrice func() uint64

+ type FloodPreventer interface

+ ApplyConsensusSize func(size int)

+ IncreaseLoad func(pid core.PeerID, size uint64) error

+ IsInterfaceNil func() bool

+ Reset func()

+ type ForkDetector interface

+ AddHeader func(header data.HeaderHandler, headerHash []byte, state BlockHeaderState, ...) error

+ CheckFork func() *ForkInfo

+ GetHighestFinalBlockHash func() []byte

+ GetHighestFinalBlockNonce func() uint64

+ GetNotarizedHeaderHash func(nonce uint64) []byte

+ IsInterfaceNil func() bool

+ ProbableHighestNonce func() uint64

+ RemoveHeader func(nonce uint64, hash []byte)

+ ResetFork func()

+ ResetProbableHighestNonce func()

+ RestoreToGenesis func()

+ SetRollBackNonce func(nonce uint64)

+ type ForkInfo struct

+ Hash []byte

+ IsDetected bool

+ Nonce uint64

+ Round uint64

+ func NewForkInfo() *ForkInfo

+ type GasHandler interface

+ ComputeGasConsumedByMiniBlock func(*block.MiniBlock, map[string]data.TransactionHandler) (uint64, uint64, error)

+ ComputeGasConsumedByTx func(txSenderShardId uint32, txReceiverShardId uint32, ...) (uint64, uint64, error)

+ GasConsumed func(hash []byte) uint64

+ GasRefunded func(hash []byte) uint64

+ Init func()

+ IsInterfaceNil func() bool

+ RemoveGasConsumed func(hashes [][]byte)

+ RemoveGasRefunded func(hashes [][]byte)

+ SetGasConsumed func(gasConsumed uint64, hash []byte)

+ SetGasRefunded func(gasRefunded uint64, hash []byte)

+ TotalGasConsumed func() uint64

+ TotalGasRefunded func() uint64

+ type HashAccesser interface

+ Hash func() []byte

+ SetHash func([]byte)

+ type HdrValidatorHandler interface

+ Hash func() []byte

+ HeaderHandler func() data.HeaderHandler

+ type HeaderConstructionValidator interface

+ IsHeaderConstructionValid func(currHdr, prevHdr data.HeaderHandler) error

+ IsInterfaceNil func() bool

+ type HeaderValidator interface

+ HeaderValidForProcessing func(headerHandler HdrValidatorHandler) error

+ IsInterfaceNil func() bool

+ type InterceptedData interface

+ CheckValidity func() error

+ Hash func() []byte

+ Identifiers func() [][]byte

+ IsForCurrentShard func() bool

+ IsInterfaceNil func() bool

+ String func() string

+ Type func() string

+ type InterceptedDataFactory interface

+ Create func(buff []byte) (InterceptedData, error)

+ IsInterfaceNil func() bool

+ type InterceptedDebugger interface

+ IsInterfaceNil func() bool

+ LogProcessedHashes func(topic string, hashes [][]byte, err error)

+ LogReceivedHashes func(topic string, hashes [][]byte)

+ type InterceptedHeaderIntegrityVerifier interface

+ IsInterfaceNil func() bool

+ Verify func(header data.HeaderHandler) error

+ type InterceptedHeaderSigVerifier interface

+ IsInterfaceNil func() bool

+ VerifyRandSeedAndLeaderSignature func(header data.HeaderHandler) error

+ VerifySignature func(header data.HeaderHandler) error

+ type Interceptor interface

+ IsInterfaceNil func() bool

+ ProcessReceivedMessage func(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error

+ RegisterHandler func(handler func(topic string, hash []byte, data interface{}))

+ SetInterceptedDebugHandler func(handler InterceptedDebugger) error

+ type InterceptorProcessor interface

+ IsInterfaceNil func() bool

+ RegisterHandler func(handler func(topic string, hash []byte, data interface{}))

+ Save func(data InterceptedData, fromConnectedPeer core.PeerID, topic string) error

+ Validate func(data InterceptedData, fromConnectedPeer core.PeerID) error

+ type InterceptorThrottler interface

+ CanProcess func() bool

+ EndProcessing func()

+ IsInterfaceNil func() bool

+ StartProcessing func()

+ type InterceptorsContainer interface

+ Add func(key string, val Interceptor) error

+ AddMultiple func(keys []string, interceptors []Interceptor) error

+ Get func(key string) (Interceptor, error)

+ IsInterfaceNil func() bool

+ Iterate func(handler func(key string, interceptor Interceptor) bool)

+ Len func() int

+ Remove func(key string)

+ Replace func(key string, val Interceptor) error

+ type InterceptorsContainerFactory interface

+ Create func() (InterceptorsContainer, error)

+ IsInterfaceNil func() bool

+ type IntermediateProcessorContainer interface

+ Add func(key block.Type, val IntermediateTransactionHandler) error

+ AddMultiple func(keys []block.Type, preprocessors []IntermediateTransactionHandler) error

+ Get func(key block.Type) (IntermediateTransactionHandler, error)

+ IsInterfaceNil func() bool

+ Keys func() []block.Type

+ Len func() int

+ Remove func(key block.Type)

+ Replace func(key block.Type, val IntermediateTransactionHandler) error

+ type IntermediateProcessorsContainerFactory interface

+ Create func() (IntermediateProcessorContainer, error)

+ IsInterfaceNil func() bool

+ type IntermediateTransactionHandler interface

+ AddIntermediateTransactions func(txs []data.TransactionHandler) error

+ CreateAllInterMiniBlocks func() []*block.MiniBlock

+ CreateBlockStarted func()

+ GetAllCurrentFinishedTxs func() map[string]data.TransactionHandler

+ GetCreatedInShardMiniBlock func() *block.MiniBlock

+ IsInterfaceNil func() bool

+ RemoveProcessedResultsFor func(txHashes [][]byte)

+ SaveCurrentIntermediateTxToStorage func() error

+ VerifyInterMiniBlocks func(body *block.Body) error

+ type MiniBlockProvider interface

+ GetMiniBlocks func(hashes [][]byte) ([]*MiniblockAndHash, [][]byte)

+ GetMiniBlocksFromPool func(hashes [][]byte) ([]*MiniblockAndHash, [][]byte)

+ IsInterfaceNil func() bool

+ type MiniblockAndHash struct

+ Hash []byte

+ Miniblock *block.MiniBlock

+ type NetworkConnectionWatcher interface

+ IsConnectedToTheNetwork func() bool

+ IsInterfaceNil func() bool

+ type NodesCoordinator interface

+ GetAllEligibleValidatorsPublicKeys func(epoch uint32) (map[uint32][][]byte, error)

+ GetAllLeavingValidatorsPublicKeys func(epoch uint32) (map[uint32][][]byte, error)

+ GetAllWaitingValidatorsPublicKeys func(epoch uint32) (map[uint32][][]byte, error)

+ IsInterfaceNil func() bool

+ type P2PAntifloodHandler interface

+ ApplyConsensusSize func(size int)

+ BlacklistPeer func(peer core.PeerID, reason string, duration time.Duration)

+ CanProcessMessage func(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error

+ CanProcessMessagesOnTopic func(pid core.PeerID, topic string, numMessages uint32, totalSize uint64, ...) error

+ IsInterfaceNil func() bool

+ IsOriginatorEligibleForTopic func(pid core.PeerID, topic string) error

+ SetDebugger func(debugger AntifloodDebugger) error

+ type PeerBlackListCacher interface

+ Has func(pid core.PeerID) bool

+ IsInterfaceNil func() bool

+ Sweep func()

+ Upsert func(pid core.PeerID, span time.Duration) error

+ type PeerChangesHandler interface

+ IsInterfaceNil func() bool

+ PeerChanges func() []block.PeerData

+ VerifyPeerChanges func(peerChanges []block.PeerData) error

+ type PeerShardMapper interface

+ GetPeerInfo func(pid core.PeerID) core.P2PPeerInfo

+ IsInterfaceNil func() bool

+ type PeerValidatorMapper interface

+ GetPeerInfo func(pid core.PeerID) core.P2PPeerInfo

+ IsInterfaceNil func() bool

+ type PendingMiniBlocksHandler interface

+ AddProcessedHeader func(handler data.HeaderHandler) error

+ GetPendingMiniBlocks func(shardID uint32) [][]byte

+ IsInterfaceNil func() bool

+ RevertHeader func(handler data.HeaderHandler) error

+ SetPendingMiniBlocks func(shardID uint32, mbHashes [][]byte)

+ type PoolsCleaner interface

+ Close func() error

+ IsInterfaceNil func() bool

+ StartCleaning func()

+ type PreProcessor interface

+ CreateAndProcessMiniBlocks func(haveTime func() bool) (block.MiniBlockSlice, error)

+ CreateBlockStarted func()

+ GetAllCurrentUsedTxs func() map[string]data.TransactionHandler

+ IsDataPrepared func(requestedTxs int, haveTime func() time.Duration) error

+ IsInterfaceNil func() bool

+ ProcessBlockTransactions func(body *block.Body, haveTime func() bool) error

+ ProcessMiniBlock func(miniBlock *block.MiniBlock, haveTime func() bool) ([][]byte, error)

+ RemoveTxBlockFromPools func(body *block.Body, miniBlockPool storage.Cacher) error

+ RequestBlockTransactions func(body *block.Body) int

+ RequestTransactionsForMiniBlock func(miniBlock *block.MiniBlock) int

+ RestoreTxBlockIntoPools func(body *block.Body, miniBlockPool storage.Cacher) (int, error)

+ SaveTxBlockToStorage func(body *block.Body) error

+ type PreProcessorsContainer interface

+ Add func(key block.Type, val PreProcessor) error

+ AddMultiple func(keys []block.Type, preprocessors []PreProcessor) error

+ Get func(key block.Type) (PreProcessor, error)

+ IsInterfaceNil func() bool

+ Keys func() []block.Type

+ Len func() int

+ Remove func(key block.Type)

+ Replace func(key block.Type, val PreProcessor) error

+ type PreProcessorsContainerFactory interface

+ Create func() (PreProcessorsContainer, error)

+ IsInterfaceNil func() bool

+ type RatingChanceHandler interface

+ GetChancePercentage func() uint32

+ GetMaxThreshold func() uint32

+ IsInterfaceNil func() bool

+ type RatingsInfoHandler interface

+ IsInterfaceNil func() bool

+ MaxRating func() uint32

+ MetaChainRatingsStepHandler func() RatingsStepHandler

+ MinRating func() uint32

+ SelectionChances func() []SelectionChance

+ ShardChainRatingsStepHandler func() RatingsStepHandler

+ SignedBlocksThreshold func() float32

+ StartRating func() uint32

+ type RatingsStepHandler interface

+ ConsecutiveMissedBlocksPenalty func() float32

+ ProposerDecreaseRatingStep func() int32

+ ProposerIncreaseRatingStep func() int32

+ ValidatorDecreaseRatingStep func() int32

+ ValidatorIncreaseRatingStep func() int32

+ type RequestBlockBodyHandler interface

+ GetBlockBodyFromPool func(headerHandler data.HeaderHandler) (data.BodyHandler, error)

+ type RequestHandler interface

+ GetNumPeersToQuery func(key string) (int, int, error)

+ IsInterfaceNil func() bool

+ RequestInterval func() time.Duration

+ RequestMetaHeader func(hash []byte)

+ RequestMetaHeaderByNonce func(nonce uint64)

+ RequestMiniBlock func(destShardID uint32, miniblockHash []byte)

+ RequestMiniBlocks func(destShardID uint32, miniblocksHashes [][]byte)

+ RequestRewardTransactions func(destShardID uint32, txHashes [][]byte)

+ RequestShardHeader func(shardID uint32, hash []byte)

+ RequestShardHeaderByNonce func(shardID uint32, nonce uint64)

+ RequestStartOfEpochMetaBlock func(epoch uint32)

+ RequestTransaction func(destShardID uint32, txHashes [][]byte)

+ RequestTrieNodes func(destShardID uint32, hashes [][]byte, topic string)

+ RequestUnsignedTransactions func(destShardID uint32, scrHashes [][]byte)

+ SetEpoch func(epoch uint32)

+ SetNumPeersToQuery func(key string, intra int, cross int) error

+ type RequiredDataPool struct

+ func (rh *RequiredDataPool) ExpectedData() [][]byte

+ func (rh *RequiredDataPool) ReceivedAll() bool

+ func (rh *RequiredDataPool) SetHashes(hashes [][]byte)

+ func (rh *RequiredDataPool) SetReceivedHash(hash []byte)

+ type RewardTransactionPreProcessor interface

+ AddComputedRewardMiniBlocks func(computedRewardMiniblocks block.MiniBlockSlice)

+ IsInterfaceNil func() bool

+ type RewardTransactionProcessor interface

+ IsInterfaceNil func() bool

+ ProcessRewardTransaction func(rewardTx *rewardTx.RewardTx) error

+ type RewardsHandler interface

+ CommunityAddress func() string

+ CommunityPercentage func() float64

+ IsInterfaceNil func() bool

+ LeaderPercentage func() float64

+ MaxInflationRate func(year uint32) float64

+ MinInflationRate func() float64

+ type RoundTimeDurationHandler interface

+ IsInterfaceNil func() bool

+ TimeDuration func() time.Duration

+ type Rounder interface

+ Index func() int64

+ IsInterfaceNil func() bool

+ type SCQuery struct

+ Arguments [][]byte

+ FuncName string

+ ScAddress []byte

+ type SCQueryService interface

+ ExecuteQuery func(query *SCQuery) (*vmcommon.VMOutput, error)

+ IsInterfaceNil func() bool

+ type SelectionChance interface

+ GetChancePercent func() uint32

+ GetMaxThreshold func() uint32

+ type SigVerifier interface

+ VerifySig func() error

+ type SignedDataValidator interface

+ type SmartContractProcessor interface

+ DeploySmartContract func(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error)

+ ExecuteSmartContractTransaction func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error)

+ IsInterfaceNil func() bool

+ ProcessIfError func(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, ...) error

+ type SmartContractResultProcessor interface

+ IsInterfaceNil func() bool

+ ProcessSmartContractResult func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)

+ type SmartContractToProtocolHandler interface

+ IsInterfaceNil func() bool

+ UpdateProtocol func(body *block.Body, nonce uint64) error

+ type StorageArgumentsParser interface

+ CreateDataFromStorageUpdate func(storageUpdates []*vmcommon.StorageUpdate) string

+ GetStorageUpdates func(data string) ([]*vmcommon.StorageUpdate, error)

+ IsInterfaceNil func() bool

+ type TemporaryAccountsHandler interface

+ AddTempAccount func(address []byte, balance *big.Int, nonce uint64)

+ CleanTempAccounts func()

+ IsInterfaceNil func() bool

+ TempAccount func(address []byte) state.AccountHandler

+ type TimeCacher interface

+ Add func(key string) error

+ Has func(key string) bool

+ IsInterfaceNil func() bool

+ Sweep func()

+ Upsert func(key string, span time.Duration) error

+ type TopicFloodPreventer interface

+ IncreaseLoad func(pid core.PeerID, topic string, numMessages uint32) error

+ IsInterfaceNil func() bool

+ ResetForNotRegisteredTopics func()

+ ResetForTopic func(topic string)

+ SetMaxMessagesForTopic func(topic string, maxNum uint32)

+ type TopicHandler interface

+ CreateTopic func(name string, createChannelForTopic bool) error

+ HasTopic func(name string) bool

+ IsInterfaceNil func() bool

+ RegisterMessageProcessor func(topic string, handler p2p.MessageProcessor) error

+ type TransactionCoordinator interface

+ CreateBlockStarted func()

+ CreateMarshalizedData func(body *block.Body) map[string][][]byte

+ CreateMbsAndProcessCrossShardTransactionsDstMe func(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, ...) (block.MiniBlockSlice, uint32, bool, error)

+ CreateMbsAndProcessTransactionsFromMe func(haveTime func() bool) block.MiniBlockSlice

+ CreatePostProcessMiniBlocks func() block.MiniBlockSlice

+ CreateReceiptsHash func() ([]byte, error)

+ GetAllCurrentUsedTxs func(blockType block.Type) map[string]data.TransactionHandler

+ IsDataPreparedForProcessing func(haveTime func() time.Duration) error

+ IsInterfaceNil func() bool

+ ProcessBlockTransaction func(body *block.Body, haveTime func() time.Duration) error

+ RemoveBlockDataFromPool func(body *block.Body) error

+ RequestBlockTransactions func(body *block.Body)

+ RequestMiniBlocks func(header data.HeaderHandler)

+ RestoreBlockDataFromStorage func(body *block.Body) (int, error)

+ SaveBlockDataToStorage func(body *block.Body) error

+ VerifyCreatedBlockTransactions func(hdr data.HeaderHandler, body *block.Body) error

+ type TransactionFeeHandler interface

+ CreateBlockStarted func()

+ GetAccumulatedFees func() *big.Int

+ GetDeveloperFees func() *big.Int

+ IsInterfaceNil func() bool

+ ProcessTransactionFee func(cost *big.Int, devFee *big.Int, txHash []byte)

+ RevertFees func(txHashes [][]byte)

+ type TransactionLogProcessor interface

+ GetLog func(txHash []byte) (data.LogHandler, error)

+ IsInterfaceNil func() bool

+ SaveLog func(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error

+ type TransactionLogProcessorDatabase interface

+ Clean func()

+ EnableLogToBeSavedInCache func()

+ GetLogFromCache func(txHash []byte) (data.LogHandler, bool)

+ IsInterfaceNil func() bool

+ type TransactionProcessor interface

+ IsInterfaceNil func() bool

+ ProcessTransaction func(transaction *transaction.Transaction) (vmcommon.ReturnCode, error)

+ type TransactionType int

+ const BuiltInFunctionCall

+ const InvalidTransaction

+ const MoveBalance

+ const RelayedTx

+ const RewardTx

+ const SCDeployment

+ const SCInvoking

+ type TransactionVerifier interface

+ IsTransactionValid func(tx data.TransactionHandler) error

+ type TransactionWithFeeHandler interface

+ GetData func() []byte

+ GetGasLimit func() uint64

+ GetGasPrice func() uint64

+ GetRcvAddr func() []byte

+ GetValue func() *big.Int

+ type TxTypeHandler interface

+ ComputeTransactionType func(tx data.TransactionHandler) TransactionType

+ IsInterfaceNil func() bool

+ type TxValidator interface

+ CheckTxValidity func(txHandler TxValidatorHandler) error

+ CheckTxWhiteList func(data InterceptedData) error

+ IsInterfaceNil func() bool

+ type TxValidatorHandler interface

+ Fee func() *big.Int

+ Nonce func() uint64

+ ReceiverShardId func() uint32

+ SenderAddress func() []byte

+ SenderShardId func() uint32

+ type ValidatorInfoSyncer interface

+ IsInterfaceNil func() bool

+ SyncMiniBlocks func(metaBlock *block.MetaBlock) ([][]byte, data.BodyHandler, error)

+ type ValidatorSettingsHandler interface

+ GenesisNodePrice func() *big.Int

+ IsInterfaceNil func() bool

+ UnBondPeriod func() uint64

+ type ValidatorStatisticsProcessor interface

+ Commit func() ([]byte, error)

+ DisplayRatings func(epoch uint32)

+ GetPeerAccount func(address []byte) (state.PeerAccountHandler, error)

+ GetValidatorInfoForRootHash func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)

+ IsInterfaceNil func() bool

+ LastFinalizedRootHash func() []byte

+ Process func(shardValidatorInfo data.ShardValidatorInfoHandler) error

+ ProcessRatingsEndOfEpoch func(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error

+ ResetValidatorStatisticsAtNewEpoch func(vInfos map[uint32][]*state.ValidatorInfo) error

+ RevertPeerState func(header data.HeaderHandler) error

+ RootHash func() ([]byte, error)

+ SetLastFinalizedRootHash func([]byte)

+ UpdatePeerState func(header data.HeaderHandler, cache map[string]data.HeaderHandler) ([]byte, error)

+ type ValidatorsProvider interface

+ GetLatestValidators func() map[string]*state.ValidatorApiResponse

+ IsInterfaceNil func() bool

+ type ValidityAttester interface

+ CheckBlockAgainstFinal func(headerHandler data.HeaderHandler) error

+ CheckBlockAgainstRounder func(headerHandler data.HeaderHandler) error

+ IsInterfaceNil func() bool

+ type VirtualMachinesContainer interface

+ Add func(key []byte, val vmcommon.VMExecutionHandler) error

+ AddMultiple func(keys [][]byte, vms []vmcommon.VMExecutionHandler) error

+ Close func() error

+ Get func(key []byte) (vmcommon.VMExecutionHandler, error)

+ IsInterfaceNil func() bool

+ Keys func() [][]byte

+ Len func() int

+ Remove func(key []byte)

+ Replace func(key []byte, val vmcommon.VMExecutionHandler) error

+ type VirtualMachinesContainerFactory interface

+ BlockChainHookImpl func() BlockChainHookHandler

+ Create func() (VirtualMachinesContainer, error)

+ IsInterfaceNil func() bool

+ type WhiteListHandler interface

+ Add func(keys [][]byte)

+ IsInterfaceNil func() bool

+ IsWhiteListed func(interceptedData InterceptedData) bool

+ Remove func(keys [][]byte)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL