mock

Documentation

Index

• func NewCountingDB() *countingDB
• func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock
• func NewNetworkShardingCollectorMock() *networkShardingCollectorMock
• func NewNilOutport() *nilOutport
• func NewNodesHandlerMock(initialNodesSetup genesis.InitialNodesHandler) (*nodesHandlerMock, error)
• type AccountsDBSyncerStub
  • func (a *AccountsDBSyncerStub) GetSyncedTries() map[string]common.Trie
  • func (a *AccountsDBSyncerStub) IsInterfaceNil() bool
  • func (a *AccountsDBSyncerStub) SyncAccounts(rootHash []byte) error
• type AccountsFactoryStub
  • func (afs *AccountsFactoryStub) CreateAccount(address []byte) (vmcommon.AccountHandler, error)
  • func (afs *AccountsFactoryStub) IsInterfaceNil() bool
• type AccountsParserStub
  • func (aps *AccountsParserStub) GetInitialAccountsForDelegated(addressBytes []byte) []genesis.InitialAccountHandler
  • func (aps *AccountsParserStub) GetTotalStakedForDelegationAddress(delegationAddress string) *big.Int
  • func (aps *AccountsParserStub) InitialAccounts() []genesis.InitialAccountHandler
  • func (aps *AccountsParserStub) InitialAccountsSplitOnAddressesShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)
  • func (aps *AccountsParserStub) InitialAccountsSplitOnDelegationAddressesShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)
  • func (aps *AccountsParserStub) IsInterfaceNil() bool
• type AppStatusHandlerStub
  • func (ashs *AppStatusHandlerStub) AddUint64(key string, value uint64)
  • func (ashs *AppStatusHandlerStub) Close()
  • func (ashs *AppStatusHandlerStub) Decrement(key string)
  • func (ashs *AppStatusHandlerStub) Increment(key string)
  • func (ashs *AppStatusHandlerStub) IsInterfaceNil() bool
  • func (ashs *AppStatusHandlerStub) SetInt64Value(key string, value int64)
  • func (ashs *AppStatusHandlerStub) SetStringValue(key string, value string)
  • func (ashs *AppStatusHandlerStub) SetUInt64Value(key string, value uint64)
• type BlackListHandlerStub
  • func (blhs *BlackListHandlerStub) Add(key string) error
  • func (blhs *BlackListHandlerStub) AddWithSpan(key string, span time.Duration) error
  • func (blhs *BlackListHandlerStub) Has(key string) bool
  • func (blhs *BlackListHandlerStub) IsInterfaceNil() bool
  • func (blhs *BlackListHandlerStub) Sweep()
• type BlockChainHookHandlerMock
  • func (e *BlockChainHookHandlerMock) DeleteCompiledCode(codeHash []byte)
  • func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool
  • func (e *BlockChainHookHandlerMock) IsPayable(address []byte) (bool, error)
  • func (e *BlockChainHookHandlerMock) NewAddress(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)
  • func (e *BlockChainHookHandlerMock) ProcessBuiltInFunction(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
  • func (e *BlockChainHookHandlerMock) SetCurrentHeader(hdr data.HeaderHandler)
• type BlockChainMock
  • func (bc *BlockChainMock) CreateNewHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetCurrentBlockHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetCurrentBlockHeaderHash() []byte
  • func (bc *BlockChainMock) GetGenesisHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetGenesisHeaderHash() []byte
  • func (bc *BlockChainMock) IsInterfaceNil() bool
  • func (bc *BlockChainMock) SetCurrentBlockHeader(header data.HeaderHandler) error
  • func (bc *BlockChainMock) SetCurrentBlockHeaderHash(hash []byte)
  • func (bc *BlockChainMock) SetGenesisHeader(genesisBlock data.HeaderHandler) error
  • func (bc *BlockChainMock) SetGenesisHeaderHash(hash []byte)
• type BlockProcessorMock
  • func (bpm *BlockProcessorMock) AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler)
  • func (bpm *BlockProcessorMock) ApplyProcessedMiniBlocks(_ *processedMb.ProcessedMiniBlockTracker)
  • func (bpm *BlockProcessorMock) Close() error
  • func (bpm *BlockProcessorMock) CommitBlock(header data.HeaderHandler, body data.BodyHandler) error
  • func (bpm *BlockProcessorMock) CreateBlock(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)
  • func (bpm *BlockProcessorMock) CreateNewHeader(round uint64, nonce uint64) data.HeaderHandler
  • func (bpm *BlockProcessorMock) DecodeBlockBody(dta []byte) data.BodyHandler
  • func (bpm *BlockProcessorMock) DecodeBlockHeader(dta []byte) data.HeaderHandler
  • func (bpm *BlockProcessorMock) IsInterfaceNil() bool
  • func (bpm *BlockProcessorMock) MarshalizedDataToBroadcast(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error)
  • func (bpm *BlockProcessorMock) ProcessBlock(header data.HeaderHandler, body data.BodyHandler, ...) error
  • func (bpm *BlockProcessorMock) PruneStateOnRollback(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)
  • func (bpm *BlockProcessorMock) RestoreBlockIntoPools(header data.HeaderHandler, body data.BodyHandler) error
  • func (bpm *BlockProcessorMock) RestoreLastNotarizedHrdsToGenesis()
  • func (bpm *BlockProcessorMock) RevertAccountState(header data.HeaderHandler)
  • func (bpm *BlockProcessorMock) RevertIndexedBlock(header data.HeaderHandler)
  • func (bpm *BlockProcessorMock) RevertStateToBlock(header data.HeaderHandler) error
  • func (bpm *BlockProcessorMock) SetNumProcessedObj(_ uint64)
• type BlockSizeThrottlerStub
  • func (bsts *BlockSizeThrottlerStub) Add(round uint64, size uint32)
  • func (bsts *BlockSizeThrottlerStub) ComputeCurrentMaxSize()
  • func (bsts *BlockSizeThrottlerStub) GetCurrentMaxSize() uint32
  • func (bsts *BlockSizeThrottlerStub) IsInterfaceNil() bool
  • func (bsts *BlockSizeThrottlerStub) Succeed(round uint64)
• type BlockTrackerStub
  • func (bts *BlockTrackerStub) AddCrossNotarizedHeader(shardID uint32, crossNotarizedHeader data.HeaderHandler, ...)
  • func (bts *BlockTrackerStub) AddSelfNotarizedHeader(shardID uint32, selfNotarizedHeader data.HeaderHandler, ...)
  • func (bts *BlockTrackerStub) AddTrackedHeader(header data.HeaderHandler, hash []byte)
  • func (bts *BlockTrackerStub) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error
  • func (bts *BlockTrackerStub) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error
  • func (bts *BlockTrackerStub) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool
  • func (bts *BlockTrackerStub) CleanupHeadersBehindNonce(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)
  • func (bts *BlockTrackerStub) CleanupInvalidCrossHeaders(_ uint32, _ uint64)
  • func (bts *BlockTrackerStub) ComputeLongestChain(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)
  • func (bts *BlockTrackerStub) ComputeLongestMetaChainFromLastNotarized() ([]data.HeaderHandler, [][]byte, error)
  • func (bts *BlockTrackerStub) ComputeLongestShardsChainsFromLastNotarized() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)
  • func (bts *BlockTrackerStub) DisplayTrackedHeaders()
  • func (bts *BlockTrackerStub) GetCrossNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
  • func (bts *BlockTrackerStub) GetLastCrossNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (bts *BlockTrackerStub) GetLastCrossNotarizedHeadersForAllShards() (map[uint32]data.HeaderHandler, error)
  • func (bts *BlockTrackerStub) GetLastSelfNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (bts *BlockTrackerStub) GetSelfNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
  • func (bts *BlockTrackerStub) GetTrackedHeaders(shardID uint32) ([]data.HeaderHandler, [][]byte)
  • func (bts *BlockTrackerStub) GetTrackedHeadersForAllShards() map[uint32][]data.HeaderHandler
  • func (bts *BlockTrackerStub) GetTrackedHeadersWithNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
  • func (bts *BlockTrackerStub) IsInterfaceNil() bool
  • func (bts *BlockTrackerStub) IsShardStuck(shardId uint32) bool
  • func (bts *BlockTrackerStub) RegisterCrossNotarizedHeadersHandler(...)
  • func (bts *BlockTrackerStub) RegisterFinalMetachainHeadersHandler(...)
  • func (bts *BlockTrackerStub) RegisterSelfNotarizedFromCrossHeadersHandler(...)
  • func (bts *BlockTrackerStub) RegisterSelfNotarizedHeadersHandler(...)
  • func (bts *BlockTrackerStub) RemoveLastNotarizedHeaders()
  • func (bts *BlockTrackerStub) RestoreToGenesis()
  • func (bts *BlockTrackerStub) ShouldAddHeader(headerHandler data.HeaderHandler) bool
• type BoostrapStorerMock
  • func (bsm *BoostrapStorerMock) Get(round int64) (bootstrapStorage.BootstrapData, error)
  • func (bsm *BoostrapStorerMock) GetHighestRound() int64
  • func (bsm *BoostrapStorerMock) IsInterfaceNil() bool
  • func (bsm *BoostrapStorerMock) Put(round int64, bootData bootstrapStorage.BootstrapData) error
  • func (bsm *BoostrapStorerMock) SaveLastRound(_ int64) error
• type BuiltInCostHandlerStub
  • func (b *BuiltInCostHandlerStub) ComputeBuiltInCost(_ data.TransactionWithFeeHandler) uint64
  • func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ data.TransactionWithFeeHandler) bool
  • func (b *BuiltInCostHandlerStub) IsInterfaceNil() bool
• type ChainStorerMock
  • func (bc *ChainStorerMock) AddStorer(key dataRetriever.UnitType, s storage.Storer)
  • func (bc *ChainStorerMock) CloseAll() error
  • func (bc *ChainStorerMock) Destroy() error
  • func (bc *ChainStorerMock) Get(unitType dataRetriever.UnitType, key []byte) ([]byte, error)
  • func (bc *ChainStorerMock) GetAll(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)
  • func (bc *ChainStorerMock) GetAllStorers() map[dataRetriever.UnitType]storage.Storer
  • func (bc *ChainStorerMock) GetStorer(unitType dataRetriever.UnitType) storage.Storer
  • func (bc *ChainStorerMock) Has(unitType dataRetriever.UnitType, key []byte) error
  • func (bc *ChainStorerMock) IsInterfaceNil() bool
  • func (bc *ChainStorerMock) Put(unitType dataRetriever.UnitType, key []byte, value []byte) error
  • func (bc *ChainStorerMock) SetEpochForPutOperation(_ uint32)
• type CoreComponentsStub
  • func (ccs *CoreComponentsStub) AddressPubKeyConverter() core.PubkeyConverter
  • func (ccs *CoreComponentsStub) AlarmScheduler() core.TimersScheduler
  • func (ccs *CoreComponentsStub) ChainID() string
  • func (ccs *CoreComponentsStub) ChanStopNodeProcess() chan endProcess.ArgEndProcess
  • func (ccs *CoreComponentsStub) CheckSubcomponents() error
  • func (ccs *CoreComponentsStub) Close() error
  • func (ccs *CoreComponentsStub) Create() error
  • func (ccs *CoreComponentsStub) EconomicsData() process.EconomicsDataHandler
  • func (ccs *CoreComponentsStub) EncodedAddressLen() uint32
  • func (ccs *CoreComponentsStub) EpochNotifier() process.EpochNotifier
  • func (ccs *CoreComponentsStub) EpochStartNotifierWithConfirm() factory.EpochStartNotifierWithConfirm
  • func (ccs *CoreComponentsStub) GenesisNodesSetup() sharding.GenesisNodesSetupHandler
  • func (ccs *CoreComponentsStub) GenesisTime() time.Time
  • func (ccs *CoreComponentsStub) Hasher() hashing.Hasher
  • func (ccs *CoreComponentsStub) InternalMarshalizer() marshal.Marshalizer
  • func (ccs *CoreComponentsStub) IsInterfaceNil() bool
  • func (ccs *CoreComponentsStub) MinTransactionVersion() uint32
  • func (ccs *CoreComponentsStub) NodeTypeProvider() core.NodeTypeProviderHandler
  • func (ccs *CoreComponentsStub) NodesShuffler() sharding.NodesShuffler
  • func (ccs *CoreComponentsStub) PathHandler() storage.PathManagerHandler
  • func (ccs *CoreComponentsStub) Rater() sharding.PeerAccountListAndRatingHandler
  • func (ccs *CoreComponentsStub) RatingsData() process.RatingsInfoHandler
  • func (ccs *CoreComponentsStub) RoundHandler() consensus.RoundHandler
  • func (ccs *CoreComponentsStub) SetInternalMarshalizer(m marshal.Marshalizer) error
  • func (ccs *CoreComponentsStub) StatusHandler() core.AppStatusHandler
  • func (ccs *CoreComponentsStub) StatusHandlerUtils() nodeFactory.StatusHandlersUtils
  • func (ccs *CoreComponentsStub) SyncTimer() ntp.SyncTimer
  • func (ccs *CoreComponentsStub) TxMarshalizer() marshal.Marshalizer
  • func (ccs *CoreComponentsStub) TxSignHasher() hashing.Hasher
  • func (ccs *CoreComponentsStub) TxVersionChecker() process.TxVersionCheckerHandler
  • func (ccs *CoreComponentsStub) Uint64ByteSliceConverter() typeConverters.Uint64ByteSliceConverter
  • func (ccs *CoreComponentsStub) ValidatorPubKeyConverter() core.PubkeyConverter
  • func (ccs *CoreComponentsStub) VmMarshalizer() marshal.Marshalizer
  • func (ccs *CoreComponentsStub) Watchdog() core.WatchdogTimer
• type CryptoComponentsStub
  • func (ccs *CryptoComponentsStub) BlockSignKeyGen() crypto.KeyGenerator
  • func (ccs *CryptoComponentsStub) BlockSigner() crypto.SingleSigner
  • func (ccs *CryptoComponentsStub) CheckSubcomponents() error
  • func (ccs *CryptoComponentsStub) Clone() interface{}
  • func (ccs *CryptoComponentsStub) Close() error
  • func (ccs *CryptoComponentsStub) Create() error
  • func (ccs *CryptoComponentsStub) IsInterfaceNil() bool
  • func (ccs *CryptoComponentsStub) MessageSignVerifier() vm.MessageSignVerifier
  • func (ccs *CryptoComponentsStub) MultiSigner() crypto.MultiSigner
  • func (ccs *CryptoComponentsStub) PeerSignatureHandler() crypto.PeerSignatureHandler
  • func (ccs *CryptoComponentsStub) PrivateKey() crypto.PrivateKey
  • func (ccs *CryptoComponentsStub) PrivateKeyBytes() []byte
  • func (ccs *CryptoComponentsStub) PublicKey() crypto.PublicKey
  • func (ccs *CryptoComponentsStub) PublicKeyBytes() []byte
  • func (ccs *CryptoComponentsStub) PublicKeyString() string
  • func (ccs *CryptoComponentsStub) SetMultiSigner(ms crypto.MultiSigner) error
  • func (ccs *CryptoComponentsStub) TxSignKeyGen() crypto.KeyGenerator
  • func (ccs *CryptoComponentsStub) TxSingleSigner() crypto.SingleSigner
• type CurrentNetworkEpochProviderStub
  • func (cneps *CurrentNetworkEpochProviderStub) EpochConfirmed(epoch uint32, timestamp uint64)
  • func (cneps *CurrentNetworkEpochProviderStub) EpochIsActiveInNetwork(epoch uint32) bool
  • func (cneps *CurrentNetworkEpochProviderStub) IsInterfaceNil() bool
• type DataComponentsStub
  • func (dcs *DataComponentsStub) Blockchain() data.ChainHandler
  • func (dcs *DataComponentsStub) CheckSubcomponents() error
  • func (dcs *DataComponentsStub) Clone() interface{}
  • func (dcs *DataComponentsStub) Close() error
  • func (dcs *DataComponentsStub) Create() error
  • func (dcs *DataComponentsStub) Datapool() dataRetriever.PoolsHolder
  • func (dcs *DataComponentsStub) EconomicsHandler() factory.EconomicsHandler
  • func (dcs *DataComponentsStub) IsInterfaceNil() bool
  • func (dcs *DataComponentsStub) MiniBlocksProvider() factory.MiniBlockProvider
  • func (dcs *DataComponentsStub) SetBlockchain(chain data.ChainHandler)
  • func (dcs *DataComponentsStub) StorageService() dataRetriever.StorageService
• type DatabaseWriterStub
  • func (dws *DatabaseWriterStub) CheckAndCreateAlias(_ string, _ string) error
  • func (dws *DatabaseWriterStub) CheckAndCreateIndex(_ string) error
  • func (dws *DatabaseWriterStub) CheckAndCreatePolicy(_ string, _ *bytes.Buffer) error
  • func (dws *DatabaseWriterStub) CheckAndCreateTemplate(_ string, _ *bytes.Buffer) error
  • func (dws *DatabaseWriterStub) DoBulkRemove(index string, hashes []string) error
  • func (dws *DatabaseWriterStub) DoBulkRequest(buff *bytes.Buffer, index string) error
  • func (dws *DatabaseWriterStub) DoMultiGet(query map[string]interface{}, index string) (map[string]interface{}, error)
  • func (dws *DatabaseWriterStub) DoRequest(req *esapi.IndexRequest) error
  • func (dws *DatabaseWriterStub) IsInterfaceNil() bool
• type EpochEconomicsStub
  • func (e *EpochEconomicsStub) ComputeEndOfEpochEconomics(metaBlock *block.MetaBlock) (*block.Economics, error)
  • func (e *EpochEconomicsStub) IsInterfaceNil() bool
  • func (e *EpochEconomicsStub) VerifyRewardsPerBlock(metaBlock *block.MetaBlock, correctedProtocolSustainability *big.Int, ...) error
• type EpochNotifierStub
  • func (ens *EpochNotifierStub) CheckEpoch(header data.HeaderHandler)
  • func (ens *EpochNotifierStub) CurrentEpoch() uint32
  • func (ens *EpochNotifierStub) IsInterfaceNil() bool
  • func (ens *EpochNotifierStub) RegisterNotifyHandler(handler vmcommon.EpochSubscriberHandler)
• type EpochRewardsCreatorStub
  • func (e *EpochRewardsCreatorStub) CreateMarshalizedData(body *block.Body) map[string][][]byte
  • func (e *EpochRewardsCreatorStub) CreateRewardsMiniBlocks(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) (block.MiniBlockSlice, error)
  • func (e *EpochRewardsCreatorStub) DeleteTxsFromStorage(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) GetLocalTxCache() epochStart.TransactionCacher
  • func (e *EpochRewardsCreatorStub) GetProtocolSustainabilityRewards() *big.Int
  • func (e *EpochRewardsCreatorStub) GetRewardsTxs(body *block.Body) map[string]data.TransactionHandler
  • func (e *EpochRewardsCreatorStub) IsInterfaceNil() bool
  • func (e *EpochRewardsCreatorStub) RemoveBlockDataFromPools(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) SaveTxBlockToStorage(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) VerifyRewardsMiniBlocks(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) error
• type EpochStartDataCreatorStub
  • func (e *EpochStartDataCreatorStub) CreateEpochStartData() (*block.EpochStart, error)
  • func (e *EpochStartDataCreatorStub) IsInterfaceNil() bool
  • func (e *EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock(metaBlock *block.MetaBlock) error
• type EpochStartNotifierStub
  • func (esnm *EpochStartNotifierStub) IsInterfaceNil() bool
  • func (esnm *EpochStartNotifierStub) NotifyAll(hdr data.HeaderHandler)
  • func (esnm *EpochStartNotifierStub) NotifyAllPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
  • func (esnm *EpochStartNotifierStub) NotifyEpochChangeConfirmed(epoch uint32)
  • func (esnm *EpochStartNotifierStub) RegisterHandler(handler epochStart.ActionHandler)
  • func (esnm *EpochStartNotifierStub) UnregisterHandler(handler epochStart.ActionHandler)
• type EpochStartSystemSCStub
  • func (e *EpochStartSystemSCStub) IsInterfaceNil() bool
  • func (e *EpochStartSystemSCStub) ProcessDelegationRewards(miniBlocks block.MiniBlockSlice, txCache epochStart.TransactionCacher) error
  • func (e *EpochStartSystemSCStub) ProcessSystemSmartContract(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error
  • func (e *EpochStartSystemSCStub) ToggleUnStakeUnBond(value bool) error
• type EpochStartTriggerStub
  • func (e *EpochStartTriggerStub) Close() error
  • func (e *EpochStartTriggerStub) Epoch() uint32
  • func (e *EpochStartTriggerStub) EpochFinalityAttestingRound() uint64
  • func (e *EpochStartTriggerStub) EpochStartMetaHdrHash() []byte
  • func (e *EpochStartTriggerStub) EpochStartRound() uint64
  • func (e *EpochStartTriggerStub) ForceEpochStart(round uint64)
  • func (e *EpochStartTriggerStub) GetRoundsPerEpoch() uint64
  • func (e *EpochStartTriggerStub) GetSavedStateKey() []byte
  • func (e *EpochStartTriggerStub) IsEpochStart() bool
  • func (e *EpochStartTriggerStub) IsInterfaceNil() bool
  • func (e *EpochStartTriggerStub) LoadState(_ []byte) error
  • func (e *EpochStartTriggerStub) MetaEpoch() uint32
  • func (e *EpochStartTriggerStub) NotifyAll(_ data.HeaderHandler)
  • func (e *EpochStartTriggerStub) ReceivedHeader(header data.HeaderHandler)
  • func (e *EpochStartTriggerStub) RequestEpochStartIfNeeded(_ data.HeaderHandler)
  • func (e *EpochStartTriggerStub) Revert(_ data.HeaderHandler)
  • func (e *EpochStartTriggerStub) RevertStateToBlock(_ data.HeaderHandler) error
  • func (e *EpochStartTriggerStub) SetAppStatusHandler(_ core.AppStatusHandler) error
  • func (e *EpochStartTriggerStub) SetCurrentEpochStartRound(_ uint64)
  • func (e *EpochStartTriggerStub) SetEpoch(_ uint32)
  • func (e *EpochStartTriggerStub) SetFinalityAttestingRound(_ uint64)
  • func (e *EpochStartTriggerStub) SetMinRoundsBetweenEpochs(_ uint64)
  • func (e *EpochStartTriggerStub) SetProcessed(header data.HeaderHandler, _ data.BodyHandler)
  • func (e *EpochStartTriggerStub) SetRoundsPerEpoch(_ uint64)
  • func (e *EpochStartTriggerStub) SetTrigger(_ epochStart.TriggerHandler)
  • func (e *EpochStartTriggerStub) Update(round uint64, nonce uint64)
• type EpochValidatorInfoCreatorStub
  • func (e *EpochValidatorInfoCreatorStub) CreateValidatorInfoMiniBlocks(validatorInfo map[uint32][]*state.ValidatorInfo) (block.MiniBlockSlice, error)
  • func (e *EpochValidatorInfoCreatorStub) DeleteValidatorInfoBlocksFromStorage(metaBlock *block.MetaBlock)
  • func (e *EpochValidatorInfoCreatorStub) IsInterfaceNil() bool
  • func (e *EpochValidatorInfoCreatorStub) RemoveBlockDataFromPools(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochValidatorInfoCreatorStub) SaveValidatorInfoBlocksToStorage(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochValidatorInfoCreatorStub) VerifyValidatorInfoMiniBlocks(miniblocks []*block.MiniBlock, ...) error
• type ExportFactoryHandlerStub
  • func (e *ExportFactoryHandlerStub) Create() (update.ExportHandler, error)
  • func (e *ExportFactoryHandlerStub) IsInterfaceNil() bool
• type ExportHandlerStub
  • func (e *ExportHandlerStub) ExportAll(epoch uint32) error
  • func (e *ExportHandlerStub) IsInterfaceNil() bool
• type FeeHandlerStub
  • func (fhs *FeeHandlerStub) CheckValidityTxValues(tx data.TransactionWithFeeHandler) error
  • func (fhs *FeeHandlerStub) ComputeFeeForProcessing(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int
  • func (fhs *FeeHandlerStub) ComputeGasLimit(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) ComputeGasLimitBasedOnBalance(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error)
  • func (fhs *FeeHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int)
  • func (fhs *FeeHandlerStub) ComputeMoveBalanceFee(tx data.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) ComputeTxFee(tx data.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) ComputeTxFeeBasedOnGasUsed(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int
  • func (fhs *FeeHandlerStub) DeveloperPercentage() float64
  • func (fhs *FeeHandlerStub) GasPerDataByte() uint64
  • func (fhs *FeeHandlerStub) GasPriceForMove(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) GasPriceForProcessing(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) GasPriceModifier() float64
  • func (fhs *FeeHandlerStub) GenesisTotalSupply() *big.Int
  • func (fhs *FeeHandlerStub) IsInterfaceNil() bool
  • func (fhs *FeeHandlerStub) MaxGasLimitPerBlock(uint32) uint64
  • func (fhs *FeeHandlerStub) MinGasLimit() uint64
  • func (fhs *FeeHandlerStub) MinGasPrice() uint64
  • func (fhs *FeeHandlerStub) MinGasPriceForProcessing() uint64
  • func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64)
  • func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64)
  • func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice uint64)
  • func (fhs *FeeHandlerStub) SplitTxGasInCategories(tx data.TransactionWithFeeHandler) (uint64, uint64)
• type ForkDetectorStub
  • func (fdm *ForkDetectorStub) AddHeader(header data.HeaderHandler, hash []byte, state process.BlockHeaderState, ...) error
  • func (fdm *ForkDetectorStub) CheckFork() *process.ForkInfo
  • func (fdm *ForkDetectorStub) GetHighestFinalBlockHash() []byte
  • func (fdm *ForkDetectorStub) GetHighestFinalBlockNonce() uint64
  • func (fdm *ForkDetectorStub) GetNotarizedHeaderHash(nonce uint64) []byte
  • func (fdm *ForkDetectorStub) IsInterfaceNil() bool
  • func (fdm *ForkDetectorStub) ProbableHighestNonce() uint64
  • func (fdm *ForkDetectorStub) RemoveHeader(nonce uint64, hash []byte)
  • func (fdm *ForkDetectorStub) ResetFork()
  • func (fdm *ForkDetectorStub) ResetProbableHighestNonce()
  • func (fdm *ForkDetectorStub) RestoreToGenesis()
  • func (fdm *ForkDetectorStub) SetFinalToLastCheckpoint()
  • func (fdm *ForkDetectorStub) SetRollBackNonce(nonce uint64)
• type GasHandlerMock
  • func (ghm *GasHandlerMock) ComputeGasConsumedByMiniBlock(miniBlock *block.MiniBlock, mapHashTx map[string]data.TransactionHandler) (uint64, uint64, error)
  • func (ghm *GasHandlerMock) ComputeGasConsumedByTx(txSenderShardId uint32, txReceiverShardId uint32, ...) (uint64, uint64, error)
  • func (ghm *GasHandlerMock) GasConsumed(hash []byte) uint64
  • func (ghm *GasHandlerMock) GasRefunded(hash []byte) uint64
  • func (ghm *GasHandlerMock) Init()
  • func (ghm *GasHandlerMock) IsInterfaceNil() bool
  • func (ghm *GasHandlerMock) RemoveGasConsumed(hashes [][]byte)
  • func (ghm *GasHandlerMock) RemoveGasRefunded(hashes [][]byte)
  • func (ghm *GasHandlerMock) SetGasConsumed(gasConsumed uint64, hash []byte)
  • func (ghm *GasHandlerMock) SetGasRefunded(gasRefunded uint64, hash []byte)
  • func (ghm *GasHandlerMock) TotalGasConsumed() uint64
  • func (ghm *GasHandlerMock) TotalGasRefunded() uint64
• type GasScheduleNotifierMock
  • func NewGasScheduleNotifierMock(gasSchedule map[string]map[string]uint64) *GasScheduleNotifierMock
  • func (g *GasScheduleNotifierMock) IsInterfaceNil() bool
  • func (g *GasScheduleNotifierMock) LatestGasSchedule() map[string]map[string]uint64
  • func (g *GasScheduleNotifierMock) RegisterNotifyHandler(handler core.GasScheduleSubscribeHandler)
  • func (g *GasScheduleNotifierMock) UnRegisterAll()
• type HardforkTriggerStub
  • func (hts *HardforkTriggerStub) AddCloser(closer update.Closer) error
  • func (hts *HardforkTriggerStub) CreateData() []byte
  • func (hts *HardforkTriggerStub) IsInterfaceNil() bool
  • func (hts *HardforkTriggerStub) IsSelfTrigger() bool
  • func (hts *HardforkTriggerStub) NotifyTriggerReceived() <-chan struct{}
  • func (hts *HardforkTriggerStub) RecordedTriggerMessage() ([]byte, bool)
  • func (hts *HardforkTriggerStub) Trigger(epoch uint32, withEarlyEndOfEpoch bool) error
  • func (hts *HardforkTriggerStub) TriggerReceived(payload []byte, data []byte, pkBytes []byte) (bool, error)
• type HeaderIntegrityVerifierStub
  • func (h *HeaderIntegrityVerifierStub) GetVersion(epoch uint32) string
  • func (h *HeaderIntegrityVerifierStub) IsInterfaceNil() bool
  • func (h *HeaderIntegrityVerifierStub) Verify(header data.HeaderHandler) error
• type HeaderResolverStub
  • func (hrs *HeaderResolverStub) Close() error
  • func (hrs *HeaderResolverStub) IsInterfaceNil() bool
  • func (hrs *HeaderResolverStub) NumPeersToQuery() (int, int)
  • func (hrs *HeaderResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (hrs *HeaderResolverStub) RequestDataFromEpoch(identifier []byte) error
  • func (hrs *HeaderResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error
  • func (hrs *HeaderResolverStub) RequestDataFromNonce(nonce uint64, epoch uint32) error
  • func (hrs *HeaderResolverStub) SetEpochHandler(epochHandler dataRetriever.EpochHandler) error
  • func (hrs *HeaderResolverStub) SetNumPeersToQuery(intra int, cross int)
  • func (hrs *HeaderResolverStub) SetResolverDebugHandler(handler dataRetriever.ResolverDebugHandler) error
• type HeaderSigVerifierStub
  • func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool
  • func (hsvm *HeaderSigVerifierStub) VerifyLeaderSignature(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifyRandSeed(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifySignature(header data.HeaderHandler) error
• type HeaderValidatorStub
  • func (hvs *HeaderValidatorStub) IsHeaderConstructionValid(currHdr, prevHdr data.HeaderHandler) error
  • func (hvs *HeaderValidatorStub) IsInterfaceNil() bool
• type HeadersCacherStub
  • func (hcs *HeadersCacherStub) AddHeader(headerHash []byte, header data.HeaderHandler)
  • func (hcs *HeadersCacherStub) Clear()
  • func (hcs *HeadersCacherStub) GetHeaderByHash(hash []byte) (data.HeaderHandler, error)
  • func (hcs *HeadersCacherStub) GetHeadersByNonceAndShardId(hdrNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error)
  • func (hcs *HeadersCacherStub) IsInterfaceNil() bool
  • func (hcs *HeadersCacherStub) Keys(shardId uint32) []uint64
  • func (hcs *HeadersCacherStub) Len() int
  • func (hcs *HeadersCacherStub) MaxSize() int
  • func (hcs *HeadersCacherStub) RegisterHandler(handler func(key []byte, value interface{}))
  • func (hcs *HeadersCacherStub) RemoveHeaderByHash(headerHash []byte)
  • func (hcs *HeadersCacherStub) RemoveHeaderByNonceAndShardId(hdrNonce uint64, shardId uint32)
• type HeartbeatComponentsStub
  • func (hbs *HeartbeatComponentsStub) CheckSubcomponents() error
  • func (hbs *HeartbeatComponentsStub) Close() error
  • func (hbs *HeartbeatComponentsStub) Create() error
  • func (hbs *HeartbeatComponentsStub) IsInterfaceNil() bool
  • func (hbs *HeartbeatComponentsStub) MessageHandler() heartbeat.MessageHandler
  • func (hbs *HeartbeatComponentsStub) Monitor() factory.HeartbeatMonitor
  • func (hbs *HeartbeatComponentsStub) Sender() factory.HeartbeatSender
  • func (hbs *HeartbeatComponentsStub) Storer() factory.HeartbeatStorer
• type HeartbeatMessageHandlerStub
  • func (hbmh *HeartbeatMessageHandlerStub) CreateHeartbeatFromP2PMessage(message p2p.MessageP2P) (*data.Heartbeat, error)
  • func (hbmh *HeartbeatMessageHandlerStub) IsInterfaceNil() bool
• type HeartbeatMonitorStub
  • func (hbms *HeartbeatMonitorStub) Cleanup()
  • func (hbms *HeartbeatMonitorStub) Close() error
  • func (hbms *HeartbeatMonitorStub) GetHeartbeats() []heartbeatData.PubKeyHeartbeat
  • func (hbms *HeartbeatMonitorStub) IsInterfaceNil() bool
  • func (hbms *HeartbeatMonitorStub) ProcessReceivedMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
• type HeartbeatSenderStub
  • func (hbss *HeartbeatSenderStub) IsInterfaceNil() bool
  • func (hbss *HeartbeatSenderStub) SendHeartbeat() error
• type HeartbeatStorerStub
  • func (hss *HeartbeatStorerStub) IsInterfaceNil() bool
  • func (hss *HeartbeatStorerStub) LoadGenesisTime() (time.Time, error)
  • func (hss *HeartbeatStorerStub) LoadHeartBeatDTO(pubKey string) (*data.HeartbeatDTO, error)
  • func (hss *HeartbeatStorerStub) LoadKeys() ([][]byte, error)
  • func (hss *HeartbeatStorerStub) SaveKeys(peersSlice [][]byte) error
  • func (hss *HeartbeatStorerStub) SavePubkeyData(pubkey []byte, heartbeat *data.HeartbeatDTO) error
  • func (hss *HeartbeatStorerStub) UpdateGenesisTime(genesisTime time.Time) error
• type ImportStartHandlerStub
  • func (ish *ImportStartHandlerStub) IsAfterExportBeforeImport() bool
  • func (ish *ImportStartHandlerStub) IsInterfaceNil() bool
  • func (ish *ImportStartHandlerStub) ResetStartImport() error
  • func (ish *ImportStartHandlerStub) SetStartImport() error
  • func (ish *ImportStartHandlerStub) ShouldStartImport() bool
• type InterimProcessorContainerMock
  • func (ipcm *InterimProcessorContainerMock) Add(key block.Type, val process.IntermediateTransactionHandler) error
  • func (ipcm *InterimProcessorContainerMock) AddMultiple(keys []block.Type, preprocessors []process.IntermediateTransactionHandler) error
  • func (ipcm *InterimProcessorContainerMock) Get(key block.Type) (process.IntermediateTransactionHandler, error)
  • func (ipcm *InterimProcessorContainerMock) IsInterfaceNil() bool
  • func (ipcm *InterimProcessorContainerMock) Keys() []block.Type
  • func (ipcm *InterimProcessorContainerMock) Len() int
  • func (ipcm *InterimProcessorContainerMock) Remove(key block.Type)
  • func (ipcm *InterimProcessorContainerMock) Replace(key block.Type, val process.IntermediateTransactionHandler) error
• type IntermediateTransactionHandlerMock
  • func (ith *IntermediateTransactionHandlerMock) AddIntermediateTransactions(txs []data.TransactionHandler) error
  • func (ith *IntermediateTransactionHandlerMock) Clean()
  • func (ith *IntermediateTransactionHandlerMock) CreateAllInterMiniBlocks() []*block.MiniBlock
  • func (ith *IntermediateTransactionHandlerMock) CreateBlockStarted()
  • func (ith *IntermediateTransactionHandlerMock) CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)
  • func (ith *IntermediateTransactionHandlerMock) GetAllCurrentFinishedTxs() map[string]data.TransactionHandler
  • func (ith *IntermediateTransactionHandlerMock) GetCreatedInShardMiniBlock() *block.MiniBlock
  • func (ith *IntermediateTransactionHandlerMock) GetIntermediateTransactions() []data.TransactionHandler
  • func (ith *IntermediateTransactionHandlerMock) GetNumOfCrossInterMbsAndTxs() (int, int)
  • func (ith *IntermediateTransactionHandlerMock) IsInterfaceNil() bool
  • func (ith *IntermediateTransactionHandlerMock) RemoveProcessedResultsFor(txHashes [][]byte)
  • func (ith *IntermediateTransactionHandlerMock) SaveCurrentIntermediateTxToStorage() error
  • func (ith *IntermediateTransactionHandlerMock) VerifyInterMiniBlocks(body *block.Body) error
• type KeyGenMock
  • func (keyGen *KeyGenMock) CheckPublicKeyValid(_ []byte) error
  • func (keyGen *KeyGenMock) GeneratePair() (crypto.PrivateKey, crypto.PublicKey)
  • func (keyGen *KeyGenMock) IsInterfaceNil() bool
  • func (keyGen *KeyGenMock) PrivateKeyFromByteArray(buff []byte) (crypto.PrivateKey, error)
  • func (keyGen *KeyGenMock) PublicKeyFromByteArray(buff []byte) (crypto.PublicKey, error)
  • func (keyGen *KeyGenMock) Suite() crypto.Suite
• type LatestStorageDataProviderStub
  • func (l *LatestStorageDataProviderStub) Get() (storage.LatestDataFromStorage, error)
  • func (l *LatestStorageDataProviderStub) GetParentDirAndLastEpoch() (string, uint32, error)
  • func (l *LatestStorageDataProviderStub) GetShardsFromDirectory(path string) ([]string, error)
  • func (l *LatestStorageDataProviderStub) IsInterfaceNil() bool
• type ListIndexUpdaterStub
  • func (lius *ListIndexUpdaterStub) IsInterfaceNil() bool
  • func (lius *ListIndexUpdaterStub) UpdateListAndIndex(pubKey string, shardID uint32, list string, index uint32) error
• type MessageSignVerifierMock
  • func (m *MessageSignVerifierMock) IsInterfaceNil() bool
  • func (m *MessageSignVerifierMock) Verify(_ []byte, _ []byte, _ []byte) error
• type MiniBlocksProviderStub
  • func (mbps *MiniBlocksProviderStub) GetMiniBlocks(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
  • func (mbps *MiniBlocksProviderStub) GetMiniBlocksFromPool(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
  • func (mbps *MiniBlocksProviderStub) IsInterfaceNil() bool
• type MiniBlocksResolverStub
  • func (mbrs *MiniBlocksResolverStub) Close() error
  • func (mbrs *MiniBlocksResolverStub) IsInterfaceNil() bool
  • func (mbrs *MiniBlocksResolverStub) NumPeersToQuery() (int, int)
  • func (mbrs *MiniBlocksResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (mbrs *MiniBlocksResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error
  • func (mbrs *MiniBlocksResolverStub) RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
  • func (mbrs *MiniBlocksResolverStub) SetNumPeersToQuery(intra int, cross int)
  • func (mbrs *MiniBlocksResolverStub) SetResolverDebugHandler(_ dataRetriever.ResolverDebugHandler) error
• type MockDB
  • func (MockDB) Close() error
  • func (MockDB) Destroy() error
  • func (MockDB) DestroyClosed() error
  • func (MockDB) Get(_ []byte) ([]byte, error)
  • func (MockDB) Has(_ []byte) error
  • func (MockDB) Init() error
  • func (s MockDB) IsInterfaceNil() bool
  • func (MockDB) Put(_, _ []byte) error
  • func (MockDB) RangeKeys(_ func(key []byte, val []byte) bool)
  • func (MockDB) Remove(_ []byte) error
• type NetworkComponentsStub
  • func (ncs *NetworkComponentsStub) CheckSubcomponents() error
  • func (ncs *NetworkComponentsStub) Close() error
  • func (ncs *NetworkComponentsStub) Create() error
  • func (ncs *NetworkComponentsStub) InputAntiFloodHandler() factory.P2PAntifloodHandler
  • func (ncs *NetworkComponentsStub) IsInterfaceNil() bool
  • func (ncs *NetworkComponentsStub) NetworkMessenger() p2p.Messenger
  • func (ncs *NetworkComponentsStub) OutputAntiFloodHandler() factory.P2PAntifloodHandler
  • func (ncs *NetworkComponentsStub) PeerBlackListHandler() process.PeerBlackListCacher
  • func (ncs *NetworkComponentsStub) PeerHonestyHandler() factory.PeerHonestyHandler
  • func (ncs *NetworkComponentsStub) PreferredPeersHolderHandler() factory.PreferredPeersHolderHandler
  • func (ncs *NetworkComponentsStub) PubKeyCacher() process.TimeCacher
• type NilAntifloodHandler
  • func (nah *NilAntifloodHandler) ApplyConsensusSize(_ int)
  • func (nah *NilAntifloodHandler) BlacklistPeer(_ core.PeerID, _ string, _ time.Duration)
  • func (nah *NilAntifloodHandler) CanProcessMessage(_ p2p.MessageP2P, _ core.PeerID) error
  • func (nah *NilAntifloodHandler) CanProcessMessagesOnTopic(_ core.PeerID, _ string, _ uint32, _ uint64, _ []byte) error
  • func (nah *NilAntifloodHandler) Close() error
  • func (nah *NilAntifloodHandler) IsInterfaceNil() bool
  • func (nah *NilAntifloodHandler) IsOriginatorEligibleForTopic(_ core.PeerID, _ string) error
  • func (nah *NilAntifloodHandler) ResetForTopic(_ string)
  • func (nah *NilAntifloodHandler) SetDebugger(_ process.AntifloodDebugger) error
  • func (nah *NilAntifloodHandler) SetMaxMessagesForTopic(_ string, _ uint32)
  • func (nah *NilAntifloodHandler) SetPeerValidatorMapper(_ process.PeerValidatorMapper) error
  • func (nah *NilAntifloodHandler) SetTopicsForAll(_ ...string)
• type NodeInfoMock
  • func NewNodeInfo(address []byte, pubKey []byte, shardId uint32, initialRating uint32) *NodeInfoMock
  • func (n *NodeInfoMock) AddressBytes() []byte
  • func (n *NodeInfoMock) AssignedShard() uint32
  • func (n *NodeInfoMock) GetInitialRating() uint32
  • func (n *NodeInfoMock) IsInterfaceNil() bool
  • func (n *NodeInfoMock) PubKeyBytes() []byte
• type NodeShufflerMock
  • func (nsm *NodeShufflerMock) IsInterfaceNil() bool
  • func (nsm *NodeShufflerMock) UpdateNodeLists(args sharding.ArgsUpdateNodes) (*sharding.ResUpdateNodes, error)
  • func (nsm *NodeShufflerMock) UpdateParams(_ uint32, _ uint32, _ float32, _ bool)
• type NodesCoordinatorCacheStub
  • func (rm *NodesCoordinatorCacheStub) Get(key []byte) (value interface{}, ok bool)
  • func (rm *NodesCoordinatorCacheStub) Put(key []byte, value interface{}) (evicted bool)
• type NodesCoordinatorMock
  • func (ncm *NodesCoordinatorMock) ComputeAdditionalLeaving([]*state.ShardValidatorInfo) (map[uint32][]sharding.Validator, error)
  • func (ncm *NodesCoordinatorMock) ComputeConsensusGroup(randomness []byte, round uint64, shardId uint32, epoch uint32) (validatorsGroup []sharding.Validator, err error)
  • func (ncm *NodesCoordinatorMock) ConsensusGroupSize(uint32) int
  • func (ncm *NodesCoordinatorMock) GetAllEligibleValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)
  • func (ncm *NodesCoordinatorMock) GetAllLeavingValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)
  • func (ncm *NodesCoordinatorMock) GetAllWaitingValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)
  • func (ncm *NodesCoordinatorMock) GetChance(uint32) uint32
  • func (ncm *NodesCoordinatorMock) GetConsensusValidatorsPublicKeys(randomness []byte, round uint64, shardId uint32, epoch uint32) ([]string, error)
  • func (ncm *NodesCoordinatorMock) GetConsensusWhitelistedNodes(_ uint32) (map[string]struct{}, error)
  • func (ncm *NodesCoordinatorMock) GetNumTotalEligible() uint64
  • func (ncm *NodesCoordinatorMock) GetOwnPublicKey() []byte
  • func (ncm *NodesCoordinatorMock) GetSavedStateKey() []byte
  • func (ncm *NodesCoordinatorMock) GetSelectedPublicKeys(_ []byte, _ uint32, _ uint32) ([]string, error)
  • func (ncm *NodesCoordinatorMock) GetValidatorWithPublicKey(publicKey []byte) (sharding.Validator, uint32, error)
  • func (ncm *NodesCoordinatorMock) GetValidatorsIndexes(_ []string, _ uint32) ([]uint64, error)
  • func (ncm *NodesCoordinatorMock) IsInterfaceNil() bool
  • func (ncm *NodesCoordinatorMock) LoadState(_ []byte) error
  • func (ncm *NodesCoordinatorMock) SetNodesPerShards(_ map[uint32][]sharding.Validator, _ map[uint32][]sharding.Validator, _ uint32) error
  • func (ncm *NodesCoordinatorMock) ShardIdForEpoch(_ uint32) (uint32, error)
  • func (ncm *NodesCoordinatorMock) ShuffleOutForEpoch(_ uint32)
  • func (ncm *NodesCoordinatorMock) ValidatorsWeights(validators []sharding.Validator) ([]uint32, error)
• type NodesSetupStub
  • func (n *NodesSetupStub) AllInitialNodes() []sharding.GenesisNodeInfoHandler
  • func (n *NodesSetupStub) GetAdaptivity() bool
  • func (n *NodesSetupStub) GetChainId() string
  • func (n *NodesSetupStub) GetHysteresis() float32
  • func (n *NodesSetupStub) GetMetaConsensusGroupSize() uint32
  • func (n *NodesSetupStub) GetMinTransactionVersion() uint32
  • func (n *NodesSetupStub) GetRoundDuration() uint64
  • func (n *NodesSetupStub) GetShardConsensusGroupSize() uint32
  • func (n *NodesSetupStub) GetShardIDForPubKey(pubkey []byte) (uint32, error)
  • func (n *NodesSetupStub) GetStartTime() int64
  • func (n *NodesSetupStub) InitialEligibleNodesPubKeysForShard(shardId uint32) ([]string, error)
  • func (n *NodesSetupStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)
  • func (n *NodesSetupStub) InitialNodesInfoForShard(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error)
  • func (n *NodesSetupStub) InitialNodesPubKeys() map[uint32][]string
  • func (n *NodesSetupStub) IsInterfaceNil() bool
  • func (n *NodesSetupStub) MinNumberOfMetaNodes() uint32
  • func (n *NodesSetupStub) MinNumberOfNodes() uint32
  • func (n *NodesSetupStub) MinNumberOfNodesWithHysteresis() uint32
  • func (n *NodesSetupStub) MinNumberOfShardNodes() uint32
  • func (n *NodesSetupStub) NumberOfShards() uint32
• type OneSCExecutorMockVM
  • func NewOneSCExecutorMockVM(blockchainHook vmcommon.BlockchainHook, hasher hashing.Hasher) (*OneSCExecutorMockVM, error)
  • func (vm *OneSCExecutorMockVM) GasScheduleChange(_ map[string]map[string]uint64)
  • func (vm *OneSCExecutorMockVM) GetVersion() string
  • func (vm *OneSCExecutorMockVM) IsInterfaceNil() bool
  • func (vm *OneSCExecutorMockVM) RunSmartContractCall(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
  • func (vm *OneSCExecutorMockVM) RunSmartContractCreate(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)
• type P2PAntifloodHandlerStub
  • func (p2pahs *P2PAntifloodHandlerStub) ApplyConsensusSize(size int)
  • func (p2pahs *P2PAntifloodHandlerStub) BlacklistPeer(peer core.PeerID, reason string, duration time.Duration)
  • func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
  • func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessagesOnTopic(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, ...) error
  • func (p2pahs *P2PAntifloodHandlerStub) Close() error
  • func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool
  • func (p2pahs *P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic(pid core.PeerID, topic string) error
  • func (p2pahs *P2PAntifloodHandlerStub) ResetForTopic(_ string)
  • func (p2pahs *P2PAntifloodHandlerStub) SetDebugger(debugger process.AntifloodDebugger) error
  • func (p2pahs *P2PAntifloodHandlerStub) SetMaxMessagesForTopic(_ string, _ uint32)
  • func (p2pahs *P2PAntifloodHandlerStub) SetPeerValidatorMapper(_ process.PeerValidatorMapper) error
  • func (p2pahs *P2PAntifloodHandlerStub) SetTopicsForAll(_ ...string)
• type PeerBlackListCacherStub
  • func (pblhs *PeerBlackListCacherStub) Add(pid core.PeerID) error
  • func (pblhs *PeerBlackListCacherStub) Has(pid core.PeerID) bool
  • func (pblhs *PeerBlackListCacherStub) IsInterfaceNil() bool
  • func (pblhs *PeerBlackListCacherStub) Sweep()
  • func (pblhs *PeerBlackListCacherStub) Upsert(pid core.PeerID, span time.Duration) error
• type PeerChangesHandler
  • func (p *PeerChangesHandler) IsInterfaceNil() bool
  • func (p *PeerChangesHandler) PeerChanges() []block.PeerData
  • func (p *PeerChangesHandler) VerifyPeerChanges(peerChanges []block.PeerData) error
• type PeerDenialEvaluatorStub
  • func (pdes *PeerDenialEvaluatorStub) IsDenied(pid core.PeerID) bool
  • func (pdes *PeerDenialEvaluatorStub) IsInterfaceNil() bool
  • func (pdes *PeerDenialEvaluatorStub) UpsertPeerID(pid core.PeerID, duration time.Duration) error
• type PeerHonestyHandlerStub
  • func (phhs *PeerHonestyHandlerStub) ChangeScore(pk string, topic string, units int)
  • func (phhs *PeerHonestyHandlerStub) Close() error
  • func (phhs *PeerHonestyHandlerStub) IsInterfaceNil() bool
• type PeerShardMapperStub
  • func (psms *PeerShardMapperStub) GetPeerInfo(_ core.PeerID) core.P2PPeerInfo
  • func (psms *PeerShardMapperStub) IsInterfaceNil() bool
• type PeerSignatureHandler
  • func (p *PeerSignatureHandler) GetPeerSignature(_ crypto.PrivateKey, _ []byte) ([]byte, error)
  • func (p *PeerSignatureHandler) IsInterfaceNil() bool
  • func (p *PeerSignatureHandler) VerifyPeerSignature(_ []byte, _ core.PeerID, _ []byte) error
• type PeerTypeProviderStub
  • func (p *PeerTypeProviderStub) Close() error
  • func (p *PeerTypeProviderStub) ComputeForPubKey(pubKey []byte) (common.PeerType, uint32, error)
  • func (p *PeerTypeProviderStub) GetAllPeerTypeInfos() []*state.PeerTypeInfo
  • func (p *PeerTypeProviderStub) IsInterfaceNil() bool
• type PendingMiniBlocksHandlerStub
  • func (p *PendingMiniBlocksHandlerStub) AddProcessedHeader(handler data.HeaderHandler) error
  • func (p *PendingMiniBlocksHandlerStub) GetPendingMiniBlocks(shardID uint32) [][]byte
  • func (p *PendingMiniBlocksHandlerStub) IsInterfaceNil() bool
  • func (p *PendingMiniBlocksHandlerStub) RevertHeader(handler data.HeaderHandler) error
  • func (p *PendingMiniBlocksHandlerStub) SetPendingMiniBlocks(shardID uint32, mbHashes [][]byte)
• type PrivateKeyMock
  • func (sk *PrivateKeyMock) GeneratePublic() crypto.PublicKey
  • func (sk *PrivateKeyMock) IsInterfaceNil() bool
  • func (sk *PrivateKeyMock) Scalar() crypto.Scalar
  • func (sk *PrivateKeyMock) Suite() crypto.Suite
  • func (sk *PrivateKeyMock) ToByteArray() ([]byte, error)
• type ProcessComponentsStub
  • func (pcs *ProcessComponentsStub) ArwenChangeLocker() process.Locker
  • func (pcs *ProcessComponentsStub) BlackListHandler() process.TimeCacher
  • func (pcs *ProcessComponentsStub) BlockProcessor() process.BlockProcessor
  • func (pcs *ProcessComponentsStub) BlockTracker() process.BlockTracker
  • func (pcs *ProcessComponentsStub) BootStorer() process.BootStorer
  • func (pcs *ProcessComponentsStub) CheckSubcomponents() error
  • func (pcs *ProcessComponentsStub) Close() error
  • func (pcs *ProcessComponentsStub) Create() error
  • func (pcs *ProcessComponentsStub) CurrentEpochProvider() process.CurrentNetworkEpochProviderHandler
  • func (pcs *ProcessComponentsStub) EpochStartNotifier() factory.EpochStartNotifier
  • func (pcs *ProcessComponentsStub) EpochStartTrigger() epochStart.TriggerHandler
  • func (pcs *ProcessComponentsStub) FallbackHeaderValidator() process.FallbackHeaderValidator
  • func (pcs *ProcessComponentsStub) ForkDetector() process.ForkDetector
  • func (pcs *ProcessComponentsStub) HeaderConstructionValidator() process.HeaderConstructionValidator
  • func (pcs *ProcessComponentsStub) HeaderIntegrityVerifier() process.HeaderIntegrityVerifier
  • func (pcs *ProcessComponentsStub) HeaderSigVerifier() process.InterceptedHeaderSigVerifier
  • func (pcs *ProcessComponentsStub) HistoryRepository() dblookupext.HistoryRepository
  • func (pcs *ProcessComponentsStub) ImportStartHandler() update.ImportStartHandler
  • func (pcs *ProcessComponentsStub) InterceptorsContainer() process.InterceptorsContainer
  • func (pcs *ProcessComponentsStub) IsInterfaceNil() bool
  • func (pcs *ProcessComponentsStub) NodeRedundancyHandler() consensus.NodeRedundancyHandler
  • func (pcs *ProcessComponentsStub) NodesCoordinator() sharding.NodesCoordinator
  • func (pcs *ProcessComponentsStub) PeerShardMapper() process.NetworkShardingCollector
  • func (pcs *ProcessComponentsStub) PendingMiniBlocksHandler() process.PendingMiniBlocksHandler
  • func (pcs *ProcessComponentsStub) RequestHandler() process.RequestHandler
  • func (pcs *ProcessComponentsStub) RequestedItemsHandler() dataRetriever.RequestedItemsHandler
  • func (pcs *ProcessComponentsStub) ResolversFinder() dataRetriever.ResolversFinder
  • func (pcs *ProcessComponentsStub) RoundHandler() consensus.RoundHandler
  • func (pcs *ProcessComponentsStub) ShardCoordinator() sharding.Coordinator
  • func (pcs *ProcessComponentsStub) TransactionSimulatorProcessor() factory.TransactionSimulatorProcessor
  • func (pcs *ProcessComponentsStub) TxLogsProcessor() process.TransactionLogProcessorDatabase
  • func (pcs *ProcessComponentsStub) ValidatorsProvider() process.ValidatorsProvider
  • func (pcs *ProcessComponentsStub) ValidatorsStatistics() process.ValidatorStatisticsProcessor
  • func (pcs *ProcessComponentsStub) WhiteListHandler() process.WhiteListHandler
  • func (pcs *ProcessComponentsStub) WhiteListerVerifiedTxs() process.WhiteListHandler
• type PublicKeyMock
  • func (sspk *PublicKeyMock) IsInterfaceNil() bool
  • func (sspk *PublicKeyMock) Point() crypto.Point
  • func (sspk *PublicKeyMock) Suite() crypto.Suite
  • func (sspk *PublicKeyMock) ToByteArray() ([]byte, error)
• type RaterMock
  • func (rm *RaterMock) ComputeDecreaseProposer(shardId uint32, currentRating uint32, consecutiveMisses uint32) uint32
  • func (rm *RaterMock) ComputeDecreaseValidator(shardId uint32, currentRating uint32) uint32
  • func (rm *RaterMock) ComputeIncreaseProposer(shardId uint32, currentRating uint32) uint32
  • func (rm *RaterMock) ComputeIncreaseValidator(shardId uint32, currentRating uint32) uint32
  • func (rm *RaterMock) GetChance(rating uint32) uint32
  • func (rm *RaterMock) GetRating(pk string) uint32
  • func (rm *RaterMock) GetSignedBlocksThreshold() float32
  • func (rm *RaterMock) GetStartRating() uint32
  • func (rm *RaterMock) IsInterfaceNil() bool
  • func (rm *RaterMock) RevertIncreaseValidator(shardId uint32, currentRating uint32, nrReverts uint32) uint32
• type RatingReaderMock
  • func (rrm *RatingReaderMock) GetRating(pk string) uint32
  • func (rrm *RatingReaderMock) IsInterfaceNil() bool
• type RedundancyHandlerStub
  • func (rhs *RedundancyHandlerStub) AdjustInactivityIfNeeded(selfPubKey string, consensusPubKeys []string, roundIndex int64)
  • func (rhs *RedundancyHandlerStub) IsInterfaceNil() bool
  • func (rhs *RedundancyHandlerStub) IsMainMachineActive() bool
  • func (rhs *RedundancyHandlerStub) IsRedundancyNode() bool
  • func (rhs *RedundancyHandlerStub) ObserverPrivateKey() crypto.PrivateKey
  • func (rhs *RedundancyHandlerStub) ResetInactivityIfNeeded(selfPubKey string, consensusMsgPubKey string, consensusMsgPeerID core.PeerID)
• type RequestedItemsHandlerStub
  • func (rihs *RequestedItemsHandlerStub) Add(key string) error
  • func (rihs *RequestedItemsHandlerStub) Has(key string) bool
  • func (rihs *RequestedItemsHandlerStub) IsInterfaceNil() bool
  • func (rihs *RequestedItemsHandlerStub) Sweep()
• type ResolversContainerStub
  • func (rcs *ResolversContainerStub) Add(key string, val dataRetriever.Resolver) error
  • func (rcs *ResolversContainerStub) AddMultiple(_ []string, _ []dataRetriever.Resolver) error
  • func (rcs *ResolversContainerStub) Close() error
  • func (rcs *ResolversContainerStub) Get(key string) (dataRetriever.Resolver, error)
  • func (rcs *ResolversContainerStub) IsInterfaceNil() bool
  • func (rcs *ResolversContainerStub) Iterate(handler func(key string, resolver dataRetriever.Resolver) bool)
  • func (rcs *ResolversContainerStub) Len() int
  • func (rcs *ResolversContainerStub) Remove(key string)
  • func (rcs *ResolversContainerStub) Replace(key string, val dataRetriever.Resolver) error
  • func (rcs *ResolversContainerStub) ResolverKeys() string
• type ResolversFinderStub
  • func (rfs *ResolversFinderStub) CrossShardResolver(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)
  • func (rfs *ResolversFinderStub) IntraShardResolver(baseTopic string) (dataRetriever.Resolver, error)
  • func (rfs *ResolversFinderStub) MetaChainResolver(baseTopic string) (dataRetriever.Resolver, error)
  • func (rfs *ResolversFinderStub) MetaCrossShardResolver(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)
• type RoundHandlerMock
  • func (rndm *RoundHandlerMock) BeforeGenesis() bool
  • func (rm *RoundHandlerMock) Index() int64
  • func (rm *RoundHandlerMock) IsInterfaceNil() bool
  • func (rm *RoundHandlerMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration
  • func (rm *RoundHandlerMock) TimeDuration() time.Duration
  • func (rm *RoundHandlerMock) TimeStamp() time.Time
  • func (rm *RoundHandlerMock) UpdateRound(time.Time, time.Time)
• type SCToProtocolStub
  • func (s *SCToProtocolStub) IsInterfaceNil() bool
  • func (s *SCToProtocolStub) UpdateProtocol(body *block.Body, nonce uint64) error
• type ScQueryStub
  • func (s *ScQueryStub) ComputeScCallGasLimit(tx *transaction.Transaction) (uint64, error)
  • func (s *ScQueryStub) ExecuteQuery(query *process.SCQuery) (*vmcommon.VMOutput, error)
  • func (s *ScQueryStub) IsInterfaceNil() bool
• type ShuffledOutHandlerStub
  • func (s *ShuffledOutHandlerStub) CurrentShardID() uint32
  • func (s *ShuffledOutHandlerStub) IsInterfaceNil() bool
  • func (s *ShuffledOutHandlerStub) Process(newShardID uint32) error
  • func (s *ShuffledOutHandlerStub) RegisterHandler(handler func(newShardID uint32))
• type SignerMock
  • func (s *SignerMock) IsInterfaceNil() bool
  • func (s *SignerMock) Sign(private crypto.PrivateKey, msg []byte) ([]byte, error)
  • func (s *SignerMock) Verify(public crypto.PublicKey, msg []byte, sig []byte) error
• type SmartContractParserStub
  • func (scps *SmartContractParserStub) GetDeployedSCAddresses(scType string) (map[string]struct{}, error)
  • func (scps *SmartContractParserStub) InitialSmartContracts() []genesis.InitialSmartContractHandler
  • func (scps *SmartContractParserStub) InitialSmartContractsSplitOnOwnersShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialSmartContractHandler, error)
  • func (scps *SmartContractParserStub) IsInterfaceNil() bool
• type SoftwareVersionCheckerMock
  • func (svcm *SoftwareVersionCheckerMock) Close() error
  • func (svcm *SoftwareVersionCheckerMock) IsInterfaceNil() bool
  • func (svcm *SoftwareVersionCheckerMock) StartCheckSoftwareVersion()
• type StatusComponentsStub
  • func (scs *StatusComponentsStub) CheckSubcomponents() error
  • func (scs *StatusComponentsStub) Close() error
  • func (scs *StatusComponentsStub) Create() error
  • func (scs *StatusComponentsStub) IsInterfaceNil() bool
  • func (scs *StatusComponentsStub) OutportHandler() outport.OutportHandler
  • func (scs *StatusComponentsStub) SoftwareVersionChecker() statistics.SoftwareVersionChecker
• type StatusMetricsStub
  • func (sms *StatusMetricsStub) ConfigMetrics() map[string]interface{}
  • func (sms *StatusMetricsStub) EconomicsMetrics() map[string]interface{}
  • func (sms *StatusMetricsStub) EnableEpochsMetrics() map[string]interface{}
  • func (sms *StatusMetricsStub) IsInterfaceNil() bool
  • func (sms *StatusMetricsStub) NetworkMetrics() map[string]interface{}
  • func (sms *StatusMetricsStub) StatusMetricsMapWithoutP2P() map[string]interface{}
  • func (sms *StatusMetricsStub) StatusMetricsWithoutP2PPrometheusString() string
  • func (sms *StatusMetricsStub) StatusP2pMetricsMap() map[string]interface{}
• type StorageBootstrapperMock
  • func (sbm *StorageBootstrapperMock) GetHighestBlockNonce() uint64
  • func (sbm *StorageBootstrapperMock) IsInterfaceNil() bool
  • func (sbm *StorageBootstrapperMock) LoadFromStorage() error
• type StorageManagerStub
  • func (sms *StorageManagerStub) Close() error
  • func (sms *StorageManagerStub) Database() common.DBWriteCacher
  • func (sms *StorageManagerStub) EnterPruningBufferingMode()
  • func (sms *StorageManagerStub) ExitPruningBufferingMode()
  • func (sms *StorageManagerStub) GetSnapshotDbBatchDelay() int
  • func (sms *StorageManagerStub) GetSnapshotThatContainsHash(d []byte) common.SnapshotDbHandler
  • func (sms *StorageManagerStub) IsInterfaceNil() bool
  • func (sms *StorageManagerStub) IsPruningBlocked() bool
  • func (sms *StorageManagerStub) IsPruningEnabled() bool
  • func (sms *StorageManagerStub) SetCheckpoint([]byte)
  • func (sms *StorageManagerStub) TakeSnapshot([]byte)
• type StorerMock
  • func NewStorerMock() *StorerMock
  • func (sm *StorerMock) ClearCache()
  • func (sm *StorerMock) Close() error
  • func (sm *StorerMock) DestroyUnit() error
  • func (sm *StorerMock) Get(key []byte) ([]byte, error)
  • func (sm *StorerMock) GetBulkFromEpoch(keys [][]byte, _ uint32) (map[string][]byte, error)
  • func (sm *StorerMock) GetFromEpoch(key []byte, _ uint32) ([]byte, error)
  • func (sm *StorerMock) GetOldestEpoch() (uint32, error)
  • func (sm *StorerMock) Has(_ []byte) error
  • func (sm *StorerMock) IsInterfaceNil() bool
  • func (sm *StorerMock) Put(key, data []byte) error
  • func (sm *StorerMock) PutInEpoch(key, data []byte, _ uint32) error
  • func (sm *StorerMock) RangeKeys(_ func(key []byte, val []byte) bool)
  • func (sm *StorerMock) Remove(_ []byte) error
  • func (sm *StorerMock) SearchFirst(_ []byte) ([]byte, error)
• type SyncTimerMock
  • func (stm *SyncTimerMock) ClockOffset() time.Duration
  • func (stm *SyncTimerMock) Close() error
  • func (stm *SyncTimerMock) CurrentTime() time.Time
  • func (stm *SyncTimerMock) FormattedCurrentTime() string
  • func (stm *SyncTimerMock) IsInterfaceNil() bool
  • func (stm *SyncTimerMock) StartSyncingTime()
• type TimeCacheStub
  • func (tcs *TimeCacheStub) Add(key string) error
  • func (tcs *TimeCacheStub) Has(key string) bool
  • func (tcs *TimeCacheStub) IsInterfaceNil() bool
  • func (tcs *TimeCacheStub) Len() int
  • func (tcs *TimeCacheStub) Sweep()
  • func (tcs *TimeCacheStub) Upsert(key string, span time.Duration) error
• type TopicAntiFloodStub
  • func (t *TopicAntiFloodStub) IncreaseLoad(pid core.PeerID, topic string, numMessages uint32) error
  • func (t *TopicAntiFloodStub) IsInterfaceNil() bool
  • func (t *TopicAntiFloodStub) ResetForNotRegisteredTopics()
  • func (t *TopicAntiFloodStub) ResetForTopic(_ string)
  • func (t *TopicAntiFloodStub) SetMaxMessagesForTopic(_ string, _ uint32)
• type TransactionCoordinatorMock
  • func (tcm *TransactionCoordinatorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
  • func (tcm *TransactionCoordinatorMock) CreateBlockStarted()
  • func (tcm *TransactionCoordinatorMock) CreateMarshalizedData(body *block.Body) map[string][][]byte
  • func (tcm *TransactionCoordinatorMock) CreateMarshalizedReceipts() ([]byte, error)
  • func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, ...) (block.MiniBlockSlice, uint32, bool, error)
  • func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe(haveTime func() bool) block.MiniBlockSlice
  • func (tcm *TransactionCoordinatorMock) CreatePostProcessMiniBlocks() block.MiniBlockSlice
  • func (tcm *TransactionCoordinatorMock) CreateReceiptsHash() ([]byte, error)
  • func (tcm *TransactionCoordinatorMock) GetAllCurrentLogs() map[string]data.LogHandler
  • func (tcm *TransactionCoordinatorMock) GetAllCurrentUsedTxs(blockType block.Type) map[string]data.TransactionHandler
  • func (tcm *TransactionCoordinatorMock) IsDataPreparedForProcessing(haveTime func() time.Duration) error
  • func (tcm *TransactionCoordinatorMock) IsInterfaceNil() bool
  • func (tcm *TransactionCoordinatorMock) ProcessBlockTransaction(body *block.Body, haveTime func() time.Duration) error
  • func (tcm *TransactionCoordinatorMock) RemoveBlockDataFromPool(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) RemoveTxsFromPool(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) RequestBlockTransactions(body *block.Body)
  • func (tcm *TransactionCoordinatorMock) RequestMiniBlocks(header data.HeaderHandler)
  • func (tcm *TransactionCoordinatorMock) RestoreBlockDataFromStorage(body *block.Body) (int, error)
  • func (tcm *TransactionCoordinatorMock) SaveTxsToStorage(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) VerifyCreatedBlockTransactions(hdr data.HeaderHandler, body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) VerifyCreatedMiniBlocks(hdr data.HeaderHandler, body *block.Body) error
• type TransactionSimulatorStub
  • func (tss *TransactionSimulatorStub) IsInterfaceNil() bool
  • func (tss *TransactionSimulatorStub) ProcessTx(tx *transaction.Transaction) (*txSimData.SimulationResults, error)
• type TriesHolderStub
  • func (ths *TriesHolderStub) Get(key []byte) common.Trie
  • func (ths *TriesHolderStub) GetAll() []common.Trie
  • func (ths *TriesHolderStub) IsInterfaceNil() bool
  • func (ths *TriesHolderStub) Put(key []byte, trie common.Trie)
  • func (ths *TriesHolderStub) Replace(key []byte, trie common.Trie)
  • func (ths *TriesHolderStub) Reset()
• type TxForCurrentBlockStub
  • func (t *TxForCurrentBlockStub) AddTx(txHash []byte, tx data.TransactionHandler)
  • func (t *TxForCurrentBlockStub) Clean()
  • func (t *TxForCurrentBlockStub) GetTx(txHash []byte) (data.TransactionHandler, error)
  • func (t *TxForCurrentBlockStub) IsInterfaceNil() bool
• type TxLogProcessorMock
  • func (t *TxLogProcessorMock) Clean()
  • func (t *TxLogProcessorMock) EnableLogToBeSavedInCache()
  • func (t *TxLogProcessorMock) GetLogFromCache(_ []byte) (data.LogHandler, bool)
  • func (t *TxLogProcessorMock) IsInterfaceNil() bool
• type TxLogsProcessorStub
  • func (txls *TxLogsProcessorStub) Clean()
  • func (txls *TxLogsProcessorStub) GetAllCurrentLogs() map[string]data.LogHandler
  • func (txls *TxLogsProcessorStub) GetLog(txHash []byte) (data.LogHandler, error)
  • func (txls *TxLogsProcessorStub) IsInterfaceNil() bool
  • func (txls *TxLogsProcessorStub) SaveLog(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error
• type Uint64ByteSliceConverterMock
  • func (u *Uint64ByteSliceConverterMock) IsInterfaceNil() bool
  • func (u *Uint64ByteSliceConverterMock) ToByteSlice(p uint64) []byte
  • func (u *Uint64ByteSliceConverterMock) ToUint64(p []byte) (uint64, error)
• type UnitOpenerStub
  • func (u *UnitOpenerStub) GetMostRecentBootstrapStorageUnit() (storage.Storer, error)
  • func (u *UnitOpenerStub) IsInterfaceNil() bool
• type VMContainerMock
  • func (vmc *VMContainerMock) Add(key []byte, val vmcommon.VMExecutionHandler) error
  • func (vmc *VMContainerMock) AddMultiple(keys [][]byte, vms []vmcommon.VMExecutionHandler) error
  • func (V *VMContainerMock) Close() error
  • func (vmc *VMContainerMock) Get(key []byte) (vmcommon.VMExecutionHandler, error)
  • func (vmc *VMContainerMock) IsInterfaceNil() bool
  • func (vmc *VMContainerMock) Keys() [][]byte
  • func (vmc *VMContainerMock) Len() int
  • func (vmc *VMContainerMock) Remove(key []byte)
  • func (vmc *VMContainerMock) Replace(key []byte, val vmcommon.VMExecutionHandler) error
• type VMExecutionHandlerStub
  • func (vm *VMExecutionHandlerStub) GasScheduleChange(gasSchedule map[string]map[string]uint64)
  • func (vm *VMExecutionHandlerStub) GetVersion() string
  • func (vm *VMExecutionHandlerStub) IsInterfaceNil() bool
  • func (vm *VMExecutionHandlerStub) RunSmartContractCall(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
  • func (vm *VMExecutionHandlerStub) RunSmartContractCreate(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)
• type ValidatorInfoSyncerStub
  • func (vip *ValidatorInfoSyncerStub) IsInterfaceNil() bool
  • func (vip *ValidatorInfoSyncerStub) SyncMiniBlocks(*block.MetaBlock) ([][]byte, data.BodyHandler, error)
• type ValidatorStatisticsProcessorStub
  • func (vsp *ValidatorStatisticsProcessorStub) Commit() ([]byte, error)
  • func (vsp *ValidatorStatisticsProcessorStub) DisplayRatings(_ uint32)
  • func (vsp *ValidatorStatisticsProcessorStub) GetExistingPeerAccount(address []byte) (state.PeerAccountHandler, error)
  • func (vsp *ValidatorStatisticsProcessorStub) GetValidatorInfoForRootHash(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)
  • func (vsp *ValidatorStatisticsProcessorStub) IsInterfaceNil() bool
  • func (vsp *ValidatorStatisticsProcessorStub) LastFinalizedRootHash() []byte
  • func (vsp *ValidatorStatisticsProcessorStub) PeerAccountToValidatorInfo(peerAccount state.PeerAccountHandler) *state.ValidatorInfo
  • func (vsp *ValidatorStatisticsProcessorStub) Process(validatorInfo data.ShardValidatorInfoHandler) error
  • func (vsp *ValidatorStatisticsProcessorStub) ProcessRatingsEndOfEpoch(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error
  • func (vsp *ValidatorStatisticsProcessorStub) ResetValidatorStatisticsAtNewEpoch(vInfos map[uint32][]*state.ValidatorInfo) error
  • func (vsp *ValidatorStatisticsProcessorStub) RevertPeerState(header data.HeaderHandler) error
  • func (vsp *ValidatorStatisticsProcessorStub) RootHash() ([]byte, error)
  • func (vsp *ValidatorStatisticsProcessorStub) SaveNodesCoordinatorUpdates(epoch uint32) (bool, error)
  • func (vsp *ValidatorStatisticsProcessorStub) SetLastFinalizedRootHash(_ []byte)
  • func (vsp *ValidatorStatisticsProcessorStub) UpdatePeerState(header data.HeaderHandler, _ map[string]data.HeaderHandler) ([]byte, error)
• type ValidatorsProviderStub
  • func (vp *ValidatorsProviderStub) Close() error
  • func (vp *ValidatorsProviderStub) GetLatestValidators() map[string]*state.ValidatorApiResponse
  • func (vp *ValidatorsProviderStub) IsInterfaceNil() bool
• type VmMachinesContainerFactoryMock
  • func (v *VmMachinesContainerFactoryMock) BlockChainHookImpl() process.BlockChainHookHandler
  • func (v *VmMachinesContainerFactoryMock) Close() error
  • func (v *VmMachinesContainerFactoryMock) Create() (process.VirtualMachinesContainer, error)
  • func (v *VmMachinesContainerFactoryMock) IsInterfaceNil() bool
• type WatchdogMock
  • func (w *WatchdogMock) IsInterfaceNil() bool
  • func (w *WatchdogMock) Reset(alarmID string)
  • func (w *WatchdogMock) Set(callback func(alarmID string), duration time.Duration, alarmID string)
  • func (w *WatchdogMock) SetDefault(duration time.Duration, alarmID string)
  • func (w *WatchdogMock) Stop(alarmID string)

Functions

func NewCountingDB

func NewCountingDB() *countingDB

NewCountingDB returns a new instance of countingDB

func NewMultiShardsCoordinatorMock

func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock

NewMultiShardsCoordinatorMock -

func NewNetworkShardingCollectorMock

func NewNetworkShardingCollectorMock() *networkShardingCollectorMock

NewNetworkShardingCollectorMock -

func NewNilOutport

func NewNilOutport() *nilOutport

NewNilOutport -

func NewNodesHandlerMock

func NewNodesHandlerMock(
	initialNodesSetup genesis.InitialNodesHandler,
) (*nodesHandlerMock, error)

NewNodesHandlerMock -

Types

type AccountsDBSyncerStub

type AccountsDBSyncerStub struct {
	GetSyncedTriesCalled func() map[string]common.Trie
	SyncAccountsCalled   func(rootHash []byte) error
}

AccountsDBSyncerStub -

func (*AccountsDBSyncerStub) GetSyncedTries

func (a *AccountsDBSyncerStub) GetSyncedTries() map[string]common.Trie

GetSyncedTries -

func (*AccountsDBSyncerStub) IsInterfaceNil

func (a *AccountsDBSyncerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*AccountsDBSyncerStub) SyncAccounts

func (a *AccountsDBSyncerStub) SyncAccounts(rootHash []byte) error

SyncAccounts -

type AccountsFactoryStub

type AccountsFactoryStub struct {
	CreateAccountCalled func(address []byte) (vmcommon.AccountHandler, error)
}

AccountsFactoryStub -

func (*AccountsFactoryStub) CreateAccount

func (afs *AccountsFactoryStub) CreateAccount(address []byte) (vmcommon.AccountHandler, error)

CreateAccount -

func (*AccountsFactoryStub) IsInterfaceNil

func (afs *AccountsFactoryStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type AccountsParserStub

type AccountsParserStub struct {
	InitialAccountsSplitOnAddressesShardsCalled           func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)
	InitialAccountsSplitOnDelegationAddressesShardsCalled func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)
	InitialAccountsCalled                                 func() []genesis.InitialAccountHandler
	GetTotalStakedForDelegationAddressCalled              func(delegationAddress string) *big.Int
	GetInitialAccountsForDelegatedCalled                  func(addressBytes []byte) []genesis.InitialAccountHandler
}

AccountsParserStub -

func (*AccountsParserStub) GetInitialAccountsForDelegated

func (aps *AccountsParserStub) GetInitialAccountsForDelegated(addressBytes []byte) []genesis.InitialAccountHandler

GetInitialAccountsForDelegated -

func (*AccountsParserStub) GetTotalStakedForDelegationAddress

func (aps *AccountsParserStub) GetTotalStakedForDelegationAddress(delegationAddress string) *big.Int

GetTotalStakedForDelegationAddress -

func (*AccountsParserStub) InitialAccounts

func (aps *AccountsParserStub) InitialAccounts() []genesis.InitialAccountHandler

InitialAccounts -

func (*AccountsParserStub) InitialAccountsSplitOnAddressesShards

func (aps *AccountsParserStub) InitialAccountsSplitOnAddressesShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)

InitialAccountsSplitOnAddressesShards -

func (*AccountsParserStub) InitialAccountsSplitOnDelegationAddressesShards

func (aps *AccountsParserStub) InitialAccountsSplitOnDelegationAddressesShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)

InitialAccountsSplitOnDelegationAddressesShards -

func (*AccountsParserStub) IsInterfaceNil

func (aps *AccountsParserStub) IsInterfaceNil() bool

IsInterfaceNil -

type AppStatusHandlerStub

type AppStatusHandlerStub struct {
	AddUint64Handler      func(key string, value uint64)
	IncrementHandler      func(key string)
	DecrementHandler      func(key string)
	SetUInt64ValueHandler func(key string, value uint64)
	SetInt64ValueHandler  func(key string, value int64)
	SetStringValueHandler func(key string, value string)
	CloseHandler          func()
}

AppStatusHandlerStub is a stub implementation of AppStatusHandler

func (*AppStatusHandlerStub) AddUint64

func (ashs *AppStatusHandlerStub) AddUint64(key string, value uint64)

AddUint64 will call the handler of the stub for incrementing

func (*AppStatusHandlerStub) Close

func (ashs *AppStatusHandlerStub) Close()

Close will call the handler of the stub for closing

func (*AppStatusHandlerStub) Decrement

func (ashs *AppStatusHandlerStub) Decrement(key string)

Decrement will call the handler of the stub for decrementing

func (*AppStatusHandlerStub) Increment

func (ashs *AppStatusHandlerStub) Increment(key string)

Increment will call the handler of the stub for incrementing

func (*AppStatusHandlerStub) IsInterfaceNil

func (ashs *AppStatusHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*AppStatusHandlerStub) SetInt64Value

func (ashs *AppStatusHandlerStub) SetInt64Value(key string, value int64)

SetInt64Value will call the handler of the stub for setting an int64 value

func (*AppStatusHandlerStub) SetStringValue

func (ashs *AppStatusHandlerStub) SetStringValue(key string, value string)

SetStringValue will call the handler of the stub for setting an string value

func (*AppStatusHandlerStub) SetUInt64Value

func (ashs *AppStatusHandlerStub) SetUInt64Value(key string, value uint64)

SetUInt64Value will call the handler of the stub for setting an uint64 value

type BlackListHandlerStub

type BlackListHandlerStub struct {
	AddCalled         func(key string) error
	AddWithSpanCalled func(key string, span time.Duration) error
	HasCalled         func(key string) bool
	SweepCalled       func()
}

BlackListHandlerStub -

func (*BlackListHandlerStub) Add

func (blhs *BlackListHandlerStub) Add(key string) error

Add -

func (*BlackListHandlerStub) AddWithSpan

func (blhs *BlackListHandlerStub) AddWithSpan(key string, span time.Duration) error

AddWithSpan -

func (*BlackListHandlerStub) Has

func (blhs *BlackListHandlerStub) Has(key string) bool

Has -

func (*BlackListHandlerStub) IsInterfaceNil

func (blhs *BlackListHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlackListHandlerStub) Sweep

func (blhs *BlackListHandlerStub) Sweep()

Sweep -

type BlockChainHookHandlerMock

type BlockChainHookHandlerMock struct {
	SetCurrentHeaderCalled       func(hdr data.HeaderHandler)
	NewAddressCalled             func(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)
	IsPayableCalled              func(address []byte) (bool, error)
	DeleteCompiledCodeCalled     func(codeHash []byte)
	ProcessBuiltInFunctionCalled func(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
}

BlockChainHookHandlerMock -

func (*BlockChainHookHandlerMock) DeleteCompiledCode

func (e *BlockChainHookHandlerMock) DeleteCompiledCode(codeHash []byte)

DeleteCompiledCode -

func (*BlockChainHookHandlerMock) IsInterfaceNil

func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockChainHookHandlerMock) IsPayable

func (e *BlockChainHookHandlerMock) IsPayable(address []byte) (bool, error)

IsPayable -

func (*BlockChainHookHandlerMock) NewAddress

func (e *BlockChainHookHandlerMock) NewAddress(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)

NewAddress -

func (*BlockChainHookHandlerMock) ProcessBuiltInFunction

func (e *BlockChainHookHandlerMock) ProcessBuiltInFunction(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)

ProcessBuiltInFunction -

func (*BlockChainHookHandlerMock) SetCurrentHeader

func (e *BlockChainHookHandlerMock) SetCurrentHeader(hdr data.HeaderHandler)

SetCurrentHeader -

type BlockChainMock

type BlockChainMock struct {
	GetGenesisHeaderCalled          func() data.HeaderHandler
	SetGenesisHeaderCalled          func(handler data.HeaderHandler) error
	GetGenesisHeaderHashCalled      func() []byte
	SetGenesisHeaderHashCalled      func([]byte)
	GetCurrentBlockHeaderCalled     func() data.HeaderHandler
	SetCurrentBlockHeaderCalled     func(data.HeaderHandler) error
	GetCurrentBlockHeaderHashCalled func() []byte
	SetCurrentBlockHeaderHashCalled func([]byte)
	GetLocalHeightCalled            func() int64
	SetLocalHeightCalled            func(int64)
	GetNetworkHeightCalled          func() int64
	SetNetworkHeightCalled          func(int64)
	HasBadBlockCalled               func([]byte) bool
	PutBadBlockCalled               func([]byte)
	CreateNewHeaderCalled           func() data.HeaderHandler
}

BlockChainMock is a mock implementation of the blockchain interface

func (*BlockChainMock) CreateNewHeader

func (bc *BlockChainMock) CreateNewHeader() data.HeaderHandler

CreateNewHeader -

func (*BlockChainMock) GetCurrentBlockHeader

func (bc *BlockChainMock) GetCurrentBlockHeader() data.HeaderHandler

GetCurrentBlockHeader returns current block header pointer

func (*BlockChainMock) GetCurrentBlockHeaderHash

func (bc *BlockChainMock) GetCurrentBlockHeaderHash() []byte

GetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) GetGenesisHeader

func (bc *BlockChainMock) GetGenesisHeader() data.HeaderHandler

GetGenesisHeader returns the genesis block header pointer

func (*BlockChainMock) GetGenesisHeaderHash

func (bc *BlockChainMock) GetGenesisHeaderHash() []byte

GetGenesisHeaderHash returns the genesis block header hash

func (*BlockChainMock) IsInterfaceNil

func (bc *BlockChainMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockChainMock) SetCurrentBlockHeader

func (bc *BlockChainMock) SetCurrentBlockHeader(header data.HeaderHandler) error

SetCurrentBlockHeader sets current block header pointer

func (*BlockChainMock) SetCurrentBlockHeaderHash

func (bc *BlockChainMock) SetCurrentBlockHeaderHash(hash []byte)

SetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) SetGenesisHeader

func (bc *BlockChainMock) SetGenesisHeader(genesisBlock data.HeaderHandler) error

SetGenesisHeader sets the genesis block header pointer

func (*BlockChainMock) SetGenesisHeaderHash

func (bc *BlockChainMock) SetGenesisHeaderHash(hash []byte)

SetGenesisHeaderHash sets the genesis block header hash

type BlockProcessorMock

type BlockProcessorMock struct {
	NrCommitBlockCalled                     uint32
	Marshalizer                             marshal.Marshalizer
	ProcessBlockCalled                      func(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error
	CommitBlockCalled                       func(header data.HeaderHandler, body data.BodyHandler) error
	RevertAccountStateCalled                func(header data.HeaderHandler)
	CreateBlockCalled                       func(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)
	RestoreBlockIntoPoolsCalled             func(header data.HeaderHandler, body data.BodyHandler) error
	MarshalizedDataToBroadcastCalled        func(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error)
	DecodeBlockBodyCalled                   func(dta []byte) data.BodyHandler
	DecodeBlockHeaderCalled                 func(dta []byte) data.HeaderHandler
	AddLastNotarizedHdrCalled               func(shardId uint32, processedHdr data.HeaderHandler)
	CreateNewHeaderCalled                   func(round uint64, nonce uint64) data.HeaderHandler
	PruneStateOnRollbackCalled              func(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)
	RestoreLastNotarizedHrdsToGenesisCalled func()
	RevertStateToBlockCalled                func(header data.HeaderHandler) error
	RevertIndexedBlockCalled                func(header data.HeaderHandler)
}

BlockProcessorMock mocks the implementation for a blockProcessor

func (*BlockProcessorMock) AddLastNotarizedHdr

func (bpm *BlockProcessorMock) AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler)

AddLastNotarizedHdr -

func (*BlockProcessorMock) ApplyProcessedMiniBlocks

func (bpm *BlockProcessorMock) ApplyProcessedMiniBlocks(_ *processedMb.ProcessedMiniBlockTracker)

ApplyProcessedMiniBlocks -

func (*BlockProcessorMock) Close

func (bpm *BlockProcessorMock) Close() error

Close -

func (*BlockProcessorMock) CommitBlock

func (bpm *BlockProcessorMock) CommitBlock(header data.HeaderHandler, body data.BodyHandler) error

CommitBlock mocks the commit of a block

func (*BlockProcessorMock) CreateBlock

func (bpm *BlockProcessorMock) CreateBlock(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)

CreateBlock -

func (*BlockProcessorMock) CreateNewHeader

func (bpm *BlockProcessorMock) CreateNewHeader(round uint64, nonce uint64) data.HeaderHandler

CreateNewHeader -

func (*BlockProcessorMock) DecodeBlockBody

func (bpm *BlockProcessorMock) DecodeBlockBody(dta []byte) data.BodyHandler

DecodeBlockBody method decodes block body from a given byte array

func (*BlockProcessorMock) DecodeBlockHeader

func (bpm *BlockProcessorMock) DecodeBlockHeader(dta []byte) data.HeaderHandler

DecodeBlockHeader method decodes block header from a given byte array

func (*BlockProcessorMock) IsInterfaceNil

func (bpm *BlockProcessorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockProcessorMock) MarshalizedDataToBroadcast

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

MarshalizedDataToBroadcast -

func (*BlockProcessorMock) ProcessBlock

func (bpm *BlockProcessorMock) ProcessBlock(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error

ProcessBlock mocks pocessing a block

func (*BlockProcessorMock) PruneStateOnRollback

func (bpm *BlockProcessorMock) PruneStateOnRollback(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)

PruneStateOnRollback recreates the state tries to the root hashes indicated by the provided header

func (*BlockProcessorMock) RestoreBlockIntoPools

func (bpm *BlockProcessorMock) RestoreBlockIntoPools(header data.HeaderHandler, body data.BodyHandler) error

RestoreBlockIntoPools -

func (*BlockProcessorMock) RestoreLastNotarizedHrdsToGenesis

func (bpm *BlockProcessorMock) RestoreLastNotarizedHrdsToGenesis()

RestoreLastNotarizedHrdsToGenesis -

func (*BlockProcessorMock) RevertAccountState

func (bpm *BlockProcessorMock) RevertAccountState(header data.HeaderHandler)

RevertAccountState mocks revert of the accounts state

func (*BlockProcessorMock) RevertIndexedBlock

func (bpm *BlockProcessorMock) RevertIndexedBlock(header data.HeaderHandler)

RevertIndexedBlock -

func (*BlockProcessorMock) RevertStateToBlock

func (bpm *BlockProcessorMock) RevertStateToBlock(header data.HeaderHandler) error

RevertStateToBlock recreates the state tries to the root hashes indicated by the provided header

func (*BlockProcessorMock) SetNumProcessedObj

func (bpm *BlockProcessorMock) SetNumProcessedObj(_ uint64)

SetNumProcessedObj -

type BlockSizeThrottlerStub

type BlockSizeThrottlerStub struct {
	GetCurrentMaxSizeCalled     func() uint32
	AddCalled                   func(round uint64, size uint32)
	SucceedCalled               func(round uint64)
	ComputeCurrentMaxSizeCalled func()
}

BlockSizeThrottlerStub -

func (*BlockSizeThrottlerStub) Add

func (bsts *BlockSizeThrottlerStub) Add(round uint64, size uint32)

Add -

func (*BlockSizeThrottlerStub) ComputeCurrentMaxSize

func (bsts *BlockSizeThrottlerStub) ComputeCurrentMaxSize()

ComputeCurrentMaxSize -

func (*BlockSizeThrottlerStub) GetCurrentMaxSize

func (bsts *BlockSizeThrottlerStub) GetCurrentMaxSize() uint32

GetCurrentMaxSize -

func (*BlockSizeThrottlerStub) IsInterfaceNil

func (bsts *BlockSizeThrottlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockSizeThrottlerStub) Succeed

func (bsts *BlockSizeThrottlerStub) Succeed(round uint64)

Succeed -

type BlockTrackerStub

type BlockTrackerStub struct {
	AddTrackedHeaderCalled                             func(header data.HeaderHandler, hash []byte)
	AddCrossNotarizedHeaderCalled                      func(shardID uint32, crossNotarizedHeader data.HeaderHandler, crossNotarizedHeaderHash []byte)
	AddSelfNotarizedHeaderCalled                       func(shardID uint32, selfNotarizedHeader data.HeaderHandler, selfNotarizedHeaderHash []byte)
	CheckBlockAgainstFinalCalled                       func(headerHandler data.HeaderHandler) error
	CheckBlockAgainstRoundHandlerCalled                func(headerHandler data.HeaderHandler) error
	CheckBlockAgainstWhitelistCalled                   func(interceptedData process.InterceptedData) bool
	CleanupHeadersBehindNonceCalled                    func(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)
	ComputeLongestChainCalled                          func(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)
	ComputeLongestMetaChainFromLastNotarizedCalled     func() ([]data.HeaderHandler, [][]byte, error)
	ComputeLongestShardsChainsFromLastNotarizedCalled  func() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)
	DisplayTrackedHeadersCalled                        func()
	GetCrossNotarizedHeaderCalled                      func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
	GetLastCrossNotarizedHeaderCalled                  func(shardID uint32) (data.HeaderHandler, []byte, error)
	GetLastCrossNotarizedHeadersForAllShardsCalled     func() (map[uint32]data.HeaderHandler, error)
	GetLastSelfNotarizedHeaderCalled                   func(shardID uint32) (data.HeaderHandler, []byte, error)
	GetSelfNotarizedHeaderCalled                       func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
	GetTrackedHeadersCalled                            func(shardID uint32) ([]data.HeaderHandler, [][]byte)
	GetTrackedHeadersForAllShardsCalled                func() map[uint32][]data.HeaderHandler
	GetTrackedHeadersWithNonceCalled                   func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
	IsShardStuckCalled                                 func(shardId uint32) bool
	RegisterCrossNotarizedHeadersHandlerCalled         func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RegisterSelfNotarizedFromCrossHeadersHandlerCalled func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RegisterSelfNotarizedHeadersHandlerCalled          func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RegisterFinalMetachainHeadersHandlerCalled         func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RemoveLastNotarizedHeadersCalled                   func()
	RestoreToGenesisCalled                             func()
	ShouldAddHeaderCalled                              func(headerHandler data.HeaderHandler) bool
}

BlockTrackerStub -

func (*BlockTrackerStub) AddCrossNotarizedHeader

func (bts *BlockTrackerStub) AddCrossNotarizedHeader(shardID uint32, crossNotarizedHeader data.HeaderHandler, crossNotarizedHeaderHash []byte)

AddCrossNotarizedHeader -

func (*BlockTrackerStub) AddSelfNotarizedHeader

func (bts *BlockTrackerStub) AddSelfNotarizedHeader(shardID uint32, selfNotarizedHeader data.HeaderHandler, selfNotarizedHeaderHash []byte)

AddSelfNotarizedHeader -

func (*BlockTrackerStub) AddTrackedHeader

func (bts *BlockTrackerStub) AddTrackedHeader(header data.HeaderHandler, hash []byte)

AddTrackedHeader -

func (*BlockTrackerStub) CheckBlockAgainstFinal

func (bts *BlockTrackerStub) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error

CheckBlockAgainstFinal -

func (*BlockTrackerStub) CheckBlockAgainstRoundHandler

func (bts *BlockTrackerStub) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error

CheckBlockAgainstRoundHandler -

func (*BlockTrackerStub) CheckBlockAgainstWhitelist

func (bts *BlockTrackerStub) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool

CheckBlockAgainstWhitelist -

func (*BlockTrackerStub) CleanupHeadersBehindNonce

func (bts *BlockTrackerStub) CleanupHeadersBehindNonce(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)

CleanupHeadersBehindNonce -

func (*BlockTrackerStub) CleanupInvalidCrossHeaders

func (bts *BlockTrackerStub) CleanupInvalidCrossHeaders(_ uint32, _ uint64)

CleanupInvalidCrossHeaders -

func (*BlockTrackerStub) ComputeLongestChain

func (bts *BlockTrackerStub) ComputeLongestChain(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)

ComputeLongestChain -

func (*BlockTrackerStub) ComputeLongestMetaChainFromLastNotarized

func (bts *BlockTrackerStub) ComputeLongestMetaChainFromLastNotarized() ([]data.HeaderHandler, [][]byte, error)

ComputeLongestMetaChainFromLastNotarized -

func (*BlockTrackerStub) ComputeLongestShardsChainsFromLastNotarized

func (bts *BlockTrackerStub) ComputeLongestShardsChainsFromLastNotarized() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)

ComputeLongestShardsChainsFromLastNotarized -

func (*BlockTrackerStub) DisplayTrackedHeaders

func (bts *BlockTrackerStub) DisplayTrackedHeaders()

DisplayTrackedHeaders -

func (*BlockTrackerStub) GetCrossNotarizedHeader

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

GetCrossNotarizedHeader -

func (*BlockTrackerStub) GetLastCrossNotarizedHeader

func (bts *BlockTrackerStub) GetLastCrossNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetLastCrossNotarizedHeader -

func (*BlockTrackerStub) GetLastCrossNotarizedHeadersForAllShards

func (bts *BlockTrackerStub) GetLastCrossNotarizedHeadersForAllShards() (map[uint32]data.HeaderHandler, error)

GetLastCrossNotarizedHeadersForAllShards -

func (*BlockTrackerStub) GetLastSelfNotarizedHeader

func (bts *BlockTrackerStub) GetLastSelfNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetLastSelfNotarizedHeader -

func (*BlockTrackerStub) GetSelfNotarizedHeader

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

GetSelfNotarizedHeader -

func (*BlockTrackerStub) GetTrackedHeaders

func (bts *BlockTrackerStub) GetTrackedHeaders(shardID uint32) ([]data.HeaderHandler, [][]byte)

GetTrackedHeaders -

func (*BlockTrackerStub) GetTrackedHeadersForAllShards

func (bts *BlockTrackerStub) GetTrackedHeadersForAllShards() map[uint32][]data.HeaderHandler

GetTrackedHeadersForAllShards -

func (*BlockTrackerStub) GetTrackedHeadersWithNonce

func (bts *BlockTrackerStub) GetTrackedHeadersWithNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)

GetTrackedHeadersWithNonce -

func (*BlockTrackerStub) IsInterfaceNil

func (bts *BlockTrackerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockTrackerStub) IsShardStuck

func (bts *BlockTrackerStub) IsShardStuck(shardId uint32) bool

IsShardStuck -

func (*BlockTrackerStub) RegisterCrossNotarizedHeadersHandler

func (bts *BlockTrackerStub) RegisterCrossNotarizedHeadersHandler(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

RegisterCrossNotarizedHeadersHandler -

func (*BlockTrackerStub) RegisterFinalMetachainHeadersHandler

func (bts *BlockTrackerStub) RegisterFinalMetachainHeadersHandler(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

RegisterFinalMetachainHeadersHandler -

func (*BlockTrackerStub) RegisterSelfNotarizedFromCrossHeadersHandler

func (bts *BlockTrackerStub) RegisterSelfNotarizedFromCrossHeadersHandler(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

RegisterSelfNotarizedFromCrossHeadersHandler -

func (*BlockTrackerStub) RegisterSelfNotarizedHeadersHandler

func (bts *BlockTrackerStub) RegisterSelfNotarizedHeadersHandler(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

RegisterSelfNotarizedHeadersHandler -

func (*BlockTrackerStub) RemoveLastNotarizedHeaders

func (bts *BlockTrackerStub) RemoveLastNotarizedHeaders()

RemoveLastNotarizedHeaders -

func (*BlockTrackerStub) RestoreToGenesis

func (bts *BlockTrackerStub) RestoreToGenesis()

RestoreToGenesis -

func (*BlockTrackerStub) ShouldAddHeader

func (bts *BlockTrackerStub) ShouldAddHeader(headerHandler data.HeaderHandler) bool

ShouldAddHeader -

type BoostrapStorerMock

type BoostrapStorerMock struct {
	PutCalled             func(round int64, bootData bootstrapStorage.BootstrapData) error
	GetCalled             func(round int64) (bootstrapStorage.BootstrapData, error)
	GetHighestRoundCalled func() int64
}

BoostrapStorerMock -

func (*BoostrapStorerMock) Get

func (bsm *BoostrapStorerMock) Get(round int64) (bootstrapStorage.BootstrapData, error)

Get -

func (*BoostrapStorerMock) GetHighestRound

func (bsm *BoostrapStorerMock) GetHighestRound() int64

GetHighestRound -

func (*BoostrapStorerMock) IsInterfaceNil

func (bsm *BoostrapStorerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BoostrapStorerMock) Put

func (bsm *BoostrapStorerMock) Put(round int64, bootData bootstrapStorage.BootstrapData) error

Put -

func (*BoostrapStorerMock) SaveLastRound

func (bsm *BoostrapStorerMock) SaveLastRound(_ int64) error

SaveLastRound -

type BuiltInCostHandlerStub

type BuiltInCostHandlerStub struct {
}

BuiltInCostHandlerStub -

func (*BuiltInCostHandlerStub) ComputeBuiltInCost

func (b *BuiltInCostHandlerStub) ComputeBuiltInCost(_ data.TransactionWithFeeHandler) uint64

ComputeBuiltInCost -

func (*BuiltInCostHandlerStub) IsBuiltInFuncCall

func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ data.TransactionWithFeeHandler) bool

IsBuiltInFuncCall -

func (*BuiltInCostHandlerStub) IsInterfaceNil

func (b *BuiltInCostHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type ChainStorerMock

type ChainStorerMock struct {
	AddStorerCalled     func(key dataRetriever.UnitType, s storage.Storer)
	GetStorerCalled     func(unitType dataRetriever.UnitType) storage.Storer
	HasCalled           func(unitType dataRetriever.UnitType, key []byte) error
	GetCalled           func(unitType dataRetriever.UnitType, key []byte) ([]byte, error)
	PutCalled           func(unitType dataRetriever.UnitType, key []byte, value []byte) error
	GetAllCalled        func(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)
	GetAllStorersCalled func() map[dataRetriever.UnitType]storage.Storer
	DestroyCalled       func() error
	CloseAllCalled      func() error
}

ChainStorerMock is a mock implementation of the ChainStorer interface

func (*ChainStorerMock) AddStorer

func (bc *ChainStorerMock) AddStorer(key dataRetriever.UnitType, s storage.Storer)

AddStorer will add a new storer to the chain map

func (*ChainStorerMock) CloseAll

func (bc *ChainStorerMock) CloseAll() error

CloseAll -

func (*ChainStorerMock) Destroy

func (bc *ChainStorerMock) Destroy() error

Destroy removes the underlying files/resources used by the storage service

func (*ChainStorerMock) Get

func (bc *ChainStorerMock) Get(unitType dataRetriever.UnitType, key []byte) ([]byte, error)

Get returns the value for the given key if found in the selected storage unit, nil otherwise. It can return an error if the provided unit type is not supported or if the storage unit underlying implementation reports an error

func (*ChainStorerMock) GetAll

func (bc *ChainStorerMock) GetAll(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)

GetAll gets all the elements with keys in the keys array, from the selected storage unit It can report an error if the provided unit type is not supported, if there is a missing key in the unit, or if the underlying implementation of the storage unit reports an error.

func (*ChainStorerMock) GetAllStorers

func (bc *ChainStorerMock) GetAllStorers() map[dataRetriever.UnitType]storage.Storer

GetAllStorers -

func (*ChainStorerMock) GetStorer

func (bc *ChainStorerMock) GetStorer(unitType dataRetriever.UnitType) storage.Storer

GetStorer returns the storer from the chain map or nil if the storer was not found

func (*ChainStorerMock) Has

func (bc *ChainStorerMock) Has(unitType dataRetriever.UnitType, key []byte) error

Has returns true if the key is found in the selected Unit or false otherwise It can return an error if the provided unit type is not supported or if the underlying implementation of the storage unit reports an error.

func (*ChainStorerMock) IsInterfaceNil

func (bc *ChainStorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ChainStorerMock) Put

func (bc *ChainStorerMock) Put(unitType dataRetriever.UnitType, key []byte, value []byte) error

Put stores the key, value pair in the selected storage unit It can return an error if the provided unit type is not supported or if the storage unit underlying implementation reports an error

func (*ChainStorerMock) SetEpochForPutOperation

func (bc *ChainStorerMock) SetEpochForPutOperation(_ uint32)

SetEpochForPutOperation won't do anything

type CoreComponentsStub

type CoreComponentsStub struct {
	InternalMarshalizerField           marshal.Marshalizer
	TxMarshalizerField                 marshal.Marshalizer
	VmMarshalizerField                 marshal.Marshalizer
	HasherField                        hashing.Hasher
	TxSignHasherField                  hashing.Hasher
	Uint64ByteSliceConverterField      typeConverters.Uint64ByteSliceConverter
	AddressPubKeyConverterField        core.PubkeyConverter
	ValidatorPubKeyConverterField      core.PubkeyConverter
	PathHandlerField                   storage.PathManagerHandler
	ChainIdCalled                      func() string
	MinTransactionVersionCalled        func() uint32
	StatusHandlerUtilsField            nodeFactory.StatusHandlersUtils
	StatusHandlerField                 core.AppStatusHandler
	WatchdogField                      core.WatchdogTimer
	AlarmSchedulerField                core.TimersScheduler
	SyncTimerField                     ntp.SyncTimer
	RoundHandlerField                  consensus.RoundHandler
	EconomicsDataField                 process.EconomicsDataHandler
	RatingsDataField                   process.RatingsInfoHandler
	RaterField                         sharding.PeerAccountListAndRatingHandler
	GenesisNodesSetupField             sharding.GenesisNodesSetupHandler
	NodesShufflerField                 sharding.NodesShuffler
	EpochNotifierField                 process.EpochNotifier
	EpochStartNotifierWithConfirmField factory.EpochStartNotifierWithConfirm
	ChanStopNodeProcessField           chan endProcess.ArgEndProcess
	GenesisTimeField                   time.Time
	TxVersionCheckField                process.TxVersionCheckerHandler
	NodeTypeProviderField              core.NodeTypeProviderHandler
}

CoreComponentsStub -

func (*CoreComponentsStub) AddressPubKeyConverter

func (ccs *CoreComponentsStub) AddressPubKeyConverter() core.PubkeyConverter

AddressPubKeyConverter -

func (*CoreComponentsStub) AlarmScheduler

func (ccs *CoreComponentsStub) AlarmScheduler() core.TimersScheduler

AlarmScheduler -

func (*CoreComponentsStub) ChainID

func (ccs *CoreComponentsStub) ChainID() string

ChainID -

func (*CoreComponentsStub) ChanStopNodeProcess

func (ccs *CoreComponentsStub) ChanStopNodeProcess() chan endProcess.ArgEndProcess

ChanStopNodeProcess -

func (*CoreComponentsStub) CheckSubcomponents

func (ccs *CoreComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*CoreComponentsStub) Close

func (ccs *CoreComponentsStub) Close() error

Close -

func (*CoreComponentsStub) Create

func (ccs *CoreComponentsStub) Create() error

Create -

func (*CoreComponentsStub) EconomicsData

func (ccs *CoreComponentsStub) EconomicsData() process.EconomicsDataHandler

EconomicsData -

func (*CoreComponentsStub) EncodedAddressLen

func (ccs *CoreComponentsStub) EncodedAddressLen() uint32

EncodedAddressLen -

func (*CoreComponentsStub) EpochNotifier

func (ccs *CoreComponentsStub) EpochNotifier() process.EpochNotifier

EpochNotifier -

func (*CoreComponentsStub) EpochStartNotifierWithConfirm

func (ccs *CoreComponentsStub) EpochStartNotifierWithConfirm() factory.EpochStartNotifierWithConfirm

EpochStartNotifierWithConfirm -

func (*CoreComponentsStub) GenesisNodesSetup

func (ccs *CoreComponentsStub) GenesisNodesSetup() sharding.GenesisNodesSetupHandler

GenesisNodesSetup -

func (*CoreComponentsStub) GenesisTime

func (ccs *CoreComponentsStub) GenesisTime() time.Time

GenesisTime -

func (*CoreComponentsStub) Hasher

func (ccs *CoreComponentsStub) Hasher() hashing.Hasher

Hasher -

func (*CoreComponentsStub) InternalMarshalizer

func (ccs *CoreComponentsStub) InternalMarshalizer() marshal.Marshalizer

InternalMarshalizer -

func (*CoreComponentsStub) IsInterfaceNil

func (ccs *CoreComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*CoreComponentsStub) MinTransactionVersion

func (ccs *CoreComponentsStub) MinTransactionVersion() uint32

MinTransactionVersion -

func (*CoreComponentsStub) NodeTypeProvider

func (ccs *CoreComponentsStub) NodeTypeProvider() core.NodeTypeProviderHandler

NodeTypeProvider -

func (*CoreComponentsStub) NodesShuffler

func (ccs *CoreComponentsStub) NodesShuffler() sharding.NodesShuffler

NodesShuffler -

func (*CoreComponentsStub) PathHandler

func (ccs *CoreComponentsStub) PathHandler() storage.PathManagerHandler

PathHandler -

func (*CoreComponentsStub) Rater

func (ccs *CoreComponentsStub) Rater() sharding.PeerAccountListAndRatingHandler

Rater -

func (*CoreComponentsStub) RatingsData

func (ccs *CoreComponentsStub) RatingsData() process.RatingsInfoHandler

RatingsData -

func (*CoreComponentsStub) RoundHandler

func (ccs *CoreComponentsStub) RoundHandler() consensus.RoundHandler

RoundHandler -

func (*CoreComponentsStub) SetInternalMarshalizer

func (ccs *CoreComponentsStub) SetInternalMarshalizer(m marshal.Marshalizer) error

SetInternalMarshalizer -

func (*CoreComponentsStub) StatusHandler

func (ccs *CoreComponentsStub) StatusHandler() core.AppStatusHandler

StatusHandler -

func (*CoreComponentsStub) StatusHandlerUtils

func (ccs *CoreComponentsStub) StatusHandlerUtils() nodeFactory.StatusHandlersUtils

StatusHandlerUtils -

func (*CoreComponentsStub) SyncTimer

func (ccs *CoreComponentsStub) SyncTimer() ntp.SyncTimer

SyncTimer -

func (*CoreComponentsStub) TxMarshalizer

func (ccs *CoreComponentsStub) TxMarshalizer() marshal.Marshalizer

TxMarshalizer -

func (*CoreComponentsStub) TxSignHasher

func (ccs *CoreComponentsStub) TxSignHasher() hashing.Hasher

TxSignHasher -

func (*CoreComponentsStub) TxVersionChecker

func (ccs *CoreComponentsStub) TxVersionChecker() process.TxVersionCheckerHandler

TxVersionChecker -

func (*CoreComponentsStub) Uint64ByteSliceConverter

func (ccs *CoreComponentsStub) Uint64ByteSliceConverter() typeConverters.Uint64ByteSliceConverter

Uint64ByteSliceConverter -

func (*CoreComponentsStub) ValidatorPubKeyConverter

func (ccs *CoreComponentsStub) ValidatorPubKeyConverter() core.PubkeyConverter

ValidatorPubKeyConverter -

func (*CoreComponentsStub) VmMarshalizer

func (ccs *CoreComponentsStub) VmMarshalizer() marshal.Marshalizer

VmMarshalizer -

func (*CoreComponentsStub) Watchdog

func (ccs *CoreComponentsStub) Watchdog() core.WatchdogTimer

Watchdog -

type CryptoComponentsStub

type CryptoComponentsStub struct {
	PubKey          crypto.PublicKey
	PrivKey         crypto.PrivateKey
	PubKeyString    string
	PrivKeyBytes    []byte
	PubKeyBytes     []byte
	BlockSig        crypto.SingleSigner
	TxSig           crypto.SingleSigner
	MultiSig        crypto.MultiSigner
	PeerSignHandler crypto.PeerSignatureHandler
	BlKeyGen        crypto.KeyGenerator
	TxKeyGen        crypto.KeyGenerator
	MsgSigVerifier  vm.MessageSignVerifier
	// contains filtered or unexported fields
}

CryptoComponentsStub -

func (*CryptoComponentsStub) BlockSignKeyGen

func (ccs *CryptoComponentsStub) BlockSignKeyGen() crypto.KeyGenerator

BlockSignKeyGen -

func (*CryptoComponentsStub) BlockSigner

func (ccs *CryptoComponentsStub) BlockSigner() crypto.SingleSigner

BlockSigner -

func (*CryptoComponentsStub) CheckSubcomponents

func (ccs *CryptoComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*CryptoComponentsStub) Clone

func (ccs *CryptoComponentsStub) Clone() interface{}

Clone -

func (*CryptoComponentsStub) Close

func (ccs *CryptoComponentsStub) Close() error

Close -

func (*CryptoComponentsStub) Create

func (ccs *CryptoComponentsStub) Create() error

Create -

func (*CryptoComponentsStub) IsInterfaceNil

func (ccs *CryptoComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*CryptoComponentsStub) MessageSignVerifier

func (ccs *CryptoComponentsStub) MessageSignVerifier() vm.MessageSignVerifier

MessageSignVerifier -

func (*CryptoComponentsStub) MultiSigner

func (ccs *CryptoComponentsStub) MultiSigner() crypto.MultiSigner

MultiSigner -

func (*CryptoComponentsStub) PeerSignatureHandler

func (ccs *CryptoComponentsStub) PeerSignatureHandler() crypto.PeerSignatureHandler

PeerSignatureHandler -

func (*CryptoComponentsStub) PrivateKey

func (ccs *CryptoComponentsStub) PrivateKey() crypto.PrivateKey

PrivateKey -

func (*CryptoComponentsStub) PrivateKeyBytes

func (ccs *CryptoComponentsStub) PrivateKeyBytes() []byte

PrivateKeyBytes -

func (*CryptoComponentsStub) PublicKey

func (ccs *CryptoComponentsStub) PublicKey() crypto.PublicKey

PublicKey -

func (*CryptoComponentsStub) PublicKeyBytes

func (ccs *CryptoComponentsStub) PublicKeyBytes() []byte

PublicKeyBytes -

func (*CryptoComponentsStub) PublicKeyString

func (ccs *CryptoComponentsStub) PublicKeyString() string

PublicKeyString -

func (*CryptoComponentsStub) SetMultiSigner

func (ccs *CryptoComponentsStub) SetMultiSigner(ms crypto.MultiSigner) error

SetMultiSigner -

func (*CryptoComponentsStub) TxSignKeyGen

func (ccs *CryptoComponentsStub) TxSignKeyGen() crypto.KeyGenerator

TxSignKeyGen -

func (*CryptoComponentsStub) TxSingleSigner

func (ccs *CryptoComponentsStub) TxSingleSigner() crypto.SingleSigner

TxSingleSigner -

type CurrentNetworkEpochProviderStub

type CurrentNetworkEpochProviderStub struct {
	SetNetworkEpochAtBootstrapCalled func(epoch uint32)
	EpochIsActiveInNetworkCalled     func(epoch uint32) bool
	EpochConfirmedCalled             func(epoch uint32, timestamp uint64)
}

CurrentNetworkEpochProviderStub -

func (*CurrentNetworkEpochProviderStub) EpochConfirmed

func (cneps *CurrentNetworkEpochProviderStub) EpochConfirmed(epoch uint32, timestamp uint64)

EpochConfirmed -

func (*CurrentNetworkEpochProviderStub) EpochIsActiveInNetwork

func (cneps *CurrentNetworkEpochProviderStub) EpochIsActiveInNetwork(epoch uint32) bool

EpochIsActiveInNetwork -

func (*CurrentNetworkEpochProviderStub) IsInterfaceNil

func (cneps *CurrentNetworkEpochProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

type DataComponentsStub

type DataComponentsStub struct {
	BlockChain    data.ChainHandler
	Store         dataRetriever.StorageService
	DataPool      dataRetriever.PoolsHolder
	MbProvider    factory.MiniBlockProvider
	EconomicsData factory.EconomicsHandler
	// contains filtered or unexported fields
}

DataComponentsStub -

func (*DataComponentsStub) Blockchain

func (dcs *DataComponentsStub) Blockchain() data.ChainHandler

Blockchain -

func (*DataComponentsStub) CheckSubcomponents

func (dcs *DataComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*DataComponentsStub) Clone

func (dcs *DataComponentsStub) Clone() interface{}

Clone -

func (*DataComponentsStub) Close

func (dcs *DataComponentsStub) Close() error

Close -

func (*DataComponentsStub) Create

func (dcs *DataComponentsStub) Create() error

Create -

func (*DataComponentsStub) Datapool

func (dcs *DataComponentsStub) Datapool() dataRetriever.PoolsHolder

Datapool -

func (*DataComponentsStub) EconomicsHandler

func (dcs *DataComponentsStub) EconomicsHandler() factory.EconomicsHandler

EconomicsHandler -

func (*DataComponentsStub) IsInterfaceNil

func (dcs *DataComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*DataComponentsStub) MiniBlocksProvider

func (dcs *DataComponentsStub) MiniBlocksProvider() factory.MiniBlockProvider

MiniBlocksProvider -

func (*DataComponentsStub) SetBlockchain

func (dcs *DataComponentsStub) SetBlockchain(chain data.ChainHandler)

SetBlockchain -

func (*DataComponentsStub) StorageService

func (dcs *DataComponentsStub) StorageService() dataRetriever.StorageService

StorageService -

type DatabaseWriterStub

type DatabaseWriterStub struct {
	DoRequestCalled     func(req *esapi.IndexRequest) error
	DoBulkRequestCalled func(buff *bytes.Buffer, index string) error
	DoBulkRemoveCalled  func(index string, hashes []string) error
	DoMultiGetCalled    func(query map[string]interface{}, index string) (map[string]interface{}, error)
}

DatabaseWriterStub --

func (*DatabaseWriterStub) CheckAndCreateAlias

func (dws *DatabaseWriterStub) CheckAndCreateAlias(_ string, _ string) error

CheckAndCreateAlias -

func (*DatabaseWriterStub) CheckAndCreateIndex

func (dws *DatabaseWriterStub) CheckAndCreateIndex(_ string) error

CheckAndCreateIndex --

func (*DatabaseWriterStub) CheckAndCreatePolicy

func (dws *DatabaseWriterStub) CheckAndCreatePolicy(_ string, _ *bytes.Buffer) error

CheckAndCreatePolicy -

func (*DatabaseWriterStub) CheckAndCreateTemplate

func (dws *DatabaseWriterStub) CheckAndCreateTemplate(_ string, _ *bytes.Buffer) error

CheckAndCreateTemplate -

func (*DatabaseWriterStub) DoBulkRemove

func (dws *DatabaseWriterStub) DoBulkRemove(index string, hashes []string) error

DoBulkRemove -

func (*DatabaseWriterStub) DoBulkRequest

func (dws *DatabaseWriterStub) DoBulkRequest(buff *bytes.Buffer, index string) error

DoBulkRequest --

func (*DatabaseWriterStub) DoMultiGet

func (dws *DatabaseWriterStub) DoMultiGet(query map[string]interface{}, index string) (map[string]interface{}, error)

DoMultiGet --

func (*DatabaseWriterStub) DoRequest

func (dws *DatabaseWriterStub) DoRequest(req *esapi.IndexRequest) error

DoRequest --

func (*DatabaseWriterStub) IsInterfaceNil

func (dws *DatabaseWriterStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type EpochEconomicsStub

type EpochEconomicsStub struct {
	ComputeEndOfEpochEconomicsCalled func(metaBlock *block.MetaBlock) (*block.Economics, error)
	VerifyRewardsPerBlockCalled      func(
		metaBlock *block.MetaBlock, correctedProtocolSustainability *big.Int, computedEconomics *block.Economics,
	) error
}

EpochEconomicsStub -

func (*EpochEconomicsStub) ComputeEndOfEpochEconomics

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

ComputeEndOfEpochEconomics -

func (*EpochEconomicsStub) IsInterfaceNil

func (e *EpochEconomicsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochEconomicsStub) VerifyRewardsPerBlock

func (e *EpochEconomicsStub) VerifyRewardsPerBlock(
	metaBlock *block.MetaBlock,
	correctedProtocolSustainability *big.Int,
	computedEconomics *block.Economics,
) error

VerifyRewardsPerBlock -

type EpochNotifierStub

type EpochNotifierStub struct {
	CheckEpochCalled            func(header data.HeaderHandler)
	CurrentEpochCalled          func() uint32
	RegisterNotifyHandlerCalled func(handler vmcommon.EpochSubscriberHandler)
}

EpochNotifierStub -

func (*EpochNotifierStub) CheckEpoch

func (ens *EpochNotifierStub) CheckEpoch(header data.HeaderHandler)

CheckEpoch -

func (*EpochNotifierStub) CurrentEpoch

func (ens *EpochNotifierStub) CurrentEpoch() uint32

CurrentEpoch -

func (*EpochNotifierStub) IsInterfaceNil

func (ens *EpochNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochNotifierStub) RegisterNotifyHandler

func (ens *EpochNotifierStub) RegisterNotifyHandler(handler vmcommon.EpochSubscriberHandler)

RegisterNotifyHandler -

type EpochRewardsCreatorStub

type EpochRewardsCreatorStub struct {
	CreateRewardsMiniBlocksCalled func(
		metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, computedEconomics *block.Economics,
	) (block.MiniBlockSlice, error)
	VerifyRewardsMiniBlocksCalled func(
		metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, computedEconomics *block.Economics,
	) error
	CreateMarshalizedDataCalled    func(body *block.Body) map[string][][]byte
	SaveTxBlockToStorageCalled     func(metaBlock *block.MetaBlock, body *block.Body)
	DeleteTxsFromStorageCalled     func(metaBlock *block.MetaBlock, body *block.Body)
	RemoveBlockDataFromPoolsCalled func(metaBlock *block.MetaBlock, body *block.Body)
	GetRewardsTxsCalled            func(body *block.Body) map[string]data.TransactionHandler
	GetProtocolSustainCalled       func() *big.Int
	GetLocalTxCacheCalled          func() epochStart.TransactionCacher
}

EpochRewardsCreatorStub -

func (*EpochRewardsCreatorStub) CreateMarshalizedData

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

CreateMarshalizedData -

func (*EpochRewardsCreatorStub) CreateRewardsMiniBlocks

func (e *EpochRewardsCreatorStub) CreateRewardsMiniBlocks(
	metaBlock *block.MetaBlock,
	validatorsInfo map[uint32][]*state.ValidatorInfo,
	computedEconomics *block.Economics,
) (block.MiniBlockSlice, error)

CreateRewardsMiniBlocks -

func (*EpochRewardsCreatorStub) DeleteTxsFromStorage

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

DeleteTxsFromStorage -

func (*EpochRewardsCreatorStub) GetLocalTxCache

func (e *EpochRewardsCreatorStub) GetLocalTxCache() epochStart.TransactionCacher

GetLocalTxCache -

func (*EpochRewardsCreatorStub) GetProtocolSustainabilityRewards

func (e *EpochRewardsCreatorStub) GetProtocolSustainabilityRewards() *big.Int

GetProtocolSustainabilityRewards -

func (*EpochRewardsCreatorStub) GetRewardsTxs

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

GetRewardsTxs --

func (*EpochRewardsCreatorStub) IsInterfaceNil

func (e *EpochRewardsCreatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochRewardsCreatorStub) RemoveBlockDataFromPools

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

RemoveBlockDataFromPools -

func (*EpochRewardsCreatorStub) SaveTxBlockToStorage

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

SaveTxBlockToStorage -

func (*EpochRewardsCreatorStub) VerifyRewardsMiniBlocks

func (e *EpochRewardsCreatorStub) VerifyRewardsMiniBlocks(
	metaBlock *block.MetaBlock,
	validatorsInfo map[uint32][]*state.ValidatorInfo,
	computedEconomics *block.Economics,
) error

VerifyRewardsMiniBlocks -

type EpochStartDataCreatorStub

type EpochStartDataCreatorStub struct {
	CreateEpochStartDataCalled             func() (*block.EpochStart, error)
	VerifyEpochStartDataForMetablockCalled func(metaBlock *block.MetaBlock) error
}

EpochStartDataCreatorStub -

func (*EpochStartDataCreatorStub) CreateEpochStartData

func (e *EpochStartDataCreatorStub) CreateEpochStartData() (*block.EpochStart, error)

CreateEpochStartData -

func (*EpochStartDataCreatorStub) IsInterfaceNil

func (e *EpochStartDataCreatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock

func (e *EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock(metaBlock *block.MetaBlock) error

VerifyEpochStartDataForMetablock -

type EpochStartNotifierStub

type EpochStartNotifierStub struct {
	RegisterHandlerCalled            func(handler epochStart.ActionHandler)
	UnregisterHandlerCalled          func(handler epochStart.ActionHandler)
	NotifyAllCalled                  func(hdr data.HeaderHandler)
	NotifyAllPrepareCalled           func(hdr data.HeaderHandler, body data.BodyHandler)
	NotifyEpochChangeConfirmedCalled func(epoch uint32)
	// contains filtered or unexported fields
}

EpochStartNotifierStub -

func (*EpochStartNotifierStub) IsInterfaceNil

func (esnm *EpochStartNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartNotifierStub) NotifyAll

func (esnm *EpochStartNotifierStub) NotifyAll(hdr data.HeaderHandler)

NotifyAll -

func (*EpochStartNotifierStub) NotifyAllPrepare

func (esnm *EpochStartNotifierStub) NotifyAllPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)

NotifyAllPrepare -

func (*EpochStartNotifierStub) NotifyEpochChangeConfirmed

func (esnm *EpochStartNotifierStub) NotifyEpochChangeConfirmed(epoch uint32)

NotifyEpochChangeConfirmed -

func (*EpochStartNotifierStub) RegisterHandler

func (esnm *EpochStartNotifierStub) RegisterHandler(handler epochStart.ActionHandler)

RegisterHandler -

func (*EpochStartNotifierStub) UnregisterHandler

func (esnm *EpochStartNotifierStub) UnregisterHandler(handler epochStart.ActionHandler)

UnregisterHandler -

type EpochStartSystemSCStub

type EpochStartSystemSCStub struct {
	ProcessSystemSmartContractCalled func(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error
	ProcessDelegationRewardsCalled   func(miniBlocks block.MiniBlockSlice, txCache epochStart.TransactionCacher) error
	ToggleUnStakeUnBondCalled        func(value bool) error
}

EpochStartSystemSCStub -

func (*EpochStartSystemSCStub) IsInterfaceNil

func (e *EpochStartSystemSCStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartSystemSCStub) ProcessDelegationRewards

func (e *EpochStartSystemSCStub) ProcessDelegationRewards(
	miniBlocks block.MiniBlockSlice,
	txCache epochStart.TransactionCacher,
) error

ProcessDelegationRewards -

func (*EpochStartSystemSCStub) ProcessSystemSmartContract

func (e *EpochStartSystemSCStub) ProcessSystemSmartContract(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error

ProcessSystemSmartContract -

func (*EpochStartSystemSCStub) ToggleUnStakeUnBond

func (e *EpochStartSystemSCStub) ToggleUnStakeUnBond(value bool) error

ToggleUnStakeUnBond -

type EpochStartTriggerStub

type EpochStartTriggerStub struct {
	ForceEpochStartCalled func(round uint64)
	IsEpochStartCalled    func() bool
	EpochCalled           func() uint32
	MetaEpochCalled       func() uint32
	ReceivedHeaderCalled  func(handler data.HeaderHandler)
	UpdateCalled          func(round uint64, nonce uint64)
	ProcessedCalled       func(header data.HeaderHandler)
	EpochStartRoundCalled func() uint64
}

EpochStartTriggerStub -

func (*EpochStartTriggerStub) Close

func (e *EpochStartTriggerStub) Close() error

Close -

func (*EpochStartTriggerStub) Epoch

func (e *EpochStartTriggerStub) Epoch() uint32

Epoch -

func (*EpochStartTriggerStub) EpochFinalityAttestingRound

func (e *EpochStartTriggerStub) EpochFinalityAttestingRound() uint64

EpochFinalityAttestingRound -

func (*EpochStartTriggerStub) EpochStartMetaHdrHash

func (e *EpochStartTriggerStub) EpochStartMetaHdrHash() []byte

EpochStartMetaHdrHash -

func (*EpochStartTriggerStub) EpochStartRound

func (e *EpochStartTriggerStub) EpochStartRound() uint64

EpochStartRound -

func (*EpochStartTriggerStub) ForceEpochStart

func (e *EpochStartTriggerStub) ForceEpochStart(round uint64)

ForceEpochStart -

func (*EpochStartTriggerStub) GetRoundsPerEpoch

func (e *EpochStartTriggerStub) GetRoundsPerEpoch() uint64

GetRoundsPerEpoch -

func (*EpochStartTriggerStub) GetSavedStateKey

func (e *EpochStartTriggerStub) GetSavedStateKey() []byte

GetSavedStateKey -

func (*EpochStartTriggerStub) IsEpochStart

func (e *EpochStartTriggerStub) IsEpochStart() bool

IsEpochStart -

func (*EpochStartTriggerStub) IsInterfaceNil

func (e *EpochStartTriggerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartTriggerStub) LoadState

func (e *EpochStartTriggerStub) LoadState(_ []byte) error

LoadState -

func (*EpochStartTriggerStub) MetaEpoch

func (e *EpochStartTriggerStub) MetaEpoch() uint32

MetaEpoch -

func (*EpochStartTriggerStub) NotifyAll

func (e *EpochStartTriggerStub) NotifyAll(_ data.HeaderHandler)

NotifyAll -

func (*EpochStartTriggerStub) ReceivedHeader

func (e *EpochStartTriggerStub) ReceivedHeader(header data.HeaderHandler)

ReceivedHeader -

func (*EpochStartTriggerStub) RequestEpochStartIfNeeded

func (e *EpochStartTriggerStub) RequestEpochStartIfNeeded(_ data.HeaderHandler)

RequestEpochStartIfNeeded -

func (*EpochStartTriggerStub) Revert

func (e *EpochStartTriggerStub) Revert(_ data.HeaderHandler)

Revert -

func (*EpochStartTriggerStub) RevertStateToBlock

func (e *EpochStartTriggerStub) RevertStateToBlock(_ data.HeaderHandler) error

RevertStateToBlock -

func (*EpochStartTriggerStub) SetAppStatusHandler

func (e *EpochStartTriggerStub) SetAppStatusHandler(_ core.AppStatusHandler) error

SetAppStatusHandler -

func (*EpochStartTriggerStub) SetCurrentEpochStartRound

func (e *EpochStartTriggerStub) SetCurrentEpochStartRound(_ uint64)

SetCurrentEpochStartRound -

func (*EpochStartTriggerStub) SetEpoch

func (e *EpochStartTriggerStub) SetEpoch(_ uint32)

SetEpoch -

func (*EpochStartTriggerStub) SetFinalityAttestingRound

func (e *EpochStartTriggerStub) SetFinalityAttestingRound(_ uint64)

SetFinalityAttestingRound -

func (*EpochStartTriggerStub) SetMinRoundsBetweenEpochs

func (e *EpochStartTriggerStub) SetMinRoundsBetweenEpochs(_ uint64)

SetMinRoundsBetweenEpochs -

func (*EpochStartTriggerStub) SetProcessed

func (e *EpochStartTriggerStub) SetProcessed(header data.HeaderHandler, _ data.BodyHandler)

SetProcessed -

func (*EpochStartTriggerStub) SetRoundsPerEpoch

func (e *EpochStartTriggerStub) SetRoundsPerEpoch(_ uint64)

SetRoundsPerEpoch -

func (*EpochStartTriggerStub) SetTrigger

func (e *EpochStartTriggerStub) SetTrigger(_ epochStart.TriggerHandler)

SetTrigger -

func (*EpochStartTriggerStub) Update

func (e *EpochStartTriggerStub) Update(round uint64, nonce uint64)

Update -

type EpochValidatorInfoCreatorStub

type EpochValidatorInfoCreatorStub struct {
	CreateValidatorInfoMiniBlocksCalled func(validatorsInfo map[uint32][]*state.ValidatorInfo) (block.MiniBlockSlice, error)
	VerifyValidatorInfoMiniBlocksCalled func(miniblocks []*block.MiniBlock, validatorsInfo map[uint32][]*state.ValidatorInfo) error
	CreateMarshalizedDataCalled         func(body block.Body) map[string][][]byte
	SaveTxBlockToStorageCalled          func(metaBlock *block.MetaBlock, body *block.Body)
	DeleteTxsFromStorageCalled          func(metaBlock *block.MetaBlock)
	RemoveBlockDataFromPoolsCalled      func(metaBlock *block.MetaBlock, body *block.Body)
}

EpochValidatorInfoCreatorStub -

func (*EpochValidatorInfoCreatorStub) CreateValidatorInfoMiniBlocks

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

CreateValidatorInfoMiniBlocks -

func (*EpochValidatorInfoCreatorStub) DeleteValidatorInfoBlocksFromStorage

func (e *EpochValidatorInfoCreatorStub) DeleteValidatorInfoBlocksFromStorage(metaBlock *block.MetaBlock)

DeleteValidatorInfoBlocksFromStorage -

func (*EpochValidatorInfoCreatorStub) IsInterfaceNil

func (e *EpochValidatorInfoCreatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochValidatorInfoCreatorStub) RemoveBlockDataFromPools

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

RemoveBlockDataFromPools -

func (*EpochValidatorInfoCreatorStub) SaveValidatorInfoBlocksToStorage

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

SaveValidatorInfoBlocksToStorage -

func (*EpochValidatorInfoCreatorStub) VerifyValidatorInfoMiniBlocks

func (e *EpochValidatorInfoCreatorStub) VerifyValidatorInfoMiniBlocks(miniblocks []*block.MiniBlock, validatorsInfo map[uint32][]*state.ValidatorInfo) error

VerifyValidatorInfoMiniBlocks -

type ExportFactoryHandlerStub

type ExportFactoryHandlerStub struct {
	CreateCalled func() (update.ExportHandler, error)
}

ExportFactoryHandlerStub -

func (*ExportFactoryHandlerStub) Create

func (e *ExportFactoryHandlerStub) Create() (update.ExportHandler, error)

Create -

func (*ExportFactoryHandlerStub) IsInterfaceNil

func (e *ExportFactoryHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type ExportHandlerStub

type ExportHandlerStub struct {
	ExportAllCalled func(epoch uint32) error
}

ExportHandlerStub -

func (*ExportHandlerStub) ExportAll

func (e *ExportHandlerStub) ExportAll(epoch uint32) error

ExportAll -

func (*ExportHandlerStub) IsInterfaceNil

func (e *ExportHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type FeeHandlerStub

type FeeHandlerStub struct {
	SetMaxGasLimitPerBlockCalled                 func(maxGasLimitPerBlock uint64)
	SetMinGasPriceCalled                         func(minGasPrice uint64)
	SetMinGasLimitCalled                         func(minGasLimit uint64)
	MaxGasLimitPerBlockCalled                    func() uint64
	ComputeGasLimitCalled                        func(tx data.TransactionWithFeeHandler) uint64
	ComputeMoveBalanceFeeCalled                  func(tx data.TransactionWithFeeHandler) *big.Int
	ComputeTxFeeCalled                           func(tx data.TransactionWithFeeHandler) *big.Int
	CheckValidityTxValuesCalled                  func(tx data.TransactionWithFeeHandler) error
	DeveloperPercentageCalled                    func() float64
	MinGasPriceCalled                            func() uint64
	GasPriceModifierCalled                       func() float64
	ComputeFeeForProcessingCalled                func(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int
	GenesisTotalSupplyCalled                     func() *big.Int
	SplitTxGasInCategoriesCalled                 func(tx data.TransactionWithFeeHandler) (uint64, uint64)
	GasPriceForProcessingCalled                  func(tx data.TransactionWithFeeHandler) uint64
	GasPriceForMoveCalled                        func(tx data.TransactionWithFeeHandler) uint64
	MinGasPriceForProcessingCalled               func() uint64
	ComputeGasUsedAndFeeBasedOnRefundValueCalled func(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int)
	ComputeTxFeeBasedOnGasUsedCalled             func(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int
	ComputeGasLimitBasedOnBalanceCalled          func(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error)
}

FeeHandlerStub -

func (*FeeHandlerStub) CheckValidityTxValues

func (fhs *FeeHandlerStub) CheckValidityTxValues(tx data.TransactionWithFeeHandler) error

CheckValidityTxValues -

func (*FeeHandlerStub) ComputeFeeForProcessing

func (fhs *FeeHandlerStub) ComputeFeeForProcessing(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int

ComputeFeeForProcessing -

func (*FeeHandlerStub) ComputeGasLimit

func (fhs *FeeHandlerStub) ComputeGasLimit(tx data.TransactionWithFeeHandler) uint64

ComputeGasLimit -

func (*FeeHandlerStub) ComputeGasLimitBasedOnBalance

func (fhs *FeeHandlerStub) ComputeGasLimitBasedOnBalance(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error)

ComputeGasLimitBasedOnBalance -

func (*FeeHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue

func (fhs *FeeHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int)

ComputeGasUsedAndFeeBasedOnRefundValue -

func (*FeeHandlerStub) ComputeMoveBalanceFee

func (fhs *FeeHandlerStub) ComputeMoveBalanceFee(tx data.TransactionWithFeeHandler) *big.Int

ComputeMoveBalanceFee -

func (*FeeHandlerStub) ComputeTxFee

func (fhs *FeeHandlerStub) ComputeTxFee(tx data.TransactionWithFeeHandler) *big.Int

ComputeTxFee -

func (*FeeHandlerStub) ComputeTxFeeBasedOnGasUsed

func (fhs *FeeHandlerStub) ComputeTxFeeBasedOnGasUsed(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int

ComputeTxFeeBasedOnGasUsed -

func (*FeeHandlerStub) DeveloperPercentage

func (fhs *FeeHandlerStub) DeveloperPercentage() float64

DeveloperPercentage -

func (*FeeHandlerStub) GasPerDataByte

func (fhs *FeeHandlerStub) GasPerDataByte() uint64

GasPerDataByte -

func (*FeeHandlerStub) GasPriceForMove

func (fhs *FeeHandlerStub) GasPriceForMove(tx data.TransactionWithFeeHandler) uint64

GasPriceForMove -

func (*FeeHandlerStub) GasPriceForProcessing

func (fhs *FeeHandlerStub) GasPriceForProcessing(tx data.TransactionWithFeeHandler) uint64

GasPriceForProcessing -

func (*FeeHandlerStub) GasPriceModifier

func (fhs *FeeHandlerStub) GasPriceModifier() float64

GasPriceModifier -

func (*FeeHandlerStub) GenesisTotalSupply

func (fhs *FeeHandlerStub) GenesisTotalSupply() *big.Int

GenesisTotalSupply -

func (*FeeHandlerStub) IsInterfaceNil

func (fhs *FeeHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*FeeHandlerStub) MaxGasLimitPerBlock

func (fhs *FeeHandlerStub) MaxGasLimitPerBlock(uint32) uint64

MaxGasLimitPerBlock -

func (*FeeHandlerStub) MinGasLimit

func (fhs *FeeHandlerStub) MinGasLimit() uint64

MinGasLimit will return min gas limit

func (*FeeHandlerStub) MinGasPrice

func (fhs *FeeHandlerStub) MinGasPrice() uint64

MinGasPrice -

func (*FeeHandlerStub) MinGasPriceForProcessing

func (fhs *FeeHandlerStub) MinGasPriceForProcessing() uint64

MinGasPriceForProcessing -

func (*FeeHandlerStub) SetMaxGasLimitPerBlock

func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64)

SetMaxGasLimitPerBlock -

func (*FeeHandlerStub) SetMinGasLimit

func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64)

SetMinGasLimit -

func (*FeeHandlerStub) SetMinGasPrice

func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice uint64)

SetMinGasPrice -

func (*FeeHandlerStub) SplitTxGasInCategories

func (fhs *FeeHandlerStub) SplitTxGasInCategories(tx data.TransactionWithFeeHandler) (uint64, uint64)

SplitTxGasInCategories -

type ForkDetectorStub

type ForkDetectorStub struct {
	AddHeaderCalled                 func(header data.HeaderHandler, hash []byte, state process.BlockHeaderState, selfNotarizedHeaders []data.HeaderHandler, selfNotarizedHeadersHashes [][]byte) error
	RemoveHeaderCalled              func(nonce uint64, hash []byte)
	CheckForkCalled                 func() *process.ForkInfo
	GetHighestFinalBlockNonceCalled func() uint64
	GetHighestFinalBlockHashCalled  func() []byte
	ProbableHighestNonceCalled      func() uint64
	ResetForkCalled                 func()
	GetNotarizedHeaderHashCalled    func(nonce uint64) []byte
	RestoreToGenesisCalled          func()
	SetRollBackNonceCalled          func(nonce uint64)
	ResetProbableHighestNonceCalled func()
	SetFinalToLastCheckpointCalled  func()
}

ForkDetectorStub is a mock implementation for the ForkDetector interface

func (*ForkDetectorStub) AddHeader

func (fdm *ForkDetectorStub) AddHeader(
	header data.HeaderHandler,
	hash []byte,
	state process.BlockHeaderState,
	selfNotarizedHeaders []data.HeaderHandler,
	selfNotarizedHeadersHashes [][]byte,
) error

AddHeader is a mock implementation for AddHeader

func (*ForkDetectorStub) CheckFork

func (fdm *ForkDetectorStub) CheckFork() *process.ForkInfo

CheckFork is a mock implementation for CheckFork

func (*ForkDetectorStub) GetHighestFinalBlockHash

func (fdm *ForkDetectorStub) GetHighestFinalBlockHash() []byte

GetHighestFinalBlockHash -

func (*ForkDetectorStub) GetHighestFinalBlockNonce

func (fdm *ForkDetectorStub) GetHighestFinalBlockNonce() uint64

GetHighestFinalBlockNonce is a mock implementation for GetHighestFinalBlockNonce

func (*ForkDetectorStub) GetNotarizedHeaderHash

func (fdm *ForkDetectorStub) GetNotarizedHeaderHash(nonce uint64) []byte

GetNotarizedHeaderHash -

func (*ForkDetectorStub) IsInterfaceNil

func (fdm *ForkDetectorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ForkDetectorStub) ProbableHighestNonce

func (fdm *ForkDetectorStub) ProbableHighestNonce() uint64

ProbableHighestNonce is a mock implementation for ProbableHighestNonce

func (*ForkDetectorStub) RemoveHeader

func (fdm *ForkDetectorStub) RemoveHeader(nonce uint64, hash []byte)

RemoveHeader is a mock implementation for RemoveHeader

func (*ForkDetectorStub) ResetFork

func (fdm *ForkDetectorStub) ResetFork()

ResetFork -

func (*ForkDetectorStub) ResetProbableHighestNonce

func (fdm *ForkDetectorStub) ResetProbableHighestNonce()

ResetProbableHighestNonce -

func (*ForkDetectorStub) RestoreToGenesis

func (fdm *ForkDetectorStub) RestoreToGenesis()

RestoreToGenesis -

func (*ForkDetectorStub) SetFinalToLastCheckpoint

func (fdm *ForkDetectorStub) SetFinalToLastCheckpoint()

SetFinalToLastCheckpoint -

func (*ForkDetectorStub) SetRollBackNonce

func (fdm *ForkDetectorStub) SetRollBackNonce(nonce uint64)

SetRollBackNonce -

type GasHandlerMock

type GasHandlerMock struct {
	InitCalled                          func()
	SetGasConsumedCalled                func(gasConsumed uint64, hash []byte)
	SetGasRefundedCalled                func(gasRefunded uint64, hash []byte)
	GasConsumedCalled                   func(hash []byte) uint64
	GasRefundedCalled                   func(hash []byte) uint64
	TotalGasConsumedCalled              func() uint64
	TotalGasRefundedCalled              func() uint64
	RemoveGasConsumedCalled             func(hashes [][]byte)
	RemoveGasRefundedCalled             func(hashes [][]byte)
	ComputeGasConsumedByMiniBlockCalled func(miniBlock *block.MiniBlock, mapHashTx map[string]data.TransactionHandler) (uint64, uint64, error)
	ComputeGasConsumedByTxCalled        func(txSenderShardId uint32, txReceiverSharedId uint32, txHandler data.TransactionHandler) (uint64, uint64, error)
}

GasHandlerMock -

func (*GasHandlerMock) ComputeGasConsumedByMiniBlock

func (ghm *GasHandlerMock) ComputeGasConsumedByMiniBlock(miniBlock *block.MiniBlock, mapHashTx map[string]data.TransactionHandler) (uint64, uint64, error)

ComputeGasConsumedByMiniBlock -

func (*GasHandlerMock) ComputeGasConsumedByTx

func (ghm *GasHandlerMock) ComputeGasConsumedByTx(txSenderShardId uint32, txReceiverShardId uint32, txHandler data.TransactionHandler) (uint64, uint64, error)

ComputeGasConsumedByTx -

func (*GasHandlerMock) GasConsumed

func (ghm *GasHandlerMock) GasConsumed(hash []byte) uint64

GasConsumed -

func (*GasHandlerMock) GasRefunded

func (ghm *GasHandlerMock) GasRefunded(hash []byte) uint64

GasRefunded -

func (*GasHandlerMock) Init

func (ghm *GasHandlerMock) Init()

Init -

func (*GasHandlerMock) IsInterfaceNil

func (ghm *GasHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*GasHandlerMock) RemoveGasConsumed

func (ghm *GasHandlerMock) RemoveGasConsumed(hashes [][]byte)

RemoveGasConsumed -

func (*GasHandlerMock) RemoveGasRefunded

func (ghm *GasHandlerMock) RemoveGasRefunded(hashes [][]byte)

RemoveGasRefunded -

func (*GasHandlerMock) SetGasConsumed

func (ghm *GasHandlerMock) SetGasConsumed(gasConsumed uint64, hash []byte)

SetGasConsumed -

func (*GasHandlerMock) SetGasRefunded

func (ghm *GasHandlerMock) SetGasRefunded(gasRefunded uint64, hash []byte)

SetGasRefunded -

func (*GasHandlerMock) TotalGasConsumed

func (ghm *GasHandlerMock) TotalGasConsumed() uint64

TotalGasConsumed -

func (*GasHandlerMock) TotalGasRefunded

func (ghm *GasHandlerMock) TotalGasRefunded() uint64

TotalGasRefunded -

type GasScheduleNotifierMock

type GasScheduleNotifierMock struct {
	GasSchedule map[string]map[string]uint64
}

GasScheduleNotifierMock -

func NewGasScheduleNotifierMock

func NewGasScheduleNotifierMock(gasSchedule map[string]map[string]uint64) *GasScheduleNotifierMock

NewGasScheduleNotifierMock -

func (*GasScheduleNotifierMock) IsInterfaceNil

func (g *GasScheduleNotifierMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*GasScheduleNotifierMock) LatestGasSchedule

func (g *GasScheduleNotifierMock) LatestGasSchedule() map[string]map[string]uint64

LatestGasSchedule -

func (*GasScheduleNotifierMock) RegisterNotifyHandler

func (g *GasScheduleNotifierMock) RegisterNotifyHandler(handler core.GasScheduleSubscribeHandler)

RegisterNotifyHandler -

func (*GasScheduleNotifierMock) UnRegisterAll

func (g *GasScheduleNotifierMock) UnRegisterAll()

UnRegisterAll -

type HardforkTriggerStub

type HardforkTriggerStub struct {
	TriggerCalled                func(epoch uint32, withEarlyEndOfEpoch bool) error
	IsSelfTriggerCalled          func() bool
	TriggerReceivedCalled        func(payload []byte, data []byte, pkBytes []byte) (bool, error)
	RecordedTriggerMessageCalled func() ([]byte, bool)
	CreateDataCalled             func() []byte
	AddCloserCalled              func(closer update.Closer) error
	NotifyTriggerReceivedCalled  func() <-chan struct{}
}

HardforkTriggerStub -

func (*HardforkTriggerStub) AddCloser

func (hts *HardforkTriggerStub) AddCloser(closer update.Closer) error

AddCloser -

func (*HardforkTriggerStub) CreateData

func (hts *HardforkTriggerStub) CreateData() []byte

CreateData -

func (*HardforkTriggerStub) IsInterfaceNil

func (hts *HardforkTriggerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HardforkTriggerStub) IsSelfTrigger

func (hts *HardforkTriggerStub) IsSelfTrigger() bool

IsSelfTrigger -

func (*HardforkTriggerStub) NotifyTriggerReceived

func (hts *HardforkTriggerStub) NotifyTriggerReceived() <-chan struct{}

NotifyTriggerReceived -

func (*HardforkTriggerStub) RecordedTriggerMessage

func (hts *HardforkTriggerStub) RecordedTriggerMessage() ([]byte, bool)

RecordedTriggerMessage -

func (*HardforkTriggerStub) Trigger

func (hts *HardforkTriggerStub) Trigger(epoch uint32, withEarlyEndOfEpoch bool) error

Trigger -

func (*HardforkTriggerStub) TriggerReceived

func (hts *HardforkTriggerStub) TriggerReceived(payload []byte, data []byte, pkBytes []byte) (bool, error)

TriggerReceived -

type HeaderIntegrityVerifierStub

type HeaderIntegrityVerifierStub struct {
	VerifyCalled     func(header data.HeaderHandler) error
	GetVersionCalled func(epoch uint32) string
}

HeaderIntegrityVerifierStub -

func (*HeaderIntegrityVerifierStub) GetVersion

func (h *HeaderIntegrityVerifierStub) GetVersion(epoch uint32) string

GetVersion -

func (*HeaderIntegrityVerifierStub) IsInterfaceNil

func (h *HeaderIntegrityVerifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeaderIntegrityVerifierStub) Verify

func (h *HeaderIntegrityVerifierStub) Verify(header data.HeaderHandler) error

Verify -

type HeaderResolverStub

type HeaderResolverStub struct {
	RequestDataFromHashCalled     func(hash []byte, epoch uint32) error
	ProcessReceivedMessageCalled  func(message p2p.MessageP2P) error
	RequestDataFromNonceCalled    func(nonce uint64, epoch uint32) error
	RequestDataFromEpochCalled    func(identifier []byte) error
	SetEpochHandlerCalled         func(epochHandler dataRetriever.EpochHandler) error
	SetNumPeersToQueryCalled      func(intra int, cross int)
	NumPeersToQueryCalled         func() (int, int)
	SetResolverDebugHandlerCalled func(handler dataRetriever.ResolverDebugHandler) error
	CloseCalled                   func() error
}

HeaderResolverStub -

func (*HeaderResolverStub) Close

func (hrs *HeaderResolverStub) Close() error

Close -

func (*HeaderResolverStub) IsInterfaceNil

func (hrs *HeaderResolverStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*HeaderResolverStub) NumPeersToQuery

func (hrs *HeaderResolverStub) NumPeersToQuery() (int, int)

NumPeersToQuery -

func (*HeaderResolverStub) ProcessReceivedMessage

func (hrs *HeaderResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*HeaderResolverStub) RequestDataFromEpoch

func (hrs *HeaderResolverStub) RequestDataFromEpoch(identifier []byte) error

RequestDataFromEpoch -

func (*HeaderResolverStub) RequestDataFromHash

func (hrs *HeaderResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error

RequestDataFromHash -

func (*HeaderResolverStub) RequestDataFromNonce

func (hrs *HeaderResolverStub) RequestDataFromNonce(nonce uint64, epoch uint32) error

RequestDataFromNonce -

func (*HeaderResolverStub) SetEpochHandler

func (hrs *HeaderResolverStub) SetEpochHandler(epochHandler dataRetriever.EpochHandler) error

SetEpochHandler -

func (*HeaderResolverStub) SetNumPeersToQuery

func (hrs *HeaderResolverStub) SetNumPeersToQuery(intra int, cross int)

SetNumPeersToQuery -

func (*HeaderResolverStub) SetResolverDebugHandler

func (hrs *HeaderResolverStub) SetResolverDebugHandler(handler dataRetriever.ResolverDebugHandler) error

SetResolverDebugHandler -

type HeaderSigVerifierStub

type HeaderSigVerifierStub struct {
	VerifyRandSeedAndLeaderSignatureCalled func(header data.HeaderHandler) error
	VerifySignatureCalled                  func(header data.HeaderHandler) error
	VerifyRandSeedCalled                   func(header data.HeaderHandler) error
	VerifyLeaderSignatureCalled            func(header data.HeaderHandler) error
}

HeaderSigVerifierStub -

func (*HeaderSigVerifierStub) IsInterfaceNil

func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeaderSigVerifierStub) VerifyLeaderSignature

func (hsvm *HeaderSigVerifierStub) VerifyLeaderSignature(header data.HeaderHandler) error

VerifyLeaderSignature -

func (*HeaderSigVerifierStub) VerifyRandSeed

func (hsvm *HeaderSigVerifierStub) VerifyRandSeed(header data.HeaderHandler) error

VerifyRandSeed -

func (*HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature

func (hsvm *HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature(header data.HeaderHandler) error

VerifyRandSeedAndLeaderSignature -

func (*HeaderSigVerifierStub) VerifySignature

func (hsvm *HeaderSigVerifierStub) VerifySignature(header data.HeaderHandler) error

VerifySignature -

type HeaderValidatorStub

type HeaderValidatorStub struct {
	IsHeaderConstructionValidCalled func(currHdr, prevHdr data.HeaderHandler) error
}

HeaderValidatorStub -

func (*HeaderValidatorStub) IsHeaderConstructionValid

func (hvs *HeaderValidatorStub) IsHeaderConstructionValid(currHdr, prevHdr data.HeaderHandler) error

IsHeaderConstructionValid -

func (*HeaderValidatorStub) IsInterfaceNil

func (hvs *HeaderValidatorStub) IsInterfaceNil() bool

IsInterfaceNil returns if underlying object is true

type HeadersCacherStub

type HeadersCacherStub struct {
	AddCalled                           func(headerHash []byte, header data.HeaderHandler)
	RemoveHeaderByHashCalled            func(headerHash []byte)
	RemoveHeaderByNonceAndShardIdCalled func(hdrNonce uint64, shardId uint32)
	GetHeaderByNonceAndShardIdCalled    func(hdrNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error)
	GetHeaderByHashCalled               func(hash []byte) (data.HeaderHandler, error)
	ClearCalled                         func()
	RegisterHandlerCalled               func(handler func(key []byte, value interface{}))
	KeysCalled                          func(shardId uint32) []uint64
	LenCalled                           func() int
	MaxSizeCalled                       func() int
}

HeadersCacherStub -

func (*HeadersCacherStub) AddHeader

func (hcs *HeadersCacherStub) AddHeader(headerHash []byte, header data.HeaderHandler)

AddHeader -

func (*HeadersCacherStub) Clear

func (hcs *HeadersCacherStub) Clear()

Clear -

func (*HeadersCacherStub) GetHeaderByHash

func (hcs *HeadersCacherStub) GetHeaderByHash(hash []byte) (data.HeaderHandler, error)

GetHeaderByHash -

func (*HeadersCacherStub) GetHeadersByNonceAndShardId

func (hcs *HeadersCacherStub) GetHeadersByNonceAndShardId(hdrNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error)

GetHeadersByNonceAndShardId -

func (*HeadersCacherStub) IsInterfaceNil

func (hcs *HeadersCacherStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeadersCacherStub) Keys

func (hcs *HeadersCacherStub) Keys(shardId uint32) []uint64

Keys -

func (*HeadersCacherStub) Len

func (hcs *HeadersCacherStub) Len() int

Len -

func (*HeadersCacherStub) MaxSize

func (hcs *HeadersCacherStub) MaxSize() int

MaxSize -

func (*HeadersCacherStub) RegisterHandler

func (hcs *HeadersCacherStub) RegisterHandler(handler func(key []byte, value interface{}))

RegisterHandler -

func (*HeadersCacherStub) RemoveHeaderByHash

func (hcs *HeadersCacherStub) RemoveHeaderByHash(headerHash []byte)

RemoveHeaderByHash -

func (*HeadersCacherStub) RemoveHeaderByNonceAndShardId

func (hcs *HeadersCacherStub) RemoveHeaderByNonceAndShardId(hdrNonce uint64, shardId uint32)

RemoveHeaderByNonceAndShardId -

type HeartbeatComponentsStub

type HeartbeatComponentsStub struct {
	HBMessenger heartbeat.MessageHandler
	HBMonitor   factory.HeartbeatMonitor
	HBSender    factory.HeartbeatSender
	HBStorer    factory.HeartbeatStorer
}

HeartbeatComponentsStub -

func (*HeartbeatComponentsStub) CheckSubcomponents

func (hbs *HeartbeatComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*HeartbeatComponentsStub) Close

func (hbs *HeartbeatComponentsStub) Close() error

Close -

func (*HeartbeatComponentsStub) Create

func (hbs *HeartbeatComponentsStub) Create() error

Create -

func (*HeartbeatComponentsStub) IsInterfaceNil

func (hbs *HeartbeatComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeartbeatComponentsStub) MessageHandler

func (hbs *HeartbeatComponentsStub) MessageHandler() heartbeat.MessageHandler

MessageHandler -

func (*HeartbeatComponentsStub) Monitor

func (hbs *HeartbeatComponentsStub) Monitor() factory.HeartbeatMonitor

Monitor -

func (*HeartbeatComponentsStub) Sender

func (hbs *HeartbeatComponentsStub) Sender() factory.HeartbeatSender

Sender -

func (*HeartbeatComponentsStub) Storer

func (hbs *HeartbeatComponentsStub) Storer() factory.HeartbeatStorer

Storer -

type HeartbeatMessageHandlerStub

type HeartbeatMessageHandlerStub struct {
	CreateHeartbeatFromP2PMessageCalled func(message p2p.MessageP2P) (*data.Heartbeat, error)
}

HeartbeatMessageHandlerStub -

func (*HeartbeatMessageHandlerStub) CreateHeartbeatFromP2PMessage

func (hbmh *HeartbeatMessageHandlerStub) CreateHeartbeatFromP2PMessage(message p2p.MessageP2P) (*data.Heartbeat, error)

CreateHeartbeatFromP2PMessage -

func (*HeartbeatMessageHandlerStub) IsInterfaceNil

func (hbmh *HeartbeatMessageHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type HeartbeatMonitorStub

type HeartbeatMonitorStub struct {
	ProcessReceivedMessageCalled func(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
	GetHeartbeatsCalled          func() []heartbeatData.PubKeyHeartbeat
	CleanupCalled                func()
}

HeartbeatMonitorStub -

func (*HeartbeatMonitorStub) Cleanup

func (hbms *HeartbeatMonitorStub) Cleanup()

Cleanup -

func (*HeartbeatMonitorStub) Close

func (hbms *HeartbeatMonitorStub) Close() error

Close -

func (*HeartbeatMonitorStub) GetHeartbeats

func (hbms *HeartbeatMonitorStub) GetHeartbeats() []heartbeatData.PubKeyHeartbeat

GetHeartbeats -

func (*HeartbeatMonitorStub) IsInterfaceNil

func (hbms *HeartbeatMonitorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeartbeatMonitorStub) ProcessReceivedMessage

func (hbms *HeartbeatMonitorStub) ProcessReceivedMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error

ProcessReceivedMessage -

type HeartbeatSenderStub

type HeartbeatSenderStub struct {
	SendHeartbeatCalled func() error
}

HeartbeatSenderStub -

func (*HeartbeatSenderStub) IsInterfaceNil

func (hbss *HeartbeatSenderStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeartbeatSenderStub) SendHeartbeat

func (hbss *HeartbeatSenderStub) SendHeartbeat() error

SendHeartbeat -

type HeartbeatStorerStub

type HeartbeatStorerStub struct {
	LoadGenesisTimeCalled   func() (time.Time, error)
	UpdateGenesisTimeCalled func(genesisTime time.Time) error
	LoadHeartBeatDTOCalled  func(pubKey string) (*data.HeartbeatDTO, error)
	SavePubkeyDataCalled    func(pubkey []byte, heartbeat *data.HeartbeatDTO) error
	LoadKeysCalled          func() ([][]byte, error)
	SaveKeysCalled          func(peersSlice [][]byte) error
}

HeartbeatStorerStub -

func (*HeartbeatStorerStub) IsInterfaceNil

func (hss *HeartbeatStorerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeartbeatStorerStub) LoadGenesisTime

func (hss *HeartbeatStorerStub) LoadGenesisTime() (time.Time, error)

LoadGenesisTime -

func (*HeartbeatStorerStub) LoadHeartBeatDTO

func (hss *HeartbeatStorerStub) LoadHeartBeatDTO(pubKey string) (*data.HeartbeatDTO, error)

LoadHeartBeatDTO -

func (*HeartbeatStorerStub) LoadKeys

func (hss *HeartbeatStorerStub) LoadKeys() ([][]byte, error)

LoadKeys -

func (*HeartbeatStorerStub) SaveKeys

func (hss *HeartbeatStorerStub) SaveKeys(peersSlice [][]byte) error

SaveKeys -

func (*HeartbeatStorerStub) SavePubkeyData

func (hss *HeartbeatStorerStub) SavePubkeyData(pubkey []byte, heartbeat *data.HeartbeatDTO) error

SavePubkeyData -

func (*HeartbeatStorerStub) UpdateGenesisTime

func (hss *HeartbeatStorerStub) UpdateGenesisTime(genesisTime time.Time) error

UpdateGenesisTime -

type ImportStartHandlerStub

type ImportStartHandlerStub struct {
	SetStartImportCalled            func() error
	ResetStartImportCalled          func() error
	ShouldStartImportCalled         func() bool
	IsAfterExportBeforeImportCalled func() bool
}

ImportStartHandlerStub -

func (*ImportStartHandlerStub) IsAfterExportBeforeImport

func (ish *ImportStartHandlerStub) IsAfterExportBeforeImport() bool

IsAfterExportBeforeImport -

func (*ImportStartHandlerStub) IsInterfaceNil

func (ish *ImportStartHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ImportStartHandlerStub) ResetStartImport

func (ish *ImportStartHandlerStub) ResetStartImport() error

ResetStartImport -

func (*ImportStartHandlerStub) SetStartImport

func (ish *ImportStartHandlerStub) SetStartImport() error

SetStartImport -

func (*ImportStartHandlerStub) ShouldStartImport

func (ish *ImportStartHandlerStub) ShouldStartImport() bool

ShouldStartImport -

type InterimProcessorContainerMock

type InterimProcessorContainerMock struct {
	GetCalled  func(key block.Type) (process.IntermediateTransactionHandler, error)
	KeysCalled func() []block.Type
}

InterimProcessorContainerMock -

func (*InterimProcessorContainerMock) Add

func (ipcm *InterimProcessorContainerMock) Add(key block.Type, val process.IntermediateTransactionHandler) error

Add -

func (*InterimProcessorContainerMock) AddMultiple

func (ipcm *InterimProcessorContainerMock) AddMultiple(keys []block.Type, preprocessors []process.IntermediateTransactionHandler) error

AddMultiple -

func (*InterimProcessorContainerMock) Get

func (ipcm *InterimProcessorContainerMock) Get(key block.Type) (process.IntermediateTransactionHandler, error)

Get -

func (*InterimProcessorContainerMock) IsInterfaceNil

func (ipcm *InterimProcessorContainerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*InterimProcessorContainerMock) Keys

func (ipcm *InterimProcessorContainerMock) Keys() []block.Type

Keys -

func (*InterimProcessorContainerMock) Len

func (ipcm *InterimProcessorContainerMock) Len() int

Len -

func (*InterimProcessorContainerMock) Remove

func (ipcm *InterimProcessorContainerMock) Remove(key block.Type)

Remove -

func (*InterimProcessorContainerMock) Replace

func (ipcm *InterimProcessorContainerMock) Replace(key block.Type, val process.IntermediateTransactionHandler) error

Replace -

type IntermediateTransactionHandlerMock

type IntermediateTransactionHandlerMock struct {
	AddIntermediateTransactionsCalled        func(txs []data.TransactionHandler) error
	GetNumOfCrossInterMbsAndTxsCalled        func() (int, int)
	CreateAllInterMiniBlocksCalled           func() []*block.MiniBlock
	VerifyInterMiniBlocksCalled              func(body *block.Body) error
	SaveCurrentIntermediateTxToStorageCalled func() error
	CreateBlockStartedCalled                 func()
	CreateMarshalizedDataCalled              func(txHashes [][]byte) ([][]byte, error)
	GetAllCurrentFinishedTxsCalled           func() map[string]data.TransactionHandler
	RemoveProcessedResultsForCalled          func(txHashes [][]byte)
	// contains filtered or unexported fields
}

IntermediateTransactionHandlerMock -

func (*IntermediateTransactionHandlerMock) AddIntermediateTransactions

func (ith *IntermediateTransactionHandlerMock) AddIntermediateTransactions(txs []data.TransactionHandler) error

AddIntermediateTransactions -

func (*IntermediateTransactionHandlerMock) Clean

func (ith *IntermediateTransactionHandlerMock) Clean()

Clean -

func (*IntermediateTransactionHandlerMock) CreateAllInterMiniBlocks

func (ith *IntermediateTransactionHandlerMock) CreateAllInterMiniBlocks() []*block.MiniBlock

CreateAllInterMiniBlocks -

func (*IntermediateTransactionHandlerMock) CreateBlockStarted

func (ith *IntermediateTransactionHandlerMock) CreateBlockStarted()

CreateBlockStarted -

func (*IntermediateTransactionHandlerMock) CreateMarshalizedData

func (ith *IntermediateTransactionHandlerMock) CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)

CreateMarshalizedData -

func (*IntermediateTransactionHandlerMock) GetAllCurrentFinishedTxs

func (ith *IntermediateTransactionHandlerMock) GetAllCurrentFinishedTxs() map[string]data.TransactionHandler

GetAllCurrentFinishedTxs -

func (*IntermediateTransactionHandlerMock) GetCreatedInShardMiniBlock

func (ith *IntermediateTransactionHandlerMock) GetCreatedInShardMiniBlock() *block.MiniBlock

GetCreatedInShardMiniBlock -

func (*IntermediateTransactionHandlerMock) GetIntermediateTransactions

func (ith *IntermediateTransactionHandlerMock) GetIntermediateTransactions() []data.TransactionHandler

GetIntermediateTransactions -

func (*IntermediateTransactionHandlerMock) GetNumOfCrossInterMbsAndTxs

func (ith *IntermediateTransactionHandlerMock) GetNumOfCrossInterMbsAndTxs() (int, int)

GetNumOfCrossInterMbsAndTxs -

func (*IntermediateTransactionHandlerMock) IsInterfaceNil

func (ith *IntermediateTransactionHandlerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*IntermediateTransactionHandlerMock) RemoveProcessedResultsFor

func (ith *IntermediateTransactionHandlerMock) RemoveProcessedResultsFor(txHashes [][]byte)

RemoveProcessedResultsFor -

func (*IntermediateTransactionHandlerMock) SaveCurrentIntermediateTxToStorage

func (ith *IntermediateTransactionHandlerMock) SaveCurrentIntermediateTxToStorage() error

SaveCurrentIntermediateTxToStorage -

func (*IntermediateTransactionHandlerMock) VerifyInterMiniBlocks

func (ith *IntermediateTransactionHandlerMock) VerifyInterMiniBlocks(body *block.Body) error

VerifyInterMiniBlocks -

type KeyGenMock

type KeyGenMock struct {
}

KeyGenMock -

func (*KeyGenMock) CheckPublicKeyValid

func (keyGen *KeyGenMock) CheckPublicKeyValid(_ []byte) error

CheckPublicKeyValid -

func (*KeyGenMock) GeneratePair

func (keyGen *KeyGenMock) GeneratePair() (crypto.PrivateKey, crypto.PublicKey)

GeneratePair -

func (*KeyGenMock) IsInterfaceNil

func (keyGen *KeyGenMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*KeyGenMock) PrivateKeyFromByteArray

func (keyGen *KeyGenMock) PrivateKeyFromByteArray(buff []byte) (crypto.PrivateKey, error)

PrivateKeyFromByteArray -

func (*KeyGenMock) PublicKeyFromByteArray

func (keyGen *KeyGenMock) PublicKeyFromByteArray(buff []byte) (crypto.PublicKey, error)

PublicKeyFromByteArray -

func (*KeyGenMock) Suite

func (keyGen *KeyGenMock) Suite() crypto.Suite

Suite -

type LatestStorageDataProviderStub

type LatestStorageDataProviderStub struct {
	GetCalled                      func() (storage.LatestDataFromStorage, error)
	GetParentDirAndLastEpochCalled func() (string, uint32, error)
	GetShardsFromDirectoryCalled   func(path string) ([]string, error)
}

LatestStorageDataProviderStub -

func (*LatestStorageDataProviderStub) Get

func (l *LatestStorageDataProviderStub) Get() (storage.LatestDataFromStorage, error)

Get -

func (*LatestStorageDataProviderStub) GetParentDirAndLastEpoch

func (l *LatestStorageDataProviderStub) GetParentDirAndLastEpoch() (string, uint32, error)

GetParentDirAndLastEpoch -

func (*LatestStorageDataProviderStub) GetShardsFromDirectory

func (l *LatestStorageDataProviderStub) GetShardsFromDirectory(path string) ([]string, error)

GetShardsFromDirectory --

func (*LatestStorageDataProviderStub) IsInterfaceNil

func (l *LatestStorageDataProviderStub) IsInterfaceNil() bool

IsInterfaceNil --

type ListIndexUpdaterStub

type ListIndexUpdaterStub struct {
	UpdateListAndIndexCalled func(pubKey string, shardID uint32, list string, index uint32) error
}

ListIndexUpdaterStub -

func (*ListIndexUpdaterStub) IsInterfaceNil

func (lius *ListIndexUpdaterStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ListIndexUpdaterStub) UpdateListAndIndex

func (lius *ListIndexUpdaterStub) UpdateListAndIndex(pubKey string, shardID uint32, list string, index uint32) error

UpdateListAndIndex -

type MessageSignVerifierMock

type MessageSignVerifierMock struct {
}

MessageSignVerifierMock -

func (*MessageSignVerifierMock) IsInterfaceNil

func (m *MessageSignVerifierMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*MessageSignVerifierMock) Verify

func (m *MessageSignVerifierMock) Verify(_ []byte, _ []byte, _ []byte) error

Verify -

type MiniBlocksProviderStub

type MiniBlocksProviderStub struct {
	GetMiniBlocksCalled         func(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
	GetMiniBlocksFromPoolCalled func(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
}

MiniBlocksProviderStub -

func (*MiniBlocksProviderStub) GetMiniBlocks

func (mbps *MiniBlocksProviderStub) GetMiniBlocks(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)

GetMiniBlocks -

func (*MiniBlocksProviderStub) GetMiniBlocksFromPool

func (mbps *MiniBlocksProviderStub) GetMiniBlocksFromPool(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)

GetMiniBlocksFromPool -

func (*MiniBlocksProviderStub) IsInterfaceNil

func (mbps *MiniBlocksProviderStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type MiniBlocksResolverStub

type MiniBlocksResolverStub struct {
	RequestDataFromHashCalled      func(hash []byte, epoch uint32) error
	RequestDataFromHashArrayCalled func(hashes [][]byte, epoch uint32) error
	ProcessReceivedMessageCalled   func(message p2p.MessageP2P) error
	SetNumPeersToQueryCalled       func(intra int, cross int)
	NumPeersToQueryCalled          func() (int, int)
	CloseCalled                    func() error
}

MiniBlocksResolverStub -

func (*MiniBlocksResolverStub) Close

func (mbrs *MiniBlocksResolverStub) Close() error

Close -

func (*MiniBlocksResolverStub) IsInterfaceNil

func (mbrs *MiniBlocksResolverStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MiniBlocksResolverStub) NumPeersToQuery

func (mbrs *MiniBlocksResolverStub) NumPeersToQuery() (int, int)

NumPeersToQuery -

func (*MiniBlocksResolverStub) ProcessReceivedMessage

func (mbrs *MiniBlocksResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*MiniBlocksResolverStub) RequestDataFromHash

func (mbrs *MiniBlocksResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error

RequestDataFromHash -

func (*MiniBlocksResolverStub) RequestDataFromHashArray

func (mbrs *MiniBlocksResolverStub) RequestDataFromHashArray(hashes [][]byte, epoch uint32) error

RequestDataFromHashArray -

func (*MiniBlocksResolverStub) SetNumPeersToQuery

func (mbrs *MiniBlocksResolverStub) SetNumPeersToQuery(intra int, cross int)

SetNumPeersToQuery -

func (*MiniBlocksResolverStub) SetResolverDebugHandler

func (mbrs *MiniBlocksResolverStub) SetResolverDebugHandler(_ dataRetriever.ResolverDebugHandler) error

SetResolverDebugHandler -

type MockDB

type MockDB struct {
}

MockDB -

func (MockDB) Close

func (MockDB) Close() error

Close -

func (MockDB) Destroy

func (MockDB) Destroy() error

Destroy -

func (MockDB) DestroyClosed

func (MockDB) DestroyClosed() error

DestroyClosed -

func (MockDB) Get

func (MockDB) Get(_ []byte) ([]byte, error)

Get -

func (MockDB) Has

func (MockDB) Has(_ []byte) error

Has -

func (MockDB) Init

func (MockDB) Init() error

Init -

func (MockDB) IsInterfaceNil

func (s MockDB) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (MockDB) Put

func (MockDB) Put(_, _ []byte) error

Put -

func (MockDB) RangeKeys

func (MockDB) RangeKeys(_ func(key []byte, val []byte) bool)

RangeKeys -

func (MockDB) Remove

func (MockDB) Remove(_ []byte) error

Remove -

type NetworkComponentsStub

type NetworkComponentsStub struct {
	Messenger            p2p.Messenger
	InputAntiFlood       factory.P2PAntifloodHandler
	OutputAntiFlood      factory.P2PAntifloodHandler
	PeerBlackList        process.PeerBlackListCacher
	PeerHonesty          factory.PeerHonestyHandler
	PreferredPeersHolder factory.PreferredPeersHolderHandler
}

NetworkComponentsStub -

func (*NetworkComponentsStub) CheckSubcomponents

func (ncs *NetworkComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*NetworkComponentsStub) Close

func (ncs *NetworkComponentsStub) Close() error

Close -

func (*NetworkComponentsStub) Create

func (ncs *NetworkComponentsStub) Create() error

Create -

func (*NetworkComponentsStub) InputAntiFloodHandler

func (ncs *NetworkComponentsStub) InputAntiFloodHandler() factory.P2PAntifloodHandler

InputAntiFloodHandler -

func (*NetworkComponentsStub) IsInterfaceNil

func (ncs *NetworkComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*NetworkComponentsStub) NetworkMessenger

func (ncs *NetworkComponentsStub) NetworkMessenger() p2p.Messenger

NetworkMessenger -

func (*NetworkComponentsStub) OutputAntiFloodHandler

func (ncs *NetworkComponentsStub) OutputAntiFloodHandler() factory.P2PAntifloodHandler

OutputAntiFloodHandler -

func (*NetworkComponentsStub) PeerBlackListHandler

func (ncs *NetworkComponentsStub) PeerBlackListHandler() process.PeerBlackListCacher

PeerBlackListHandler -

func (*NetworkComponentsStub) PeerHonestyHandler

func (ncs *NetworkComponentsStub) PeerHonestyHandler() factory.PeerHonestyHandler

PeerHonestyHandler -

func (*NetworkComponentsStub) PreferredPeersHolderHandler

func (ncs *NetworkComponentsStub) PreferredPeersHolderHandler() factory.PreferredPeersHolderHandler

PreferredPeersHolderHandler -

func (*NetworkComponentsStub) PubKeyCacher

func (ncs *NetworkComponentsStub) PubKeyCacher() process.TimeCacher

PubKeyCacher -

type NilAntifloodHandler

type NilAntifloodHandler struct {
}

NilAntifloodHandler is an empty implementation of P2PAntifloodHandler it does nothing

func (*NilAntifloodHandler) ApplyConsensusSize

func (nah *NilAntifloodHandler) ApplyConsensusSize(_ int)

ApplyConsensusSize does nothing

func (*NilAntifloodHandler) BlacklistPeer

func (nah *NilAntifloodHandler) BlacklistPeer(_ core.PeerID, _ string, _ time.Duration)

BlacklistPeer does nothing

func (*NilAntifloodHandler) CanProcessMessage

func (nah *NilAntifloodHandler) CanProcessMessage(_ p2p.MessageP2P, _ core.PeerID) error

CanProcessMessage will always return nil, allowing messages to go to interceptors

func (*NilAntifloodHandler) CanProcessMessagesOnTopic

func (nah *NilAntifloodHandler) CanProcessMessagesOnTopic(_ core.PeerID, _ string, _ uint32, _ uint64, _ []byte) error

CanProcessMessagesOnTopic will always return nil, allowing messages to go to interceptors

func (*NilAntifloodHandler) Close

func (nah *NilAntifloodHandler) Close() error

Close does nothing

func (*NilAntifloodHandler) IsInterfaceNil

func (nah *NilAntifloodHandler) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*NilAntifloodHandler) IsOriginatorEligibleForTopic

func (nah *NilAntifloodHandler) IsOriginatorEligibleForTopic(_ core.PeerID, _ string) error

IsOriginatorEligibleForTopic returns nil

func (*NilAntifloodHandler) ResetForTopic

func (nah *NilAntifloodHandler) ResetForTopic(_ string)

ResetForTopic won't do anything

func (*NilAntifloodHandler) SetDebugger

func (nah *NilAntifloodHandler) SetDebugger(_ process.AntifloodDebugger) error

SetDebugger returns nil

func (*NilAntifloodHandler) SetMaxMessagesForTopic

func (nah *NilAntifloodHandler) SetMaxMessagesForTopic(_ string, _ uint32)

SetMaxMessagesForTopic won't do anything

func (*NilAntifloodHandler) SetPeerValidatorMapper

func (nah *NilAntifloodHandler) SetPeerValidatorMapper(_ process.PeerValidatorMapper) error

SetPeerValidatorMapper -

func (*NilAntifloodHandler) SetTopicsForAll

func (nah *NilAntifloodHandler) SetTopicsForAll(_ ...string)

SetTopicsForAll -

type NodeInfoMock

type NodeInfoMock struct {
	// contains filtered or unexported fields
}

NodeInfoMock -

func NewNodeInfo

func NewNodeInfo(address []byte, pubKey []byte, shardId uint32, initialRating uint32) *NodeInfoMock

NewNodeInfo -

func (*NodeInfoMock) AddressBytes

func (n *NodeInfoMock) AddressBytes() []byte

AddressBytes -

func (*NodeInfoMock) AssignedShard

func (n *NodeInfoMock) AssignedShard() uint32

AssignedShard -

func (*NodeInfoMock) GetInitialRating

func (n *NodeInfoMock) GetInitialRating() uint32

GetInitialRating -

func (*NodeInfoMock) IsInterfaceNil

func (n *NodeInfoMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*NodeInfoMock) PubKeyBytes

func (n *NodeInfoMock) PubKeyBytes() []byte

PubKeyBytes -

type NodeShufflerMock

type NodeShufflerMock struct {
}

NodeShufflerMock -

func (*NodeShufflerMock) IsInterfaceNil

func (nsm *NodeShufflerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*NodeShufflerMock) UpdateNodeLists

func (nsm *NodeShufflerMock) UpdateNodeLists(args sharding.ArgsUpdateNodes) (*sharding.ResUpdateNodes, error)

UpdateNodeLists -

func (*NodeShufflerMock) UpdateParams

func (nsm *NodeShufflerMock) UpdateParams(
	_ uint32,
	_ uint32,
	_ float32,
	_ bool,
)

UpdateParams -

type NodesCoordinatorCacheStub

type NodesCoordinatorCacheStub struct {
	PutCalled func(key []byte, value interface{}) (evicted bool)
	GetCalled func(key []byte) (value interface{}, ok bool)
}

NodesCoordinatorCacheStub -

func (*NodesCoordinatorCacheStub) Get

func (rm *NodesCoordinatorCacheStub) Get(key []byte) (value interface{}, ok bool)

Get -

func (*NodesCoordinatorCacheStub) Put

func (rm *NodesCoordinatorCacheStub) Put(key []byte, value interface{}) (evicted bool)

Put -

type NodesCoordinatorMock

type NodesCoordinatorMock struct {
	ComputeValidatorsGroupCalled        func(randomness []byte, round uint64, shardId uint32, epoch uint32) ([]sharding.Validator, error)
	GetValidatorsPublicKeysCalled       func(randomness []byte, round uint64, shardId uint32, epoch uint32) ([]string, error)
	GetValidatorsRewardsAddressesCalled func(randomness []byte, round uint64, shardId uint32, epoch uint32) ([]string, error)
	GetValidatorWithPublicKeyCalled     func(publicKey []byte) (validator sharding.Validator, shardId uint32, err error)
	GetAllValidatorsPublicKeysCalled    func() (map[uint32][][]byte, error)
}

NodesCoordinatorMock -

func (*NodesCoordinatorMock) ComputeAdditionalLeaving

func (ncm *NodesCoordinatorMock) ComputeAdditionalLeaving([]*state.ShardValidatorInfo) (map[uint32][]sharding.Validator, error)

ComputeAdditionalLeaving -

func (*NodesCoordinatorMock) ComputeConsensusGroup

func (ncm *NodesCoordinatorMock) ComputeConsensusGroup(
	randomness []byte,
	round uint64,
	shardId uint32,
	epoch uint32,
) (validatorsGroup []sharding.Validator, err error)

ComputeConsensusGroup -

func (*NodesCoordinatorMock) ConsensusGroupSize

func (ncm *NodesCoordinatorMock) ConsensusGroupSize(uint32) int

ConsensusGroupSize -

func (*NodesCoordinatorMock) GetAllEligibleValidatorsPublicKeys

func (ncm *NodesCoordinatorMock) GetAllEligibleValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)

GetAllEligibleValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetAllLeavingValidatorsPublicKeys

func (ncm *NodesCoordinatorMock) GetAllLeavingValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)

GetAllLeavingValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetAllWaitingValidatorsPublicKeys

func (ncm *NodesCoordinatorMock) GetAllWaitingValidatorsPublicKeys(_ uint32) (map[uint32][][]byte, error)

GetAllWaitingValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetChance

func (ncm *NodesCoordinatorMock) GetChance(uint32) uint32

GetChance -

func (*NodesCoordinatorMock) GetConsensusValidatorsPublicKeys

func (ncm *NodesCoordinatorMock) GetConsensusValidatorsPublicKeys(
	randomness []byte,
	round uint64,
	shardId uint32,
	epoch uint32,
) ([]string, error)

GetConsensusValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetConsensusWhitelistedNodes

func (ncm *NodesCoordinatorMock) GetConsensusWhitelistedNodes(
	_ uint32,
) (map[string]struct{}, error)

GetConsensusWhitelistedNodes return the whitelisted nodes allowed to send consensus messages, for each of the shards

func (*NodesCoordinatorMock) GetNumTotalEligible

func (ncm *NodesCoordinatorMock) GetNumTotalEligible() uint64

GetNumTotalEligible -

func (*NodesCoordinatorMock) GetOwnPublicKey

func (ncm *NodesCoordinatorMock) GetOwnPublicKey() []byte

GetOwnPublicKey -

func (*NodesCoordinatorMock) GetSavedStateKey

func (ncm *NodesCoordinatorMock) GetSavedStateKey() []byte

GetSavedStateKey -

func (*NodesCoordinatorMock) GetSelectedPublicKeys

func (ncm *NodesCoordinatorMock) GetSelectedPublicKeys(_ []byte, _ uint32, _ uint32) ([]string, error)

GetSelectedPublicKeys -

func (*NodesCoordinatorMock) GetValidatorWithPublicKey

func (ncm *NodesCoordinatorMock) GetValidatorWithPublicKey(publicKey []byte) (sharding.Validator, uint32, error)

GetValidatorWithPublicKey -

func (*NodesCoordinatorMock) GetValidatorsIndexes

func (ncm *NodesCoordinatorMock) GetValidatorsIndexes(_ []string, _ uint32) ([]uint64, error)

GetValidatorsIndexes -

func (*NodesCoordinatorMock) IsInterfaceNil

func (ncm *NodesCoordinatorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*NodesCoordinatorMock) LoadState

func (ncm *NodesCoordinatorMock) LoadState(_ []byte) error

LoadState -

func (*NodesCoordinatorMock) SetNodesPerShards

func (ncm *NodesCoordinatorMock) SetNodesPerShards(_ map[uint32][]sharding.Validator, _ map[uint32][]sharding.Validator, _ uint32) error

SetNodesPerShards -

func (*NodesCoordinatorMock) ShardIdForEpoch

func (ncm *NodesCoordinatorMock) ShardIdForEpoch(_ uint32) (uint32, error)

ShardIdForEpoch returns the nodesCoordinator configured ShardId for specified epoch if epoch configuration exists, otherwise error

func (*NodesCoordinatorMock) ShuffleOutForEpoch

func (ncm *NodesCoordinatorMock) ShuffleOutForEpoch(_ uint32)

ShuffleOutForEpoch verifies if the shards changed in the new epoch and calls the shuffleOutHandler

func (*NodesCoordinatorMock) ValidatorsWeights

func (ncm *NodesCoordinatorMock) ValidatorsWeights(validators []sharding.Validator) ([]uint32, error)

ValidatorsWeights -

type NodesSetupStub

type NodesSetupStub struct {
	InitialNodesInfoForShardCalled            func(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error)
	InitialNodesInfoCalled                    func() (map[uint32][]sharding.GenesisNodeInfoHandler, map[uint32][]sharding.GenesisNodeInfoHandler)
	GetStartTimeCalled                        func() int64
	GetRoundDurationCalled                    func() uint64
	GetChainIdCalled                          func() string
	GetMinTransactionVersionCalled            func() uint32
	GetShardConsensusGroupSizeCalled          func() uint32
	GetMetaConsensusGroupSizeCalled           func() uint32
	NumberOfShardsCalled                      func() uint32
	MinNumberOfNodesCalled                    func() uint32
	MinNumberOfShardNodesCalled               func() uint32
	MinNumberOfMetaNodesCalled                func() uint32
	GetHysteresisCalled                       func() float32
	GetAdaptivityCalled                       func() bool
	AllInitialNodesCalled                     func() []sharding.GenesisNodeInfoHandler
	GetShardIDForPubKeyCalled                 func(pubkey []byte) (uint32, error)
	InitialEligibleNodesPubKeysForShardCalled func(shardId uint32) ([]string, error)
	InitialNodesPubKeysCalled                 func() map[uint32][]string
	MinNumberOfNodesWithHysteresisCalled      func() uint32
}

NodesSetupStub -

func (*NodesSetupStub) AllInitialNodes

func (n *NodesSetupStub) AllInitialNodes() []sharding.GenesisNodeInfoHandler

AllInitialNodes -

func (*NodesSetupStub) GetAdaptivity

func (n *NodesSetupStub) GetAdaptivity() bool

GetAdaptivity -

func (*NodesSetupStub) GetChainId

func (n *NodesSetupStub) GetChainId() string

GetChainId -

func (*NodesSetupStub) GetHysteresis

func (n *NodesSetupStub) GetHysteresis() float32

GetHysteresis -

func (*NodesSetupStub) GetMetaConsensusGroupSize

func (n *NodesSetupStub) GetMetaConsensusGroupSize() uint32

GetMetaConsensusGroupSize -

func (*NodesSetupStub) GetMinTransactionVersion

func (n *NodesSetupStub) GetMinTransactionVersion() uint32

GetMinTransactionVersion -

func (*NodesSetupStub) GetRoundDuration

func (n *NodesSetupStub) GetRoundDuration() uint64

GetRoundDuration -

func (*NodesSetupStub) GetShardConsensusGroupSize

func (n *NodesSetupStub) GetShardConsensusGroupSize() uint32

GetShardConsensusGroupSize -

func (*NodesSetupStub) GetShardIDForPubKey

func (n *NodesSetupStub) GetShardIDForPubKey(pubkey []byte) (uint32, error)

GetShardIDForPubKey -

func (*NodesSetupStub) GetStartTime

func (n *NodesSetupStub) GetStartTime() int64

GetStartTime -

func (*NodesSetupStub) InitialEligibleNodesPubKeysForShard

func (n *NodesSetupStub) InitialEligibleNodesPubKeysForShard(shardId uint32) ([]string, error)

InitialEligibleNodesPubKeysForShard -

func (*NodesSetupStub) InitialNodesInfo

func (n *NodesSetupStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, map[uint32][]sharding.GenesisNodeInfoHandler)

InitialNodesInfo -

func (*NodesSetupStub) InitialNodesInfoForShard

func (n *NodesSetupStub) InitialNodesInfoForShard(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error)

InitialNodesInfoForShard -

func (*NodesSetupStub) InitialNodesPubKeys

func (n *NodesSetupStub) InitialNodesPubKeys() map[uint32][]string

InitialNodesPubKeys -

func (*NodesSetupStub) IsInterfaceNil

func (n *NodesSetupStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*NodesSetupStub) MinNumberOfMetaNodes

func (n *NodesSetupStub) MinNumberOfMetaNodes() uint32

MinNumberOfMetaNodes -

func (*NodesSetupStub) MinNumberOfNodes

func (n *NodesSetupStub) MinNumberOfNodes() uint32

MinNumberOfNodes -

func (*NodesSetupStub) MinNumberOfNodesWithHysteresis

func (n *NodesSetupStub) MinNumberOfNodesWithHysteresis() uint32

MinNumberOfNodesWithHysteresis -

func (*NodesSetupStub) MinNumberOfShardNodes

func (n *NodesSetupStub) MinNumberOfShardNodes() uint32

MinNumberOfShardNodes -

func (*NodesSetupStub) NumberOfShards

func (n *NodesSetupStub) NumberOfShards() uint32

NumberOfShards -

type OneSCExecutorMockVM

type OneSCExecutorMockVM struct {
	GasForOperation uint64
	// contains filtered or unexported fields
}

OneSCExecutorMockVM contains one hardcoded SC with the following behaviour (written in golang): ------------------------------------- var a int

func init(initial int){
    a = initial
}

func Add(value int){
    a += value
}

func Get() int{
    return a
}

-------------------------------------

func NewOneSCExecutorMockVM

func NewOneSCExecutorMockVM(blockchainHook vmcommon.BlockchainHook, hasher hashing.Hasher) (*OneSCExecutorMockVM, error)

NewOneSCExecutorMockVM -

func (*OneSCExecutorMockVM) GasScheduleChange

func (vm *OneSCExecutorMockVM) GasScheduleChange(_ map[string]map[string]uint64)

GasScheduleChange -

func (*OneSCExecutorMockVM) GetVersion

func (vm *OneSCExecutorMockVM) GetVersion() string

GetVersion -

func (*OneSCExecutorMockVM) IsInterfaceNil

func (vm *OneSCExecutorMockVM) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*OneSCExecutorMockVM) RunSmartContractCall

func (vm *OneSCExecutorMockVM) RunSmartContractCall(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)

RunSmartContractCall -

func (*OneSCExecutorMockVM) RunSmartContractCreate

func (vm *OneSCExecutorMockVM) RunSmartContractCreate(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)

RunSmartContractCreate -

type P2PAntifloodHandlerStub

type P2PAntifloodHandlerStub struct {
	CanProcessMessageCalled            func(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
	CanProcessMessagesOnTopicCalled    func(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, sequence []byte) error
	ApplyConsensusSizeCalled           func(size int)
	SetDebuggerCalled                  func(debugger process.AntifloodDebugger) error
	BlacklistPeerCalled                func(peer core.PeerID, reason string, duration time.Duration)
	IsOriginatorEligibleForTopicCalled func(pid core.PeerID, topic string) error
}

P2PAntifloodHandlerStub -

func (*P2PAntifloodHandlerStub) ApplyConsensusSize

func (p2pahs *P2PAntifloodHandlerStub) ApplyConsensusSize(size int)

ApplyConsensusSize -

func (*P2PAntifloodHandlerStub) BlacklistPeer

func (p2pahs *P2PAntifloodHandlerStub) BlacklistPeer(peer core.PeerID, reason string, duration time.Duration)

BlacklistPeer -

func (*P2PAntifloodHandlerStub) CanProcessMessage

func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error

CanProcessMessage -

func (*P2PAntifloodHandlerStub) CanProcessMessagesOnTopic

func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessagesOnTopic(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, sequence []byte) error

CanProcessMessagesOnTopic -

func (*P2PAntifloodHandlerStub) Close

func (p2pahs *P2PAntifloodHandlerStub) Close() error

Close -

func (*P2PAntifloodHandlerStub) IsInterfaceNil

func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic

func (p2pahs *P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic(pid core.PeerID, topic string) error

IsOriginatorEligibleForTopic -

func (*P2PAntifloodHandlerStub) ResetForTopic

func (p2pahs *P2PAntifloodHandlerStub) ResetForTopic(_ string)

ResetForTopic -

func (*P2PAntifloodHandlerStub) SetDebugger

func (p2pahs *P2PAntifloodHandlerStub) SetDebugger(debugger process.AntifloodDebugger) error

SetDebugger -

func (*P2PAntifloodHandlerStub) SetMaxMessagesForTopic

func (p2pahs *P2PAntifloodHandlerStub) SetMaxMessagesForTopic(_ string, _ uint32)

SetMaxMessagesForTopic -

func (*P2PAntifloodHandlerStub) SetPeerValidatorMapper

func (p2pahs *P2PAntifloodHandlerStub) SetPeerValidatorMapper(_ process.PeerValidatorMapper) error

SetPeerValidatorMapper -

func (*P2PAntifloodHandlerStub) SetTopicsForAll

func (p2pahs *P2PAntifloodHandlerStub) SetTopicsForAll(_ ...string)

SetTopicsForAll -

type PeerBlackListCacherStub

type PeerBlackListCacherStub struct {
	AddCalled    func(pid core.PeerID) error
	UpsertCalled func(pid core.PeerID, span time.Duration) error
	HasCalled    func(pid core.PeerID) bool
	SweepCalled  func()
}

PeerBlackListCacherStub -

func (*PeerBlackListCacherStub) Add

func (pblhs *PeerBlackListCacherStub) Add(pid core.PeerID) error

Add -

func (*PeerBlackListCacherStub) Has

func (pblhs *PeerBlackListCacherStub) Has(pid core.PeerID) bool

Has -

func (*PeerBlackListCacherStub) IsInterfaceNil

func (pblhs *PeerBlackListCacherStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerBlackListCacherStub) Sweep

func (pblhs *PeerBlackListCacherStub) Sweep()

Sweep -

func (*PeerBlackListCacherStub) Upsert

func (pblhs *PeerBlackListCacherStub) Upsert(pid core.PeerID, span time.Duration) error

Upsert -

type PeerChangesHandler

type PeerChangesHandler struct {
	PeerChangesCalled       func() []block.PeerData
	VerifyPeerChangesCalled func(peerChanges []block.PeerData) error
}

PeerChangesHandler -

func (*PeerChangesHandler) IsInterfaceNil

func (p *PeerChangesHandler) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerChangesHandler) PeerChanges

func (p *PeerChangesHandler) PeerChanges() []block.PeerData

PeerChanges -

func (*PeerChangesHandler) VerifyPeerChanges

func (p *PeerChangesHandler) VerifyPeerChanges(peerChanges []block.PeerData) error

VerifyPeerChanges -

type PeerDenialEvaluatorStub

type PeerDenialEvaluatorStub struct {
	IsDeniedCalled    func(pid core.PeerID) bool
	UpsertPeerIDClled func(pid core.PeerID, duration time.Duration) error
}

PeerDenialEvaluatorStub -

func (*PeerDenialEvaluatorStub) IsDenied

func (pdes *PeerDenialEvaluatorStub) IsDenied(pid core.PeerID) bool

IsDenied -

func (*PeerDenialEvaluatorStub) IsInterfaceNil

func (pdes *PeerDenialEvaluatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerDenialEvaluatorStub) UpsertPeerID

func (pdes *PeerDenialEvaluatorStub) UpsertPeerID(pid core.PeerID, duration time.Duration) error

UpsertPeerID -

type PeerHonestyHandlerStub

type PeerHonestyHandlerStub struct {
	ChangeScoreCalled func(pk string, topic string, units int)
}

PeerHonestyHandlerStub -

func (*PeerHonestyHandlerStub) ChangeScore

func (phhs *PeerHonestyHandlerStub) ChangeScore(pk string, topic string, units int)

ChangeScore -

func (*PeerHonestyHandlerStub) Close

func (phhs *PeerHonestyHandlerStub) Close() error

Close -

func (*PeerHonestyHandlerStub) IsInterfaceNil

func (phhs *PeerHonestyHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type PeerShardMapperStub

type PeerShardMapperStub struct {
}

PeerShardMapperStub -

func (*PeerShardMapperStub) GetPeerInfo

func (psms *PeerShardMapperStub) GetPeerInfo(_ core.PeerID) core.P2PPeerInfo

GetPeerInfo -

func (*PeerShardMapperStub) IsInterfaceNil

func (psms *PeerShardMapperStub) IsInterfaceNil() bool

IsInterfaceNil -

type PeerSignatureHandler

type PeerSignatureHandler struct{}

PeerSignatureHandler -

func (*PeerSignatureHandler) GetPeerSignature

func (p *PeerSignatureHandler) GetPeerSignature(_ crypto.PrivateKey, _ []byte) ([]byte, error)

GetPeerSignature -

func (*PeerSignatureHandler) IsInterfaceNil

func (p *PeerSignatureHandler) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerSignatureHandler) VerifyPeerSignature

func (p *PeerSignatureHandler) VerifyPeerSignature(_ []byte, _ core.PeerID, _ []byte) error

VerifyPeerSignature -

type PeerTypeProviderStub

type PeerTypeProviderStub struct {
	ComputeForPubKeyCalled func(pubKey []byte) (common.PeerType, uint32, error)
}

PeerTypeProviderStub -

func (*PeerTypeProviderStub) Close

func (p *PeerTypeProviderStub) Close() error

Close -

func (*PeerTypeProviderStub) ComputeForPubKey

func (p *PeerTypeProviderStub) ComputeForPubKey(pubKey []byte) (common.PeerType, uint32, error)

ComputeForPubKey -

func (*PeerTypeProviderStub) GetAllPeerTypeInfos

func (p *PeerTypeProviderStub) GetAllPeerTypeInfos() []*state.PeerTypeInfo

GetAllPeerTypeInfos -

func (*PeerTypeProviderStub) IsInterfaceNil

func (p *PeerTypeProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

type PendingMiniBlocksHandlerStub

type PendingMiniBlocksHandlerStub struct {
	AddProcessedHeaderCalled   func(handler data.HeaderHandler) error
	RevertHeaderCalled         func(handler data.HeaderHandler) error
	GetPendingMiniBlocksCalled func(shardID uint32) [][]byte
	SetPendingMiniBlocksCalled func(shardID uint32, mbHashes [][]byte)
}

PendingMiniBlocksHandlerStub -

func (*PendingMiniBlocksHandlerStub) AddProcessedHeader

func (p *PendingMiniBlocksHandlerStub) AddProcessedHeader(handler data.HeaderHandler) error

AddProcessedHeader -

func (*PendingMiniBlocksHandlerStub) GetPendingMiniBlocks

func (p *PendingMiniBlocksHandlerStub) GetPendingMiniBlocks(shardID uint32) [][]byte

GetPendingMiniBlocks -

func (*PendingMiniBlocksHandlerStub) IsInterfaceNil

func (p *PendingMiniBlocksHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PendingMiniBlocksHandlerStub) RevertHeader

func (p *PendingMiniBlocksHandlerStub) RevertHeader(handler data.HeaderHandler) error

RevertHeader -

func (*PendingMiniBlocksHandlerStub) SetPendingMiniBlocks

func (p *PendingMiniBlocksHandlerStub) SetPendingMiniBlocks(shardID uint32, mbHashes [][]byte)

SetPendingMiniBlocks -

type PrivateKeyMock

type PrivateKeyMock struct {
	// contains filtered or unexported fields
}

PrivateKeyMock -

func (*PrivateKeyMock) GeneratePublic

func (sk *PrivateKeyMock) GeneratePublic() crypto.PublicKey

GeneratePublic -

func (*PrivateKeyMock) IsInterfaceNil

func (sk *PrivateKeyMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PrivateKeyMock) Scalar

func (sk *PrivateKeyMock) Scalar() crypto.Scalar

Scalar -

func (*PrivateKeyMock) Suite

func (sk *PrivateKeyMock) Suite() crypto.Suite

Suite -

func (*PrivateKeyMock) ToByteArray

func (sk *PrivateKeyMock) ToByteArray() ([]byte, error)

ToByteArray -

type ProcessComponentsStub

type ProcessComponentsStub struct {
	NodesCoord                     sharding.NodesCoordinator
	ShardCoord                     sharding.Coordinator
	IntContainer                   process.InterceptorsContainer
	ResFinder                      dataRetriever.ResolversFinder
	RoundHandlerField              consensus.RoundHandler
	EpochTrigger                   epochStart.TriggerHandler
	EpochNotifier                  factory.EpochStartNotifier
	ForkDetect                     process.ForkDetector
	BlockProcess                   process.BlockProcessor
	BlackListHdl                   process.TimeCacher
	BootSore                       process.BootStorer
	HeaderSigVerif                 process.InterceptedHeaderSigVerifier
	HeaderIntegrVerif              process.HeaderIntegrityVerifier
	ValidatorStatistics            process.ValidatorStatisticsProcessor
	ValidatorProvider              process.ValidatorsProvider
	BlockTrack                     process.BlockTracker
	PendingMiniBlocksHdl           process.PendingMiniBlocksHandler
	ReqHandler                     process.RequestHandler
	TxLogsProcess                  process.TransactionLogProcessorDatabase
	HeaderConstructValidator       process.HeaderConstructionValidator
	PeerMapper                     process.NetworkShardingCollector
	TxSimulatorProcessor           factory.TransactionSimulatorProcessor
	FallbackHdrValidator           process.FallbackHeaderValidator
	WhiteListHandlerInternal       process.WhiteListHandler
	WhiteListerVerifiedTxsInternal process.WhiteListHandler
	HistoryRepositoryInternal      dblookupext.HistoryRepository
	ImportStartHandlerInternal     update.ImportStartHandler
	RequestedItemsHandlerInternal  dataRetriever.RequestedItemsHandler
	NodeRedundancyHandlerInternal  consensus.NodeRedundancyHandler
	ArwenChangeLockerInternal      process.Locker
	CurrentEpochProviderInternal   process.CurrentNetworkEpochProviderHandler
}

ProcessComponentsStub -

func (*ProcessComponentsStub) ArwenChangeLocker

func (pcs *ProcessComponentsStub) ArwenChangeLocker() process.Locker

ArwenChangeLocker -

func (*ProcessComponentsStub) BlackListHandler

func (pcs *ProcessComponentsStub) BlackListHandler() process.TimeCacher

BlackListHandler -

func (*ProcessComponentsStub) BlockProcessor

func (pcs *ProcessComponentsStub) BlockProcessor() process.BlockProcessor

BlockProcessor -

func (*ProcessComponentsStub) BlockTracker

func (pcs *ProcessComponentsStub) BlockTracker() process.BlockTracker

BlockTracker -

func (*ProcessComponentsStub) BootStorer

func (pcs *ProcessComponentsStub) BootStorer() process.BootStorer

BootStorer -

func (*ProcessComponentsStub) CheckSubcomponents

func (pcs *ProcessComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*ProcessComponentsStub) Close

func (pcs *ProcessComponentsStub) Close() error

Close -

func (*ProcessComponentsStub) Create

func (pcs *ProcessComponentsStub) Create() error

Create -

func (*ProcessComponentsStub) CurrentEpochProvider

func (pcs *ProcessComponentsStub) CurrentEpochProvider() process.CurrentNetworkEpochProviderHandler

CurrentEpochProvider -

func (*ProcessComponentsStub) EpochStartNotifier

func (pcs *ProcessComponentsStub) EpochStartNotifier() factory.EpochStartNotifier

EpochStartNotifier -

func (*ProcessComponentsStub) EpochStartTrigger

func (pcs *ProcessComponentsStub) EpochStartTrigger() epochStart.TriggerHandler

EpochStartTrigger -

func (*ProcessComponentsStub) FallbackHeaderValidator

func (pcs *ProcessComponentsStub) FallbackHeaderValidator() process.FallbackHeaderValidator

FallbackHeaderValidator -

func (*ProcessComponentsStub) ForkDetector

func (pcs *ProcessComponentsStub) ForkDetector() process.ForkDetector

ForkDetector -

func (*ProcessComponentsStub) HeaderConstructionValidator

func (pcs *ProcessComponentsStub) HeaderConstructionValidator() process.HeaderConstructionValidator

HeaderConstructionValidator -

func (*ProcessComponentsStub) HeaderIntegrityVerifier

func (pcs *ProcessComponentsStub) HeaderIntegrityVerifier() process.HeaderIntegrityVerifier

HeaderIntegrityVerifier -

func (*ProcessComponentsStub) HeaderSigVerifier

func (pcs *ProcessComponentsStub) HeaderSigVerifier() process.InterceptedHeaderSigVerifier

HeaderSigVerifier -

func (*ProcessComponentsStub) HistoryRepository

func (pcs *ProcessComponentsStub) HistoryRepository() dblookupext.HistoryRepository

HistoryRepository -

func (*ProcessComponentsStub) ImportStartHandler

func (pcs *ProcessComponentsStub) ImportStartHandler() update.ImportStartHandler

ImportStartHandler -

func (*ProcessComponentsStub) InterceptorsContainer

func (pcs *ProcessComponentsStub) InterceptorsContainer() process.InterceptorsContainer

InterceptorsContainer -

func (*ProcessComponentsStub) IsInterfaceNil

func (pcs *ProcessComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ProcessComponentsStub) NodeRedundancyHandler

func (pcs *ProcessComponentsStub) NodeRedundancyHandler() consensus.NodeRedundancyHandler

NodeRedundancyHandler -

func (*ProcessComponentsStub) NodesCoordinator

func (pcs *ProcessComponentsStub) NodesCoordinator() sharding.NodesCoordinator

NodesCoordinator -

func (*ProcessComponentsStub) PeerShardMapper

func (pcs *ProcessComponentsStub) PeerShardMapper() process.NetworkShardingCollector

PeerShardMapper -

func (*ProcessComponentsStub) PendingMiniBlocksHandler

func (pcs *ProcessComponentsStub) PendingMiniBlocksHandler() process.PendingMiniBlocksHandler

PendingMiniBlocksHandler -

func (*ProcessComponentsStub) RequestHandler

func (pcs *ProcessComponentsStub) RequestHandler() process.RequestHandler

RequestHandler -

func (*ProcessComponentsStub) RequestedItemsHandler

func (pcs *ProcessComponentsStub) RequestedItemsHandler() dataRetriever.RequestedItemsHandler

RequestedItemsHandler -

func (*ProcessComponentsStub) ResolversFinder

func (pcs *ProcessComponentsStub) ResolversFinder() dataRetriever.ResolversFinder

ResolversFinder -

func (*ProcessComponentsStub) RoundHandler

func (pcs *ProcessComponentsStub) RoundHandler() consensus.RoundHandler

RoundHandler -

func (*ProcessComponentsStub) ShardCoordinator

func (pcs *ProcessComponentsStub) ShardCoordinator() sharding.Coordinator

ShardCoordinator -

func (*ProcessComponentsStub) TransactionSimulatorProcessor

func (pcs *ProcessComponentsStub) TransactionSimulatorProcessor() factory.TransactionSimulatorProcessor

TransactionSimulatorProcessor -

func (*ProcessComponentsStub) TxLogsProcessor

func (pcs *ProcessComponentsStub) TxLogsProcessor() process.TransactionLogProcessorDatabase

TxLogsProcessor -

func (*ProcessComponentsStub) ValidatorsProvider

func (pcs *ProcessComponentsStub) ValidatorsProvider() process.ValidatorsProvider

ValidatorsProvider -

func (*ProcessComponentsStub) ValidatorsStatistics

func (pcs *ProcessComponentsStub) ValidatorsStatistics() process.ValidatorStatisticsProcessor

ValidatorsStatistics -

func (*ProcessComponentsStub) WhiteListHandler

func (pcs *ProcessComponentsStub) WhiteListHandler() process.WhiteListHandler

WhiteListHandler -

func (*ProcessComponentsStub) WhiteListerVerifiedTxs

func (pcs *ProcessComponentsStub) WhiteListerVerifiedTxs() process.WhiteListHandler

WhiteListerVerifiedTxs -

type PublicKeyMock

type PublicKeyMock struct {
	// contains filtered or unexported fields
}

PublicKeyMock -

func (*PublicKeyMock) IsInterfaceNil

func (sspk *PublicKeyMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PublicKeyMock) Point

func (sspk *PublicKeyMock) Point() crypto.Point

Point -

func (*PublicKeyMock) Suite

func (sspk *PublicKeyMock) Suite() crypto.Suite

Suite -

func (*PublicKeyMock) ToByteArray

func (sspk *PublicKeyMock) ToByteArray() ([]byte, error)

ToByteArray -

type RaterMock

type RaterMock struct {
	GetRatingCalled                func(string) uint32
	GetStartRatingCalled           func() uint32
	GetSignedBlocksThresholdCalled func() float32
	ComputeIncreaseProposerCalled  func(shardId uint32, rating uint32) uint32
	ComputeDecreaseProposerCalled  func(shardId uint32, rating uint32, consecutiveMissedBlocks uint32) uint32
	RevertIncreaseProposerCalled   func(shardId uint32, rating uint32, nrReverts uint32) uint32
	ComputeIncreaseValidatorCalled func(shardId uint32, rating uint32) uint32
	ComputeDecreaseValidatorCalled func(shardId uint32, rating uint32) uint32
	GetChanceCalled                func(rating uint32) uint32
}

RaterMock -

func (*RaterMock) ComputeDecreaseProposer

func (rm *RaterMock) ComputeDecreaseProposer(shardId uint32, currentRating uint32, consecutiveMisses uint32) uint32

ComputeDecreaseProposer -

func (*RaterMock) ComputeDecreaseValidator

func (rm *RaterMock) ComputeDecreaseValidator(shardId uint32, currentRating uint32) uint32

ComputeDecreaseValidator -

func (*RaterMock) ComputeIncreaseProposer

func (rm *RaterMock) ComputeIncreaseProposer(shardId uint32, currentRating uint32) uint32

ComputeIncreaseProposer -

func (*RaterMock) ComputeIncreaseValidator

func (rm *RaterMock) ComputeIncreaseValidator(shardId uint32, currentRating uint32) uint32

ComputeIncreaseValidator -

func (*RaterMock) GetChance

func (rm *RaterMock) GetChance(rating uint32) uint32

GetChance -

func (*RaterMock) GetRating

func (rm *RaterMock) GetRating(pk string) uint32

GetRating -

func (*RaterMock) GetSignedBlocksThreshold

func (rm *RaterMock) GetSignedBlocksThreshold() float32

GetSignedBlocksThreshold -

func (*RaterMock) GetStartRating

func (rm *RaterMock) GetStartRating() uint32

GetStartRating -

func (*RaterMock) IsInterfaceNil

func (rm *RaterMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*RaterMock) RevertIncreaseValidator

func (rm *RaterMock) RevertIncreaseValidator(shardId uint32, currentRating uint32, nrReverts uint32) uint32

RevertIncreaseValidator -

type RatingReaderMock

type RatingReaderMock struct {
	GetRatingCalled  func(string) uint32
	GetRatingsCalled func([]string) map[string]uint32
	RatingsMap       map[string]uint32
}

RatingReaderMock -

func (*RatingReaderMock) GetRating

func (rrm *RatingReaderMock) GetRating(pk string) uint32

GetRating -

func (*RatingReaderMock) IsInterfaceNil

func (rrm *RatingReaderMock) IsInterfaceNil() bool

IsInterfaceNil -

type RedundancyHandlerStub

type RedundancyHandlerStub struct {
	IsRedundancyNodeCalled         func() bool
	IsMainMachineActiveCalled      func() bool
	ObserverPrivateKeyCalled       func() crypto.PrivateKey
	AdjustInactivityIfNeededCalled func(selfPubKey string, consensusPubKeys []string, roundIndex int64)
	ResetInactivityIfNeededCalled  func(selfPubKey string, consensusMsgPubKey string, consensusMsgPeerID core.PeerID)
}

RedundancyHandlerStub -

func (*RedundancyHandlerStub) AdjustInactivityIfNeeded

func (rhs *RedundancyHandlerStub) AdjustInactivityIfNeeded(selfPubKey string, consensusPubKeys []string, roundIndex int64)

AdjustInactivityIfNeeded -

func (*RedundancyHandlerStub) IsInterfaceNil

func (rhs *RedundancyHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*RedundancyHandlerStub) IsMainMachineActive

func (rhs *RedundancyHandlerStub) IsMainMachineActive() bool

IsMainMachineActive -

func (*RedundancyHandlerStub) IsRedundancyNode

func (rhs *RedundancyHandlerStub) IsRedundancyNode() bool

IsRedundancyNode -

func (*RedundancyHandlerStub) ObserverPrivateKey

func (rhs *RedundancyHandlerStub) ObserverPrivateKey() crypto.PrivateKey

ObserverPrivateKey -

func (*RedundancyHandlerStub) ResetInactivityIfNeeded

func (rhs *RedundancyHandlerStub) ResetInactivityIfNeeded(selfPubKey string, consensusMsgPubKey string, consensusMsgPeerID core.PeerID)

ResetInactivityIfNeeded -

type RequestedItemsHandlerStub

type RequestedItemsHandlerStub struct {
	AddCalled   func(key string) error
	HasCalled   func(key string) bool
	SweepCalled func()
}

RequestedItemsHandlerStub -

func (*RequestedItemsHandlerStub) Add

func (rihs *RequestedItemsHandlerStub) Add(key string) error

Add -

func (*RequestedItemsHandlerStub) Has

func (rihs *RequestedItemsHandlerStub) Has(key string) bool

Has -

func (*RequestedItemsHandlerStub) IsInterfaceNil

func (rihs *RequestedItemsHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*RequestedItemsHandlerStub) Sweep

func (rihs *RequestedItemsHandlerStub) Sweep()

Sweep -

type ResolversContainerStub

type ResolversContainerStub struct {
	GetCalled          func(key string) (dataRetriever.Resolver, error)
	AddCalled          func(key string, val dataRetriever.Resolver) error
	ReplaceCalled      func(key string, val dataRetriever.Resolver) error
	RemoveCalled       func(key string)
	LenCalled          func() int
	ResolverKeysCalled func() string
	IterateCalled      func(handler func(key string, resolver dataRetriever.Resolver) bool)
	CloseCalled        func() error
}

ResolversContainerStub -

func (*ResolversContainerStub) Add

func (rcs *ResolversContainerStub) Add(key string, val dataRetriever.Resolver) error

Add -

func (*ResolversContainerStub) AddMultiple

func (rcs *ResolversContainerStub) AddMultiple(_ []string, _ []dataRetriever.Resolver) error

AddMultiple -

func (*ResolversContainerStub) Close

func (rcs *ResolversContainerStub) Close() error

Close -

func (*ResolversContainerStub) Get

func (rcs *ResolversContainerStub) Get(key string) (dataRetriever.Resolver, error)

Get -

func (*ResolversContainerStub) IsInterfaceNil

func (rcs *ResolversContainerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ResolversContainerStub) Iterate

func (rcs *ResolversContainerStub) Iterate(handler func(key string, resolver dataRetriever.Resolver) bool)

Iterate -

func (*ResolversContainerStub) Len

func (rcs *ResolversContainerStub) Len() int

Len -

func (*ResolversContainerStub) Remove

func (rcs *ResolversContainerStub) Remove(key string)

Remove -

func (*ResolversContainerStub) Replace

func (rcs *ResolversContainerStub) Replace(key string, val dataRetriever.Resolver) error

Replace -

func (*ResolversContainerStub) ResolverKeys

func (rcs *ResolversContainerStub) ResolverKeys() string

ResolverKeys -

type ResolversFinderStub

type ResolversFinderStub struct {
	ResolversContainerStub
	IntraShardResolverCalled     func(baseTopic string) (dataRetriever.Resolver, error)
	MetaChainResolverCalled      func(baseTopic string) (dataRetriever.Resolver, error)
	CrossShardResolverCalled     func(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)
	MetaCrossShardResolverCalled func(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)
}

ResolversFinderStub -

func (*ResolversFinderStub) CrossShardResolver

func (rfs *ResolversFinderStub) CrossShardResolver(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)

CrossShardResolver -

func (*ResolversFinderStub) IntraShardResolver

func (rfs *ResolversFinderStub) IntraShardResolver(baseTopic string) (dataRetriever.Resolver, error)

IntraShardResolver -

func (*ResolversFinderStub) MetaChainResolver

func (rfs *ResolversFinderStub) MetaChainResolver(baseTopic string) (dataRetriever.Resolver, error)

MetaChainResolver -

func (*ResolversFinderStub) MetaCrossShardResolver

func (rfs *ResolversFinderStub) MetaCrossShardResolver(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)

MetaCrossShardResolver -

type RoundHandlerMock

type RoundHandlerMock struct {
	IndexField          int64
	TimeStampField      time.Time
	TimeDurationField   time.Duration
	RemainingTimeField  time.Duration
	BeforeGenesisCalled func() bool
}

RoundHandlerMock -

func (*RoundHandlerMock) BeforeGenesis

func (rndm *RoundHandlerMock) BeforeGenesis() bool

BeforeGenesis -

func (*RoundHandlerMock) Index

func (rm *RoundHandlerMock) Index() int64

Index -

func (*RoundHandlerMock) IsInterfaceNil

func (rm *RoundHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*RoundHandlerMock) RemainingTime

func (rm *RoundHandlerMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration

RemainingTime -

func (*RoundHandlerMock) TimeDuration

func (rm *RoundHandlerMock) TimeDuration() time.Duration

TimeDuration -

func (*RoundHandlerMock) TimeStamp

func (rm *RoundHandlerMock) TimeStamp() time.Time

TimeStamp -

func (*RoundHandlerMock) UpdateRound

func (rm *RoundHandlerMock) UpdateRound(time.Time, time.Time)

UpdateRound -

type SCToProtocolStub

type SCToProtocolStub struct {
	UpdateProtocolCalled func(body *block.Body, nonce uint64) error
}

SCToProtocolStub -

func (*SCToProtocolStub) IsInterfaceNil

func (s *SCToProtocolStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*SCToProtocolStub) UpdateProtocol

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

UpdateProtocol -

type ScQueryStub

type ScQueryStub struct {
	ExecuteQueryCalled          func(query *process.SCQuery) (*vmcommon.VMOutput, error)
	ComputeScCallGasLimitCalled func(tx *transaction.Transaction) (uint64, error)
}

ScQueryStub -

func (*ScQueryStub) ComputeScCallGasLimit

func (s *ScQueryStub) ComputeScCallGasLimit(tx *transaction.Transaction) (uint64, error)

ComputeScCallGasLimit --

func (*ScQueryStub) ExecuteQuery

func (s *ScQueryStub) ExecuteQuery(query *process.SCQuery) (*vmcommon.VMOutput, error)

ExecuteQuery -

func (*ScQueryStub) IsInterfaceNil

func (s *ScQueryStub) IsInterfaceNil() bool

IsInterfaceNil -

type ShuffledOutHandlerStub

type ShuffledOutHandlerStub struct {
	ProcessCalled         func(newShardID uint32) error
	RegisterHandlerCalled func(handler func(newShardID uint32))
	CurrentShardIDCalled  func() uint32
}

ShuffledOutHandlerStub -

func (*ShuffledOutHandlerStub) CurrentShardID

func (s *ShuffledOutHandlerStub) CurrentShardID() uint32

CurrentShardID -

func (*ShuffledOutHandlerStub) IsInterfaceNil

func (s *ShuffledOutHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ShuffledOutHandlerStub) Process

func (s *ShuffledOutHandlerStub) Process(newShardID uint32) error

Process -

func (*ShuffledOutHandlerStub) RegisterHandler

func (s *ShuffledOutHandlerStub) RegisterHandler(handler func(newShardID uint32))

RegisterHandler -

type SignerMock

type SignerMock struct {
	SignStub   func(private crypto.PrivateKey, msg []byte) ([]byte, error)
	VerifyStub func(public crypto.PublicKey, msg []byte, sig []byte) error
}

SignerMock -

func (*SignerMock) IsInterfaceNil

func (s *SignerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SignerMock) Sign

func (s *SignerMock) Sign(private crypto.PrivateKey, msg []byte) ([]byte, error)

Sign -

func (*SignerMock) Verify

func (s *SignerMock) Verify(public crypto.PublicKey, msg []byte, sig []byte) error

Verify -

type SmartContractParserStub

type SmartContractParserStub struct {
	InitialSmartContractsSplitOnOwnersShardsCalled func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialSmartContractHandler, error)
	InitialSmartContractsCalled                    func() []genesis.InitialSmartContractHandler
	GetDeployedSCAddressesCalled                   func(scType string) (map[string]struct{}, error)
}

SmartContractParserStub -

func (*SmartContractParserStub) GetDeployedSCAddresses

func (scps *SmartContractParserStub) GetDeployedSCAddresses(scType string) (map[string]struct{}, error)

GetDeployedSCAddresses -

func (*SmartContractParserStub) InitialSmartContracts

func (scps *SmartContractParserStub) InitialSmartContracts() []genesis.InitialSmartContractHandler

InitialSmartContracts -

func (*SmartContractParserStub) InitialSmartContractsSplitOnOwnersShards

func (scps *SmartContractParserStub) InitialSmartContractsSplitOnOwnersShards(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialSmartContractHandler, error)

InitialSmartContractsSplitOnOwnersShards -

func (*SmartContractParserStub) IsInterfaceNil

func (scps *SmartContractParserStub) IsInterfaceNil() bool

IsInterfaceNil -

type SoftwareVersionCheckerMock

type SoftwareVersionCheckerMock struct {
}

SoftwareVersionCheckerMock -

func (*SoftwareVersionCheckerMock) Close

func (svcm *SoftwareVersionCheckerMock) Close() error

Close -

func (*SoftwareVersionCheckerMock) IsInterfaceNil

func (svcm *SoftwareVersionCheckerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*SoftwareVersionCheckerMock) StartCheckSoftwareVersion

func (svcm *SoftwareVersionCheckerMock) StartCheckSoftwareVersion()

StartCheckSoftwareVersion -

type StatusComponentsStub

type StatusComponentsStub struct {
	Outport              outport.OutportHandler
	SoftwareVersionCheck statistics.SoftwareVersionChecker
	AppStatusHandler     core.AppStatusHandler
}

StatusComponentsStub -

func (*StatusComponentsStub) CheckSubcomponents

func (scs *StatusComponentsStub) CheckSubcomponents() error

CheckSubcomponents -

func (*StatusComponentsStub) Close

func (scs *StatusComponentsStub) Close() error

Close -

func (*StatusComponentsStub) Create

func (scs *StatusComponentsStub) Create() error

Create -

func (*StatusComponentsStub) IsInterfaceNil

func (scs *StatusComponentsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*StatusComponentsStub) OutportHandler

func (scs *StatusComponentsStub) OutportHandler() outport.OutportHandler

OutportHandler -

func (*StatusComponentsStub) SoftwareVersionChecker

func (scs *StatusComponentsStub) SoftwareVersionChecker() statistics.SoftwareVersionChecker

SoftwareVersionChecker -

type StatusMetricsStub

type StatusMetricsStub struct {
	StatusMetricsMapWithoutP2PCalled              func() map[string]interface{}
	StatusP2pMetricsMapCalled                     func() map[string]interface{}
	ConfigMetricsCalled                           func() map[string]interface{}
	EnableEpochMetricsCalled                      func() map[string]interface{}
	NetworkMetricsCalled                          func() map[string]interface{}
	EconomicsMetricsCalled                        func() map[string]interface{}
	StatusMetricsWithoutP2PPrometheusStringCalled func() string
}

StatusMetricsStub -

func (*StatusMetricsStub) ConfigMetrics

func (sms *StatusMetricsStub) ConfigMetrics() map[string]interface{}

ConfigMetrics -

func (*StatusMetricsStub) EconomicsMetrics

func (sms *StatusMetricsStub) EconomicsMetrics() map[string]interface{}

EconomicsMetrics -

func (*StatusMetricsStub) EnableEpochsMetrics

func (sms *StatusMetricsStub) EnableEpochsMetrics() map[string]interface{}

EnableEpochsMetrics

func (*StatusMetricsStub) IsInterfaceNil

func (sms *StatusMetricsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*StatusMetricsStub) NetworkMetrics

func (sms *StatusMetricsStub) NetworkMetrics() map[string]interface{}

NetworkMetrics -

func (*StatusMetricsStub) StatusMetricsMapWithoutP2P

func (sms *StatusMetricsStub) StatusMetricsMapWithoutP2P() map[string]interface{}

StatusMetricsMapWithoutP2P -

func (*StatusMetricsStub) StatusMetricsWithoutP2PPrometheusString

func (sms *StatusMetricsStub) StatusMetricsWithoutP2PPrometheusString() string

StatusMetricsWithoutP2PPrometheusString -

func (*StatusMetricsStub) StatusP2pMetricsMap

func (sms *StatusMetricsStub) StatusP2pMetricsMap() map[string]interface{}

StatusP2pMetricsMap -

type StorageBootstrapperMock

type StorageBootstrapperMock struct {
	LoadFromStorageCalled func() error
}

StorageBootstrapperMock -

func (*StorageBootstrapperMock) GetHighestBlockNonce

func (sbm *StorageBootstrapperMock) GetHighestBlockNonce() uint64

GetHighestBlockNonce -

func (*StorageBootstrapperMock) IsInterfaceNil

func (sbm *StorageBootstrapperMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*StorageBootstrapperMock) LoadFromStorage

func (sbm *StorageBootstrapperMock) LoadFromStorage() error

LoadFromStorage -

type StorageManagerStub

type StorageManagerStub struct {
	DatabaseCalled                    func() common.DBWriteCacher
	TakeSnapshotCalled                func([]byte)
	SetCheckpointCalled               func([]byte)
	GetDbThatContainsHashCalled       func([]byte) common.DBWriteCacher
	GetSnapshotThatContainsHashCalled func(rootHash []byte) common.SnapshotDbHandler
	IsPruningEnabledCalled            func() bool
	IsPruningBlockedCalled            func() bool
	EnterPruningBufferingModeCalled   func()
	ExitPruningBufferingModeCalled    func()
	IsInterfaceNilCalled              func() bool
}

StorageManagerStub -

func (*StorageManagerStub) Close

func (sms *StorageManagerStub) Close() error

Close -

func (*StorageManagerStub) Database

func (sms *StorageManagerStub) Database() common.DBWriteCacher

Database -

func (*StorageManagerStub) EnterPruningBufferingMode

func (sms *StorageManagerStub) EnterPruningBufferingMode()

EnterPruningBufferingMode -

func (*StorageManagerStub) ExitPruningBufferingMode

func (sms *StorageManagerStub) ExitPruningBufferingMode()

ExitPruningBufferingMode -

func (*StorageManagerStub) GetSnapshotDbBatchDelay

func (sms *StorageManagerStub) GetSnapshotDbBatchDelay() int

GetSnapshotDbBatchDelay -

func (*StorageManagerStub) GetSnapshotThatContainsHash

func (sms *StorageManagerStub) GetSnapshotThatContainsHash(d []byte) common.SnapshotDbHandler

GetSnapshotThatContainsHash -

func (*StorageManagerStub) IsInterfaceNil

func (sms *StorageManagerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*StorageManagerStub) IsPruningBlocked

func (sms *StorageManagerStub) IsPruningBlocked() bool

IsPruningBlocked -

func (*StorageManagerStub) IsPruningEnabled

func (sms *StorageManagerStub) IsPruningEnabled() bool

IsPruningEnabled -

func (*StorageManagerStub) SetCheckpoint

func (sms *StorageManagerStub) SetCheckpoint([]byte)

SetCheckpoint -

func (*StorageManagerStub) TakeSnapshot

func (sms *StorageManagerStub) TakeSnapshot([]byte)

TakeSnapshot -

type StorerMock

type StorerMock struct {
	// contains filtered or unexported fields
}

StorerMock -

func NewStorerMock

func NewStorerMock() *StorerMock

NewStorerMock -

func (*StorerMock) ClearCache

func (sm *StorerMock) ClearCache()

ClearCache -

func (*StorerMock) Close

func (sm *StorerMock) Close() error

Close -

func (*StorerMock) DestroyUnit

func (sm *StorerMock) DestroyUnit() error

DestroyUnit -

func (*StorerMock) Get

func (sm *StorerMock) Get(key []byte) ([]byte, error)

Get -

func (*StorerMock) GetBulkFromEpoch

func (sm *StorerMock) GetBulkFromEpoch(keys [][]byte, _ uint32) (map[string][]byte, error)

GetBulkFromEpoch -

func (*StorerMock) GetFromEpoch

func (sm *StorerMock) GetFromEpoch(key []byte, _ uint32) ([]byte, error)

GetFromEpoch -

func (*StorerMock) GetOldestEpoch

func (sm *StorerMock) GetOldestEpoch() (uint32, error)

GetOldestEpoch -

func (*StorerMock) Has

func (sm *StorerMock) Has(_ []byte) error

Has -

func (*StorerMock) IsInterfaceNil

func (sm *StorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*StorerMock) Put

func (sm *StorerMock) Put(key, data []byte) error

Put -

func (*StorerMock) PutInEpoch

func (sm *StorerMock) PutInEpoch(key, data []byte, _ uint32) error

PutInEpoch -

func (*StorerMock) RangeKeys

func (sm *StorerMock) RangeKeys(_ func(key []byte, val []byte) bool)

RangeKeys -

func (*StorerMock) Remove

func (sm *StorerMock) Remove(_ []byte) error

Remove -

func (*StorerMock) SearchFirst

func (sm *StorerMock) SearchFirst(_ []byte) ([]byte, error)

SearchFirst -

type SyncTimerMock

type SyncTimerMock struct {
	ClockOffsetCalled func() time.Duration
	CurrentTimeCalled func() time.Time
}

SyncTimerMock mocks the implementation for a SyncTimer

func (*SyncTimerMock) ClockOffset

func (stm *SyncTimerMock) ClockOffset() time.Duration

ClockOffset method gets the current time offset

func (*SyncTimerMock) Close

func (stm *SyncTimerMock) Close() error

Close -

func (*SyncTimerMock) CurrentTime

func (stm *SyncTimerMock) CurrentTime() time.Time

CurrentTime method gets the current time on which is added the current offset

func (*SyncTimerMock) FormattedCurrentTime

func (stm *SyncTimerMock) FormattedCurrentTime() string

FormattedCurrentTime method gets the formatted current time on which is added a given offset

func (*SyncTimerMock) IsInterfaceNil

func (stm *SyncTimerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SyncTimerMock) StartSyncingTime

func (stm *SyncTimerMock) StartSyncingTime()

StartSyncingTime method does the time synchronization at every syncPeriod time elapsed. This should be started as a go routine

type TimeCacheStub

type TimeCacheStub struct {
	AddCalled    func(key string) error
	UpsertCalled func(key string, span time.Duration) error
	HasCalled    func(key string) bool
	SweepCalled  func()
	LenCalled    func() int
}

TimeCacheStub -

func (*TimeCacheStub) Add

func (tcs *TimeCacheStub) Add(key string) error

Add -

func (*TimeCacheStub) Has

func (tcs *TimeCacheStub) Has(key string) bool

Has -

func (*TimeCacheStub) IsInterfaceNil

func (tcs *TimeCacheStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TimeCacheStub) Len

func (tcs *TimeCacheStub) Len() int

Len -

func (*TimeCacheStub) Sweep

func (tcs *TimeCacheStub) Sweep()

Sweep -

func (*TimeCacheStub) Upsert

func (tcs *TimeCacheStub) Upsert(key string, span time.Duration) error

Upsert -

type TopicAntiFloodStub

type TopicAntiFloodStub struct {
	IncreaseLoadCalled func(pid core.PeerID, topic string, numMessages uint32) error
}

TopicAntiFloodStub -

func (*TopicAntiFloodStub) IncreaseLoad

func (t *TopicAntiFloodStub) IncreaseLoad(pid core.PeerID, topic string, numMessages uint32) error

IncreaseLoad -

func (*TopicAntiFloodStub) IsInterfaceNil

func (t *TopicAntiFloodStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TopicAntiFloodStub) ResetForNotRegisteredTopics

func (t *TopicAntiFloodStub) ResetForNotRegisteredTopics()

ResetForNotRegisteredTopics -

func (*TopicAntiFloodStub) ResetForTopic

func (t *TopicAntiFloodStub) ResetForTopic(_ string)

ResetForTopic -

func (*TopicAntiFloodStub) SetMaxMessagesForTopic

func (t *TopicAntiFloodStub) SetMaxMessagesForTopic(_ string, _ uint32)

SetMaxMessagesForTopic -

type TransactionCoordinatorMock

type TransactionCoordinatorMock struct {
	ComputeTransactionTypeCalled                         func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
	RequestMiniBlocksCalled                              func(header data.HeaderHandler)
	RequestBlockTransactionsCalled                       func(body *block.Body)
	IsDataPreparedForProcessingCalled                    func(haveTime func() time.Duration) error
	SaveTxsToStorageCalled                               func(body *block.Body) error
	RestoreBlockDataFromStorageCalled                    func(body *block.Body) (int, error)
	RemoveBlockDataFromPoolCalled                        func(body *block.Body) error
	RemoveTxsFromPoolCalled                              func(body *block.Body) error
	ProcessBlockTransactionCalled                        func(body *block.Body, haveTime func() time.Duration) error
	CreateBlockStartedCalled                             func()
	CreateMbsAndProcessCrossShardTransactionsDstMeCalled func(header data.HeaderHandler,
		processedMiniBlocksHashes map[string]struct{},

		haveTime func() bool,
	) (block.MiniBlockSlice, uint32, bool, error)
	CreateMbsAndProcessTransactionsFromMeCalled func(haveTime func() bool) block.MiniBlockSlice
	CreateMarshalizedDataCalled                 func(body *block.Body) map[string][][]byte
	GetAllCurrentUsedTxsCalled                  func(blockType block.Type) map[string]data.TransactionHandler
	VerifyCreatedBlockTransactionsCalled        func(hdr data.HeaderHandler, body *block.Body) error
	CreatePostProcessMiniBlocksCalled           func() block.MiniBlockSlice
	CreateMarshalizedReceiptsCalled             func() ([]byte, error)
	VerifyCreatedMiniBlocksCalled               func(hdr data.HeaderHandler, body *block.Body) error
}

TransactionCoordinatorMock -

func (*TransactionCoordinatorMock) ComputeTransactionType

func (tcm *TransactionCoordinatorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)

ComputeTransactionType -

func (*TransactionCoordinatorMock) CreateBlockStarted

func (tcm *TransactionCoordinatorMock) CreateBlockStarted()

CreateBlockStarted -

func (*TransactionCoordinatorMock) CreateMarshalizedData

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

CreateMarshalizedData -

func (*TransactionCoordinatorMock) CreateMarshalizedReceipts

func (tcm *TransactionCoordinatorMock) CreateMarshalizedReceipts() ([]byte, error)

CreateMarshalizedReceipts -

func (*TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe

func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe(
	header data.HeaderHandler,
	processedMiniBlocksHashes map[string]struct{},

	haveTime func() bool,
) (block.MiniBlockSlice, uint32, bool, error)

CreateMbsAndProcessCrossShardTransactionsDstMe -

func (*TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe

func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe(haveTime func() bool) block.MiniBlockSlice

CreateMbsAndProcessTransactionsFromMe -

func (*TransactionCoordinatorMock) CreatePostProcessMiniBlocks

func (tcm *TransactionCoordinatorMock) CreatePostProcessMiniBlocks() block.MiniBlockSlice

CreatePostProcessMiniBlocks -

func (*TransactionCoordinatorMock) CreateReceiptsHash

func (tcm *TransactionCoordinatorMock) CreateReceiptsHash() ([]byte, error)

CreateReceiptsHash -

func (*TransactionCoordinatorMock) GetAllCurrentLogs

func (tcm *TransactionCoordinatorMock) GetAllCurrentLogs() map[string]data.LogHandler

GetAllCurrentLogs -

func (*TransactionCoordinatorMock) GetAllCurrentUsedTxs

func (tcm *TransactionCoordinatorMock) GetAllCurrentUsedTxs(blockType block.Type) map[string]data.TransactionHandler

GetAllCurrentUsedTxs -

func (*TransactionCoordinatorMock) IsDataPreparedForProcessing

func (tcm *TransactionCoordinatorMock) IsDataPreparedForProcessing(haveTime func() time.Duration) error

IsDataPreparedForProcessing -

func (*TransactionCoordinatorMock) IsInterfaceNil

func (tcm *TransactionCoordinatorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TransactionCoordinatorMock) ProcessBlockTransaction

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

ProcessBlockTransaction -

func (*TransactionCoordinatorMock) RemoveBlockDataFromPool

func (tcm *TransactionCoordinatorMock) RemoveBlockDataFromPool(body *block.Body) error

RemoveBlockDataFromPool -

func (*TransactionCoordinatorMock) RemoveTxsFromPool

func (tcm *TransactionCoordinatorMock) RemoveTxsFromPool(body *block.Body) error

RemoveTxsFromPool -

func (*TransactionCoordinatorMock) RequestBlockTransactions

func (tcm *TransactionCoordinatorMock) RequestBlockTransactions(body *block.Body)

RequestBlockTransactions -

func (*TransactionCoordinatorMock) RequestMiniBlocks

func (tcm *TransactionCoordinatorMock) RequestMiniBlocks(header data.HeaderHandler)

RequestMiniBlocks -

func (*TransactionCoordinatorMock) RestoreBlockDataFromStorage

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

RestoreBlockDataFromStorage -

func (*TransactionCoordinatorMock) SaveTxsToStorage

func (tcm *TransactionCoordinatorMock) SaveTxsToStorage(body *block.Body) error

SaveTxsToStorage -

func (*TransactionCoordinatorMock) VerifyCreatedBlockTransactions

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

VerifyCreatedBlockTransactions -

func (*TransactionCoordinatorMock) VerifyCreatedMiniBlocks

func (tcm *TransactionCoordinatorMock) VerifyCreatedMiniBlocks(hdr data.HeaderHandler, body *block.Body) error

VerifyCreatedMiniBlocks -

type TransactionSimulatorStub

type TransactionSimulatorStub struct {
	ProcessTxCalled func(tx *transaction.Transaction) (*txSimData.SimulationResults, error)
}

TransactionSimulatorStub -

func (*TransactionSimulatorStub) IsInterfaceNil

func (tss *TransactionSimulatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TransactionSimulatorStub) ProcessTx

func (tss *TransactionSimulatorStub) ProcessTx(tx *transaction.Transaction) (*txSimData.SimulationResults, error)

ProcessTx -

type TriesHolderStub

type TriesHolderStub struct {
	PutCalled    func([]byte, common.Trie)
	RemoveCalled func([]byte, common.Trie)
	GetCalled    func([]byte) common.Trie
	GetAllCalled func() []common.Trie
	ResetCalled  func()
}

TriesHolderStub -

func (*TriesHolderStub) Get

func (ths *TriesHolderStub) Get(key []byte) common.Trie

Get -

func (*TriesHolderStub) GetAll

func (ths *TriesHolderStub) GetAll() []common.Trie

GetAll -

func (*TriesHolderStub) IsInterfaceNil

func (ths *TriesHolderStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TriesHolderStub) Put

func (ths *TriesHolderStub) Put(key []byte, trie common.Trie)

Put -

func (*TriesHolderStub) Replace

func (ths *TriesHolderStub) Replace(key []byte, trie common.Trie)

Replace -

func (*TriesHolderStub) Reset

func (ths *TriesHolderStub) Reset()

Reset -

type TxForCurrentBlockStub

type TxForCurrentBlockStub struct {
	CleanCalled func()
	GetTxCalled func(txHash []byte) (data.TransactionHandler, error)
	AddTxCalled func(txHash []byte, tx data.TransactionHandler)
}

TxForCurrentBlockStub -

func (*TxForCurrentBlockStub) AddTx

func (t *TxForCurrentBlockStub) AddTx(txHash []byte, tx data.TransactionHandler)

AddTx -

func (*TxForCurrentBlockStub) Clean

func (t *TxForCurrentBlockStub) Clean()

Clean -

func (*TxForCurrentBlockStub) GetTx

func (t *TxForCurrentBlockStub) GetTx(txHash []byte) (data.TransactionHandler, error)

GetTx -

func (*TxForCurrentBlockStub) IsInterfaceNil

func (t *TxForCurrentBlockStub) IsInterfaceNil() bool

IsInterfaceNil -

type TxLogProcessorMock

type TxLogProcessorMock struct {
}

TxLogProcessorMock -

func (*TxLogProcessorMock) Clean

func (t *TxLogProcessorMock) Clean()

Clean -

func (*TxLogProcessorMock) EnableLogToBeSavedInCache

func (t *TxLogProcessorMock) EnableLogToBeSavedInCache()

EnableLogToBeSavedInCache -

func (*TxLogProcessorMock) GetLogFromCache

func (t *TxLogProcessorMock) GetLogFromCache(_ []byte) (data.LogHandler, bool)

GetLogFromCache -

func (*TxLogProcessorMock) IsInterfaceNil

func (t *TxLogProcessorMock) IsInterfaceNil() bool

IsInterfaceNil -

type TxLogsProcessorStub

type TxLogsProcessorStub struct {
	GetLogCalled  func(txHash []byte) (data.LogHandler, error)
	SaveLogCalled func(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error
}

TxLogsProcessorStub -

func (*TxLogsProcessorStub) Clean

func (txls *TxLogsProcessorStub) Clean()

Clean -

func (*TxLogsProcessorStub) GetAllCurrentLogs

func (txls *TxLogsProcessorStub) GetAllCurrentLogs() map[string]data.LogHandler

GetAllCurrentLogs -

func (*TxLogsProcessorStub) GetLog

func (txls *TxLogsProcessorStub) GetLog(txHash []byte) (data.LogHandler, error)

GetLog -

func (*TxLogsProcessorStub) IsInterfaceNil

func (txls *TxLogsProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TxLogsProcessorStub) SaveLog

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

SaveLog -

type Uint64ByteSliceConverterMock

type Uint64ByteSliceConverterMock struct {
	ToByteSliceCalled func(uint64) []byte
	ToUint64Called    func([]byte) (uint64, error)
}

Uint64ByteSliceConverterMock converts byte slice to/from uint64

func (*Uint64ByteSliceConverterMock) IsInterfaceNil

func (u *Uint64ByteSliceConverterMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*Uint64ByteSliceConverterMock) ToByteSlice

func (u *Uint64ByteSliceConverterMock) ToByteSlice(p uint64) []byte

ToByteSlice is a mock implementation for Uint64ByteSliceConverter

func (*Uint64ByteSliceConverterMock) ToUint64

func (u *Uint64ByteSliceConverterMock) ToUint64(p []byte) (uint64, error)

ToUint64 is a mock implementation for Uint64ByteSliceConverter

type UnitOpenerStub

type UnitOpenerStub struct {
}

UnitOpenerStub -

func (*UnitOpenerStub) GetMostRecentBootstrapStorageUnit

func (u *UnitOpenerStub) GetMostRecentBootstrapStorageUnit() (storage.Storer, error)

GetMostRecentBootstrapStorageUnit -

func (*UnitOpenerStub) IsInterfaceNil

func (u *UnitOpenerStub) IsInterfaceNil() bool

IsInterfaceNil -

type VMContainerMock

type VMContainerMock struct {
	GetCalled         func(key []byte) (vmcommon.VMExecutionHandler, error)
	AddCalled         func(key []byte, val vmcommon.VMExecutionHandler) error
	AddMultipleCalled func(keys [][]byte, preprocessors []vmcommon.VMExecutionHandler) error
	ReplaceCalled     func(key []byte, val vmcommon.VMExecutionHandler) error
	RemoveCalled      func(key []byte)
	LenCalled         func() int
	KeysCalled        func() [][]byte
}

VMContainerMock -

func (*VMContainerMock) Add

func (vmc *VMContainerMock) Add(key []byte, val vmcommon.VMExecutionHandler) error

Add -

func (*VMContainerMock) AddMultiple

func (vmc *VMContainerMock) AddMultiple(keys [][]byte, vms []vmcommon.VMExecutionHandler) error

AddMultiple -

func (*VMContainerMock) Close

func (V *VMContainerMock) Close() error

Close -

func (*VMContainerMock) Get

func (vmc *VMContainerMock) Get(key []byte) (vmcommon.VMExecutionHandler, error)

Get -

func (*VMContainerMock) IsInterfaceNil

func (vmc *VMContainerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*VMContainerMock) Keys

func (vmc *VMContainerMock) Keys() [][]byte

Keys -

func (*VMContainerMock) Len

func (vmc *VMContainerMock) Len() int

Len -

func (*VMContainerMock) Remove

func (vmc *VMContainerMock) Remove(key []byte)

Remove -

func (*VMContainerMock) Replace

func (vmc *VMContainerMock) Replace(key []byte, val vmcommon.VMExecutionHandler) error

Replace -

type VMExecutionHandlerStub

type VMExecutionHandlerStub struct {
	RunSmartContractCreateCalled func(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)
	RunSmartContractCallCalled   func(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
	GasScheduleChangeCalled      func(gasSchedule map[string]map[string]uint64)
	GetVersionCalled             func() string
}

VMExecutionHandlerStub -

func (*VMExecutionHandlerStub) GasScheduleChange

func (vm *VMExecutionHandlerStub) GasScheduleChange(gasSchedule map[string]map[string]uint64)

GasScheduleChange -

func (*VMExecutionHandlerStub) GetVersion

func (vm *VMExecutionHandlerStub) GetVersion() string

GetVersion -

func (*VMExecutionHandlerStub) IsInterfaceNil

func (vm *VMExecutionHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*VMExecutionHandlerStub) RunSmartContractCall

func (vm *VMExecutionHandlerStub) RunSmartContractCall(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)

RunSmartContractCall computes the result of a smart contract call and how the system must change after the execution

func (*VMExecutionHandlerStub) RunSmartContractCreate

func (vm *VMExecutionHandlerStub) RunSmartContractCreate(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)

RunSmartContractCreate --

type ValidatorInfoSyncerStub

type ValidatorInfoSyncerStub struct {
}

ValidatorInfoSyncerStub -

func (*ValidatorInfoSyncerStub) IsInterfaceNil

func (vip *ValidatorInfoSyncerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorInfoSyncerStub) SyncMiniBlocks

func (vip *ValidatorInfoSyncerStub) SyncMiniBlocks(*block.MetaBlock) ([][]byte, data.BodyHandler, error)

SyncMiniBlocks -

type ValidatorStatisticsProcessorStub

type ValidatorStatisticsProcessorStub struct {
	UpdatePeerStateCalled                    func(header data.HeaderHandler) ([]byte, error)
	RevertPeerStateCalled                    func(header data.HeaderHandler) error
	GetPeerAccountCalled                     func(address []byte) (state.PeerAccountHandler, error)
	RootHashCalled                           func() ([]byte, error)
	ResetValidatorStatisticsAtNewEpochCalled func(vInfos map[uint32][]*state.ValidatorInfo) error
	GetValidatorInfoForRootHashCalled        func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)
	ProcessRatingsEndOfEpochCalled           func(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error
	ProcessCalled                            func(validatorInfo data.ShardValidatorInfoHandler) error
	CommitCalled                             func() ([]byte, error)
	PeerAccountToValidatorInfoCalled         func(peerAccount state.PeerAccountHandler) *state.ValidatorInfo
	SaveNodesCoordinatorUpdatesCalled        func(epoch uint32) (bool, error)
}

ValidatorStatisticsProcessorStub -

func (*ValidatorStatisticsProcessorStub) Commit

func (vsp *ValidatorStatisticsProcessorStub) Commit() ([]byte, error)

Commit -

func (*ValidatorStatisticsProcessorStub) DisplayRatings

func (vsp *ValidatorStatisticsProcessorStub) DisplayRatings(_ uint32)

DisplayRatings -

func (*ValidatorStatisticsProcessorStub) GetExistingPeerAccount

func (vsp *ValidatorStatisticsProcessorStub) GetExistingPeerAccount(address []byte) (state.PeerAccountHandler, error)

GetExistingPeerAccount -

func (*ValidatorStatisticsProcessorStub) GetValidatorInfoForRootHash

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

GetValidatorInfoForRootHash -

func (*ValidatorStatisticsProcessorStub) IsInterfaceNil

func (vsp *ValidatorStatisticsProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorStatisticsProcessorStub) LastFinalizedRootHash

func (vsp *ValidatorStatisticsProcessorStub) LastFinalizedRootHash() []byte

LastFinalizedRootHash -

func (*ValidatorStatisticsProcessorStub) PeerAccountToValidatorInfo

func (vsp *ValidatorStatisticsProcessorStub) PeerAccountToValidatorInfo(peerAccount state.PeerAccountHandler) *state.ValidatorInfo

PeerAccountToValidatorInfo -

func (*ValidatorStatisticsProcessorStub) Process

func (vsp *ValidatorStatisticsProcessorStub) Process(validatorInfo data.ShardValidatorInfoHandler) error

Process -

func (*ValidatorStatisticsProcessorStub) ProcessRatingsEndOfEpoch

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

ProcessRatingsEndOfEpoch -

func (*ValidatorStatisticsProcessorStub) ResetValidatorStatisticsAtNewEpoch

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

ResetValidatorStatisticsAtNewEpoch -

func (*ValidatorStatisticsProcessorStub) RevertPeerState

func (vsp *ValidatorStatisticsProcessorStub) RevertPeerState(header data.HeaderHandler) error

RevertPeerState -

func (*ValidatorStatisticsProcessorStub) RootHash

func (vsp *ValidatorStatisticsProcessorStub) RootHash() ([]byte, error)

RootHash -

func (*ValidatorStatisticsProcessorStub) SaveNodesCoordinatorUpdates

func (vsp *ValidatorStatisticsProcessorStub) SaveNodesCoordinatorUpdates(epoch uint32) (bool, error)

SaveNodesCoordinatorUpdates -

func (*ValidatorStatisticsProcessorStub) SetLastFinalizedRootHash

func (vsp *ValidatorStatisticsProcessorStub) SetLastFinalizedRootHash(_ []byte)

SetLastFinalizedRootHash -

func (*ValidatorStatisticsProcessorStub) UpdatePeerState

func (vsp *ValidatorStatisticsProcessorStub) UpdatePeerState(header data.HeaderHandler, _ map[string]data.HeaderHandler) ([]byte, error)

UpdatePeerState -

type ValidatorsProviderStub

type ValidatorsProviderStub struct {
	GetLatestValidatorsCalled func() map[string]*state.ValidatorApiResponse
}

ValidatorsProviderStub -

func (*ValidatorsProviderStub) Close

func (vp *ValidatorsProviderStub) Close() error

Close -

func (*ValidatorsProviderStub) GetLatestValidators

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

GetLatestValidators -

func (*ValidatorsProviderStub) IsInterfaceNil

func (vp *ValidatorsProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

type VmMachinesContainerFactoryMock

type VmMachinesContainerFactoryMock struct {
}

VmMachinesContainerFactoryMock -

func (*VmMachinesContainerFactoryMock) BlockChainHookImpl

func (v *VmMachinesContainerFactoryMock) BlockChainHookImpl() process.BlockChainHookHandler

BlockChainHookImpl -

func (*VmMachinesContainerFactoryMock) Close

func (v *VmMachinesContainerFactoryMock) Close() error

Close -

func (*VmMachinesContainerFactoryMock) Create

func (v *VmMachinesContainerFactoryMock) Create() (process.VirtualMachinesContainer, error)

Create -

func (*VmMachinesContainerFactoryMock) IsInterfaceNil

func (v *VmMachinesContainerFactoryMock) IsInterfaceNil() bool

IsInterfaceNil -

type WatchdogMock

type WatchdogMock struct {
}

WatchdogMock -

func (*WatchdogMock) IsInterfaceNil

func (w *WatchdogMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*WatchdogMock) Reset

func (w *WatchdogMock) Reset(alarmID string)

Reset -

func (*WatchdogMock) Set

func (w *WatchdogMock) Set(callback func(alarmID string), duration time.Duration, alarmID string)

Set -

func (*WatchdogMock) SetDefault

func (w *WatchdogMock) SetDefault(duration time.Duration, alarmID string)

SetDefault -

func (*WatchdogMock) Stop

func (w *WatchdogMock) Stop(alarmID string)

Stop -