Versions in this module Expand all Collapse all v1 v1.1.66 Jun 17, 2021 v1.1.65 Jun 17, 2021 Changes in this version + const BlockFinality + const EpochChangeGracePeriod + const MaxGasFeeHigherFactorAccepted + const MaxHeaderRequestsAllowed + const MaxHeadersToRequestInAdvance + const MaxHeadersToWhitelistInAdvance + const MaxMetaHeadersAllowedInOneShardBlock + const MaxMetaNoncesBehind + const MaxNumOfTxsToSelect + const MaxNumPendingMiniBlocksPerShard + 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 ErrActionNotAllowed = errors.New("action is not allowed") + var ErrAddressIsNotESDTSystemSC = errors.New("destination is not system sc address") + var ErrArwenOutOfProcessUnsupported = errors.New("out-of-process Arwen instance not supported") + 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 ErrBuiltInFunctionsAreDisabled = errors.New("built in functions are disabled") + var ErrCallerIsNotTheDNSAddress = errors.New("not a dns address") + var ErrCannotWipeAccountNotFrozen = errors.New("cannot wipe because the account is not frozen for this esdt token") + 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 ErrDuplicateThreshold = errors.New("two thresholds are the same") + var ErrESDTIsFrozenForAccount = errors.New("account is frozen for this esdt token") + var ErrESDTTokenIsPaused = errors.New("esdt token is paused") + 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 ErrEmptyPeerID = errors.New("empty peer ID") + var ErrEmptyTopic = errors.New("empty topic") + var ErrEmptyVersionsByEpochsList = errors.New("empty versions by epochs list") + 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 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 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 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 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 ErrInvalidNFTQuantity = errors.New("invalid NFT quantity") + var ErrInvalidNonceRequest = errors.New("invalid nonce request") + var ErrInvalidPeerAccount = errors.New("invalid peer account") + 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 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 ErrInvalidVersionOnEpochValues = errors.New("invalid version provided on epoch values") + var ErrInvalidVersionStringTooLong = errors.New("invalid version provided: string too large") + 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 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 ErrMoreGasConsumedThanProvided = errors.New("more gas used than provided") + var ErrMoreGasThanGasLimitPerBlock = errors.New("more gas was provided than gas limit per block") + var ErrNFTDoesNotHaveMetadata = errors.New("NFT does not have metadata") + var ErrNFTTokenDoesNotExist = errors.New("NFT token does not exist") + var ErrNegativeBalanceDeltaOnCrossShardAccount = errors.New("negative balance delta on cross shard account") + var ErrNegativeValue = errors.New("negative value") + var ErrNewNFTDataOnSenderAddress = errors.New("new NFT data on sender") + 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 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 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 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 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 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 ErrNilHistoryRepository = errors.New("history repository is nil") + var ErrNilIndexer = errors.New("indexer 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 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 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 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 ErrNilOrEmptyList = errors.New("nil or empty provided list") + var ErrNilPauseHandler = errors.New("nil pause handler") + var ErrNilPayableHandler = errors.New("nil payableHandler was provided") + 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 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 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 ErrNilRolesHandler = errors.New("nil roles handler") + var ErrNilRootHash = errors.New("root hash is nil") + var ErrNilRounder = errors.New("nil Rounder") + 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 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 ErrNilTpsBenchmark = errors.New("tps benchmark object is nil") + 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 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 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 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 ErrOnlyFungibleTokensHaveBalanceTransfer = errors.New("only fungible tokens have balance transfer") + var ErrOnlySystemAccountAccepted = errors.New("only system account is accepted") + 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 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 ErrRelayedTxValueHigherThenUserTxValue = errors.New("relayed tx value is higher than user tx value") + var ErrReservedFieldNotSupportedYet = errors.New("reserved field not supported yet") + 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 ErrSmartContractDeploymentIsDisabled = errors.New("smart Contract deployment is disabled") + 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 ErrTransactionSignedWithHashIsNotEnabled = errors.New("transaction signed with hash is not enabled") + 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 ErrUserNameChangeIsDisabled = errors.New("user name change is disabled") + 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 ErrWrongNFTOnDestination = errors.New("wrong NFT on destination") + 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 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 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) + func SortVMOutputInsideData(vmOutput *vmcommon.VMOutput) []*vmcommon.OutputAccount + 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 BaseOperationCost struct + AoTPreparePerByte uint64 + CompilePerByte uint64 + DataCopyPerByte uint64 + PersistPerByte uint64 + ReleasePerByte uint64 + StorePerByte uint64 + type BlockChainHookHandler interface + DeleteCompiledCode func(codeHash []byte) + GetBuiltInFunctions func() BuiltInFunctionContainer + IsInterfaceNil func() bool + IsPayable func(address []byte) (bool, error) + 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 + 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 + 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 BuiltInCost struct + ChangeOwnerAddress uint64 + ClaimDeveloperRewards uint64 + ESDTBurn uint64 + ESDTLocalBurn uint64 + ESDTLocalMint uint64 + ESDTNFTAddQuantity uint64 + ESDTNFTBurn uint64 + ESDTNFTChangeCreateOwner uint64 + ESDTNFTCreate uint64 + ESDTNFTTransfer uint64 + ESDTTransfer uint64 + SaveKeyValue uint64 + SaveUserName uint64 + 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) + SetNewGasConfig func(gasCost *GasCost) + 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 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 + CheckValidityTxValues func(tx TransactionWithFeeHandler) error + ComputeFeeForProcessing func(tx TransactionWithFeeHandler, gasToUse uint64) *big.Int + ComputeGasLimit func(tx TransactionWithFeeHandler) uint64 + ComputeMoveBalanceFee func(tx TransactionWithFeeHandler) *big.Int + ComputeTxFee func(tx TransactionWithFeeHandler) *big.Int + DeveloperPercentage func() float64 + GasPerDataByte func() uint64 + GasPriceForMove func(tx TransactionWithFeeHandler) uint64 + GasPriceForProcessing func(tx TransactionWithFeeHandler) uint64 + GasPriceModifier func() float64 + GenesisTotalSupply func() *big.Int + IsInterfaceNil func() bool + LeaderPercentage func() float64 + MaxGasLimitPerBlock func(shardID uint32) uint64 + MaxInflationRate func(year uint32) float64 + MinGasLimit func() uint64 + MinGasPrice func() uint64 + MinGasPriceForProcessing func() uint64 + MinInflationRate func() float64 + ProtocolSustainabilityAddress func() string + ProtocolSustainabilityPercentage func() float64 + RewardsTopUpFactor func() float64 + RewardsTopUpGradientPoint func() *big.Int + SplitTxGasInCategories func(tx TransactionWithFeeHandler) (uint64, uint64) + 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(epoch uint32) + CurrentEpoch func() uint32 + IsInterfaceNil func() bool + RegisterNotifyHandler func(handler core.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 *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 FallbackHeaderValidator interface + IsInterfaceNil func() bool + ShouldApplyFallbackValidation func(headerHandler data.HeaderHandler) bool + type FeeHandler interface + CheckValidityTxValues func(tx TransactionWithFeeHandler) error + ComputeFeeForProcessing func(tx TransactionWithFeeHandler, gasToUse uint64) *big.Int + ComputeGasLimit func(tx TransactionWithFeeHandler) uint64 + ComputeMoveBalanceFee func(tx TransactionWithFeeHandler) *big.Int + ComputeTxFee func(tx TransactionWithFeeHandler) *big.Int + DeveloperPercentage func() float64 + GasPriceModifier func() float64 + GenesisTotalSupply func() *big.Int + 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() + 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 + 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 HeaderIntegrityVerifier interface + GetVersion func(epoch uint32) string + IsInterfaceNil func() bool + Verify func(header data.HeaderHandler) error + type HeaderValidator interface + HeaderValidForProcessing func(headerHandler HdrValidatorHandler) error + IsInterfaceNil func() bool + type Indexer interface + Close func() error + IsInterfaceNil func() bool + IsNilIndexer func() bool + RevertIndexedBlock func(header data.HeaderHandler, body data.BodyHandler) + SaveAccounts func(blockTimestamp uint64, acc []state.UserAccountHandler) + SaveBlock func(args *indexer.ArgsSaveBlockData) + SaveRoundsInfo func(roundsInfos []*indexer.RoundInfo) + SaveValidatorsPubKeys func(validatorsPubKeys map[uint32][][]byte, epoch uint32) + SaveValidatorsRating func(indexID string, infoRating []*indexer.ValidatorRatingInfo) + SetTxLogsProcessor func(txLogsProc TransactionLogProcessorDatabase) + UpdateTPS func(tpsBenchmark statistics.TPSBenchmark) + 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 + 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 + GetNumOfCrossInterMbsAndTxs func() (int, int) + IsInterfaceNil func() bool + RemoveProcessedResultsFor func(txHashes [][]byte) + SaveCurrentIntermediateTxToStorage func() error + VerifyInterMiniBlocks func(body *block.Body) error + type Locker interface + Lock func() + RLock func() + RUnlock func() + Unlock func() + 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 PayableHandler interface + IsInterfaceNil func() bool + IsPayable func(address []byte) (bool, 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, int, 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 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 RewardsCreator 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) + GetLocalTxCache func() epochStart.TransactionCacher + GetProtocolSustainabilityRewards func() *big.Int + 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 RewardsHandler interface + IsInterfaceNil func() bool + LeaderPercentage func() float64 + MaxInflationRate func(year uint32) float64 + MinInflationRate func() float64 + ProtocolSustainabilityAddress func() string + ProtocolSustainabilityPercentage func() float64 + RewardsTopUpFactor func() float64 + RewardsTopUpGradientPoint func() *big.Int + type RoundTimeDurationHandler interface + IsInterfaceNil func() bool + TimeDuration func() time.Duration + type Rounder interface + Index func() int64 + IsInterfaceNil func() bool + type SCQuery struct + Arguments [][]byte + CallValue *big.Int + CallerAddr []byte + FuncName string + ScAddress []byte + type SCQueryService interface + ComputeScCallGasLimit func(tx *transaction.Transaction) (uint64, error) + 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) + 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(address []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, handler p2p.MessageProcessor) error + type TransactionCoordinator interface + CreateBlockStarted func() + CreateMarshalizedData func(body *block.Body) map[string][][]byte + CreateMarshalizedReceipts func() ([]byte, error) + 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 + 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) error + VerifyCreatedBlockTransactions func(hdr data.HeaderHandler, body *block.Body) error + VerifyCreatedMiniBlocks func(hdr data.HeaderHandler, body *block.Body) error + type TransactionFeeCalculator interface + ComputeGasLimit func(tx TransactionWithFeeHandler) uint64 + ComputeGasUsedAndFeeBasedOnRefundValue func(tx TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int) + ComputeTxFeeBasedOnGasUsed func(tx TransactionWithFeeHandler, gasUsed uint64) *big.Int + IsInterfaceNil func() bool + 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 TxGasHandler interface + GasPriceForMove func(tx TransactionWithFeeHandler) uint64 + GasPriceForProcessing func(tx TransactionWithFeeHandler) uint64 + IsInterfaceNil func() bool + MinGasLimit func() uint64 + MinGasPrice func() uint64 + MinGasPriceForProcessing func() uint64 + SplitTxGasInCategories func(tx 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 ValidatorInfoSyncer interface + IsInterfaceNil func() bool + SyncMiniBlocks func(metaBlock *block.MetaBlock) ([][]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.HeaderHandler) error + RootHash func() ([]byte, error) + SaveNodesCoordinatorUpdates func(epoch uint32) (bool, 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 + 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 + 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)