mock

Documentation

Index

• Constants
• func NewCountingDB() *countingDB
• func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock
• func NewNetworkShardingCollectorMock() *networkShardingCollectorMock
• func NewNodesHandlerMock(initialNodesSetup genesis.InitialNodesHandler) (*nodesHandlerMock, error)
• type AccountsFactoryStub
  • func (afs *AccountsFactoryStub) CreateAccount(address []byte) (state.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 AccountsStub
  • func (as *AccountsStub) CancelPrune(rootHash []byte, identifier data.TriePruningIdentifier)
  • func (as *AccountsStub) Commit() ([]byte, error)
  • func (as *AccountsStub) GetAllLeaves(rootHash []byte, ctx context.Context) (chan core.KeyValueHolder, error)
  • func (as *AccountsStub) GetCode(_ []byte) []byte
  • func (as *AccountsStub) GetExistingAccount(address []byte) (state.AccountHandler, error)
  • func (as *AccountsStub) GetNumCheckpoints() uint32
  • func (as *AccountsStub) IsInterfaceNil() bool
  • func (as *AccountsStub) IsPruningEnabled() bool
  • func (as *AccountsStub) JournalLen() int
  • func (as *AccountsStub) LoadAccount(address []byte) (state.AccountHandler, error)
  • func (as *AccountsStub) PruneTrie(rootHash []byte, identifier data.TriePruningIdentifier)
  • func (as *AccountsStub) RecreateAllTries(_ []byte, _ context.Context) (map[string]data.Trie, error)
  • func (as *AccountsStub) RecreateTrie(rootHash []byte) error
  • func (as *AccountsStub) RemoveAccount(address []byte) error
  • func (as *AccountsStub) RevertToSnapshot(snapshot int) error
  • func (as *AccountsStub) RootHash() ([]byte, error)
  • func (as *AccountsStub) SaveAccount(account state.AccountHandler) error
  • func (as *AccountsStub) SetStateCheckpoint(rootHash []byte, ctx context.Context)
  • func (as *AccountsStub) SnapshotState(rootHash []byte, ctx context.Context)
• 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 BelNevMock
  • func NewMultiSigner(nrConsens uint32) *BelNevMock
  • func (bnm *BelNevMock) AggregateCommitments(bitmap []byte) error
  • func (bnm *BelNevMock) AggregateSigs(bitmap []byte) ([]byte, error)
  • func (bnm *BelNevMock) Commitment(index uint16) ([]byte, error)
  • func (bnm *BelNevMock) CommitmentHash(index uint16) ([]byte, error)
  • func (bnm *BelNevMock) Create(pubKeys []string, index uint16) (crypto.MultiSigner, error)
  • func (bnm *BelNevMock) CreateCommitment() (commSecret []byte, commitment []byte)
  • func (bnm *BelNevMock) CreateSignatureShare(msg []byte, bitmap []byte) ([]byte, error)
  • func (bnm *BelNevMock) IsInterfaceNil() bool
  • func (bnm *BelNevMock) Reset(pubKeys []string, index uint16) error
  • func (bnm *BelNevMock) SetAggregatedSig(aggSig []byte) error
  • func (bnm *BelNevMock) SignatureShare(index uint16) ([]byte, error)
  • func (bnm *BelNevMock) StoreCommitment(index uint16, value []byte) error
  • func (bnm *BelNevMock) StoreCommitmentHash(index uint16, commHash []byte) error
  • func (bnm *BelNevMock) StoreSignatureShare(index uint16, sig []byte) error
  • func (bnm *BelNevMock) Verify(msg []byte, bitmap []byte) error
  • func (bnm *BelNevMock) VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error
• 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) GetBuiltInFunctions() process.BuiltInFunctionContainer
  • 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) 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) 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) CheckBlockAgainstRounder(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(_ process.TransactionWithFeeHandler) uint64
  • func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ process.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) 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 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(epoch uint32)
  • func (ens *EpochNotifierStub) CurrentEpoch() uint32
  • func (ens *EpochNotifierStub) IsInterfaceNil() bool
  • func (ens *EpochNotifierStub) RegisterNotifyHandler(handler core.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 (esns *EpochStartNotifierStub) IsInterfaceNil() bool
  • func (esns *EpochStartNotifierStub) NotifyAll(hdr data.HeaderHandler)
  • func (esns *EpochStartNotifierStub) NotifyAllPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
  • func (esns *EpochStartNotifierStub) RegisterHandler(handler epochStart.ActionHandler)
  • func (esns *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 process.TransactionWithFeeHandler) error
  • func (fhs *FeeHandlerStub) ComputeFeeForProcessing(tx process.TransactionWithFeeHandler, gasToUse uint64) *big.Int
  • func (fhs *FeeHandlerStub) ComputeGasLimit(tx process.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) ComputeMoveBalanceFee(tx process.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) ComputeTxFee(tx process.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) DeveloperPercentage() float64
  • 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) MinGasPrice() uint64
  • func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64)
  • func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64)
  • func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice 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 HeaderResolverMock
  • func (hrm *HeaderResolverMock) IsInterfaceNil() bool
  • func (hrm *HeaderResolverMock) NumPeersToQuery() (int, int)
  • func (hrm *HeaderResolverMock) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (hrm *HeaderResolverMock) RequestDataFromEpoch(identifier []byte) error
  • func (hrm *HeaderResolverMock) RequestDataFromHash(hash []byte, epoch uint32) error
  • func (hrm *HeaderResolverMock) RequestDataFromNonce(nonce uint64, epoch uint32) error
  • func (hrm *HeaderResolverMock) SetEpochHandler(epochHandler dataRetriever.EpochHandler) error
  • func (hrm *HeaderResolverMock) SetNumPeersToQuery(intra int, cross int)
  • func (hrm *HeaderResolverMock) 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 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 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 InterceptorStub
  • func (is *InterceptorStub) IsInterfaceNil() bool
  • func (is *InterceptorStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (is *InterceptorStub) RegisterHandler(_ func(topic string, hash []byte, data interface{}))
  • func (is *InterceptorStub) SetInterceptedDebugHandler(handler process.InterceptedDebugger) error
• type InterceptorsContainerStub
  • func (ics *InterceptorsContainerStub) Add(_ string, _ process.Interceptor) error
  • func (ics *InterceptorsContainerStub) AddMultiple(_ []string, _ []process.Interceptor) error
  • func (ics *InterceptorsContainerStub) Get(topic string) (process.Interceptor, error)
  • func (ics *InterceptorsContainerStub) IsInterfaceNil() bool
  • func (ics *InterceptorsContainerStub) Iterate(handler func(key string, interceptor process.Interceptor) bool)
  • func (ics *InterceptorsContainerStub) Len() int
  • func (ics *InterceptorsContainerStub) Remove(_ string)
  • func (ics *InterceptorsContainerStub) Replace(_ string, _ process.Interceptor) error
• 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 MiniBlocksResolverMock
  • func (hrm *MiniBlocksResolverMock) IsInterfaceNil() bool
  • func (hrm *MiniBlocksResolverMock) NumPeersToQuery() (int, int)
  • func (hrm *MiniBlocksResolverMock) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (hrm *MiniBlocksResolverMock) RequestDataFromHash(hash []byte, epoch uint32) error
  • func (hrm *MiniBlocksResolverMock) RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
  • func (hrm *MiniBlocksResolverMock) SetNumPeersToQuery(intra int, cross int)
  • func (hrm *MiniBlocksResolverMock) 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 NetworkShardingCollectorStub
  • func (nscs *NetworkShardingCollectorStub) IsInterfaceNil() bool
  • func (nscs *NetworkShardingCollectorStub) UpdatePeerIdPublicKey(pid core.PeerID, pk []byte)
  • func (nscs *NetworkShardingCollectorStub) UpdatePeerIdShardId(pid core.PeerID, shardId uint32)
  • func (nscs *NetworkShardingCollectorStub) UpdatePublicKeyShardId(pk []byte, shardId uint32)
• 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) 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)
• 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) 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) GetStartTime() int64
  • func (n *NodesSetupStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)
  • func (n *NodesSetupStub) InitialNodesInfoForShard(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error)
  • 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) 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) IsInterfaceNil() bool
  • func (p2pahs *P2PAntifloodHandlerStub) ResetForTopic(_ string)
  • func (p2pahs *P2PAntifloodHandlerStub) SetMaxMessagesForTopic(_ string, _ uint32)
• type PathManagerStub
  • func (p *PathManagerStub) IsInterfaceNil() bool
  • func (p *PathManagerStub) PathForEpoch(shardId string, epoch uint32, identifier string) string
  • func (p *PathManagerStub) PathForStatic(shardId string, identifier string) 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) IsInterfaceNil() bool
• type PeerShardMapperStub
  • func (psms *PeerShardMapperStub) GetPeerInfo(_ core.PeerID) core.P2PPeerInfo
  • func (psms *PeerShardMapperStub) IsInterfaceNil() bool
• type PeerTypeProviderStub
  • func (p *PeerTypeProviderStub) Close() error
  • func (p *PeerTypeProviderStub) ComputeForPubKey(pubKey []byte) (core.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 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 RequestHandlerStub
  • func (rhs *RequestHandlerStub) GetNumPeersToQuery(key string) (int, int, error)
  • func (rhs *RequestHandlerStub) IsInterfaceNil() bool
  • func (rhs *RequestHandlerStub) RequestInterval() time.Duration
  • func (rhs *RequestHandlerStub) RequestMetaHeader(hash []byte)
  • func (rhs *RequestHandlerStub) RequestMetaHeaderByNonce(nonce uint64)
  • func (rhs *RequestHandlerStub) RequestMiniBlock(destShardID uint32, miniblockHash []byte)
  • func (rhs *RequestHandlerStub) RequestMiniBlocks(destShardID uint32, miniblocksHashes [][]byte)
  • func (rhs *RequestHandlerStub) RequestRewardTransactions(destShardID uint32, txHashes [][]byte)
  • func (rhs *RequestHandlerStub) RequestShardHeader(shardID uint32, hash []byte)
  • func (rhs *RequestHandlerStub) RequestShardHeaderByNonce(shardID uint32, nonce uint64)
  • func (rhs *RequestHandlerStub) RequestStartOfEpochMetaBlock(epoch uint32)
  • func (rhs *RequestHandlerStub) RequestTransaction(destShardID uint32, txHashes [][]byte)
  • func (rhs *RequestHandlerStub) RequestTrieNodes(destShardID uint32, hashes [][]byte, topic string)
  • func (rhs *RequestHandlerStub) RequestUnsignedTransactions(destShardID uint32, txHashes [][]byte)
  • func (rhs *RequestHandlerStub) SetEpoch(_ uint32)
  • func (rhs *RequestHandlerStub) SetNumPeersToQuery(key string, intra int, cross int) error
• 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) 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 RounderMock
  • func (rndm *RounderMock) BeforeGenesis() bool
  • func (rm *RounderMock) Index() int64
  • func (rm *RounderMock) IsInterfaceNil() bool
  • func (rm *RounderMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration
  • func (rm *RounderMock) TimeDuration() time.Duration
  • func (rm *RounderMock) TimeStamp() time.Time
  • func (rm *RounderMock) UpdateRound(time.Time, time.Time)
• type SCProcessorMock
  • func (sc *SCProcessorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
  • func (sc *SCProcessorMock) DeploySmartContract(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error)
  • func (sc *SCProcessorMock) ExecuteBuiltInFunction(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error)
  • func (sc *SCProcessorMock) ExecuteSmartContractTransaction(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error)
  • func (sc *SCProcessorMock) IsInterfaceNil() bool
  • func (sc *SCProcessorMock) IsPayable(address []byte) (bool, error)
  • func (sc *SCProcessorMock) ProcessIfError(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, ...) error
  • func (sc *SCProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)
• 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 SmartContractResultsProcessorMock
  • func (scrp *SmartContractResultsProcessorMock) IsInterfaceNil() bool
  • func (scrp *SmartContractResultsProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)
• type StatusMetricsStub
  • func (sms *StatusMetricsStub) ConfigMetrics() map[string]interface{}
  • func (sms *StatusMetricsStub) EconomicsMetrics() 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 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) Has(_ []byte) error
  • func (sm *StorerMock) HasInEpoch(key []byte, _ uint32) 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) 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 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 TxLogsProcessorStub
  • 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 TxProcessorMock
  • func (etm *TxProcessorMock) IsInterfaceNil() bool
  • func (etm *TxProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)
  • func (etm *TxProcessorMock) ProcessTransaction(transaction *transaction.Transaction) (vmcommon.ReturnCode, error)
  • func (etm *TxProcessorMock) SetBalancesToTrie(accBalance map[string]*big.Int) (rootHash []byte, err error)
• type TxTypeHandlerMock
  • func (th *TxTypeHandlerMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
  • func (th *TxTypeHandlerMock) IsInterfaceNil() bool
• 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 UnsignedTxHandlerMock
  • func (ut *UnsignedTxHandlerMock) AddRewardTxFromBlock(tx data.TransactionHandler)
  • func (ut *UnsignedTxHandlerMock) CleanProcessedUTxs()
  • func (ut *UnsignedTxHandlerMock) CreateAllUTxs() []data.TransactionHandler
  • func (ut *UnsignedTxHandlerMock) CreateBlockStarted()
  • func (ut *UnsignedTxHandlerMock) GetAccumulatedFees() *big.Int
  • func (ut *UnsignedTxHandlerMock) GetDeveloperFees() *big.Int
  • func (ut *UnsignedTxHandlerMock) IsInterfaceNil() bool
  • func (ut *UnsignedTxHandlerMock) ProcessTransactionFee(cost *big.Int, devFee *big.Int, txHash []byte)
  • func (ut *UnsignedTxHandlerMock) RevertFees(txHashes [][]byte)
  • func (ut *UnsignedTxHandlerMock) VerifyCreatedUTxs() error
• 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) GetLatestValidators() map[string]*state.ValidatorApiResponse
  • func (vp *ValidatorsProviderStub) 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)

Constants

const SignatureSize = 48

SignatureSize -

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 NewNodesHandlerMock

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

NewNodesHandlerMock -

Types

type AccountsFactoryStub

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

AccountsFactoryStub -

func (*AccountsFactoryStub) CreateAccount

func (afs *AccountsFactoryStub) CreateAccount(address []byte) (state.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 AccountsStub

type AccountsStub struct {
	GetExistingAccountCalled func(address []byte) (state.AccountHandler, error)
	LoadAccountCalled        func(address []byte) (state.AccountHandler, error)
	SaveAccountCalled        func(account state.AccountHandler) error
	RemoveAccountCalled      func(address []byte) error
	CommitCalled             func() ([]byte, error)
	JournalLenCalled         func() int
	RevertToSnapshotCalled   func(snapshot int) error
	RootHashCalled           func() ([]byte, error)
	RecreateTrieCalled       func(rootHash []byte) error
	PruneTrieCalled          func(rootHash []byte, identifier data.TriePruningIdentifier)
	CancelPruneCalled        func(rootHash []byte, identifier data.TriePruningIdentifier)
	SnapshotStateCalled      func(rootHash []byte, ctx context.Context)
	SetStateCheckpointCalled func(rootHash []byte, ctx context.Context)
	IsPruningEnabledCalled   func() bool
	GetAllLeavesCalled       func(rootHash []byte, ctx context.Context) (chan core.KeyValueHolder, error)
}

AccountsStub -

func (*AccountsStub) CancelPrune

func (as *AccountsStub) CancelPrune(rootHash []byte, identifier data.TriePruningIdentifier)

CancelPrune -

func (*AccountsStub) Commit

func (as *AccountsStub) Commit() ([]byte, error)

Commit -

func (*AccountsStub) GetAllLeaves

func (as *AccountsStub) GetAllLeaves(rootHash []byte, ctx context.Context) (chan core.KeyValueHolder, error)

GetAllLeaves -

func (*AccountsStub) GetCode

func (as *AccountsStub) GetCode(_ []byte) []byte

GetCode -

func (*AccountsStub) GetExistingAccount

func (as *AccountsStub) GetExistingAccount(address []byte) (state.AccountHandler, error)

GetExistingAccount -

func (*AccountsStub) GetNumCheckpoints

func (as *AccountsStub) GetNumCheckpoints() uint32

GetNumCheckpoints -

func (*AccountsStub) IsInterfaceNil

func (as *AccountsStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*AccountsStub) IsPruningEnabled

func (as *AccountsStub) IsPruningEnabled() bool

IsPruningEnabled -

func (*AccountsStub) JournalLen

func (as *AccountsStub) JournalLen() int

JournalLen -

func (*AccountsStub) LoadAccount

func (as *AccountsStub) LoadAccount(address []byte) (state.AccountHandler, error)

LoadAccount -

func (*AccountsStub) PruneTrie

func (as *AccountsStub) PruneTrie(rootHash []byte, identifier data.TriePruningIdentifier)

PruneTrie -

func (*AccountsStub) RecreateAllTries

func (as *AccountsStub) RecreateAllTries(_ []byte, _ context.Context) (map[string]data.Trie, error)

RecreateAllTries -

func (*AccountsStub) RecreateTrie

func (as *AccountsStub) RecreateTrie(rootHash []byte) error

RecreateTrie -

func (*AccountsStub) RemoveAccount

func (as *AccountsStub) RemoveAccount(address []byte) error

RemoveAccount -

func (*AccountsStub) RevertToSnapshot

func (as *AccountsStub) RevertToSnapshot(snapshot int) error

RevertToSnapshot -

func (*AccountsStub) RootHash

func (as *AccountsStub) RootHash() ([]byte, error)

RootHash -

func (*AccountsStub) SaveAccount

func (as *AccountsStub) SaveAccount(account state.AccountHandler) error

SaveAccount -

func (*AccountsStub) SetStateCheckpoint

func (as *AccountsStub) SetStateCheckpoint(rootHash []byte, ctx context.Context)

SetStateCheckpoint -

func (*AccountsStub) SnapshotState

func (as *AccountsStub) SnapshotState(rootHash []byte, ctx context.Context)

SnapshotState -

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 BelNevMock

type BelNevMock struct {
	VerifyMock               func(msg []byte, bitmap []byte) error
	CommitmentHashMock       func(index uint16) ([]byte, error)
	CreateCommitmentMock     func() ([]byte, []byte)
	AggregateCommitmentsMock func(bitmap []byte) error
	CreateSignatureShareMock func(msg []byte, bitmap []byte) ([]byte, error)
	VerifySignatureShareMock func(index uint16, sig []byte, msg []byte, bitmap []byte) error
	AggregateSigsMock        func(bitmap []byte) ([]byte, error)
	SignatureShareMock       func(index uint16) ([]byte, error)
	StoreCommitmentMock      func(index uint16, value []byte) error
	StoreCommitmentHashMock  func(uint16, []byte) error
	CommitmentMock           func(uint16) ([]byte, error)
	CreateCalled             func(pubKeys []string, index uint16) (crypto.MultiSigner, error)
	ResetCalled              func(pubKeys []string, index uint16) error
	// contains filtered or unexported fields
}

BelNevMock is used to mock belare neven multisignature scheme

func NewMultiSigner

func NewMultiSigner(nrConsens uint32) *BelNevMock

NewMultiSigner -

func (*BelNevMock) AggregateCommitments

func (bnm *BelNevMock) AggregateCommitments(bitmap []byte) error

AggregateCommitments aggregates the list of commitments

func (*BelNevMock) AggregateSigs

func (bnm *BelNevMock) AggregateSigs(bitmap []byte) ([]byte, error)

AggregateSigs aggregates all collected partial signatures

func (*BelNevMock) Commitment

func (bnm *BelNevMock) Commitment(index uint16) ([]byte, error)

Commitment returns the commitment from the list with the specified position

func (*BelNevMock) CommitmentHash

func (bnm *BelNevMock) CommitmentHash(index uint16) ([]byte, error)

CommitmentHash returns the commitment hash from the list on the specified position

func (*BelNevMock) Create

func (bnm *BelNevMock) Create(pubKeys []string, index uint16) (crypto.MultiSigner, error)

Create creates a multiSigner using receiver as template and initializes corresponding fields with the given params

func (*BelNevMock) CreateCommitment

func (bnm *BelNevMock) CreateCommitment() (commSecret []byte, commitment []byte)

CreateCommitment creates a secret commitment and the corresponding public commitment point

func (*BelNevMock) CreateSignatureShare

func (bnm *BelNevMock) CreateSignatureShare(msg []byte, bitmap []byte) ([]byte, error)

CreateSignatureShare creates a partial signature

func (*BelNevMock) IsInterfaceNil

func (bnm *BelNevMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BelNevMock) Reset

func (bnm *BelNevMock) Reset(pubKeys []string, index uint16) error

Reset -

func (*BelNevMock) SetAggregatedSig

func (bnm *BelNevMock) SetAggregatedSig(aggSig []byte) error

SetAggregatedSig sets the aggregated signature according to the given byte array

func (*BelNevMock) SignatureShare

func (bnm *BelNevMock) SignatureShare(index uint16) ([]byte, error)

SignatureShare -

func (*BelNevMock) StoreCommitment

func (bnm *BelNevMock) StoreCommitment(index uint16, value []byte) error

StoreCommitment adds a commitment to the list on the specified position

func (*BelNevMock) StoreCommitmentHash

func (bnm *BelNevMock) StoreCommitmentHash(index uint16, commHash []byte) error

StoreCommitmentHash adds a commitment hash to the list on the specified position

func (*BelNevMock) StoreSignatureShare

func (bnm *BelNevMock) StoreSignatureShare(index uint16, sig []byte) error

StoreSignatureShare adds the partial signature of the signer with specified position

func (*BelNevMock) Verify

func (bnm *BelNevMock) Verify(msg []byte, bitmap []byte) error

Verify returns nil if the aggregateed signature is verified for the given public keys

func (*BelNevMock) VerifySignatureShare

func (bnm *BelNevMock) VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error

VerifySignatureShare verifies the partial signature of the signer with specified position

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)
}

BlockChainHookHandlerMock -

func (*BlockChainHookHandlerMock) DeleteCompiledCode

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

DeleteCompiledCode -

func (*BlockChainHookHandlerMock) GetBuiltInFunctions

func (e *BlockChainHookHandlerMock) GetBuiltInFunctions() process.BuiltInFunctionContainer

GetBuiltInFunctions -

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) 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) 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
	CheckBlockAgainstRounderCalled                     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) CheckBlockAgainstRounder

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

CheckBlockAgainstRounder -

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(_ process.TransactionWithFeeHandler) uint64

ComputeBuiltInCost -

func (*BuiltInCostHandlerStub) IsBuiltInFuncCall

func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ process.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)
	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) 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 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(epoch uint32)
	CurrentEpochCalled          func() uint32
	RegisterNotifyHandlerCalled func(handler core.EpochSubscriberHandler)
}

EpochNotifierStub -

func (*EpochNotifierStub) CheckEpoch

func (ens *EpochNotifierStub) CheckEpoch(epoch uint32)

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 core.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)
	// contains filtered or unexported fields
}

EpochStartNotifierStub -

func (*EpochStartNotifierStub) IsInterfaceNil

func (esns *EpochStartNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartNotifierStub) NotifyAll

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

NotifyAll -

func (*EpochStartNotifierStub) NotifyAllPrepare

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

NotifyAllPrepare -

func (*EpochStartNotifierStub) RegisterHandler

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

RegisterHandler -

func (*EpochStartNotifierStub) UnregisterHandler

func (esns *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 process.TransactionWithFeeHandler) uint64
	ComputeMoveBalanceFeeCalled   func(tx process.TransactionWithFeeHandler) *big.Int
	ComputeTxFeeCalled            func(tx process.TransactionWithFeeHandler) *big.Int
	CheckValidityTxValuesCalled   func(tx process.TransactionWithFeeHandler) error
	DeveloperPercentageCalled     func() float64
	MinGasPriceCalled             func() uint64
	GasPriceModifierCalled        func() float64
	ComputeFeeForProcessingCalled func(tx process.TransactionWithFeeHandler, gasToUse uint64) *big.Int
	GenesisTotalSupplyCalled      func() *big.Int
}

FeeHandlerStub -

func (*FeeHandlerStub) CheckValidityTxValues

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

CheckValidityTxValues -

func (*FeeHandlerStub) ComputeFeeForProcessing

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

ComputeFeeForProcessing -

func (*FeeHandlerStub) ComputeGasLimit

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

ComputeGasLimit -

func (*FeeHandlerStub) ComputeMoveBalanceFee

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

ComputeMoveBalanceFee -

func (*FeeHandlerStub) ComputeTxFee

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

ComputeTxFee -

func (*FeeHandlerStub) DeveloperPercentage

func (fhs *FeeHandlerStub) DeveloperPercentage() float64

DeveloperPercentage -

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) MinGasPrice

func (fhs *FeeHandlerStub) MinGasPrice() uint64

MinGasPrice -

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 -

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 HeaderResolverMock

type HeaderResolverMock 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
}

HeaderResolverMock -

func (*HeaderResolverMock) IsInterfaceNil

func (hrm *HeaderResolverMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*HeaderResolverMock) NumPeersToQuery

func (hrm *HeaderResolverMock) NumPeersToQuery() (int, int)

NumPeersToQuery -

func (*HeaderResolverMock) ProcessReceivedMessage

func (hrm *HeaderResolverMock) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*HeaderResolverMock) RequestDataFromEpoch

func (hrm *HeaderResolverMock) RequestDataFromEpoch(identifier []byte) error

RequestDataFromEpoch -

func (*HeaderResolverMock) RequestDataFromHash

func (hrm *HeaderResolverMock) RequestDataFromHash(hash []byte, epoch uint32) error

RequestDataFromHash -

func (*HeaderResolverMock) RequestDataFromNonce

func (hrm *HeaderResolverMock) RequestDataFromNonce(nonce uint64, epoch uint32) error

RequestDataFromNonce -

func (*HeaderResolverMock) SetEpochHandler

func (hrm *HeaderResolverMock) SetEpochHandler(epochHandler dataRetriever.EpochHandler) error

SetEpochHandler -

func (*HeaderResolverMock) SetNumPeersToQuery

func (hrm *HeaderResolverMock) SetNumPeersToQuery(intra int, cross int)

SetNumPeersToQuery -

func (*HeaderResolverMock) SetResolverDebugHandler

func (hrm *HeaderResolverMock) 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 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 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 InterceptorStub

type InterceptorStub struct {
	ProcessReceivedMessageCalled     func(message p2p.MessageP2P) error
	SetInterceptedDebugHandlerCalled func(handler process.InterceptedDebugger) error
}

InterceptorStub -

func (*InterceptorStub) IsInterfaceNil

func (is *InterceptorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*InterceptorStub) ProcessReceivedMessage

func (is *InterceptorStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*InterceptorStub) RegisterHandler

func (is *InterceptorStub) RegisterHandler(_ func(topic string, hash []byte, data interface{}))

RegisterHandler -

func (*InterceptorStub) SetInterceptedDebugHandler

func (is *InterceptorStub) SetInterceptedDebugHandler(handler process.InterceptedDebugger) error

SetInterceptedDebugHandler -

type InterceptorsContainerStub

type InterceptorsContainerStub struct {
	IterateCalled func(handler func(key string, interceptor process.Interceptor) bool)
	GetCalled     func(string) (process.Interceptor, error)
}

InterceptorsContainerStub -

func (*InterceptorsContainerStub) Add

func (ics *InterceptorsContainerStub) Add(_ string, _ process.Interceptor) error

Add -

func (*InterceptorsContainerStub) AddMultiple

func (ics *InterceptorsContainerStub) AddMultiple(_ []string, _ []process.Interceptor) error

AddMultiple -

func (*InterceptorsContainerStub) Get

func (ics *InterceptorsContainerStub) Get(topic string) (process.Interceptor, error)

Get -

func (*InterceptorsContainerStub) IsInterfaceNil

func (ics *InterceptorsContainerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*InterceptorsContainerStub) Iterate

func (ics *InterceptorsContainerStub) Iterate(handler func(key string, interceptor process.Interceptor) bool)

Iterate -

func (*InterceptorsContainerStub) Len

func (ics *InterceptorsContainerStub) Len() int

Len -

func (*InterceptorsContainerStub) Remove

func (ics *InterceptorsContainerStub) Remove(_ string)

Remove -

func (*InterceptorsContainerStub) Replace

func (ics *InterceptorsContainerStub) Replace(_ string, _ process.Interceptor) error

Replace -

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 MiniBlocksResolverMock

type MiniBlocksResolverMock 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)
}

MiniBlocksResolverMock -

func (*MiniBlocksResolverMock) IsInterfaceNil

func (hrm *MiniBlocksResolverMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MiniBlocksResolverMock) NumPeersToQuery

func (hrm *MiniBlocksResolverMock) NumPeersToQuery() (int, int)

NumPeersToQuery -

func (*MiniBlocksResolverMock) ProcessReceivedMessage

func (hrm *MiniBlocksResolverMock) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*MiniBlocksResolverMock) RequestDataFromHash

func (hrm *MiniBlocksResolverMock) RequestDataFromHash(hash []byte, epoch uint32) error

RequestDataFromHash -

func (*MiniBlocksResolverMock) RequestDataFromHashArray

func (hrm *MiniBlocksResolverMock) RequestDataFromHashArray(hashes [][]byte, epoch uint32) error

RequestDataFromHashArray -

func (*MiniBlocksResolverMock) SetNumPeersToQuery

func (hrm *MiniBlocksResolverMock) SetNumPeersToQuery(intra int, cross int)

SetNumPeersToQuery -

func (*MiniBlocksResolverMock) SetResolverDebugHandler

func (hrm *MiniBlocksResolverMock) 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 NetworkShardingCollectorStub

type NetworkShardingCollectorStub struct {
	UpdatePeerIdPublicKeyCalled  func(pid core.PeerID, pk []byte)
	UpdatePublicKeyShardIdCalled func(pk []byte, shardId uint32)
	UpdatePeerIdShardIdCalled    func(pid core.PeerID, shardId uint32)
}

NetworkShardingCollectorStub -

func (*NetworkShardingCollectorStub) IsInterfaceNil

func (nscs *NetworkShardingCollectorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*NetworkShardingCollectorStub) UpdatePeerIdPublicKey

func (nscs *NetworkShardingCollectorStub) UpdatePeerIdPublicKey(pid core.PeerID, pk []byte)

UpdatePeerIdPublicKey -

func (*NetworkShardingCollectorStub) UpdatePeerIdShardId

func (nscs *NetworkShardingCollectorStub) UpdatePeerIdShardId(pid core.PeerID, shardId uint32)

UpdatePeerIdShardId -

func (*NetworkShardingCollectorStub) UpdatePublicKeyShardId

func (nscs *NetworkShardingCollectorStub) UpdatePublicKeyShardId(pk []byte, shardId uint32)

UpdatePublicKeyShardId -

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) 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

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
	MinNumberOfNodesWithHysteresisCalled func() uint32
}

NodesSetupStub -

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) GetStartTime

func (n *NodesSetupStub) GetStartTime() int64

GetStartTime -

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) 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
	BlacklistPeerCalled             func(peer core.PeerID, reason string, duration time.Duration)
}

P2PAntifloodHandlerStub -

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) IsInterfaceNil

func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*P2PAntifloodHandlerStub) ResetForTopic

func (p2pahs *P2PAntifloodHandlerStub) ResetForTopic(_ string)

ResetForTopic -

func (*P2PAntifloodHandlerStub) SetMaxMessagesForTopic

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

SetMaxMessagesForTopic -

type PathManagerStub

type PathManagerStub struct {
	PathForEpochCalled  func(shardId string, epoch uint32, identifier string) string
	PathForStaticCalled func(shardId string, identifier string) string
}

PathManagerStub -

func (*PathManagerStub) IsInterfaceNil

func (p *PathManagerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PathManagerStub) PathForEpoch

func (p *PathManagerStub) PathForEpoch(shardId string, epoch uint32, identifier string) string

PathForEpoch -

func (*PathManagerStub) PathForStatic

func (p *PathManagerStub) PathForStatic(shardId string, identifier string) string

PathForStatic -

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) 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 PeerTypeProviderStub

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

PeerTypeProviderStub -

func (*PeerTypeProviderStub) Close

func (p *PeerTypeProviderStub) Close() error

Close -

func (*PeerTypeProviderStub) ComputeForPubKey

func (p *PeerTypeProviderStub) ComputeForPubKey(pubKey []byte) (core.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 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 RequestHandlerStub

type RequestHandlerStub struct {
	RequestShardHeaderCalled           func(shardID uint32, hash []byte)
	RequestMetaHeaderCalled            func(hash []byte)
	RequestMetaHeaderByNonceCalled     func(nonce uint64)
	RequestShardHeaderByNonceCalled    func(shardID uint32, nonce uint64)
	RequestTransactionHandlerCalled    func(destShardID uint32, txHashes [][]byte)
	RequestScrHandlerCalled            func(destShardID uint32, txHashes [][]byte)
	RequestRewardTxHandlerCalled       func(destShardID uint32, txHashes [][]byte)
	RequestMiniBlockHandlerCalled      func(destShardID uint32, miniblockHash []byte)
	RequestMiniBlocksHandlerCalled     func(destShardID uint32, miniblocksHashes [][]byte)
	RequestTrieNodesCalled             func(destShardID uint32, hashes [][]byte, topic string)
	RequestStartOfEpochMetaBlockCalled func(epoch uint32)
	SetNumPeersToQueryCalled           func(key string, intra int, cross int) error
	GetNumPeersToQueryCalled           func(key string) (int, int, error)
}

RequestHandlerStub -

func (*RequestHandlerStub) GetNumPeersToQuery

func (rhs *RequestHandlerStub) GetNumPeersToQuery(key string) (int, int, error)

GetNumPeersToQuery -

func (*RequestHandlerStub) IsInterfaceNil

func (rhs *RequestHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*RequestHandlerStub) RequestInterval

func (rhs *RequestHandlerStub) RequestInterval() time.Duration

RequestInterval -

func (*RequestHandlerStub) RequestMetaHeader

func (rhs *RequestHandlerStub) RequestMetaHeader(hash []byte)

RequestMetaHeader -

func (*RequestHandlerStub) RequestMetaHeaderByNonce

func (rhs *RequestHandlerStub) RequestMetaHeaderByNonce(nonce uint64)

RequestMetaHeaderByNonce -

func (*RequestHandlerStub) RequestMiniBlock

func (rhs *RequestHandlerStub) RequestMiniBlock(destShardID uint32, miniblockHash []byte)

RequestMiniBlock -

func (*RequestHandlerStub) RequestMiniBlocks

func (rhs *RequestHandlerStub) RequestMiniBlocks(destShardID uint32, miniblocksHashes [][]byte)

RequestMiniBlocks -

func (*RequestHandlerStub) RequestRewardTransactions

func (rhs *RequestHandlerStub) RequestRewardTransactions(destShardID uint32, txHashes [][]byte)

RequestRewardTransactions -

func (*RequestHandlerStub) RequestShardHeader

func (rhs *RequestHandlerStub) RequestShardHeader(shardID uint32, hash []byte)

RequestShardHeader -

func (*RequestHandlerStub) RequestShardHeaderByNonce

func (rhs *RequestHandlerStub) RequestShardHeaderByNonce(shardID uint32, nonce uint64)

RequestShardHeaderByNonce -

func (*RequestHandlerStub) RequestStartOfEpochMetaBlock

func (rhs *RequestHandlerStub) RequestStartOfEpochMetaBlock(epoch uint32)

RequestStartOfEpochMetaBlock -

func (*RequestHandlerStub) RequestTransaction

func (rhs *RequestHandlerStub) RequestTransaction(destShardID uint32, txHashes [][]byte)

RequestTransaction -

func (*RequestHandlerStub) RequestTrieNodes

func (rhs *RequestHandlerStub) RequestTrieNodes(destShardID uint32, hashes [][]byte, topic string)

RequestTrieNodes -

func (*RequestHandlerStub) RequestUnsignedTransactions

func (rhs *RequestHandlerStub) RequestUnsignedTransactions(destShardID uint32, txHashes [][]byte)

RequestUnsignedTransactions -

func (*RequestHandlerStub) SetEpoch

func (rhs *RequestHandlerStub) SetEpoch(_ uint32)

SetEpoch -

func (*RequestHandlerStub) SetNumPeersToQuery

func (rhs *RequestHandlerStub) SetNumPeersToQuery(key string, intra int, cross int) error

SetNumPeersToQuery -

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)
}

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) 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 RounderMock

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

RounderMock -

func (*RounderMock) BeforeGenesis

func (rndm *RounderMock) BeforeGenesis() bool

BeforeGenesis -

func (*RounderMock) Index

func (rm *RounderMock) Index() int64

Index -

func (*RounderMock) IsInterfaceNil

func (rm *RounderMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*RounderMock) RemainingTime

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

RemainingTime -

func (*RounderMock) TimeDuration

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

TimeDuration -

func (*RounderMock) TimeStamp

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

TimeStamp -

func (*RounderMock) UpdateRound

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

UpdateRound -

type SCProcessorMock

type SCProcessorMock struct {
	ComputeTransactionTypeCalled          func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
	ExecuteSmartContractTransactionCalled func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error)
	ExecuteBuiltInFunctionCalled          func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error)
	DeploySmartContractCalled             func(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error)
	ProcessSmartContractResultCalled      func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)
	ProcessIfErrorCalled                  func(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, returnCode string, returnMessage []byte, snapshot int, gasLocked uint64) error
	IsPayableCalled                       func(address []byte) (bool, error)
}

SCProcessorMock -

func (*SCProcessorMock) ComputeTransactionType

func (sc *SCProcessorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)

ComputeTransactionType -

func (*SCProcessorMock) DeploySmartContract

func (sc *SCProcessorMock) DeploySmartContract(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error)

DeploySmartContract -

func (*SCProcessorMock) ExecuteBuiltInFunction

func (sc *SCProcessorMock) ExecuteBuiltInFunction(
	tx data.TransactionHandler,
	acntSrc, acntDst state.UserAccountHandler,
) (vmcommon.ReturnCode, error)

ExecuteBuiltInFunction -

func (*SCProcessorMock) ExecuteSmartContractTransaction

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

ExecuteSmartContractTransaction -

func (*SCProcessorMock) IsInterfaceNil

func (sc *SCProcessorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SCProcessorMock) IsPayable

func (sc *SCProcessorMock) IsPayable(address []byte) (bool, error)

IsPayable -

func (*SCProcessorMock) ProcessIfError

func (sc *SCProcessorMock) ProcessIfError(
	acntSnd state.UserAccountHandler,
	txHash []byte,
	tx data.TransactionHandler,
	returnCode string,
	returnMessage []byte,
	snapshot int,
	gasLocked uint64,
) error

ProcessIfError -

func (*SCProcessorMock) ProcessSmartContractResult

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

ProcessSmartContractResult -

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 SmartContractResultsProcessorMock

type SmartContractResultsProcessorMock struct {
	ProcessSmartContractResultCalled func(scr *smartContractResult.SmartContractResult) error
}

SmartContractResultsProcessorMock -

func (*SmartContractResultsProcessorMock) IsInterfaceNil

func (scrp *SmartContractResultsProcessorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SmartContractResultsProcessorMock) ProcessSmartContractResult

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

ProcessSmartContractResult -

type StatusMetricsStub

type StatusMetricsStub struct {
	StatusMetricsMapWithoutP2PCalled              func() map[string]interface{}
	StatusP2pMetricsMapCalled                     func() map[string]interface{}
	ConfigMetricsCalled                           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) 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 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) Has

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

Has -

func (*StorerMock) HasInEpoch

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

HasInEpoch -

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) 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 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 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) 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 TxProcessorMock

type TxProcessorMock struct {
	ProcessTransactionCalled         func(transaction *transaction.Transaction) (vmcommon.ReturnCode, error)
	SetBalancesToTrieCalled          func(accBalance map[string]*big.Int) (rootHash []byte, err error)
	ProcessSmartContractResultCalled func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error)
}

TxProcessorMock -

func (*TxProcessorMock) IsInterfaceNil

func (etm *TxProcessorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TxProcessorMock) ProcessSmartContractResult

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

ProcessSmartContractResult -

func (*TxProcessorMock) ProcessTransaction

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

ProcessTransaction -

func (*TxProcessorMock) SetBalancesToTrie

func (etm *TxProcessorMock) SetBalancesToTrie(accBalance map[string]*big.Int) (rootHash []byte, err error)

SetBalancesToTrie -

type TxTypeHandlerMock

type TxTypeHandlerMock struct {
	ComputeTransactionTypeCalled func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
}

TxTypeHandlerMock -

func (*TxTypeHandlerMock) ComputeTransactionType

func (th *TxTypeHandlerMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)

ComputeTransactionType -

func (*TxTypeHandlerMock) IsInterfaceNil

func (th *TxTypeHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

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 UnsignedTxHandlerMock

type UnsignedTxHandlerMock struct {
	CleanProcessedUtxsCalled    func()
	ProcessTransactionFeeCalled func(cost *big.Int, hash []byte)
	CreateAllUTxsCalled         func() []data.TransactionHandler
	VerifyCreatedUTxsCalled     func() error
	AddTxFeeFromBlockCalled     func(tx data.TransactionHandler)
	GetAccumulatedFeesCalled    func() *big.Int
	GetDeveloperFeesCalled      func() *big.Int
	RevertFeesCalled            func(txHashes [][]byte)
}

UnsignedTxHandlerMock -

func (*UnsignedTxHandlerMock) AddRewardTxFromBlock

func (ut *UnsignedTxHandlerMock) AddRewardTxFromBlock(tx data.TransactionHandler)

AddRewardTxFromBlock -

func (*UnsignedTxHandlerMock) CleanProcessedUTxs

func (ut *UnsignedTxHandlerMock) CleanProcessedUTxs()

CleanProcessedUTxs -

func (*UnsignedTxHandlerMock) CreateAllUTxs

func (ut *UnsignedTxHandlerMock) CreateAllUTxs() []data.TransactionHandler

CreateAllUTxs -

func (*UnsignedTxHandlerMock) CreateBlockStarted

func (ut *UnsignedTxHandlerMock) CreateBlockStarted()

CreateBlockStarted -

func (*UnsignedTxHandlerMock) GetAccumulatedFees

func (ut *UnsignedTxHandlerMock) GetAccumulatedFees() *big.Int

GetAccumulatedFees -

func (*UnsignedTxHandlerMock) GetDeveloperFees

func (ut *UnsignedTxHandlerMock) GetDeveloperFees() *big.Int

GetDeveloperFees -

func (*UnsignedTxHandlerMock) IsInterfaceNil

func (ut *UnsignedTxHandlerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*UnsignedTxHandlerMock) ProcessTransactionFee

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

ProcessTransactionFee -

func (*UnsignedTxHandlerMock) RevertFees

func (ut *UnsignedTxHandlerMock) RevertFees(txHashes [][]byte)

RevertFees -

func (*UnsignedTxHandlerMock) VerifyCreatedUTxs

func (ut *UnsignedTxHandlerMock) VerifyCreatedUTxs() error

VerifyCreatedUTxs -

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 {
	GetVersionCalled             func() string
	RunSmartContractCreateCalled func(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error)
	RunSmartContractCallCalled   func(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
	GasScheduleChangeCalled      func(gasSchedule map[string]map[string]uint64)
}

VMExecutionHandlerStub -

func (*VMExecutionHandlerStub) GasScheduleChange

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

GasScheduleChange -

func (*VMExecutionHandlerStub) GetVersion

func (vm *VMExecutionHandlerStub) GetVersion() string

GetVersion returns the version of the VM

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) GetLatestValidators

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

GetLatestValidators -

func (*ValidatorsProviderStub) IsInterfaceNil

func (vp *ValidatorsProviderStub) 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 -