Versions in this module Expand all Collapse all v1 v1.999.0 Nov 17, 2022 Changes in this version + const BlockFinality + const EpochChangeGracePeriod + const MaxGasBandwidthPerBatchPerSender + const MaxGasFeeHigherFactorAccepted + const MaxHeaderRequestsAllowed + const MaxHeadersToRequestInAdvance + const MaxHeadersToWhitelistInAdvance + const MaxMetaHeadersAllowedInOneShardBlock + const MaxMetaNoncesBehind + const MaxMetaNoncesBehindForGlobalStuck + const MaxNumOfTxsToSelect + const MaxRoundsToKeepUnprocessedMiniBlocks + const MaxRoundsToKeepUnprocessedTransactions + const MaxRoundsWithoutCommittedBlock + const MaxRoundsWithoutNewBlockReceived + const MaxShardHeadersAllowedInOneMetaBlock + const MaxShardNoncesBehind + const MaxSyncWithErrorsAllowed + const MetaBlockValidity + const MinForkRound + const MinShardHeadersFromSameShardInOneMetaBlock + const NonceDifferenceWhenSynced + const NumTxPerSenderBatchForFillingMiniblock + const RoundModulusTrigger + const RoundModulusTriggerWhenSyncIsStuck + var ErrAccountNotFound = errors.New("account not found") + var ErrAccountNotPayable = errors.New("sending value to non payable contract") + 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 ErrBuiltInFunctionsAreDisabled = errors.New("built in functions are disabled") + 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 ErrDevFeesInEpochDoNotMatch = errors.New("developer fees in epoch do not match") + var ErrDeveloperFeesDoNotMatch = errors.New("developer fees do not match") + var ErrDuplicateRoundActivationName = errors.New("round activation name already exists in config file") + var ErrDuplicateThreshold = errors.New("two thresholds are the same") + var ErrEmptyConsensusGroup = errors.New("consensusGroup is empty") + var ErrEmptyEpochRewardsConfig = errors.New("the epoch rewards config is empty") + var ErrEmptyFloodPreventerList = errors.New("empty flood preventer provided") + var ErrEmptyFunctionName = errors.New("empty function name") + var ErrEmptyGasLimitSettings = errors.New("the gas limit settings is empty") + var ErrEmptyPeerID = errors.New("empty peer ID") + var ErrEmptyTopic = errors.New("empty topic") + var ErrEmptyYearSettings = errors.New("the year settings is empty") + 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 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 ErrIncompatibleReference = errors.New("incompatible reference when processing batch") + var ErrIncreaseStepLowerThanOne = errors.New("increase step is lower than one") + var ErrIndexDoesNotMatchWithFullyExecutedMiniBlock = errors.New("index does not match with a fully executed mini block") + var ErrIndexDoesNotMatchWithPartialExecutedMiniBlock = errors.New("index does not match with a partial executed mini block") + var ErrIndexIsOutOfBound = errors.New("index is out of bound") + 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 ErrInvalidArguments = errors.New("invalid arguments to process built-in function") + var ErrInvalidBadPeerThreshold = errors.New("invalid bad peer threshold") + var ErrInvalidBlockRequestOldEpoch = errors.New("invalid block request from old epoch") + 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 ErrInvalidEpochStartMetaBlockConsensusPercentage = errors.New("invalid epoch start meta block consensus percentage") + var ErrInvalidExpiryTimespan = errors.New("invalid expiry timespan") + var ErrInvalidGasModifier = errors.New("invalid gas modifier") + 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 ErrInvalidMaxGasLimitPerMetaBlock = errors.New("invalid max gas limit per meta block") + var ErrInvalidMaxGasLimitPerMetaMiniBlock = errors.New("invalid max gas limit per meta mini block") + var ErrInvalidMaxGasLimitPerMiniBlock = errors.New("invalid max gas limit per mini block") + var ErrInvalidMaxGasLimitPerTx = errors.New("invalid max gas limit per tx") + 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 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 ErrInvalidPeerSubType = errors.New("invalid peer subtype") + var ErrInvalidProcessWaitTime = errors.New("invalid process wait time") + var ErrInvalidRcvAddr = errors.New("invalid receiver address") + var ErrInvalidRewardsPercentages = errors.New("invalid rewards percentages") + var ErrInvalidRewardsTopUpGradientPoint = errors.New("rewards top up gradient point is invalid") + var ErrInvalidRoundActivationConfig = errors.New("invalid round config struct; should be of type config.ActivationRoundByName") + var ErrInvalidShardCacherIdentifier = errors.New("invalid identifier for shard cacher") + var ErrInvalidShardId = errors.New("invalid shard id") + var ErrInvalidSndAddr = errors.New("invalid sender address") + var ErrInvalidTransactionVersion = errors.New("invalid transaction version") + var ErrInvalidTxInPool = errors.New("invalid transaction in the transactions pool") + var ErrInvalidUnitValue = errors.New("invalid unit value") + var ErrInvalidUserNameLength = errors.New("invalid user name length") + var ErrInvalidVMInputGasComputation = errors.New("invalid vm input gas computation") + 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 ErrMaxAccumulatedFeesExceeded = errors.New("max accumulated fees has been exceeded") + var ErrMaxBlockSizeReached = errors.New("max block size has been reached") + var ErrMaxDeveloperFeesExceeded = errors.New("max developer fees has been exceeded") + 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 ErrMaxGasLimitPerOneTxInReceiverShardIsReached = errors.New("max gas limit per one transaction in receiver shard is reached") + var ErrMaxGasLimitUsedForDestMeTxsIsReached = errors.New("max gas limit used for dest me txs is reached") + var ErrMaxRatingIsSmallerThanMinRating = errors.New("max rating is smaller than min rating") + var ErrMaxRatingZero = errors.New("max rating is zero") + var ErrMessageExpired = errors.New("message expired") + var ErrMetaHeaderEpochOutOfRange = errors.New("epoch out of range for meta block header") + 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 ErrMissingMiniBlock = errors.New("missing mini block") + var ErrMissingMiniBlockHeader = errors.New("missing mini block header") + var ErrMissingPreProcessor = errors.New("pre processor is missing") + var ErrMissingTransaction = errors.New("missing transaction") + var ErrMoreGasConsumedThanProvided = errors.New("more gas used than provided") + var ErrMoreGasThanGasLimitPerBlock = errors.New("more gas was provided than gas limit per block") + var ErrMoreGasThanGasLimitPerMiniBlockForSafeCrossShard = errors.New("more gas was provided than gas limit per mini block for safe cross shard") + var ErrNegativeBalanceDeltaOnCrossShardAccount = errors.New("negative balance delta on cross shard account") + var ErrNegativeValue = errors.New("negative value") + var ErrNilAccountTxsPerShard = errors.New("nil account transactions per shard mapping") + var ErrNilAccountsAdapter = errors.New("nil AccountsAdapter") + var ErrNilAccountsDBSyncer = errors.New("nil accounts DB syncer") + var ErrNilActivationRoundName = errors.New("round activation name is empty in config file") + var ErrNilAdditionalData = errors.New("nil additional data") + var ErrNilAddressContainer = errors.New("nil AddressContainer") + var ErrNilAllowExternalQueriesChan = errors.New("nil channel for signaling the allowance of external queries") + var ErrNilAntifloodHandler = errors.New("nil antiflood handler") + var ErrNilAppStatusHandler = errors.New("nil AppStatusHandler") + var ErrNilArgsBuiltInFunctionsConstHandler = errors.New("nil arguments for built in functions cost handler") + 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 ErrNilBootstrapComponentsHolder = errors.New("nil bootstrap components holder") + var ErrNilBootstrapper = errors.New("nil bootstrapper") + var ErrNilBuffer = errors.New("provided byte buffer is nil") + var ErrNilBuiltInFunction = errors.New("built in function is nil") + var ErrNilBuiltInFunctionsCostHandler = errors.New("nil built in functions cost handler") + var ErrNilCacher = errors.New("nil cacher") + var ErrNilChunksProcessor = errors.New("nil chunks processor") + var ErrNilContainerElement = errors.New("element cannot be nil") + var ErrNilCoreComponentsHolder = errors.New("nil core components holder") + var ErrNilCrawlerAllowedAddress = errors.New("nil crawler allowed address") + var ErrNilCryptoComponentsHolder = errors.New("nil crypto components holder") + var ErrNilCurrentNetworkEpochProvider = errors.New("nil current network epoch provider") + var ErrNilDataComponentsHolder = errors.New("nil data components holder") + 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 ErrNilDoubleTransactionsDetector = errors.New("nil double transactions detector") + var ErrNilESDTGlobalSettingsHandler = errors.New("nil esdt global settings handler") + var ErrNilESDTTransferParser = errors.New("nil esdt transfer parser") + 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 ErrNilEpochNotifier = errors.New("nil EpochNotifier") + var ErrNilEpochStartDataCreator = errors.New("nil epoch start data creator") + var ErrNilEpochStartNotifier = errors.New("nil epochStartNotifier") + var ErrNilEpochStartSystemSCProcessor = errors.New("nil epoch start system sc processor") + var ErrNilEpochStartTrigger = errors.New("nil start of epoch trigger") + var ErrNilEpochStartValidatorInfoCreator = errors.New("nil epoch start validator info creator") + var ErrNilFallbackHeaderValidator = errors.New("nil fallback header validator") + var ErrNilForkDetector = errors.New("nil fork detector") + var ErrNilGasHandler = errors.New("nil gas handler") + var ErrNilGasSchedule = errors.New("nil GasSchedule") + var ErrNilHardforkTrigger = errors.New("nil hardfork trigger") + var ErrNilHasher = errors.New("nil Hasher") + var ErrNilHaveTimeHandler = errors.New("nil have time handler") + 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 ErrNilHeartbeatCacher = errors.New("nil heartbeat cacher") + var ErrNilHistoryRepository = errors.New("history repository is nil") + 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 ErrNilIntermediateProcessor = errors.New("intermediate processor is nil") + var ErrNilIntermediateProcessorContainer = errors.New("intermediate processor container is nil") + var ErrNilIntermediateTransactionHandler = errors.New("intermediate transaction handler is nil") + var ErrNilIsMaxBlockSizeReachedHandler = errors.New("nil handler for max block size reached") + var ErrNilIsShardStuckHandler = errors.New("nil handler for checking stuck shard") + var ErrNilKeyGen = errors.New("nil key generator") + var ErrNilLocker = errors.New("nil locker") + 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 ErrNilNFTStorageHandler = errors.New("nil NFT storage handler") + 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 ErrNilNumConnectedPeersProvider = errors.New("nil number of connected peers provider") + var ErrNilOrEmptyList = errors.New("nil or empty provided list") + var ErrNilOutportHandler = errors.New("outport handler is nil") + var ErrNilPayloadValidator = errors.New("nil payload validator") + var ErrNilPeerAccountsAdapter = errors.New("nil peer accounts database") + var ErrNilPeerAuthenticationCacher = errors.New("nil peer authentication cacher") + var ErrNilPeerShardMapper = errors.New("nil peer shard mapper") + var ErrNilPeerSignatureHandler = errors.New("nil peer signature handler") + 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 ErrNilPreferredPeersHolder = errors.New("nil preferred peers holder") + var ErrNilPrevRandSeed = errors.New("provided previous rand seed is nil") + var ErrNilPreviousBlockHash = errors.New("nil previous block header hash") + var ErrNilProcessedMiniBlocksTracker = errors.New("nil processed mini blocks tracker") + var ErrNilProtocolSustainabilityAddress = errors.New("nil protocol sustainability address") + 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 ErrNilReceiptsRepository = errors.New("nil receipts repository") + 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 ErrNilRewardsCreator = errors.New("nil epoch start rewards creator") + 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 ErrNilRoundHandler = errors.New("nil RoundHandler") + var ErrNilRoundNotifier = errors.New("nil round notifier has been provided") + var ErrNilRoundTimeDurationHandler = errors.New("nil RoundTimeDurationHandler") + var ErrNilSCDestAccount = errors.New("nil destination SC account") + var ErrNilSCToProtocol = errors.New("nil sc to protocol") + var ErrNilScAddress = errors.New("nil SC address") + var ErrNilScQueryElement = errors.New("nil SC query service element") + var ErrNilScheduledTxsExecutionHandler = errors.New("nil scheduled txs execution handler") + var ErrNilShardCoordinator = errors.New("nil shard coordinator") + var ErrNilShardedDataCacherNotifier = errors.New("nil sharded data cacher notifier") + var ErrNilSignature = errors.New("nil signature") + var ErrNilSignaturesHandler = errors.New("nil signatures handler") + 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 ErrNilStatusComponentsHolder = errors.New("nil status components holder") + var ErrNilStorage = errors.New("nil storage") + var ErrNilStore = errors.New("nil data storage service") + var ErrNilSyncTimer = errors.New("sync timer is nil") + 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 ErrNilTransactionVersionChecker = errors.New("nil transaction version checker") + 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 ErrNilTxMaxTotalCostHandler = errors.New("nil transaction max total cost") + 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 ErrNilUserAccount = errors.New("nil user account") + 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 ErrNilVersionedHeaderFactory = errors.New("nil versioned header factory") + 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 ErrNoTxToProcess = errors.New("no transaction to process") + var ErrNoVM = errors.New("no VM (hook not set)") + var ErrNodeIsNotSynced = errors.New("node is not synced") + var ErrNotAllowedToWriteUnderProtectedKey = errors.New("not allowed to write under protected key") + var ErrNotEnoughGas = errors.New("not enough gas was sent in the transaction") + var ErrNotEnoughGasInUserTx = errors.New("not enough gas provided in user tx") + 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 ErrNumOfMiniBlocksAndMiniBlocksHeadersMismatch = errors.New("num of mini blocks and mini blocks headers does not match") + var ErrOnlyValidatorsCanUseThisTopic = errors.New("only validators can use this topic") + 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 ErrProcessClosed = errors.New("incomplete processing: process is closing") + var ErrPropertyTooLong = errors.New("property too long") + var ErrPropertyTooShort = errors.New("property too short") + var ErrQueriesNotAllowedYet = errors.New("node is not ready yet to process VM Queries") + var ErrRandSeedDoesNotMatch = errors.New("random seed does not match") + var ErrReceiptsHashMissmatch = errors.New("receipts hash missmatch") + var ErrRecursiveRelayedTxIsNotAllowed = errors.New("recursive relayed tx is not allowed") + var ErrRelayedGasPriceMissmatch = errors.New("relayed gas price missmatch") + var ErrRelayedTxBeneficiaryDoesNotMatchReceiver = errors.New("invalid address in relayed tx") + var ErrRelayedTxDisabled = errors.New("relayed tx is disabled") + var ErrRelayedTxGasLimitMissmatch = errors.New("relayed tx gas limit higher then user tx gas limit") + var ErrRelayedTxV2Disabled = errors.New("relayed tx v2 is disabled") + var ErrRelayedTxV2ZeroVal = errors.New("relayed tx v2 value should be 0") + var ErrRelayedTxValueHigherThenUserTxValue = errors.New("relayed tx value is higher than user tx value") + var ErrReservedFieldInvalid = errors.New("reserved field content is invalid") + var ErrResultingSCRIsTooBig = errors.New("resulting SCR is too big") + 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 ErrScheduledMiniBlocksMismatch = errors.New("scheduled miniblocks does not match") + var ErrScheduledRootHashDoesNotMatch = errors.New("scheduled root hash does not match") + 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 ErrSmartContractDeploymentIsDisabled = errors.New("smart Contract deployment is disabled") + var ErrStartRatingNotBetweenMinAndMax = errors.New("start rating is not between min and max rating") + var ErrStateChangedWhileExecutingVmQuery = errors.New("state changed while executing vm query") + 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 ErrTransactionSignedWithHashIsNotEnabled = errors.New("transaction signed with hash is not enabled") + var ErrTrieNodeIsNotWhitelisted = errors.New("trie node 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 ErrUpgradeNotAllowed = errors.New("upgrade is allowed only for owner") + var ErrUserNameDoesNotMatch = errors.New("user name does not match") + var ErrUserNameDoesNotMatchInCrossShardTx = errors.New("mismatch between receiver username and address") + 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") + var ErrZeroMaxConsecutiveRoundsOfRatingDecrease = errors.New(...) + func AddHeaderToBlackList(blackListHandler TimeCacher, hash []byte) + func CheckIfIndexesAreOutOfBound(indexOfFirstTxToBeProcessed int32, indexOfLastTxToBeProcessed int32, ...) error + func DisplayProcessTxDetails(message string, accountHandler vmcommon.AccountHandler, ...) + func GetFinalCrossMiniBlockHashes(header data.HeaderHandler, shardID uint32) map[string]uint32 + func GetHeaderFromStorage(shardId uint32, hash []byte, marshalizer marshal.Marshalizer, ...) (data.HeaderHandler, error) + func GetHeaderFromStorageWithNonce(nonce uint64, shardId uint32, storageService dataRetriever.StorageService, ...) (data.HeaderHandler, []byte, error) + func GetHeaderHashFromStorageWithNonce(nonce uint64, storageService dataRetriever.StorageService, ...) ([]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 GetMiniBlockHeaderWithHash(header data.HeaderHandler, miniBlockHash []byte) data.MiniBlockHeaderHandler + func GetShardHeader(hash []byte, headersCacher dataRetriever.HeadersPool, ...) (data.ShardHeaderHandler, error) + func GetShardHeaderFromPool(hash []byte, headersCacher dataRetriever.HeadersPool) (data.ShardHeaderHandler, error) + func GetShardHeaderFromPoolWithNonce(nonce uint64, shardId uint32, headersCacher dataRetriever.HeadersPool) (data.HeaderHandler, []byte, error) + func GetShardHeaderFromStorage(hash []byte, marshalizer marshal.Marshalizer, ...) (data.ShardHeaderHandler, error) + func GetShardHeaderFromStorageWithNonce(nonce uint64, shardId uint32, storageService dataRetriever.StorageService, ...) (data.HeaderHandler, []byte, error) + func GetShardHeaderWithNonce(nonce uint64, shardId uint32, headersCacher dataRetriever.HeadersPool, ...) (data.HeaderHandler, []byte, error) + func GetSortedStorageUpdates(account *vmcommon.OutputAccount) []*vmcommon.StorageUpdate + 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 GetZeroGasAndFees() scheduled.GasAndFees + func HaveAdditionalTime() func() bool + func IsAllowedToSaveUnderKey(key []byte) bool + func IsInProperRound(index int64) bool + func IsScheduledMode(header data.HeaderHandler, body *block.Body, hasher hashing.Hasher, ...) (bool, error) + 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) + func SortVMOutputInsideData(vmOutput *vmcommon.VMOutput) []*vmcommon.OutputAccount + func UnmarshalHeader(shardId uint32, marshalizer marshal.Marshalizer, headerBuffer []byte) (data.HeaderHandler, error) + func UnmarshalMetaHeader(marshalizer marshal.Marshalizer, headerBuffer []byte) (data.MetaHeaderHandler, error) + func UnmarshalShardHeader(marshalizer marshal.Marshalizer, hdrBuff []byte) (data.ShardHeaderHandler, error) + func UnmarshalShardHeaderV1(marshalizer marshal.Marshalizer, hdrBuff []byte) (data.ShardHeaderHandler, error) + func UnmarshalShardHeaderV2(marshalizer marshal.Marshalizer, hdrBuff []byte) (data.ShardHeaderHandler, error) + type AccountsDBSyncer interface + IsInterfaceNil func() bool + SyncAccounts func(rootHash []byte) error + 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 + ParseArguments func(data string) ([][]byte, error) + ParseCallData func(data string) (string, [][]byte, error) + ParseDeployData func(data string) (*parsers.DeployArgs, error) + type BaseOperationCost struct + AoTPreparePerByte uint64 + CompilePerByte uint64 + DataCopyPerByte uint64 + PersistPerByte uint64 + ReleasePerByte uint64 + StorePerByte uint64 + type BlockChainHookHandler interface + ApplyFiltersOnCodeMetadata func(codeMetadata vmcommon.CodeMetadata) vmcommon.CodeMetadata + ClearCompiledCodes func() + Close func() error + CurrentEpoch func() uint32 + CurrentNonce func() uint64 + CurrentRandomSeed func() []byte + CurrentRound func() uint64 + CurrentTimeStamp func() uint64 + DeleteCompiledCode func(codeHash []byte) + FilterCodeMetadataForUpgrade func(input []byte) ([]byte, error) + GetAllState func(_ []byte) (map[string][]byte, error) + GetBlockhash func(nonce uint64) ([]byte, error) + GetBuiltinFunctionNames func() vmcommon.FunctionNames + GetBuiltinFunctionsContainer func() vmcommon.BuiltInFunctionContainer + GetCode func(account vmcommon.UserAccountHandler) []byte + GetCompiledCode func(codeHash []byte) (bool, []byte) + GetESDTToken func(address []byte, tokenID []byte, nonce uint64) (*esdt.ESDigitalToken, error) + GetShardOfAddress func(address []byte) uint32 + GetSnapshot func() int + GetStateRootHash func() []byte + GetStorageData func(accountAddress []byte, index []byte) ([]byte, error) + GetUserAccount func(address []byte) (vmcommon.UserAccountHandler, error) + IsInterfaceNil func() bool + IsLimitedTransfer func(tokenID []byte) bool + IsPaused func(tokenID []byte) bool + IsPayable func(sndAddress []byte, recvAddress []byte) (bool, error) + IsSmartContract func(address []byte) bool + LastEpoch func() uint32 + LastNonce func() uint64 + LastRandomSeed func() []byte + LastRound func() uint64 + LastTimeStamp func() uint64 + NewAddress func(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error) + NumberOfShards func() uint32 + ProcessBuiltInFunction func(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error) + RevertToSnapshot func(snapshot int) error + SaveCompiledCode func(codeHash []byte, code []byte) + SaveNFTMetaDataToSystemAccount func(tx data.TransactionHandler) error + SetCurrentHeader func(hdr data.HeaderHandler) + type BlockHeaderState int + const BHNotarized + const BHProcessed + const BHProposed + const BHReceived + const BHReceivedTooLate + type BlockProcessor interface + Close func() error + 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, error) + 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 + ProcessScheduledBlock func(header data.HeaderHandler, body data.BodyHandler, ...) error + PruneStateOnRollback func(currHeader data.HeaderHandler, currHeaderHash []byte, ...) + RestoreBlockBodyIntoPools func(body data.BodyHandler) error + RestoreBlockIntoPools func(header data.HeaderHandler, body data.BodyHandler) error + RevertCurrentBlock func() + RevertStateToBlock func(header data.HeaderHandler, rootHash []byte) 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 + CheckBlockAgainstRoundHandler func(headerHandler data.HeaderHandler) error + CheckBlockAgainstWhitelist func(interceptedData InterceptedData) bool + 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)) + RegisterFinalMetachainHeadersHandler func(func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte)) + RegisterSelfNotarizedFromCrossHeadersHandler 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 + ShouldSkipMiniBlocksCreationFromSelf func() 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() common.NodeState + IsInterfaceNil func() bool + StartSyncingBlocks func() + type BootstrapperFromStorage interface + GetHighestBlockNonce func() uint64 + IsInterfaceNil func() bool + LoadFromStorage func() error + type BuiltInCost struct + ChangeOwnerAddress uint64 + ClaimDeveloperRewards uint64 + ESDTBurn uint64 + ESDTLocalBurn uint64 + ESDTLocalMint uint64 + ESDTNFTAddQuantity uint64 + ESDTNFTAddUri uint64 + ESDTNFTBurn uint64 + ESDTNFTChangeCreateOwner uint64 + ESDTNFTCreate uint64 + ESDTNFTMultiTransfer uint64 + ESDTNFTTransfer uint64 + ESDTNFTUpdateAttributes uint64 + ESDTTransfer uint64 + SaveKeyValue uint64 + SaveUserName uint64 + type CallArgumentsParser interface + IsInterfaceNil func() bool + ParseArguments func(data string) ([][]byte, error) + ParseData func(data string) (string, [][]byte, error) + type CheckedChunkResult struct + CompleteBuffer []byte + HaveAllChunks bool + IsChunk bool + type Checker interface + Integrity func(coordinator sharding.Coordinator) error + IntegrityAndValidity func(coordinator sharding.Coordinator) error + IsInterfaceNil func() bool + type CoreComponentsHolder interface + AddressPubKeyConverter func() core.PubkeyConverter + ChainID func() string + ChanStopNodeProcess func() chan endProcess.ArgEndProcess + EpochNotifier func() EpochNotifier + GenesisNodesSetup func() sharding.GenesisNodesSetupHandler + HardforkTriggerPubKey func() []byte + Hasher func() hashing.Hasher + InternalMarshalizer func() marshal.Marshalizer + IsInterfaceNil func() bool + MinTransactionVersion func() uint32 + NodeTypeProvider func() core.NodeTypeProviderHandler + PathHandler func() storage.PathManagerHandler + ProcessStatusHandler func() common.ProcessStatusHandler + SetInternalMarshalizer func(marshalizer marshal.Marshalizer) error + StatusHandler func() core.AppStatusHandler + TxMarshalizer func() marshal.Marshalizer + TxSignHasher func() hashing.Hasher + TxVersionChecker func() TxVersionCheckerHandler + Uint64ByteSliceConverter func() typeConverters.Uint64ByteSliceConverter + ValidatorPubKeyConverter func() core.PubkeyConverter + type CryptoComponentsHolder interface + BlockSignKeyGen func() crypto.KeyGenerator + BlockSigner func() crypto.SingleSigner + Clone func() interface{} + IsInterfaceNil func() bool + MultiSigner func() crypto.MultiSigner + PeerSignatureHandler func() crypto.PeerSignatureHandler + PublicKey func() crypto.PublicKey + SetMultiSigner func(ms crypto.MultiSigner) error + TxSignKeyGen func() crypto.KeyGenerator + TxSingleSigner func() crypto.SingleSigner + type CurrentNetworkEpochProviderHandler interface + EpochIsActiveInNetwork func(epoch uint32) bool + 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 DoubleTransactionDetector interface + IsInterfaceNil func() bool + ProcessBlockBody func(body *block.Body) + type ESDTPauseHandler interface + IsInterfaceNil func() bool + IsPaused func(token []byte) bool + type ESDTRoleHandler interface + CheckAllowedToExecute func(account state.UserAccountHandler, tokenID []byte, action []byte) error + IsInterfaceNil func() bool + type EconomicsDataHandler interface + IsInterfaceNil func() bool + type EndOfEpochEconomics interface + ComputeEndOfEpochEconomics func(metaBlock *block.MetaBlock) (*block.Economics, error) + IsInterfaceNil func() bool + VerifyRewardsPerBlock func(metaBlock *block.MetaBlock, correctedProtocolSustainability *big.Int, ...) error + type EpochBootstrapper interface + IsInterfaceNil func() bool + SetCurrentEpochStartRound func(round uint64) + type EpochHandler interface + IsInterfaceNil func() bool + MetaEpoch func() uint32 + type EpochNotifier interface + CheckEpoch func(header data.HeaderHandler) + CurrentEpoch func() uint32 + IsInterfaceNil func() bool + RegisterNotifyHandler func(handler vmcommon.EpochSubscriberHandler) + 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 EpochStartSystemSCProcessor interface + IsInterfaceNil func() bool + ProcessDelegationRewards func(miniBlocks block.MiniBlockSlice, rewardTxs epochStart.TransactionCacher) error + ProcessSystemSmartContract func(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error + ToggleUnStakeUnBond func(value bool) 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 data.HeaderHandler) + IsInterfaceNil func() bool + RemoveBlockDataFromPools func(metaBlock data.HeaderHandler, body *block.Body) + SaveValidatorInfoBlocksToStorage func(metaBlock data.HeaderHandler, body *block.Body) + VerifyValidatorInfoMiniBlocks func(miniblocks []*block.MiniBlock, ...) error + type FallbackHeaderValidator interface + IsInterfaceNil func() bool + ShouldApplyFallbackValidation func(headerHandler data.HeaderHandler) bool + type FeeHandler interface + IsInterfaceNil func() bool + 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() + SetFinalToLastCheckpoint func() + SetRollBackNonce func(nonce uint64) + type ForkInfo struct + Hash []byte + IsDetected bool + Nonce uint64 + Round uint64 + func NewForkInfo() *ForkInfo + type GasCost struct + BaseOperationCost BaseOperationCost + BuiltInCost BuiltInCost + type GasHandler interface + ComputeGasProvidedByMiniBlock func(*block.MiniBlock, map[string]data.TransactionHandler) (uint64, uint64, error) + ComputeGasProvidedByTx func(txSenderShardId uint32, txReceiverShardId uint32, ...) (uint64, uint64, error) + GasPenalized func(hash []byte) uint64 + GasProvided func(hash []byte) uint64 + GasProvidedAsScheduled func(hash []byte) uint64 + GasRefunded func(hash []byte) uint64 + Init func() + IsInterfaceNil func() bool + RemoveGasPenalized func(hashes [][]byte) + RemoveGasProvided func(hashes [][]byte) + RemoveGasProvidedAsScheduled func(hashes [][]byte) + RemoveGasRefunded func(hashes [][]byte) + Reset func(key []byte) + RestoreGasSinceLastReset func(key []byte) + SetGasPenalized func(gasPenalized uint64, hash []byte) + SetGasProvided func(gasProvided uint64, hash []byte) + SetGasProvidedAsScheduled func(gasProvided uint64, hash []byte) + SetGasRefunded func(gasRefunded uint64, hash []byte) + TotalGasPenalized func() uint64 + TotalGasProvided func() uint64 + TotalGasProvidedAsScheduled func() uint64 + TotalGasProvidedWithScheduled 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 HeaderIntegrityVerifier interface + GetVersion func(epoch uint32) string + IsInterfaceNil func() bool + Verify func(header data.HeaderHandler) error + type InterceptedChunksProcessor interface + CheckBatch func(b *batch.Batch, whiteListHandler WhiteListHandler) (CheckedChunkResult, error) + Close func() 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 InterceptedHeaderSigVerifier interface + IsInterfaceNil func() bool + VerifyLeaderSignature func(header data.HeaderHandler) error + VerifyRandSeed func(header data.HeaderHandler) error + VerifyRandSeedAndLeaderSignature func(header data.HeaderHandler) error + VerifySignature func(header data.HeaderHandler) error + type Interceptor interface + Close func() error + 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 + Close func() 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 + GetNumOfCrossInterMbsAndTxs func() (int, int) + InitProcessedResults func(key []byte) + IsInterfaceNil func() bool + RemoveProcessedResults func(key []byte) [][]byte + SaveCurrentIntermediateTxToStorage func() + VerifyInterMiniBlocks func(body *block.Body) error + type MiniBlockProvider interface + GetMiniBlocks func(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte) + GetMiniBlocksFromPool func(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte) + GetMiniBlocksFromStorer func(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte) + IsInterfaceNil func() bool + type NetworkConnectionWatcher interface + IsConnectedToTheNetwork func() bool + IsInterfaceNil func() bool + type NetworkShardingCollector interface + UpdatePeerIDInfo func(pid core.PeerID, pk []byte, shardID uint32) + 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 NumConnectedPeersProvider interface + ConnectedPeers func() []core.PeerID + 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 + Close func() error + IsInterfaceNil func() bool + IsOriginatorEligibleForTopic func(pid core.PeerID, topic string) error + SetDebugger func(debugger AntifloodDebugger) error + type PayableHandler interface + IsInterfaceNil func() bool + IsPayable func(sndAddress []byte, recvAddress []byte) (bool, error) + type PeerAuthenticationPayloadValidator interface + IsInterfaceNil func() bool + ValidateTimestamp func(payloadTimestamp int64) 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 + PutPeerIdShardId func(pid core.PeerID, shardID uint32) + PutPeerIdSubType func(pid core.PeerID, peerSubType core.P2PPeerSubType) + UpdatePeerIDPublicKeyPair func(pid core.PeerID, pk []byte) + 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 + AddTransactions func(txHandlers []data.TransactionHandler) + AddTxsFromMiniBlocks func(miniBlocks block.MiniBlockSlice) + CreateAndProcessMiniBlocks func(haveTime func() bool, randomness []byte) (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(header data.HeaderHandler, body *block.Body, haveTime func() bool) error + ProcessMiniBlock func(miniBlock *block.MiniBlock, haveTime func() bool, ...) ([][]byte, int, bool, error) + RemoveBlockDataFromPools func(body *block.Body, miniBlockPool storage.Cacher) error + RemoveTxsFromPools func(body *block.Body) error + RequestBlockTransactions func(body *block.Body) int + RequestTransactionsForMiniBlock func(miniBlock *block.MiniBlock) int + RestoreBlockDataIntoPools func(body *block.Body, miniBlockPool storage.Cacher) (int, error) + SaveTxsToStorage func(body *block.Body) error + type PreProcessorExecutionInfoHandler interface + GetNumOfCrossInterMbsAndTxs func() (int, int) + InitProcessedTxsResults func(key []byte) + RevertProcessedTxsResults func(txHashes [][]byte, key []byte) + 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 PreferredPeersHolderHandler interface + Contains func(peerID core.PeerID) bool + Get func() map[uint32][]core.PeerID + IsInterfaceNil func() bool + type ProcessedMiniBlocksTracker interface + ConvertProcessedMiniBlocksMapToSlice func() []bootstrapStorage.MiniBlocksInMeta + ConvertSliceToProcessedMiniBlocksMap func(miniBlocksInMetaBlocks []bootstrapStorage.MiniBlocksInMeta) + DisplayProcessedMiniBlocks func() + GetProcessedMiniBlockInfo func(miniBlockHash []byte) (*processedMb.ProcessedMiniBlockInfo, []byte) + GetProcessedMiniBlocksInfo func(metaBlockHash []byte) map[string]*processedMb.ProcessedMiniBlockInfo + IsInterfaceNil func() bool + IsMiniBlockFullyProcessed func(metaBlockHash []byte, miniBlockHash []byte) bool + RemoveMetaBlockHash func(metaBlockHash []byte) + RemoveMiniBlockHash func(miniBlockHash []byte) + SetProcessedMiniBlockInfo func(metaBlockHash []byte, miniBlockHash []byte, ...) + 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 + CreateTrieNodeIdentifier func(requestHash []byte, chunkIndex uint32) []byte + 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) + RequestPeerAuthenticationsByHashes func(destShardID uint32, hashes [][]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) + RequestTrieNode func(requestHash []byte, topic string, chunkIndex uint32) + 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 RewardsCreator interface + CreateMarshalizedData func(body *block.Body) map[string][][]byte + CreateRewardsMiniBlocks func(metaBlock data.MetaHeaderHandler, ...) (block.MiniBlockSlice, error) + DeleteTxsFromStorage func(metaBlock data.MetaHeaderHandler, body *block.Body) + GetLocalTxCache func() epochStart.TransactionCacher + GetProtocolSustainabilityRewards func() *big.Int + GetRewardsTxs func(body *block.Body) map[string]data.TransactionHandler + IsInterfaceNil func() bool + RemoveBlockDataFromPools func(metaBlock data.MetaHeaderHandler, body *block.Body) + SaveTxBlockToStorage func(metaBlock data.MetaHeaderHandler, body *block.Body) + VerifyRewardsMiniBlocks func(metaBlock data.MetaHeaderHandler, ...) error + type RewardsHandler interface + IsInterfaceNil func() bool + type RoundActivationHandler interface + IsEnabled func(name string) bool + IsEnabledInRound func(name string, round uint64) bool + IsInterfaceNil func() bool + type RoundHandler interface + Index func() int64 + IsInterfaceNil func() bool + type RoundNotifier interface + CheckRound func(round uint64) + IsInterfaceNil func() bool + RegisterNotifyHandler func(handler RoundSubscriberHandler) + type RoundSubscriberHandler interface + IsInterfaceNil func() bool + RoundConfirmed func(round uint64) + type RoundTimeDurationHandler interface + IsInterfaceNil func() bool + TimeDuration func() time.Duration + type SCQuery struct + Arguments [][]byte + CallValue *big.Int + CallerAddr []byte + FuncName string + SameScState bool + ScAddress []byte + ShouldBeSynced bool + type SCQueryService interface + Close func() error + ComputeScCallGasLimit func(tx *transaction.Transaction) (uint64, error) + ExecuteQuery func(query *SCQuery) (*vmcommon.VMOutput, error) + IsInterfaceNil func() bool + type ScheduledBlockProcessor interface + IsInterfaceNil func() bool + ProcessScheduledBlock func(header data.HeaderHandler, body data.BodyHandler, ...) error + type ScheduledInfo struct + GasAndFees scheduled.GasAndFees + IntermediateTxs map[block.Type][]data.TransactionHandler + MiniBlocks block.MiniBlockSlice + RootHash []byte + type ScheduledTxsExecutionHandler interface + AddScheduledMiniBlocks func(miniBlocks block.MiniBlockSlice) + AddScheduledTx func(txHash []byte, tx data.TransactionHandler) bool + Execute func(txHash []byte) error + ExecuteAll func(haveTime func() time.Duration) error + GetScheduledGasAndFees func() scheduled.GasAndFees + GetScheduledIntermediateTxs func() map[block.Type][]data.TransactionHandler + GetScheduledMiniBlocks func() block.MiniBlockSlice + GetScheduledRootHash func() []byte + GetScheduledRootHashForHeader func(headerHash []byte) ([]byte, error) + GetScheduledRootHashForHeaderWithEpoch func(headerHash []byte, epoch uint32) ([]byte, error) + Init func() + IsInterfaceNil func() bool + IsMiniBlockExecuted func(mbHash []byte) bool + IsScheduledTx func(txHash []byte) bool + RollBackToBlock func(headerHash []byte) error + SaveState func(headerHash []byte, scheduledInfo *ScheduledInfo) + SaveStateIfNeeded func(headerHash []byte) + SetScheduledGasAndFees func(gasAndFees scheduled.GasAndFees) + SetScheduledInfo func(scheduledInfo *ScheduledInfo) + SetScheduledRootHash func(rootHash []byte) + SetTransactionCoordinator func(txCoordinator TransactionCoordinator) + SetTransactionProcessor func(txProcessor TransactionProcessor) + type SelectionChance interface + GetChancePercent func() uint32 + GetMaxThreshold func() uint32 + type SigVerifier interface + VerifySig func() error + type SignaturesHandler interface + IsInterfaceNil func() bool + Verify func(payload []byte, pid core.PeerID, signature []byte) error + type SignedDataValidator interface + type SmartContractProcessor interface + DeploySmartContract func(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error) + ExecuteBuiltInFunction func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + ExecuteSmartContractTransaction func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + IsInterfaceNil func() bool + IsPayable func(sndAddress []byte, recvAddress []byte) (bool, error) + 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 TimeCacher interface + Add func(key string) error + Has func(key string) bool + IsInterfaceNil func() bool + Len func() int + 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 + ID func() core.PeerID + IsInterfaceNil func() bool + RegisterMessageProcessor func(topic string, identifier string, handler p2p.MessageProcessor) error + type TransactionCoordinator interface + AddIntermediateTransactions func(mapSCRs map[block.Type][]data.TransactionHandler) error + AddTransactions func(txHandlers []data.TransactionHandler, blockType block.Type) + AddTxsFromMiniBlocks func(miniBlocks block.MiniBlockSlice) + CreateBlockStarted func() + CreateMarshalizedData func(body *block.Body) map[string][][]byte + CreateMbsAndProcessCrossShardTransactionsDstMe func(header data.HeaderHandler, ...) (block.MiniBlockSlice, uint32, bool, error) + CreateMbsAndProcessTransactionsFromMe func(haveTime func() bool, randomness []byte) block.MiniBlockSlice + CreatePostProcessMiniBlocks func() block.MiniBlockSlice + CreateReceiptsHash func() ([]byte, error) + GetAllCurrentLogs func() []*data.LogData + GetAllCurrentUsedTxs func(blockType block.Type) map[string]data.TransactionHandler + GetAllIntermediateTxs func() map[block.Type]map[string]data.TransactionHandler + GetCreatedInShardMiniBlocks func() []*block.MiniBlock + IsDataPreparedForProcessing func(haveTime func() time.Duration) error + IsInterfaceNil func() bool + ProcessBlockTransaction func(header data.HeaderHandler, body *block.Body, haveTime func() time.Duration) error + RemoveBlockDataFromPool func(body *block.Body) error + RemoveTxsFromPool func(body *block.Body) error + RequestBlockTransactions func(body *block.Body) + RequestMiniBlocks func(header data.HeaderHandler) + RestoreBlockDataFromStorage func(body *block.Body) (int, error) + SaveTxsToStorage func(body *block.Body) + VerifyCreatedBlockTransactions func(hdr data.HeaderHandler, body *block.Body) error + VerifyCreatedMiniBlocks func(hdr data.HeaderHandler, body *block.Body) error + type TransactionFeeHandler interface + CreateBlockStarted func(gasAndFees scheduled.GasAndFees) + GetAccumulatedFees func() *big.Int + GetDeveloperFees func() *big.Int + IsInterfaceNil func() bool + ProcessTransactionFee func(cost *big.Int, devFee *big.Int, txHash []byte) + ProcessTransactionFeeRelayedUserTx func(cost *big.Int, devFee *big.Int, userTxHash []byte, originalTxHash []byte) + RevertFees func(txHashes [][]byte) + type TransactionLogProcessor interface + Clean func() + GetAllCurrentLogs func() []*data.LogData + 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.LogData, bool) + IsInterfaceNil func() bool + type TransactionProcessor interface + IsInterfaceNil func() bool + ProcessTransaction func(transaction *transaction.Transaction) (vmcommon.ReturnCode, error) + VerifyTransaction func(transaction *transaction.Transaction) error + type TransactionType int + const BuiltInFunctionCall + const InvalidTransaction + const MoveBalance + const RelayedTx + const RelayedTxV2 + const RewardTx + const SCDeployment + const SCInvoking + func (transactionType TransactionType) String() string + type TransactionVerifier interface + IsTransactionValid func(tx data.TransactionHandler) error + type TxGasHandler interface + ComputeFeeForProcessing func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int + GasPriceForMove func(tx data.TransactionWithFeeHandler) uint64 + GasPriceForProcessing func(tx data.TransactionWithFeeHandler) uint64 + GasPriceModifier func() float64 + IsInterfaceNil func() bool + MinGasLimit func() uint64 + MinGasPrice func() uint64 + MinGasPriceForProcessing func() uint64 + SplitTxGasInCategories func(tx data.TransactionWithFeeHandler) (uint64, uint64) + type TxTypeHandler interface + ComputeTransactionType func(tx data.TransactionHandler) (TransactionType, 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 TxVersionCheckerHandler interface + CheckTxVersion func(tx *transaction.Transaction) error + IsInterfaceNil func() bool + IsSignedWithHash func(tx *transaction.Transaction) bool + type TxsSenderHandler interface + Close func() error + IsInterfaceNil func() bool + SendBulkTransactions func(txs []*transaction.Transaction) (uint64, error) + type ValidatorInfoSyncer interface + IsInterfaceNil func() bool + SyncMiniBlocks func(metaBlock data.HeaderHandler) ([][]byte, data.BodyHandler, error) + type ValidatorStatisticsProcessor interface + Commit func() ([]byte, error) + DisplayRatings func(epoch uint32) + GetValidatorInfoForRootHash func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error) + IsInterfaceNil func() bool + LastFinalizedRootHash func() []byte + PeerAccountToValidatorInfo func(peerAccount state.PeerAccountHandler) *state.ValidatorInfo + 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.MetaHeaderHandler) error + RootHash func() ([]byte, error) + SaveNodesCoordinatorUpdates func(epoch uint32) (bool, error) + SetLastFinalizedRootHash func([]byte) + UpdatePeerState func(header data.MetaHeaderHandler, cache map[string]data.HeaderHandler) ([]byte, error) + type ValidatorsProvider interface + Close func() error + GetLatestValidators func() map[string]*state.ValidatorApiResponse + IsInterfaceNil func() bool + type ValidityAttester interface + CheckBlockAgainstFinal func(headerHandler data.HeaderHandler) error + CheckBlockAgainstRoundHandler func(headerHandler data.HeaderHandler) error + CheckBlockAgainstWhitelist func(interceptedData InterceptedData) bool + 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 + Close func() error + Create func() (VirtualMachinesContainer, error) + IsInterfaceNil func() bool + type WhiteListHandler interface + Add func(keys [][]byte) + IsInterfaceNil func() bool + IsWhiteListed func(interceptedData InterceptedData) bool + IsWhiteListedAtLeastOne func(identifiers [][]byte) bool + Remove func(keys [][]byte)