mock

Documentation

Index

• func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock
• func NewMultipleShardsCoordinatorMock() *multipleShardsCoordinatorMock
• func NewNilTxValidator() (*nilTxValidator, error)
• func NewNonceHashConverterMock() *nonceHashConverterMock
• func NewOneShardCoordinatorMock() *oneShardCoordinatorMock
• type AccountWrapMock
  • func NewAccountWrapMock(adr []byte) *AccountWrapMock
  • func (awm *AccountWrapMock) AccountDataHandler() vmcommon.AccountDataHandler
  • func (awm *AccountWrapMock) AddToBalance(_ *big.Int) error
  • func (awm *AccountWrapMock) AddToDeveloperReward(*big.Int)
  • func (awm *AccountWrapMock) AddressBytes() []byte
  • func (awm *AccountWrapMock) ChangeOwnerAddress([]byte, []byte) error
  • func (awm *AccountWrapMock) ClaimDeveloperRewards([]byte) (*big.Int, error)
  • func (awm *AccountWrapMock) DataTrie() common.Trie
  • func (awm *AccountWrapMock) DataTrieTracker() state.DataTrieTracker
  • func (awm *AccountWrapMock) GetBalance() *big.Int
  • func (awm *AccountWrapMock) GetCodeHash() []byte
  • func (awm *AccountWrapMock) GetCodeMetadata() []byte
  • func (awm *AccountWrapMock) GetDeveloperReward() *big.Int
  • func (awm *AccountWrapMock) GetNonce() uint64
  • func (awm *AccountWrapMock) GetOwnerAddress() []byte
  • func (awm *AccountWrapMock) GetRootHash() []byte
  • func (awm *AccountWrapMock) GetUserName() []byte
  • func (awm *AccountWrapMock) HasNewCode() bool
  • func (awm *AccountWrapMock) IncreaseNonce(val uint64)
  • func (awm *AccountWrapMock) IsInterfaceNil() bool
  • func (awm *AccountWrapMock) RetrieveValueFromDataTrieTracker(key []byte) ([]byte, error)
  • func (awm *AccountWrapMock) SetCode(code []byte)
  • func (awm *AccountWrapMock) SetCodeHash(codeHash []byte)
  • func (awm *AccountWrapMock) SetCodeMetadata(codeMetadata []byte)
  • func (awm *AccountWrapMock) SetDataTrie(trie common.Trie)
  • func (awm *AccountWrapMock) SetOwnerAddress([]byte)
  • func (awm *AccountWrapMock) SetRootHash(rootHash []byte)
  • func (awm *AccountWrapMock) SetUserName(_ []byte)
  • func (awm *AccountWrapMock) SubFromBalance(_ *big.Int) error
• type AccountsDBSyncerStub
  • func (a *AccountsDBSyncerStub) GetSyncedTries() map[string]common.Trie
  • func (a *AccountsDBSyncerStub) IsInterfaceNil() bool
  • func (a *AccountsDBSyncerStub) SyncAccounts(rootHash []byte) error
• type AntifloodDebuggerStub
  • func (ads *AntifloodDebuggerStub) AddData(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, ...)
  • func (ads *AntifloodDebuggerStub) Close() error
  • func (ads *AntifloodDebuggerStub) IsInterfaceNil() bool
• type ArgumentParserMock
  • func (ap *ArgumentParserMock) CreateDataFromStorageUpdate(storageUpdates []*vmcommon.StorageUpdate) string
  • func (ap *ArgumentParserMock) GetStorageUpdates(data string) ([]*vmcommon.StorageUpdate, error)
  • func (ap *ArgumentParserMock) IsInterfaceNil() bool
  • func (ap *ArgumentParserMock) ParseCallData(data string) (string, [][]byte, error)
  • func (ap *ArgumentParserMock) ParseDeployData(data string) (*parsers.DeployArgs, error)
• type BalanceComputationStub
  • func (bcs *BalanceComputationStub) AddBalanceToAddress(address []byte, value *big.Int) bool
  • func (bcs *BalanceComputationStub) AddressHasEnoughBalance(address []byte, value *big.Int) bool
  • func (bcs *BalanceComputationStub) Init()
  • func (bcs *BalanceComputationStub) IsAddressSet(address []byte) bool
  • func (bcs *BalanceComputationStub) IsInterfaceNil() bool
  • func (bcs *BalanceComputationStub) SetBalanceToAddress(address []byte, value *big.Int)
  • func (bcs *BalanceComputationStub) SubBalanceFromAddress(address []byte, value *big.Int) bool
• type BlackListHandlerStub
  • func (blhs *BlackListHandlerStub) Add(key string) error
  • func (blhs *BlackListHandlerStub) Has(key string) bool
  • func (blhs *BlackListHandlerStub) IsInterfaceNil() bool
  • func (blhs *BlackListHandlerStub) Len() int
  • func (blhs *BlackListHandlerStub) Sweep()
  • func (blhs *BlackListHandlerStub) Upsert(key string, span time.Duration) error
• type BlockChainHookHandlerMock
  • func (e *BlockChainHookHandlerMock) DeleteCompiledCode(codeHash []byte)
  • func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool
  • func (e *BlockChainHookHandlerMock) IsPayable(address []byte) (bool, error)
  • func (e *BlockChainHookHandlerMock) NewAddress(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)
  • func (e *BlockChainHookHandlerMock) ProcessBuiltInFunction(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
  • func (e *BlockChainHookHandlerMock) SetCurrentHeader(hdr data.HeaderHandler)
• type BlockChainMock
  • func (bc *BlockChainMock) CreateNewHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetCurrentBlockHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetCurrentBlockHeaderHash() []byte
  • func (bc *BlockChainMock) GetGenesisHeader() data.HeaderHandler
  • func (bc *BlockChainMock) GetGenesisHeaderHash() []byte
  • func (bc *BlockChainMock) IsInterfaceNil() bool
  • func (bc *BlockChainMock) SetCurrentBlockHeader(header data.HeaderHandler) error
  • func (bc *BlockChainMock) SetCurrentBlockHeaderHash(hash []byte)
  • func (bc *BlockChainMock) SetGenesisHeader(genesisBlock data.HeaderHandler) error
  • func (bc *BlockChainMock) SetGenesisHeaderHash(hash []byte)
• type BlockNotarizerHandlerMock
  • func (bngm *BlockNotarizerHandlerMock) AddNotarizedHeader(shardID uint32, notarizedHeader data.HeaderHandler, notarizedHeaderHash []byte)
  • func (bngm *BlockNotarizerHandlerMock) CleanupNotarizedHeadersBehindNonce(shardID uint32, nonce uint64)
  • func (bngm *BlockNotarizerHandlerMock) DisplayNotarizedHeaders(shardID uint32, message string)
  • func (bngm *BlockNotarizerHandlerMock) GetFirstNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (bngm *BlockNotarizerHandlerMock) GetLastNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (bngm *BlockNotarizerHandlerMock) GetLastNotarizedHeaderNonce(shardID uint32) uint64
  • func (bngm *BlockNotarizerHandlerMock) GetNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
  • func (bngm *BlockNotarizerHandlerMock) InitNotarizedHeaders(startHeaders map[uint32]data.HeaderHandler) error
  • func (bngm *BlockNotarizerHandlerMock) IsInterfaceNil() bool
  • func (bngm *BlockNotarizerHandlerMock) RemoveLastNotarizedHeader()
  • func (bngm *BlockNotarizerHandlerMock) RestoreNotarizedHeadersToGenesis()
• type BlockNotifierHandlerStub
  • func (bnhs *BlockNotifierHandlerStub) CallHandlers(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte)
  • func (bnhs *BlockNotifierHandlerStub) GetNumRegisteredHandlers() int
  • func (bnhs *BlockNotifierHandlerStub) IsInterfaceNil() bool
  • func (bnhs *BlockNotifierHandlerStub) RegisterHandler(...)
• type BlockProcessorMock
  • func (bpm *BlockProcessorMock) AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler)
  • func (bpm *BlockProcessorMock) ApplyProcessedMiniBlocks(*processedMb.ProcessedMiniBlockTracker)
  • func (bpm *BlockProcessorMock) Close() error
  • func (bpm *BlockProcessorMock) CommitBlock(header data.HeaderHandler, body data.BodyHandler) error
  • func (bpm *BlockProcessorMock) CreateBlock(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)
  • func (bpm *BlockProcessorMock) CreateGenesisBlock(balances map[string]*big.Int) (data.HeaderHandler, 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 BlockSizeComputationStub
  • func (bscs *BlockSizeComputationStub) AddNumMiniBlocks(numMiniBlocks int)
  • func (bscs *BlockSizeComputationStub) AddNumTxs(numTxs int)
  • func (bscs *BlockSizeComputationStub) Init()
  • func (bscs *BlockSizeComputationStub) IsInterfaceNil() bool
  • func (bscs *BlockSizeComputationStub) IsMaxBlockSizeReached(numNewMiniBlocks int, numNewTxs int) bool
  • func (bscs *BlockSizeComputationStub) IsMaxBlockSizeWithoutThrottleReached(numNewMiniBlocks int, numNewTxs int) bool
• 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 BlockTrackerHandlerMock
  • func (bthm *BlockTrackerHandlerMock) AddHeaderFromPool(shardID uint32, nonce uint64)
  • func (bthm *BlockTrackerHandlerMock) ComputeCrossInfo(headers []data.HeaderHandler)
  • func (bthm *BlockTrackerHandlerMock) ComputeLongestSelfChain() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte)
  • func (bthm *BlockTrackerHandlerMock) GetSelfHeaders(headerHandler data.HeaderHandler) []*track.HeaderInfo
  • func (bthm *BlockTrackerHandlerMock) IsInterfaceNil() bool
  • func (bthm *BlockTrackerHandlerMock) SortHeadersFromNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
• type BlockTrackerMock
  • func NewBlockTrackerMock(shardCoordinator sharding.Coordinator, ...) *BlockTrackerMock
  • func (btm *BlockTrackerMock) AddCrossNotarizedHeader(shardID uint32, crossNotarizedHeader data.HeaderHandler, ...)
  • func (btm *BlockTrackerMock) AddSelfNotarizedHeader(shardID uint32, selfNotarizedHeader data.HeaderHandler, ...)
  • func (btm *BlockTrackerMock) AddTrackedHeader(header data.HeaderHandler, hash []byte)
  • func (btm *BlockTrackerMock) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error
  • func (btm *BlockTrackerMock) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error
  • func (btm *BlockTrackerMock) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool
  • func (btm *BlockTrackerMock) CleanupHeadersBehindNonce(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)
  • func (btm *BlockTrackerMock) CleanupInvalidCrossHeaders(_ uint32, _ uint64)
  • func (btm *BlockTrackerMock) ComputeLongestChain(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)
  • func (btm *BlockTrackerMock) ComputeLongestMetaChainFromLastNotarized() ([]data.HeaderHandler, [][]byte, error)
  • func (btm *BlockTrackerMock) ComputeLongestShardsChainsFromLastNotarized() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)
  • func (btm *BlockTrackerMock) DisplayTrackedHeaders()
  • func (btm *BlockTrackerMock) GetCrossNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
  • func (btm *BlockTrackerMock) GetLastCrossNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (btm *BlockTrackerMock) GetLastCrossNotarizedHeadersForAllShards() (map[uint32]data.HeaderHandler, error)
  • func (btm *BlockTrackerMock) GetLastSelfNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)
  • func (btm *BlockTrackerMock) GetSelfNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
  • func (btm *BlockTrackerMock) GetTrackedHeaders(shardID uint32) ([]data.HeaderHandler, [][]byte)
  • func (btm *BlockTrackerMock) GetTrackedHeadersForAllShards() map[uint32][]data.HeaderHandler
  • func (btm *BlockTrackerMock) GetTrackedHeadersWithNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
  • func (btm *BlockTrackerMock) InitNotarizedHeaders(startHeaders map[uint32]data.HeaderHandler) error
  • func (btm *BlockTrackerMock) IsInterfaceNil() bool
  • func (btm *BlockTrackerMock) IsShardStuck(shardId uint32) bool
  • func (btm *BlockTrackerMock) RegisterCrossNotarizedHeadersHandler(...)
  • func (btm *BlockTrackerMock) RegisterFinalMetachainHeadersHandler(...)
  • func (btm *BlockTrackerMock) RegisterSelfNotarizedFromCrossHeadersHandler(...)
  • func (btm *BlockTrackerMock) RegisterSelfNotarizedHeadersHandler(...)
  • func (btm *BlockTrackerMock) RemoveLastNotarizedHeaders()
  • func (btm *BlockTrackerMock) RestoreToGenesis()
  • func (btm *BlockTrackerMock) 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 BootstrapComponentsMock
  • func (bcm *BootstrapComponentsMock) HeaderIntegrityVerifier() factory.HeaderIntegrityVerifierHandler
  • func (bcm *BootstrapComponentsMock) IsInterfaceNil() bool
  • func (bcm *BootstrapComponentsMock) ShardCoordinator() sharding.Coordinator
• type BuiltInCostHandlerStub
  • func (b *BuiltInCostHandlerStub) ComputeBuiltInCost(_ data.TransactionWithFeeHandler) uint64
  • func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ data.TransactionWithFeeHandler) bool
  • func (b *BuiltInCostHandlerStub) IsInterfaceNil() bool
• type BuiltInFunctionStub
  • func (b *BuiltInFunctionStub) IsActive() bool
  • func (b *BuiltInFunctionStub) IsInterfaceNil() bool
  • func (b *BuiltInFunctionStub) ProcessBuiltinFunction(acntSnd, acntDst vmcommon.UserAccountHandler, ...) (*vmcommon.VMOutput, error)
  • func (b *BuiltInFunctionStub) SetNewGasConfig(gasCost *vmcommon.GasCost)
• type ChainStorerMock
  • func (csm *ChainStorerMock) AddStorer(key dataRetriever.UnitType, s storage.Storer)
  • func (csm *ChainStorerMock) CloseAll() error
  • func (csm *ChainStorerMock) Destroy() error
  • func (csm *ChainStorerMock) Get(unitType dataRetriever.UnitType, key []byte) ([]byte, error)
  • func (csm *ChainStorerMock) GetAll(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)
  • func (csm *ChainStorerMock) GetAllStorers() map[dataRetriever.UnitType]storage.Storer
  • func (csm *ChainStorerMock) GetStorer(unitType dataRetriever.UnitType) storage.Storer
  • func (csm *ChainStorerMock) Has(unitType dataRetriever.UnitType, key []byte) error
  • func (csm *ChainStorerMock) IsInterfaceNil() bool
  • func (csm *ChainStorerMock) Put(unitType dataRetriever.UnitType, key []byte, value []byte) error
  • func (csm *ChainStorerMock) SetEpochForPutOperation(epoch uint32)
• type ChunkProcessorStub
  • func (c *ChunkProcessorStub) CheckBatch(b *batch.Batch, w process.WhiteListHandler) (process.CheckedChunkResult, error)
  • func (c *ChunkProcessorStub) Close() error
  • func (c *ChunkProcessorStub) IsInterfaceNil() bool
• type CloserStub
  • func (cs *CloserStub) Close() error
• type CoordinatorStub
  • func (coordinator *CoordinatorStub) CommunicationIdentifier(destShardID uint32) string
  • func (coordinator *CoordinatorStub) ComputeId(address []byte) uint32
  • func (coordinator *CoordinatorStub) IsInterfaceNil() bool
  • func (coordinator *CoordinatorStub) NumberOfShards() uint32
  • func (coordinator *CoordinatorStub) SameShard(firstAddress, secondAddress []byte) bool
  • func (coordinator *CoordinatorStub) SelfId() uint32
• type CoreComponentsMock
  • func (ccm *CoreComponentsMock) AddressPubKeyConverter() core.PubkeyConverter
  • func (ccm *CoreComponentsMock) ChainID() string
  • func (ccm *CoreComponentsMock) ChanStopNodeProcess() chan endProcess.ArgEndProcess
  • func (ccm *CoreComponentsMock) EpochNotifier() process.EpochNotifier
  • func (ccm *CoreComponentsMock) GenesisNodesSetup() sharding.GenesisNodesSetupHandler
  • func (ccm *CoreComponentsMock) Hasher() hashing.Hasher
  • func (ccm *CoreComponentsMock) InternalMarshalizer() marshal.Marshalizer
  • func (ccm *CoreComponentsMock) IsInterfaceNil() bool
  • func (ccm *CoreComponentsMock) MinTransactionVersion() uint32
  • func (ccm *CoreComponentsMock) NodeTypeProvider() core.NodeTypeProviderHandler
  • func (ccm *CoreComponentsMock) PathHandler() storage.PathManagerHandler
  • func (ccm *CoreComponentsMock) RoundHandler() consensus.RoundHandler
  • func (ccm *CoreComponentsMock) SetInternalMarshalizer(m marshal.Marshalizer) error
  • func (ccm *CoreComponentsMock) StatusHandler() core.AppStatusHandler
  • func (ccm *CoreComponentsMock) TxMarshalizer() marshal.Marshalizer
  • func (ccm *CoreComponentsMock) TxSignHasher() hashing.Hasher
  • func (ccm *CoreComponentsMock) TxVersionChecker() process.TxVersionCheckerHandler
  • func (ccm *CoreComponentsMock) Uint64ByteSliceConverter() typeConverters.Uint64ByteSliceConverter
  • func (ccm *CoreComponentsMock) ValidatorPubKeyConverter() core.PubkeyConverter
• type CryptoComponentsMock
  • func (ccm *CryptoComponentsMock) BlockSignKeyGen() crypto.KeyGenerator
  • func (ccm *CryptoComponentsMock) BlockSigner() crypto.SingleSigner
  • func (ccm *CryptoComponentsMock) Clone() interface{}
  • func (ccm *CryptoComponentsMock) IsInterfaceNil() bool
  • func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner
  • func (ccm *CryptoComponentsMock) PublicKey() crypto.PublicKey
  • func (ccm *CryptoComponentsMock) SetMultiSigner(multiSigner crypto.MultiSigner) error
  • func (ccm *CryptoComponentsMock) TxSignKeyGen() crypto.KeyGenerator
  • func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner
• type CurrentNetworkEpochSetterStub
  • func (c *CurrentNetworkEpochSetterStub) IsInterfaceNil() bool
  • func (c *CurrentNetworkEpochSetterStub) SetNetworkEpochAtBootstrap(epoch uint32)
• type DataComponentsMock
  • func (dcm *DataComponentsMock) Blockchain() data.ChainHandler
  • func (dcm *DataComponentsMock) Clone() interface{}
  • func (dcm *DataComponentsMock) Datapool() dataRetriever.PoolsHolder
  • func (dcm *DataComponentsMock) IsInterfaceNil() bool
  • func (dcm *DataComponentsMock) StorageService() dataRetriever.StorageService
• type DataTrieTrackerStub
  • func (dtts *DataTrieTrackerStub) ClearDataCaches()
  • func (dtts *DataTrieTrackerStub) DataTrie() common.Trie
  • func (dtts *DataTrieTrackerStub) DirtyData() map[string][]byte
  • func (dtts *DataTrieTrackerStub) IsInterfaceNil() bool
  • func (dtts *DataTrieTrackerStub) RetrieveValue(key []byte) ([]byte, error)
  • func (dtts *DataTrieTrackerStub) SaveKeyValue(key []byte, value []byte) error
  • func (dtts *DataTrieTrackerStub) SetDataTrie(tr common.Trie)
• type ESDTRoleHandlerStub
  • func (e *ESDTRoleHandlerStub) CheckAllowedToExecute(account state.UserAccountHandler, tokenID []byte, action []byte) error
  • func (e *ESDTRoleHandlerStub) IsInterfaceNil() bool
• type EpochEconomicsStub
  • func (e *EpochEconomicsStub) ComputeEndOfEpochEconomics(metaBlock *block.MetaBlock) (*block.Economics, error)
  • func (e *EpochEconomicsStub) IsInterfaceNil() bool
  • func (e *EpochEconomicsStub) VerifyRewardsPerBlock(metaBlock *block.MetaBlock, correctedProtocolSustainability *big.Int, ...) error
• type EpochNotifierStub
  • func (ens *EpochNotifierStub) CheckEpoch(header data.HeaderHandler)
  • func (ens *EpochNotifierStub) CurrentEpoch() uint32
  • func (ens *EpochNotifierStub) IsInterfaceNil() bool
  • func (ens *EpochNotifierStub) RegisterNotifyHandler(handler vmcommon.EpochSubscriberHandler)
• type EpochRewardsCreatorStub
  • func (e *EpochRewardsCreatorStub) CreateMarshalizedData(body *block.Body) map[string][][]byte
  • func (e *EpochRewardsCreatorStub) CreateRewardsMiniBlocks(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) (block.MiniBlockSlice, error)
  • func (e *EpochRewardsCreatorStub) DeleteTxsFromStorage(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) GetLocalTxCache() epochStart.TransactionCacher
  • func (e *EpochRewardsCreatorStub) GetProtocolSustainabilityRewards() *big.Int
  • func (e *EpochRewardsCreatorStub) GetRewardsTxs(body *block.Body) map[string]data.TransactionHandler
  • func (e *EpochRewardsCreatorStub) IsInterfaceNil() bool
  • func (e *EpochRewardsCreatorStub) RemoveBlockDataFromPools(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) SaveTxBlockToStorage(metaBlock *block.MetaBlock, body *block.Body)
  • func (e *EpochRewardsCreatorStub) VerifyRewardsMiniBlocks(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) error
• type EpochStartDataCreatorStub
  • func (e *EpochStartDataCreatorStub) CreateEpochStartData() (*block.EpochStart, error)
  • func (e *EpochStartDataCreatorStub) IsInterfaceNil() bool
  • func (e *EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock(metaBlock *block.MetaBlock) error
• type EpochStartNotifierStub
  • func (esnm *EpochStartNotifierStub) IsInterfaceNil() bool
  • func (esnm *EpochStartNotifierStub) NotifyAll(hdr data.HeaderHandler)
  • func (esnm *EpochStartNotifierStub) NotifyAllPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
  • func (esnm *EpochStartNotifierStub) RegisterHandler(handler epochStart.ActionHandler)
  • func (esnm *EpochStartNotifierStub) UnregisterHandler(handler epochStart.ActionHandler)
• type EpochStartSystemSCStub
  • func (e *EpochStartSystemSCStub) IsInterfaceNil() bool
  • func (e *EpochStartSystemSCStub) ProcessDelegationRewards(miniBlocks block.MiniBlockSlice, txCache epochStart.TransactionCacher) error
  • func (e *EpochStartSystemSCStub) ProcessSystemSmartContract(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error
  • func (e *EpochStartSystemSCStub) ToggleUnStakeUnBond(value bool) error
• type EpochStartTriggerStub
  • func (e *EpochStartTriggerStub) Close() error
  • func (e *EpochStartTriggerStub) Epoch() uint32
  • func (e *EpochStartTriggerStub) EpochFinalityAttestingRound() uint64
  • func (e *EpochStartTriggerStub) EpochStartMetaHdrHash() []byte
  • func (e *EpochStartTriggerStub) EpochStartRound() uint64
  • func (e *EpochStartTriggerStub) ForceEpochStart() error
  • 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) 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) SetFinalityAttestingRound(_ uint64)
  • func (e *EpochStartTriggerStub) SetProcessed(header data.HeaderHandler, _ data.BodyHandler)
  • 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 FeeAccumulatorStub
  • func (f *FeeAccumulatorStub) CreateBlockStarted()
  • func (f *FeeAccumulatorStub) GetAccumulatedFees() *big.Int
  • func (f *FeeAccumulatorStub) GetDeveloperFees() *big.Int
  • func (f *FeeAccumulatorStub) IsInterfaceNil() bool
  • func (f *FeeAccumulatorStub) ProcessTransactionFee(cost *big.Int, devFee *big.Int, txHash []byte)
  • func (f *FeeAccumulatorStub) RevertFees(txHashes [][]byte)
• type FeeHandlerStub
  • func (fhs *FeeHandlerStub) CheckValidityTxValues(tx data.TransactionWithFeeHandler) error
  • func (fhs *FeeHandlerStub) ComputeFeeForProcessing(tx data.TransactionWithFeeHandler, gasToUse uint64) *big.Int
  • func (fhs *FeeHandlerStub) ComputeGasLimit(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) ComputeGasLimitBasedOnBalance(tx data.TransactionWithFeeHandler, balance *big.Int) (uint64, error)
  • func (fhs *FeeHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue(tx data.TransactionWithFeeHandler, refundValue *big.Int) (uint64, *big.Int)
  • func (fhs *FeeHandlerStub) ComputeMoveBalanceFee(tx data.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) ComputeTxFee(tx data.TransactionWithFeeHandler) *big.Int
  • func (fhs *FeeHandlerStub) ComputeTxFeeBasedOnGasUsed(tx data.TransactionWithFeeHandler, gasUsed uint64) *big.Int
  • func (fhs *FeeHandlerStub) DeveloperPercentage() float64
  • func (fhs *FeeHandlerStub) GasPerDataByte() uint64
  • func (fhs *FeeHandlerStub) GasPriceForMove(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) GasPriceForProcessing(tx data.TransactionWithFeeHandler) uint64
  • func (fhs *FeeHandlerStub) GasPriceModifier() float64
  • func (fhs *FeeHandlerStub) GenesisTotalSupply() *big.Int
  • func (fhs *FeeHandlerStub) IsInterfaceNil() bool
  • func (fhs *FeeHandlerStub) MaxGasLimitPerBlock(uint32) uint64
  • func (fhs *FeeHandlerStub) MinGasLimit() uint64
  • func (fhs *FeeHandlerStub) MinGasPrice() uint64
  • func (fhs *FeeHandlerStub) MinGasPriceForProcessing() uint64
  • func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64)
  • func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64)
  • func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice uint64)
  • func (fhs *FeeHandlerStub) SplitTxGasInCategories(tx data.TransactionWithFeeHandler) (uint64, uint64)
• type FloodPreventerStub
  • func (fps *FloodPreventerStub) ApplyConsensusSize(size int)
  • func (fps *FloodPreventerStub) IncreaseLoad(pid core.PeerID, size uint64) error
  • func (fps *FloodPreventerStub) IsInterfaceNil() bool
  • func (fps *FloodPreventerStub) Reset()
• type ForkDetectorMock
  • func (fdm *ForkDetectorMock) AddHeader(header data.HeaderHandler, hash []byte, state process.BlockHeaderState, ...) error
  • func (fdm *ForkDetectorMock) CheckFork() *process.ForkInfo
  • func (fdm *ForkDetectorMock) GetHighestFinalBlockHash() []byte
  • func (fdm *ForkDetectorMock) GetHighestFinalBlockNonce() uint64
  • func (fdm *ForkDetectorMock) GetNotarizedHeaderHash(nonce uint64) []byte
  • func (fdm *ForkDetectorMock) IsInterfaceNil() bool
  • func (fdm *ForkDetectorMock) ProbableHighestNonce() uint64
  • func (fdm *ForkDetectorMock) RemoveHeader(nonce uint64, hash []byte)
  • func (fdm *ForkDetectorMock) ResetFork()
  • func (fdm *ForkDetectorMock) ResetProbableHighestNonce()
  • func (fdm *ForkDetectorMock) RestoreToGenesis()
  • func (fdm *ForkDetectorMock) SetFinalToLastCheckpoint()
  • func (fdm *ForkDetectorMock) 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 GetHdrHandlerStub
  • func (ghhs *GetHdrHandlerStub) HeaderHandler() data.HeaderHandler
• type HasherMock
  • func (sha HasherMock) Compute(s string) []byte
  • func (sha HasherMock) EmptyHash() []byte
  • func (sha HasherMock) IsInterfaceNil() bool
  • func (HasherMock) Size() int
• type HasherStub
  • func (hash *HasherStub) Compute(s string) []byte
  • func (hash *HasherStub) EmptyHash() []byte
  • func (hash *HasherStub) IsInterfaceNil() bool
  • func (hash *HasherStub) Size() int
• 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) 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
• type HeaderSigVerifierStub
  • func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool
  • func (hsvm *HeaderSigVerifierStub) VerifyLeaderSignature(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifyRandSeed(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature(header data.HeaderHandler) error
  • func (hsvm *HeaderSigVerifierStub) VerifySignature(header data.HeaderHandler) error
• type HeaderValidatorStub
  • func (h *HeaderValidatorStub) HeaderValidForProcessing(headerHandler process.HdrValidatorHandler) error
  • func (h *HeaderValidatorStub) IsInterfaceNil() bool
• type HeadersCacherStub
  • func (hcs *HeadersCacherStub) AddHeader(headerHash []byte, header data.HeaderHandler)
  • func (hcs *HeadersCacherStub) Clear()
  • func (hcs *HeadersCacherStub) GetHeaderByHash(hash []byte) (data.HeaderHandler, error)
  • func (hcs *HeadersCacherStub) GetHeadersByNonceAndShardId(hdrNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error)
  • func (hcs *HeadersCacherStub) GetNumHeaders(shardId uint32) int
  • func (hcs *HeadersCacherStub) IsInterfaceNil() bool
  • func (hcs *HeadersCacherStub) Len() int
  • func (hcs *HeadersCacherStub) MaxSize() int
  • func (hcs *HeadersCacherStub) Nonces(shardId uint32) []uint64
  • func (hcs *HeadersCacherStub) RegisterHandler(handler func(header data.HeaderHandler, shardHeaderHash []byte))
  • func (hcs *HeadersCacherStub) RemoveHeaderByHash(headerHash []byte)
  • func (hcs *HeadersCacherStub) RemoveHeaderByNonceAndShardId(hdrNonce uint64, shardId uint32)
• type InterceptedDataFactoryStub
  • func (idfs *InterceptedDataFactoryStub) Create(buff []byte) (process.InterceptedData, error)
  • func (idfs *InterceptedDataFactoryStub) IsInterfaceNil() bool
• type InterceptedDataVerifierMock
  • func (i *InterceptedDataVerifierMock) IsForCurrentShard(_ process.InterceptedData) bool
  • func (i *InterceptedDataVerifierMock) IsInterfaceNil() bool
• type InterceptedDebugHandlerStub
  • func (idhs *InterceptedDebugHandlerStub) IsInterfaceNil() bool
  • func (idhs *InterceptedDebugHandlerStub) LogProcessedHashes(topic string, hashes [][]byte, err error)
  • func (idhs *InterceptedDebugHandlerStub) LogReceivedHashes(topic string, hashes [][]byte)
• type InterceptedTrieNodeStub
  • func (ins *InterceptedTrieNodeStub) CheckValidity() error
  • func (ins *InterceptedTrieNodeStub) Hash() []byte
  • func (ins *InterceptedTrieNodeStub) Identifiers() [][]byte
  • func (ins *InterceptedTrieNodeStub) IsForCurrentShard() bool
  • func (ins *InterceptedTrieNodeStub) IsInterfaceNil() bool
  • func (ins *InterceptedTrieNodeStub) SizeInBytes() int
  • func (ins *InterceptedTrieNodeStub) String() string
  • func (ins *InterceptedTrieNodeStub) Type() string
• type InterceptedTxHandlerStub
  • func (iths *InterceptedTxHandlerStub) Fee() *big.Int
  • func (iths *InterceptedTxHandlerStub) Nonce() uint64
  • func (iths *InterceptedTxHandlerStub) ReceiverShardId() uint32
  • func (iths *InterceptedTxHandlerStub) SenderAddress() []byte
  • func (iths *InterceptedTxHandlerStub) SenderShardId() uint32
  • func (iths *InterceptedTxHandlerStub) Transaction() data.TransactionHandler
• type InterceptorProcessorStub
  • func (ips *InterceptorProcessorStub) IsInterfaceNil() bool
  • func (ips *InterceptorProcessorStub) RegisterHandler(handler func(topic string, hash []byte, data interface{}))
  • func (ips *InterceptorProcessorStub) Save(data process.InterceptedData, _ core.PeerID, _ string) error
  • func (ips *InterceptorProcessorStub) Validate(data process.InterceptedData, _ core.PeerID) error
• type InterceptorThrottlerStub
  • func (its *InterceptorThrottlerStub) CanProcess() bool
  • func (its *InterceptorThrottlerStub) EndProcessing()
  • func (its *InterceptorThrottlerStub) EndProcessingCount() int32
  • func (its *InterceptorThrottlerStub) IsInterfaceNil() bool
  • func (its *InterceptorThrottlerStub) StartProcessing()
  • func (its *InterceptorThrottlerStub) StartProcessingCount() int32
• type InterimProcessorContainerMock
  • func (ipcm *InterimProcessorContainerMock) Add(_ block.Type, _ process.IntermediateTransactionHandler) error
  • func (ipcm *InterimProcessorContainerMock) AddMultiple(_ []block.Type, _ []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(_ block.Type)
  • func (ipcm *InterimProcessorContainerMock) Replace(_ block.Type, _ process.IntermediateTransactionHandler) error
• type IntermProcessorContainerStub
  • func (ipcm *IntermProcessorContainerStub) Add(_ block.Type, _ process.IntermediateTransactionHandler) error
  • func (ipcm *IntermProcessorContainerStub) AddMultiple(_ []block.Type, _ []process.IntermediateTransactionHandler) error
  • func (ipcm *IntermProcessorContainerStub) Get(key block.Type) (process.IntermediateTransactionHandler, error)
  • func (ipcm *IntermProcessorContainerStub) IsInterfaceNil() bool
  • func (ipcm *IntermProcessorContainerStub) Keys() []block.Type
  • func (ipcm *IntermProcessorContainerStub) Len() int
  • func (ipcm *IntermProcessorContainerStub) Remove(_ block.Type)
  • func (ipcm *IntermProcessorContainerStub) Replace(_ block.Type, _ process.IntermediateTransactionHandler) error
• type IntermediateTransactionHandlerMock
  • func (ith *IntermediateTransactionHandlerMock) AddIntermediateTransactions(txs []data.TransactionHandler) error
  • 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 IntermediateTransactionHandlerStub
  • func (ith *IntermediateTransactionHandlerStub) AddIntermediateTransactions(txs []data.TransactionHandler) error
  • func (ith *IntermediateTransactionHandlerStub) CreateAllInterMiniBlocks() []*block.MiniBlock
  • func (ith *IntermediateTransactionHandlerStub) CreateBlockStarted()
  • func (ith *IntermediateTransactionHandlerStub) CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)
  • func (ith *IntermediateTransactionHandlerStub) GetAllCurrentFinishedTxs() map[string]data.TransactionHandler
  • func (ith *IntermediateTransactionHandlerStub) GetCreatedInShardMiniBlock() *block.MiniBlock
  • func (ith *IntermediateTransactionHandlerStub) GetIntermediateTransactions() []data.TransactionHandler
  • func (ith *IntermediateTransactionHandlerStub) GetNumOfCrossInterMbsAndTxs() (int, int)
  • func (ith *IntermediateTransactionHandlerStub) IsInterfaceNil() bool
  • func (ith *IntermediateTransactionHandlerStub) RemoveProcessedResultsFor(txHashes [][]byte)
  • func (ith *IntermediateTransactionHandlerStub) SaveCurrentIntermediateTxToStorage() error
  • func (ith *IntermediateTransactionHandlerStub) VerifyInterMiniBlocks(body *block.Body) error
• type MarshalizerMock
  • func (mm *MarshalizerMock) IsInterfaceNil() bool
  • func (mm *MarshalizerMock) Marshal(obj interface{}) ([]byte, error)
  • func (mm *MarshalizerMock) Unmarshal(obj interface{}, buff []byte) error
• type MarshalizerStub
  • func (ms *MarshalizerStub) IsInterfaceNil() bool
  • func (ms *MarshalizerStub) Marshal(obj interface{}) ([]byte, error)
  • func (ms *MarshalizerStub) Unmarshal(obj interface{}, buff []byte) error
• type MessageHandlerStub
  • func (mhs *MessageHandlerStub) ConnectedPeersOnTopic(topic string) []core.PeerID
  • func (mhs *MessageHandlerStub) IsInterfaceNil() bool
  • func (mhs *MessageHandlerStub) SendToConnectedPeer(topic string, buff []byte, peerID core.PeerID) error
• type MessageSignVerifierMock
  • func (m *MessageSignVerifierMock) IsInterfaceNil() bool
  • func (m *MessageSignVerifierMock) Verify(_ []byte, _ []byte, _ []byte) error
• type MessengerStub
  • func (ms *MessengerStub) Addresses() []string
  • func (ms *MessengerStub) Bootstrap() error
  • func (ms *MessengerStub) Broadcast(topic string, buff []byte)
  • func (ms *MessengerStub) BroadcastOnChannel(channel string, topic string, buff []byte)
  • func (ms *MessengerStub) Close() error
  • func (ms *MessengerStub) ConnectToPeer(address string) error
  • func (ms *MessengerStub) ConnectedPeers() []core.PeerID
  • func (ms *MessengerStub) ConnectedPeersOnTopic(_ string) []core.PeerID
  • func (ms *MessengerStub) CreateTopic(name string, createChannelForTopic bool) error
  • func (ms *MessengerStub) HasTopic(name string) bool
  • func (ms *MessengerStub) HasTopicValidator(name string) bool
  • func (ms *MessengerStub) ID() core.PeerID
  • func (ms *MessengerStub) IsConnected(peerID core.PeerID) bool
  • func (ms *MessengerStub) IsInterfaceNil() bool
  • func (ms *MessengerStub) OutgoingChannelLoadBalancer() p2p.ChannelLoadBalancer
  • func (ms *MessengerStub) Peers() []core.PeerID
  • func (ms *MessengerStub) RegisterMessageProcessor(topic string, handler p2p.MessageProcessor) error
  • func (ms *MessengerStub) SendToConnectedPeer(topic string, buff []byte, peerID core.PeerID) error
  • func (ms *MessengerStub) TrimConnections()
  • func (ms *MessengerStub) UnjoinAllTopics() error
  • func (ms *MessengerStub) UnregisterAllMessageProcessors() error
  • func (ms *MessengerStub) UnregisterMessageProcessor(topic string) error
• type MiniBlocksProviderStub
  • func (mbps *MiniBlocksProviderStub) GetMiniBlocks(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
  • func (mbps *MiniBlocksProviderStub) GetMiniBlocksFromPool(hashes [][]byte) ([]*block.MiniblockAndHash, [][]byte)
  • func (mbps *MiniBlocksProviderStub) IsInterfaceNil() bool
• type NetworkConnectionWatcherStub
  • func (cws *NetworkConnectionWatcherStub) IsConnectedToTheNetwork() bool
  • func (cws *NetworkConnectionWatcherStub) IsInterfaceNil() bool
• 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 NodesConfigProviderStub
  • func (n *NodesConfigProviderStub) IsInterfaceNil() bool
  • func (n *NodesConfigProviderStub) MinNumberOfNodes() uint32
  • func (n *NodesConfigProviderStub) MinNumberOfNodesWithHysteresis() uint32
• type NodesCoordinatorMock
  • func NewNodesCoordinatorMock() *NodesCoordinatorMock
  • func (ncm *NodesCoordinatorMock) ComputeAdditionalLeaving([]*state.ShardValidatorInfo) (map[uint32][]sharding.Validator, error)
  • func (ncm *NodesCoordinatorMock) ComputeConsensusGroup(randomess []byte, round uint64, shardId uint32, epoch uint32) ([]sharding.Validator, error)
  • func (ncm *NodesCoordinatorMock) ConsensusGroupSize(shardId 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(selection []byte, shardId uint32, epoch uint32) (publicKeys []string, err 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(eligible map[uint32][]sharding.Validator, _ map[uint32][]sharding.Validator, ...) error
  • func (ncm *NodesCoordinatorMock) ShardIdForEpoch(_ uint32) (uint32, error)
  • func (ncm *NodesCoordinatorMock) ShuffleOutForEpoch(_ uint32)
  • func (ncm *NodesCoordinatorMock) ValidatorsWeights(validators []sharding.Validator) ([]uint32, error)
• type NodesSetupStub
  • func (n *NodesSetupStub) AllInitialNodes() []sharding.GenesisNodeInfoHandler
  • func (n *NodesSetupStub) GetAdaptivity() bool
  • func (n *NodesSetupStub) GetHysteresis() float32
  • func (n *NodesSetupStub) GetMetaConsensusGroupSize() uint32
  • func (n *NodesSetupStub) GetRoundDuration() uint64
  • func (n *NodesSetupStub) GetShardConsensusGroupSize() uint32
  • func (n *NodesSetupStub) GetShardIDForPubKey(pubkey []byte) (uint32, error)
  • func (n *NodesSetupStub) GetStartTime() int64
  • func (n *NodesSetupStub) InitialEligibleNodesPubKeysForShard(shardId uint32) ([]string, error)
  • func (n *NodesSetupStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)
  • func (n *NodesSetupStub) InitialNodesInfoForShard(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error)
  • func (n *NodesSetupStub) InitialNodesPubKeys() map[uint32][]string
  • func (n *NodesSetupStub) IsInterfaceNil() bool
  • func (n *NodesSetupStub) MinNumberOfMetaNodes() uint32
  • func (n *NodesSetupStub) MinNumberOfNodes() uint32
  • func (n *NodesSetupStub) MinNumberOfNodesWithHysteresis() uint32
  • func (n *NodesSetupStub) MinNumberOfShardNodes() uint32
  • func (n *NodesSetupStub) NumberOfShards() uint32
• type ObjectsContainerStub
  • func (ocs *ObjectsContainerStub) Add(key string, val interface{}) error
  • func (ocs *ObjectsContainerStub) Get(key string) (interface{}, error)
  • func (ocs *ObjectsContainerStub) Len() int
  • func (ocs *ObjectsContainerStub) Remove(key string)
  • func (ocs *ObjectsContainerStub) Replace(key string, val interface{}) error
• type P2PAntifloodHandlerStub
  • func (p2pahs *P2PAntifloodHandlerStub) ApplyConsensusSize(size int)
  • func (p2pahs *P2PAntifloodHandlerStub) BlacklistPeer(peer core.PeerID, reason string, duration time.Duration)
  • func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
  • func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessagesOnTopic(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, ...) error
  • func (af *P2PAntifloodHandlerStub) Close() error
  • func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool
  • func (p2pahs *P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic(pid core.PeerID, topic string) error
  • func (p2pahs *P2PAntifloodHandlerStub) SetDebugger(debugger process.AntifloodDebugger) error
• type P2PMessageMock
  • func (msg *P2PMessageMock) Data() []byte
  • func (msg *P2PMessageMock) From() []byte
  • func (msg *P2PMessageMock) IsInterfaceNil() bool
  • func (msg *P2PMessageMock) Key() []byte
  • func (msg *P2PMessageMock) Payload() []byte
  • func (msg *P2PMessageMock) Peer() core.PeerID
  • func (msg *P2PMessageMock) SeqNo() []byte
  • func (msg *P2PMessageMock) Signature() []byte
  • func (msg *P2PMessageMock) Timestamp() int64
  • func (msg *P2PMessageMock) Topic() string
• type PauseHandlerStub
  • func (p *PauseHandlerStub) IsInterfaceNil() bool
  • func (p *PauseHandlerStub) IsPaused(token []byte) bool
• type PayableHandlerStub
  • func (p *PayableHandlerStub) IsInterfaceNil() bool
  • func (p *PayableHandlerStub) IsPayable(address []byte) (bool, error)
• type PeerAccountHandlerMock
  • func (p *PeerAccountHandlerMock) AddToAccumulatedFees(val *big.Int)
  • func (p *PeerAccountHandlerMock) AddressBytes() []byte
  • func (p *PeerAccountHandlerMock) DataTrie() common.Trie
  • func (p *PeerAccountHandlerMock) DataTrieTracker() state.DataTrieTracker
  • func (p *PeerAccountHandlerMock) DecreaseLeaderSuccessRate(val uint32)
  • func (p *PeerAccountHandlerMock) DecreaseValidatorSuccessRate(val uint32)
  • func (p *PeerAccountHandlerMock) GetAccumulatedFees() *big.Int
  • func (p *PeerAccountHandlerMock) GetBLSPublicKey() []byte
  • func (p *PeerAccountHandlerMock) GetCode() []byte
  • func (p *PeerAccountHandlerMock) GetCodeHash() []byte
  • func (p *PeerAccountHandlerMock) GetConsecutiveProposerMisses() uint32
  • func (p *PeerAccountHandlerMock) GetIndexInList() uint32
  • func (p *PeerAccountHandlerMock) GetLeaderSuccessRate() state.SignRate
  • func (p *PeerAccountHandlerMock) GetList() string
  • func (p *PeerAccountHandlerMock) GetNonce() uint64
  • func (p *PeerAccountHandlerMock) GetNumSelectedInSuccessBlocks() uint32
  • func (p *PeerAccountHandlerMock) GetRating() uint32
  • func (p *PeerAccountHandlerMock) GetRewardAddress() []byte
  • func (p *PeerAccountHandlerMock) GetRootHash() []byte
  • func (p *PeerAccountHandlerMock) GetShardId() uint32
  • func (p *PeerAccountHandlerMock) GetStake() *big.Int
  • func (p *PeerAccountHandlerMock) GetTempRating() uint32
  • func (p *PeerAccountHandlerMock) GetTotalLeaderSuccessRate() state.SignRate
  • func (p *PeerAccountHandlerMock) GetTotalValidatorIgnoredSignaturesRate() uint32
  • func (p *PeerAccountHandlerMock) GetTotalValidatorSuccessRate() state.SignRate
  • func (p *PeerAccountHandlerMock) GetUnStakedEpoch() uint32
  • func (p *PeerAccountHandlerMock) GetValidatorIgnoredSignaturesRate() uint32
  • func (p *PeerAccountHandlerMock) GetValidatorSuccessRate() state.SignRate
  • func (p *PeerAccountHandlerMock) IncreaseLeaderSuccessRate(val uint32)
  • func (p *PeerAccountHandlerMock) IncreaseNonce(_ uint64)
  • func (p *PeerAccountHandlerMock) IncreaseNumSelectedInSuccessBlocks()
  • func (p *PeerAccountHandlerMock) IncreaseValidatorIgnoredSignaturesRate(val uint32)
  • func (p *PeerAccountHandlerMock) IncreaseValidatorSuccessRate(val uint32)
  • func (p *PeerAccountHandlerMock) IsInterfaceNil() bool
  • func (p *PeerAccountHandlerMock) ResetAtNewEpoch()
  • func (p *PeerAccountHandlerMock) SetBLSPublicKey([]byte) error
  • func (p *PeerAccountHandlerMock) SetCode(_ []byte)
  • func (p *PeerAccountHandlerMock) SetCodeHash(_ []byte)
  • func (p *PeerAccountHandlerMock) SetConsecutiveProposerMisses(consecutiveMisses uint32)
  • func (p *PeerAccountHandlerMock) SetDataTrie(_ common.Trie)
  • func (p *PeerAccountHandlerMock) SetListAndIndex(shardID uint32, list string, index uint32)
  • func (p *PeerAccountHandlerMock) SetRating(uint32)
  • func (p *PeerAccountHandlerMock) SetRewardAddress([]byte) error
  • func (p *PeerAccountHandlerMock) SetRootHash([]byte)
  • func (p *PeerAccountHandlerMock) SetStake(_ *big.Int) error
  • func (p *PeerAccountHandlerMock) SetTempRating(val uint32)
  • func (p *PeerAccountHandlerMock) SetUnStakedEpoch(_ uint32)
• type PeerBlackListHandlerStub
  • func (pblhs *PeerBlackListHandlerStub) Has(pid core.PeerID) bool
  • func (pblhs *PeerBlackListHandlerStub) IsInterfaceNil() bool
  • func (pblhs *PeerBlackListHandlerStub) Sweep()
  • func (pblhs *PeerBlackListHandlerStub) 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 PeerShardMapperStub
  • func (psms *PeerShardMapperStub) GetPeerInfo(pid core.PeerID) core.P2PPeerInfo
  • func (psms *PeerShardMapperStub) IsInterfaceNil() bool
  • func (psms *PeerShardMapperStub) UpdatePeerIdPublicKey(pid core.PeerID, pk []byte)
  • func (psms *PeerShardMapperStub) UpdatePeerIdShardId(pid core.PeerID, shardId uint32)
  • func (psms *PeerShardMapperStub) UpdatePublicKeyShardId(pk []byte, shardId uint32)
• type PeerShardResolverStub
  • func (psrs *PeerShardResolverStub) GetPeerInfo(pid core.PeerID) core.P2PPeerInfo
  • func (psrs *PeerShardResolverStub) 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 PreProcessorContainerMock
  • func (ppcm *PreProcessorContainerMock) Add(_ block.Type, _ process.PreProcessor) error
  • func (ppcm *PreProcessorContainerMock) AddMultiple(_ []block.Type, _ []process.PreProcessor) error
  • func (ppcm *PreProcessorContainerMock) Get(key block.Type) (process.PreProcessor, error)
  • func (ppcm *PreProcessorContainerMock) IsInterfaceNil() bool
  • func (ppcm *PreProcessorContainerMock) Keys() []block.Type
  • func (ppcm *PreProcessorContainerMock) Len() int
  • func (ppcm *PreProcessorContainerMock) Remove(_ block.Type)
  • func (ppcm *PreProcessorContainerMock) Replace(_ block.Type, _ process.PreProcessor) error
• type PreProcessorMock
  • func (ppm *PreProcessorMock) CreateAndProcessMiniBlocks(haveTime func() bool) (block.MiniBlockSlice, error)
  • func (ppm *PreProcessorMock) CreateBlockStarted()
  • func (ppm *PreProcessorMock) CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)
  • func (ppm *PreProcessorMock) GetAllCurrentUsedTxs() map[string]data.TransactionHandler
  • func (ppm *PreProcessorMock) IsDataPrepared(requestedTxs int, haveTime func() time.Duration) error
  • func (ppm *PreProcessorMock) IsInterfaceNil() bool
  • func (ppm *PreProcessorMock) ProcessBlockTransactions(body *block.Body, haveTime func() bool) error
  • func (ppm *PreProcessorMock) ProcessMiniBlock(miniBlock *block.MiniBlock, haveTime func() bool, ...) ([][]byte, int, error)
  • func (ppm *PreProcessorMock) RemoveBlockDataFromPools(body *block.Body, miniBlockPool storage.Cacher) error
  • func (ppm *PreProcessorMock) RemoveTxsFromPools(body *block.Body) error
  • func (ppm *PreProcessorMock) RequestBlockTransactions(body *block.Body) int
  • func (ppm *PreProcessorMock) RequestTransactionsForMiniBlock(miniBlock *block.MiniBlock) int
  • func (ppm *PreProcessorMock) RestoreBlockDataIntoPools(body *block.Body, miniBlockPool storage.Cacher) (int, error)
  • func (ppm *PreProcessorMock) SaveTxsToStorage(body *block.Body) error
• type ProtobufMarshalizerMock
  • func (x *ProtobufMarshalizerMock) IsInterfaceNil() bool
  • func (x *ProtobufMarshalizerMock) Marshal(obj interface{}) ([]byte, error)
  • func (x *ProtobufMarshalizerMock) Unmarshal(obj interface{}, buff []byte) error
• type PubkeyConverterMock
  • func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock
  • func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error)
  • func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string
  • func (pcm *PubkeyConverterMock) IsInterfaceNil() bool
  • func (pcm *PubkeyConverterMock) Len() int
• type PubkeyConverterStub
  • func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error)
  • func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string
  • func (pcs *PubkeyConverterStub) IsInterfaceNil() bool
  • func (pcs *PubkeyConverterStub) Len() int
• type QuotaStatusHandlerStub
  • func (qshs *QuotaStatusHandlerStub) AddQuota(pid core.PeerID, numReceived uint32, sizeReceived uint64, numProcessed uint32, ...)
  • func (qshs *QuotaStatusHandlerStub) IsInterfaceNil() bool
  • func (qshs *QuotaStatusHandlerStub) ResetStatistics()
• type RaterMock
  • func GetNewMockRater() *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 RatingStepMock
  • func (rd *RatingStepMock) ConsecutiveMissedBlocksPenalty() float32
  • func (rd *RatingStepMock) ProposerDecreaseRatingStep() int32
  • func (rd *RatingStepMock) ProposerIncreaseRatingStep() int32
  • func (rd *RatingStepMock) ValidatorDecreaseRatingStep() int32
  • func (rd *RatingStepMock) ValidatorIncreaseRatingStep() int32
• type RatingsInfoMock
  • func (rd *RatingsInfoMock) IsInterfaceNil() bool
  • func (rd *RatingsInfoMock) MaxRating() uint32
  • func (rd *RatingsInfoMock) MetaChainRatingsStepHandler() process.RatingsStepHandler
  • func (rd *RatingsInfoMock) MinRating() uint32
  • func (rd *RatingsInfoMock) SelectionChances() []process.SelectionChance
  • func (rd *RatingsInfoMock) ShardChainRatingsStepHandler() process.RatingsStepHandler
  • func (rd *RatingsInfoMock) SignedBlocksThreshold() float32
  • func (rd *RatingsInfoMock) StartRating() uint32
• 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 ResolverStub
  • func (rs *ResolverStub) IsInterfaceNil() bool
  • func (rs *ResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error
  • func (rs *ResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error
• 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) Len() int
  • func (rcs *ResolversContainerStub) Remove(key string)
  • func (rcs *ResolversContainerStub) Replace(key string, val dataRetriever.Resolver) error
• 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)
• type RewardsHandlerMock
  • func (rhm *RewardsHandlerMock) IsInterfaceNil() bool
  • func (rhm *RewardsHandlerMock) LeaderPercentage() float64
  • func (rhm *RewardsHandlerMock) MaxInflationRate(uint32) float64
  • func (rhm *RewardsHandlerMock) MinInflationRate() float64
  • func (rhm *RewardsHandlerMock) ProtocolSustainabilityAddress() string
  • func (rhm *RewardsHandlerMock) ProtocolSustainabilityPercentage() float64
  • func (rhm *RewardsHandlerMock) RewardsTopUpFactor() float64
  • func (rhm *RewardsHandlerMock) RewardsTopUpGradientPoint() *big.Int
• type RoundHandlerMock
  • func (rndm *RoundHandlerMock) BeforeGenesis() bool
  • func (rndm *RoundHandlerMock) Index() int64
  • func (rndm *RoundHandlerMock) IsInterfaceNil() bool
  • func (rndm *RoundHandlerMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration
  • func (rndm *RoundHandlerMock) TimeDuration() time.Duration
  • func (rndm *RoundHandlerMock) TimeStamp() time.Time
  • func (rndm *RoundHandlerMock) UpdateRound(genesisRoundTimeStamp time.Time, timeStamp time.Time)
• type RoundStub
  • func (rnds *RoundStub) Index() int64
  • func (rnds *RoundStub) IsInterfaceNil() bool
  • func (rnds *RoundStub) RemainingTime(startTime time.Time, maxTime time.Duration) time.Duration
  • func (rnds *RoundStub) TimeDuration() time.Duration
  • func (rnds *RoundStub) TimeStamp() time.Time
  • func (rnds *RoundStub) UpdateRound(genesisRoundTimeStamp time.Time, timeStamp time.Time)
• type SCToProtocolStub
  • func (s *SCToProtocolStub) IsInterfaceNil() bool
  • func (s *SCToProtocolStub) UpdateProtocol(body *block.Body, nonce uint64) error
• type ScQueryStub
  • func (s *ScQueryStub) Close() error
  • 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 ShardCoordinatorStub
  • func (coordinator *ShardCoordinatorStub) CommunicationIdentifier(destShardID uint32) string
  • func (coordinator *ShardCoordinatorStub) ComputeId(address []byte) uint32
  • func (coordinator *ShardCoordinatorStub) IsInterfaceNil() bool
  • func (coordinator *ShardCoordinatorStub) NumberOfShards() uint32
  • func (coordinator *ShardCoordinatorStub) SameShard(firstAddress, secondAddress []byte) bool
  • func (coordinator *ShardCoordinatorStub) SelfId() uint32
• type ShardIdHasMapMock
  • func (sihsm *ShardIdHasMapMock) Delete(shardId uint32)
  • func (sihsm *ShardIdHasMapMock) IsInterfaceNil() bool
  • func (sihsm *ShardIdHasMapMock) Load(shardId uint32) ([]byte, bool)
  • func (sihsm *ShardIdHasMapMock) Range(f func(shardId uint32, hash []byte) bool)
  • func (sihsm *ShardIdHasMapMock) Store(shardId uint32, hash []byte)
• 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 SingleSignKeyGenMock
  • func (sskgm *SingleSignKeyGenMock) CheckPublicKeyValid(_ []byte) error
  • func (sskgm *SingleSignKeyGenMock) GeneratePair() (crypto.PrivateKey, crypto.PublicKey)
  • func (sskgm *SingleSignKeyGenMock) IsInterfaceNil() bool
  • func (sskgm *SingleSignKeyGenMock) PrivateKeyFromByteArray(_ []byte) (crypto.PrivateKey, error)
  • func (sskgm *SingleSignKeyGenMock) PublicKeyFromByteArray(b []byte) (crypto.PublicKey, error)
  • func (sskgm *SingleSignKeyGenMock) Suite() crypto.Suite
• type SingleSignPublicKey
  • func (sspk *SingleSignPublicKey) IsInterfaceNil() bool
  • func (sspk *SingleSignPublicKey) Point() crypto.Point
  • func (sspk *SingleSignPublicKey) Suite() crypto.Suite
  • func (sspk *SingleSignPublicKey) ToByteArray() ([]byte, error)
• type StatusComponentsMock
  • func (scm *StatusComponentsMock) IsInterfaceNil() bool
  • func (scm *StatusComponentsMock) OutportHandler() outport.OutportHandler
• 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) GetOldestEpoch() (uint32, error)
  • func (sm *StorerMock) Has(_ []byte) error
  • func (sm *StorerMock) IsInterfaceNil() bool
  • func (sm *StorerMock) Put(key, data []byte) error
  • func (sm *StorerMock) PutInEpoch(key, data []byte, _ uint32) error
  • func (sm *StorerMock) RangeKeys(_ func(key []byte, val []byte) bool)
  • func (sm *StorerMock) Remove(key []byte) error
  • func (sm *StorerMock) SearchFirst(_ []byte) ([]byte, error)
• type SyncStarterStub
  • func (sss *SyncStarterStub) SyncBlock() 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(topic string)
  • func (t *TopicAntiFloodStub) SetMaxMessagesForTopic(topic string, num uint32)
• type TopicHandlerStub
  • func (ths *TopicHandlerStub) CreateTopic(name string, createChannelForTopic bool) error
  • func (ths *TopicHandlerStub) HasTopic(name string) bool
  • func (ths *TopicHandlerStub) ID() core.PeerID
  • func (ths *TopicHandlerStub) IsInterfaceNil() bool
  • func (ths *TopicHandlerStub) RegisterMessageProcessor(topic string, identifier string, handler p2p.MessageProcessor) error
• type TransactionCoordinatorMock
  • func (tcm *TransactionCoordinatorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType)
  • func (tcm *TransactionCoordinatorMock) CreateBlockStarted()
  • func (tcm *TransactionCoordinatorMock) CreateMarshalizedData(body *block.Body) map[string][][]byte
  • func (tcm *TransactionCoordinatorMock) CreateMarshalizedReceipts() ([]byte, error)
  • func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, ...) (block.MiniBlockSlice, uint32, bool, error)
  • func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe(haveTime func() bool) block.MiniBlockSlice
  • func (tcm *TransactionCoordinatorMock) CreatePostProcessMiniBlocks() block.MiniBlockSlice
  • func (tcm *TransactionCoordinatorMock) CreateReceiptsHash() ([]byte, error)
  • func (tcm *TransactionCoordinatorMock) GetAllCurrentLogs() map[string]data.LogHandler
  • func (tcm *TransactionCoordinatorMock) GetAllCurrentUsedTxs(blockType block.Type) map[string]data.TransactionHandler
  • func (tcm *TransactionCoordinatorMock) IsDataPreparedForProcessing(haveTime func() time.Duration) error
  • func (tcm *TransactionCoordinatorMock) IsInterfaceNil() bool
  • func (tcm *TransactionCoordinatorMock) ProcessBlockTransaction(body *block.Body, haveTime func() time.Duration) error
  • func (tcm *TransactionCoordinatorMock) RemoveBlockDataFromPool(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) RemoveTxsFromPool(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) RequestBlockTransactions(body *block.Body)
  • func (tcm *TransactionCoordinatorMock) RequestMiniBlocks(header data.HeaderHandler)
  • func (tcm *TransactionCoordinatorMock) RestoreBlockDataFromStorage(body *block.Body) (int, error)
  • func (tcm *TransactionCoordinatorMock) SaveTxsToStorage(body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) VerifyCreatedBlockTransactions(hdr data.HeaderHandler, body *block.Body) error
  • func (tcm *TransactionCoordinatorMock) VerifyCreatedMiniBlocks(hdr data.HeaderHandler, body *block.Body) error
• type TransactionInterceptorMock
  • func (tim *TransactionInterceptorMock) Check() bool
  • func (tim *TransactionInterceptorMock) GetTransaction() *transaction.Transaction
  • func (tim *TransactionInterceptorMock) Hash() []byte
  • func (tim *TransactionInterceptorMock) ID() string
  • func (tim *TransactionInterceptorMock) IsAddressedToOtherShards() bool
  • func (tim *TransactionInterceptorMock) IsInterfaceNil() bool
  • func (tim *TransactionInterceptorMock) PubkeyConverter() core.PubkeyConverter
  • func (tim *TransactionInterceptorMock) RcvShard() uint32
  • func (tim *TransactionInterceptorMock) SetHash(hash []byte)
  • func (tim *TransactionInterceptorMock) SetPubkeyConverter(converter core.PubkeyConverter)
  • func (tim *TransactionInterceptorMock) SndShard() uint32
  • func (tim *TransactionInterceptorMock) VerifySig() bool
• type TransactionPoolMock
  • func (tpm *TransactionPoolMock) MiniPoolTxStore(shardID uint32) (c storage.Cacher)
  • func (tpm *TransactionPoolMock) RegisterTransactionHandler(transactionHandler func(txHash []byte))
  • func (tpm *TransactionPoolMock) RemoveTransactionsFromPool(txHashes [][]byte, destShardID uint32)
• type TransactionSimulatorStub
  • func (tss *TransactionSimulatorStub) IsInterfaceNil() bool
  • func (tss *TransactionSimulatorStub) ProcessTx(tx *transaction.Transaction) (*txSimData.SimulationResults, 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) Clean()
  • func (txls *TxLogsProcessorStub) GetAllCurrentLogs() map[string]data.LogHandler
  • func (txls *TxLogsProcessorStub) GetLog(txHash []byte) (data.LogHandler, error)
  • func (txls *TxLogsProcessorStub) IsInterfaceNil() bool
  • func (txls *TxLogsProcessorStub) SaveLog(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error
• type TxValidatorHandlerStub
  • func (tvhs *TxValidatorHandlerStub) Fee() *big.Int
  • func (tvhs *TxValidatorHandlerStub) Nonce() uint64
  • func (tvhs *TxValidatorHandlerStub) ReceiverShardId() uint32
  • func (tvhs *TxValidatorHandlerStub) SenderAddress() []byte
  • func (tvhs *TxValidatorHandlerStub) SenderShardId() uint32
• type TxValidatorStub
  • func (t *TxValidatorStub) CheckTxValidity(txValidatorHandler process.TxValidatorHandler) error
  • func (t *TxValidatorStub) CheckTxWhiteList(data process.InterceptedData) error
  • func (t *TxValidatorStub) 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 Uint64SyncMapCacherStub
  • func (usmcs *Uint64SyncMapCacherStub) Clear()
  • func (usmcs *Uint64SyncMapCacherStub) Get(nonce uint64) (dataRetriever.ShardIdHashMap, bool)
  • func (usmcs *Uint64SyncMapCacherStub) Has(nonce uint64, shardId uint32) bool
  • func (usmcs *Uint64SyncMapCacherStub) IsInterfaceNil() bool
  • func (usmcs *Uint64SyncMapCacherStub) Merge(nonce uint64, src dataRetriever.ShardIdHashMap)
  • func (usmcs *Uint64SyncMapCacherStub) RegisterHandler(handler func(nonce uint64, shardId uint32, value []byte))
  • func (usmcs *Uint64SyncMapCacherStub) Remove(nonce uint64, shardId uint32)
  • func (usmcs *Uint64SyncMapCacherStub) UnRegisterHandler(handler func(key []byte, value interface{}))
• type VMContainerMock
  • func (v *VMContainerMock) Add(key []byte, val vmcommon.VMExecutionHandler) error
  • func (v *VMContainerMock) AddMultiple(keys [][]byte, vms []vmcommon.VMExecutionHandler) error
  • func (v *VMContainerMock) Close() error
  • func (v *VMContainerMock) Get(key []byte) (vmcommon.VMExecutionHandler, error)
  • func (v *VMContainerMock) IsInterfaceNil() bool
  • func (v *VMContainerMock) Keys() [][]byte
  • func (v *VMContainerMock) Len() int
  • func (v *VMContainerMock) Remove(key []byte)
  • func (v *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 ValidatorMock
  • func NewValidatorMock(pubkey []byte) *ValidatorMock
  • func (vm *ValidatorMock) Chances() uint32
  • func (vm *ValidatorMock) Index() uint32
  • func (vm *ValidatorMock) PubKey() []byte
  • func (vm *ValidatorMock) Size() int
• type ValidatorSettingsStub
  • func (v *ValidatorSettingsStub) GenesisNodePrice() *big.Int
  • func (v *ValidatorSettingsStub) IsInterfaceNil() bool
  • func (v *ValidatorSettingsStub) UnBondPeriod() uint64
• type ValidatorStatisticsProcessorStub
  • func (vsp *ValidatorStatisticsProcessorStub) Commit() ([]byte, error)
  • func (vsp *ValidatorStatisticsProcessorStub) DisplayRatings(_ uint32)
  • func (vsp *ValidatorStatisticsProcessorStub) GetExistingPeerAccount(address []byte) (state.PeerAccountHandler, error)
  • func (vsp *ValidatorStatisticsProcessorStub) GetValidatorInfoForRootHash(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)
  • func (vsp *ValidatorStatisticsProcessorStub) IsInterfaceNil() bool
  • func (vsp *ValidatorStatisticsProcessorStub) LastFinalizedRootHash() []byte
  • func (vsp *ValidatorStatisticsProcessorStub) PeerAccountToValidatorInfo(peerAccount state.PeerAccountHandler) *state.ValidatorInfo
  • func (vsp *ValidatorStatisticsProcessorStub) Process(validatorInfo data.ShardValidatorInfoHandler) error
  • func (vsp *ValidatorStatisticsProcessorStub) ProcessRatingsEndOfEpoch(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error
  • func (vsp *ValidatorStatisticsProcessorStub) ResetValidatorStatisticsAtNewEpoch(vInfos map[uint32][]*state.ValidatorInfo) error
  • func (vsp *ValidatorStatisticsProcessorStub) RevertPeerState(header data.HeaderHandler) error
  • func (vsp *ValidatorStatisticsProcessorStub) RootHash() ([]byte, error)
  • func (vsp *ValidatorStatisticsProcessorStub) SaveNodesCoordinatorUpdates(epoch uint32) (bool, error)
  • func (vsp *ValidatorStatisticsProcessorStub) SetLastFinalizedRootHash(_ []byte)
  • func (vsp *ValidatorStatisticsProcessorStub) UpdatePeerState(header data.HeaderHandler, _ map[string]data.HeaderHandler) ([]byte, error)
• type ValidatorsProviderStub
  • func (vp *ValidatorsProviderStub) Close() error
  • func (vp *ValidatorsProviderStub) GetLatestValidators() map[string]*state.ValidatorApiResponse
  • func (vp *ValidatorsProviderStub) IsInterfaceNil() bool
• type ValidityAttesterStub
  • func (vas *ValidityAttesterStub) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error
  • func (vas *ValidityAttesterStub) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error
  • func (vas *ValidityAttesterStub) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool
  • func (vas *ValidityAttesterStub) IsInterfaceNil() bool

Functions

func NewMultiShardsCoordinatorMock

func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock

NewMultiShardsCoordinatorMock -

func NewMultipleShardsCoordinatorMock

func NewMultipleShardsCoordinatorMock() *multipleShardsCoordinatorMock

NewMultipleShardsCoordinatorMock -

func NewNilTxValidator

func NewNilTxValidator() (*nilTxValidator, error)

NewNilTxValidator creates a new nil tx handler validator instance

func NewNonceHashConverterMock

func NewNonceHashConverterMock() *nonceHashConverterMock

NewNonceHashConverterMock -

func NewOneShardCoordinatorMock

func NewOneShardCoordinatorMock() *oneShardCoordinatorMock

NewOneShardCoordinatorMock -

Types

type AccountWrapMock

type AccountWrapMock struct {
	MockValue int

	SetNonceWithJournalCalled    func(nonce uint64) error    `json:"-"`
	SetCodeHashWithJournalCalled func(codeHash []byte) error `json:"-"`
	SetCodeWithJournalCalled     func(codeHash []byte) error `json:"-"`
	// contains filtered or unexported fields
}

AccountWrapMock -

func NewAccountWrapMock

func NewAccountWrapMock(adr []byte) *AccountWrapMock

NewAccountWrapMock -

func (*AccountWrapMock) AccountDataHandler

func (awm *AccountWrapMock) AccountDataHandler() vmcommon.AccountDataHandler

AccountDataHandler -

func (*AccountWrapMock) AddToBalance

func (awm *AccountWrapMock) AddToBalance(_ *big.Int) error

AddToBalance -

func (*AccountWrapMock) AddToDeveloperReward

func (awm *AccountWrapMock) AddToDeveloperReward(*big.Int)

AddToDeveloperReward -

func (*AccountWrapMock) AddressBytes

func (awm *AccountWrapMock) AddressBytes() []byte

AddressBytes -

func (*AccountWrapMock) ChangeOwnerAddress

func (awm *AccountWrapMock) ChangeOwnerAddress([]byte, []byte) error

ChangeOwnerAddress -

func (*AccountWrapMock) ClaimDeveloperRewards

func (awm *AccountWrapMock) ClaimDeveloperRewards([]byte) (*big.Int, error)

ClaimDeveloperRewards -

func (*AccountWrapMock) DataTrie

func (awm *AccountWrapMock) DataTrie() common.Trie

DataTrie -

func (*AccountWrapMock) DataTrieTracker

func (awm *AccountWrapMock) DataTrieTracker() state.DataTrieTracker

DataTrieTracker -

func (*AccountWrapMock) GetBalance

func (awm *AccountWrapMock) GetBalance() *big.Int

GetBalance -

func (*AccountWrapMock) GetCodeHash

func (awm *AccountWrapMock) GetCodeHash() []byte

GetCodeHash -

func (*AccountWrapMock) GetCodeMetadata

func (awm *AccountWrapMock) GetCodeMetadata() []byte

GetCodeMetadata -

func (*AccountWrapMock) GetDeveloperReward

func (awm *AccountWrapMock) GetDeveloperReward() *big.Int

GetDeveloperReward -

func (*AccountWrapMock) GetNonce

func (awm *AccountWrapMock) GetNonce() uint64

GetNonce -

func (*AccountWrapMock) GetOwnerAddress

func (awm *AccountWrapMock) GetOwnerAddress() []byte

GetOwnerAddress -

func (*AccountWrapMock) GetRootHash

func (awm *AccountWrapMock) GetRootHash() []byte

GetRootHash -

func (*AccountWrapMock) GetUserName

func (awm *AccountWrapMock) GetUserName() []byte

GetUserName -

func (*AccountWrapMock) HasNewCode

func (awm *AccountWrapMock) HasNewCode() bool

HasNewCode -

func (*AccountWrapMock) IncreaseNonce

func (awm *AccountWrapMock) IncreaseNonce(val uint64)

IncreaseNonce -

func (*AccountWrapMock) IsInterfaceNil

func (awm *AccountWrapMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*AccountWrapMock) RetrieveValueFromDataTrieTracker

func (awm *AccountWrapMock) RetrieveValueFromDataTrieTracker(key []byte) ([]byte, error)

RetrieveValueFromDataTrieTracker -

func (*AccountWrapMock) SetCode

func (awm *AccountWrapMock) SetCode(code []byte)

SetCode -

func (*AccountWrapMock) SetCodeHash

func (awm *AccountWrapMock) SetCodeHash(codeHash []byte)

SetCodeHash -

func (*AccountWrapMock) SetCodeMetadata

func (awm *AccountWrapMock) SetCodeMetadata(codeMetadata []byte)

SetCodeMetadata -

func (*AccountWrapMock) SetDataTrie

func (awm *AccountWrapMock) SetDataTrie(trie common.Trie)

SetDataTrie -

func (*AccountWrapMock) SetOwnerAddress

func (awm *AccountWrapMock) SetOwnerAddress([]byte)

SetOwnerAddress -

func (*AccountWrapMock) SetRootHash

func (awm *AccountWrapMock) SetRootHash(rootHash []byte)

SetRootHash -

func (*AccountWrapMock) SetUserName

func (awm *AccountWrapMock) SetUserName(_ []byte)

SetUserName -

func (*AccountWrapMock) SubFromBalance

func (awm *AccountWrapMock) SubFromBalance(_ *big.Int) error

SubFromBalance -

type AccountsDBSyncerStub

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

AccountsDBSyncerStub -

func (*AccountsDBSyncerStub) GetSyncedTries

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

GetSyncedTries -

func (*AccountsDBSyncerStub) IsInterfaceNil

func (a *AccountsDBSyncerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*AccountsDBSyncerStub) SyncAccounts

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

SyncAccounts -

type AntifloodDebuggerStub

type AntifloodDebuggerStub struct {
	AddDataCalled func(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, sequence []byte, isBlacklisted bool)
	CloseCalled   func() error
}

AntifloodDebuggerStub -

func (*AntifloodDebuggerStub) AddData

func (ads *AntifloodDebuggerStub) AddData(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, sequence []byte, isBlacklisted bool)

AddData -

func (*AntifloodDebuggerStub) Close

func (ads *AntifloodDebuggerStub) Close() error

Close -

func (*AntifloodDebuggerStub) IsInterfaceNil

func (ads *AntifloodDebuggerStub) IsInterfaceNil() bool

IsInterfaceNil -

type ArgumentParserMock

type ArgumentParserMock struct {
	ParseCallDataCalled               func(data string) (string, [][]byte, error)
	ParseDeployDataCalled             func(data string) (*parsers.DeployArgs, error)
	CreateDataFromStorageUpdateCalled func(storageUpdates []*vmcommon.StorageUpdate) string
	GetStorageUpdatesCalled           func(data string) ([]*vmcommon.StorageUpdate, error)
}

ArgumentParserMock -

func (*ArgumentParserMock) CreateDataFromStorageUpdate

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

CreateDataFromStorageUpdate -

func (*ArgumentParserMock) GetStorageUpdates

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

GetStorageUpdates -

func (*ArgumentParserMock) IsInterfaceNil

func (ap *ArgumentParserMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ArgumentParserMock) ParseCallData

func (ap *ArgumentParserMock) ParseCallData(data string) (string, [][]byte, error)

ParseCallData -

func (*ArgumentParserMock) ParseDeployData

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

ParseDeployData -

type BalanceComputationStub

type BalanceComputationStub struct {
	InitCalled                    func()
	SetBalanceToAddressCalled     func(address []byte, value *big.Int)
	AddBalanceToAddressCalled     func(address []byte, value *big.Int) bool
	SubBalanceFromAddressCalled   func(address []byte, value *big.Int) bool
	IsAddressSetCalled            func(address []byte) bool
	AddressHasEnoughBalanceCalled func(address []byte, value *big.Int) bool
}

BalanceComputationStub -

func (*BalanceComputationStub) AddBalanceToAddress

func (bcs *BalanceComputationStub) AddBalanceToAddress(address []byte, value *big.Int) bool

AddBalanceToAddress -

func (*BalanceComputationStub) AddressHasEnoughBalance

func (bcs *BalanceComputationStub) AddressHasEnoughBalance(address []byte, value *big.Int) bool

AddressHasEnoughBalance -

func (*BalanceComputationStub) Init

func (bcs *BalanceComputationStub) Init()

Init -

func (*BalanceComputationStub) IsAddressSet

func (bcs *BalanceComputationStub) IsAddressSet(address []byte) bool

IsAddressSet -

func (*BalanceComputationStub) IsInterfaceNil

func (bcs *BalanceComputationStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BalanceComputationStub) SetBalanceToAddress

func (bcs *BalanceComputationStub) SetBalanceToAddress(address []byte, value *big.Int)

SetBalanceToAddress -

func (*BalanceComputationStub) SubBalanceFromAddress

func (bcs *BalanceComputationStub) SubBalanceFromAddress(address []byte, value *big.Int) bool

SubBalanceFromAddress -

type BlackListHandlerStub

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

BlackListHandlerStub -

func (*BlackListHandlerStub) Add

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

Add -

func (*BlackListHandlerStub) Has

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

Has -

func (*BlackListHandlerStub) IsInterfaceNil

func (blhs *BlackListHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlackListHandlerStub) Len

func (blhs *BlackListHandlerStub) Len() int

Len -

func (*BlackListHandlerStub) Sweep

func (blhs *BlackListHandlerStub) Sweep()

Sweep -

func (*BlackListHandlerStub) Upsert

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

Upsert -

type BlockChainHookHandlerMock

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

BlockChainHookHandlerMock -

func (*BlockChainHookHandlerMock) DeleteCompiledCode

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

DeleteCompiledCode -

func (*BlockChainHookHandlerMock) IsInterfaceNil

func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockChainHookHandlerMock) IsPayable

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

IsPayable -

func (*BlockChainHookHandlerMock) NewAddress

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

NewAddress -

func (*BlockChainHookHandlerMock) ProcessBuiltInFunction

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

ProcessBuiltInFunction -

func (*BlockChainHookHandlerMock) SetCurrentHeader

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

SetCurrentHeader -

type BlockChainMock

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

BlockChainMock is a mock implementation of the blockchain interface

func (*BlockChainMock) CreateNewHeader

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

CreateNewHeader -

func (*BlockChainMock) GetCurrentBlockHeader

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

GetCurrentBlockHeader returns current block header pointer

func (*BlockChainMock) GetCurrentBlockHeaderHash

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

GetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) GetGenesisHeader

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

GetGenesisHeader returns the genesis block header pointer

func (*BlockChainMock) GetGenesisHeaderHash

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

GetGenesisHeaderHash returns the genesis block header hash

func (*BlockChainMock) IsInterfaceNil

func (bc *BlockChainMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockChainMock) SetCurrentBlockHeader

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

SetCurrentBlockHeader sets current block header pointer

func (*BlockChainMock) SetCurrentBlockHeaderHash

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

SetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) SetGenesisHeader

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

SetGenesisHeader sets the genesis block header pointer

func (*BlockChainMock) SetGenesisHeaderHash

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

SetGenesisHeaderHash sets the genesis block header hash

type BlockNotarizerHandlerMock

type BlockNotarizerHandlerMock struct {
	AddNotarizedHeaderCalled                 func(shardID uint32, notarizedHeader data.HeaderHandler, notarizedHeaderHash []byte)
	CleanupNotarizedHeadersBehindNonceCalled func(shardID uint32, nonce uint64)
	DisplayNotarizedHeadersCalled            func(shardID uint32, message string)
	GetFirstNotarizedHeaderCalled            func(shardID uint32) (data.HeaderHandler, []byte, error)
	GetLastNotarizedHeaderCalled             func(shardID uint32) (data.HeaderHandler, []byte, error)
	GetLastNotarizedHeaderNonceCalled        func(shardID uint32) uint64
	GetNotarizedHeaderCalled                 func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)
	InitNotarizedHeadersCalled               func(startHeaders map[uint32]data.HeaderHandler) error
	RemoveLastNotarizedHeaderCalled          func()
	RestoreNotarizedHeadersToGenesisCalled   func()
}

BlockNotarizerHandlerMock -

func (*BlockNotarizerHandlerMock) AddNotarizedHeader

func (bngm *BlockNotarizerHandlerMock) AddNotarizedHeader(shardID uint32, notarizedHeader data.HeaderHandler, notarizedHeaderHash []byte)

AddNotarizedHeader -

func (*BlockNotarizerHandlerMock) CleanupNotarizedHeadersBehindNonce

func (bngm *BlockNotarizerHandlerMock) CleanupNotarizedHeadersBehindNonce(shardID uint32, nonce uint64)

CleanupNotarizedHeadersBehindNonce -

func (*BlockNotarizerHandlerMock) DisplayNotarizedHeaders

func (bngm *BlockNotarizerHandlerMock) DisplayNotarizedHeaders(shardID uint32, message string)

DisplayNotarizedHeaders -

func (*BlockNotarizerHandlerMock) GetFirstNotarizedHeader

func (bngm *BlockNotarizerHandlerMock) GetFirstNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetFirstNotarizedHeader -

func (*BlockNotarizerHandlerMock) GetLastNotarizedHeader

func (bngm *BlockNotarizerHandlerMock) GetLastNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetLastNotarizedHeader -

func (*BlockNotarizerHandlerMock) GetLastNotarizedHeaderNonce

func (bngm *BlockNotarizerHandlerMock) GetLastNotarizedHeaderNonce(shardID uint32) uint64

GetLastNotarizedHeaderNonce -

func (*BlockNotarizerHandlerMock) GetNotarizedHeader

func (bngm *BlockNotarizerHandlerMock) GetNotarizedHeader(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error)

GetNotarizedHeader -

func (*BlockNotarizerHandlerMock) InitNotarizedHeaders

func (bngm *BlockNotarizerHandlerMock) InitNotarizedHeaders(startHeaders map[uint32]data.HeaderHandler) error

InitNotarizedHeaders -

func (*BlockNotarizerHandlerMock) IsInterfaceNil

func (bngm *BlockNotarizerHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockNotarizerHandlerMock) RemoveLastNotarizedHeader

func (bngm *BlockNotarizerHandlerMock) RemoveLastNotarizedHeader()

RemoveLastNotarizedHeader -

func (*BlockNotarizerHandlerMock) RestoreNotarizedHeadersToGenesis

func (bngm *BlockNotarizerHandlerMock) RestoreNotarizedHeadersToGenesis()

RestoreNotarizedHeadersToGenesis -

type BlockNotifierHandlerStub

type BlockNotifierHandlerStub struct {
	CallHandlersCalled             func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte)
	RegisterHandlerCalled          func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	GetNumRegisteredHandlersCalled func() int
}

BlockNotifierHandlerStub -

func (*BlockNotifierHandlerStub) CallHandlers

func (bnhs *BlockNotifierHandlerStub) CallHandlers(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte)

CallHandlers -

func (*BlockNotifierHandlerStub) GetNumRegisteredHandlers

func (bnhs *BlockNotifierHandlerStub) GetNumRegisteredHandlers() int

GetNumRegisteredHandlers -

func (*BlockNotifierHandlerStub) IsInterfaceNil

func (bnhs *BlockNotifierHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockNotifierHandlerStub) RegisterHandler

func (bnhs *BlockNotifierHandlerStub) RegisterHandler(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))

RegisterHandler -

type BlockProcessorMock

type BlockProcessorMock struct {
	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)
	CreateGenesisBlockCalled         func(balances map[string]*big.Int) (data.HeaderHandler, error)
	CreateBlockCalled                func(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)
	RestoreBlockIntoPoolsCalled      func(header data.HeaderHandler, body data.BodyHandler) error
	SetOnRequestTransactionCalled    func(f func(destShardID uint32, txHash []byte))
	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)
	RevertStateToBlockCalled         func(header data.HeaderHandler) error
	RevertIndexedBlockCalled         func(header data.HeaderHandler)
}

BlockProcessorMock -

func (*BlockProcessorMock) AddLastNotarizedHdr

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

AddLastNotarizedHdr -

func (*BlockProcessorMock) ApplyProcessedMiniBlocks

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

ApplyProcessedMiniBlocks -

func (*BlockProcessorMock) Close

func (bpm *BlockProcessorMock) Close() error

Close -

func (*BlockProcessorMock) CommitBlock

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

CommitBlock -

func (*BlockProcessorMock) CreateBlock

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

CreateBlock -

func (*BlockProcessorMock) CreateGenesisBlock

func (bpm *BlockProcessorMock) CreateGenesisBlock(balances map[string]*big.Int) (data.HeaderHandler, error)

CreateGenesisBlock -

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 -

func (*BlockProcessorMock) DecodeBlockHeader

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

DecodeBlockHeader -

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 -

func (*BlockProcessorMock) PruneStateOnRollback

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

PruneStateOnRollback recreates thee 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 -

func (*BlockProcessorMock) RevertIndexedBlock

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

RevertIndexedBlock -

func (*BlockProcessorMock) RevertStateToBlock

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

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

func (*BlockProcessorMock) SetNumProcessedObj

func (bpm *BlockProcessorMock) SetNumProcessedObj(_ uint64)

SetNumProcessedObj -

type BlockSizeComputationStub

type BlockSizeComputationStub struct {
	InitCalled                                 func()
	AddNumMiniBlocksCalled                     func(int)
	AddNumTxsCalled                            func(int)
	IsMaxBlockSizeReachedCalled                func(int, int) bool
	IsMaxBlockSizeWithoutThrottleReachedCalled func(int, int) bool
}

BlockSizeComputationStub -

func (*BlockSizeComputationStub) AddNumMiniBlocks

func (bscs *BlockSizeComputationStub) AddNumMiniBlocks(numMiniBlocks int)

AddNumMiniBlocks -

func (*BlockSizeComputationStub) AddNumTxs

func (bscs *BlockSizeComputationStub) AddNumTxs(numTxs int)

AddNumTxs -

func (*BlockSizeComputationStub) Init

func (bscs *BlockSizeComputationStub) Init()

Init -

func (*BlockSizeComputationStub) IsInterfaceNil

func (bscs *BlockSizeComputationStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockSizeComputationStub) IsMaxBlockSizeReached

func (bscs *BlockSizeComputationStub) IsMaxBlockSizeReached(numNewMiniBlocks int, numNewTxs int) bool

IsMaxBlockSizeReached -

func (*BlockSizeComputationStub) IsMaxBlockSizeWithoutThrottleReached

func (bscs *BlockSizeComputationStub) IsMaxBlockSizeWithoutThrottleReached(numNewMiniBlocks int, numNewTxs int) bool

IsMaxBlockSizeWithoutThrottleReached -

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 BlockTrackerHandlerMock

type BlockTrackerHandlerMock struct {
	GetSelfHeadersCalled          func(headerHandler data.HeaderHandler) []*track.HeaderInfo
	ComputeCrossInfoCalled        func(headers []data.HeaderHandler)
	ComputeLongestSelfChainCalled func() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte)
	SortHeadersFromNonceCalled    func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
	AddHeaderFromPoolCalled       func(shardID uint32, nonce uint64)
}

BlockTrackerHandlerMock -

func (*BlockTrackerHandlerMock) AddHeaderFromPool

func (bthm *BlockTrackerHandlerMock) AddHeaderFromPool(shardID uint32, nonce uint64)

AddHeaderFromPool -

func (*BlockTrackerHandlerMock) ComputeCrossInfo

func (bthm *BlockTrackerHandlerMock) ComputeCrossInfo(headers []data.HeaderHandler)

ComputeCrossInfo -

func (*BlockTrackerHandlerMock) ComputeLongestSelfChain

func (bthm *BlockTrackerHandlerMock) ComputeLongestSelfChain() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte)

ComputeLongestSelfChain -

func (*BlockTrackerHandlerMock) GetSelfHeaders

func (bthm *BlockTrackerHandlerMock) GetSelfHeaders(headerHandler data.HeaderHandler) []*track.HeaderInfo

GetSelfHeaders -

func (*BlockTrackerHandlerMock) IsInterfaceNil

func (bthm *BlockTrackerHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockTrackerHandlerMock) SortHeadersFromNonce

func (bthm *BlockTrackerHandlerMock) SortHeadersFromNonce(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)

SortHeadersFromNonce -

type BlockTrackerMock

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

BlockTrackerMock -

func NewBlockTrackerMock

func NewBlockTrackerMock(shardCoordinator sharding.Coordinator, startHeaders map[uint32]data.HeaderHandler) *BlockTrackerMock

NewBlockTrackerMock -

func (*BlockTrackerMock) AddCrossNotarizedHeader

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

AddCrossNotarizedHeader -

func (*BlockTrackerMock) AddSelfNotarizedHeader

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

AddSelfNotarizedHeader -

func (*BlockTrackerMock) AddTrackedHeader

func (btm *BlockTrackerMock) AddTrackedHeader(header data.HeaderHandler, hash []byte)

AddTrackedHeader -

func (*BlockTrackerMock) CheckBlockAgainstFinal

func (btm *BlockTrackerMock) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error

CheckBlockAgainstFinal -

func (*BlockTrackerMock) CheckBlockAgainstRoundHandler

func (btm *BlockTrackerMock) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error

CheckBlockAgainstRoundHandler -

func (*BlockTrackerMock) CheckBlockAgainstWhitelist

func (btm *BlockTrackerMock) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool

CheckBlockAgainstWhitelist -

func (*BlockTrackerMock) CleanupHeadersBehindNonce

func (btm *BlockTrackerMock) CleanupHeadersBehindNonce(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64)

CleanupHeadersBehindNonce -

func (*BlockTrackerMock) CleanupInvalidCrossHeaders

func (btm *BlockTrackerMock) CleanupInvalidCrossHeaders(_ uint32, _ uint64)

CleanupInvalidCrossHeaders -

func (*BlockTrackerMock) ComputeLongestChain

func (btm *BlockTrackerMock) ComputeLongestChain(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte)

ComputeLongestChain -

func (*BlockTrackerMock) ComputeLongestMetaChainFromLastNotarized

func (btm *BlockTrackerMock) ComputeLongestMetaChainFromLastNotarized() ([]data.HeaderHandler, [][]byte, error)

ComputeLongestMetaChainFromLastNotarized -

func (*BlockTrackerMock) ComputeLongestShardsChainsFromLastNotarized

func (btm *BlockTrackerMock) ComputeLongestShardsChainsFromLastNotarized() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error)

ComputeLongestShardsChainsFromLastNotarized -

func (*BlockTrackerMock) DisplayTrackedHeaders

func (btm *BlockTrackerMock) DisplayTrackedHeaders()

DisplayTrackedHeaders -

func (*BlockTrackerMock) GetCrossNotarizedHeader

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

GetCrossNotarizedHeader -

func (*BlockTrackerMock) GetLastCrossNotarizedHeader

func (btm *BlockTrackerMock) GetLastCrossNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetLastCrossNotarizedHeader -

func (*BlockTrackerMock) GetLastCrossNotarizedHeadersForAllShards

func (btm *BlockTrackerMock) GetLastCrossNotarizedHeadersForAllShards() (map[uint32]data.HeaderHandler, error)

GetLastCrossNotarizedHeadersForAllShards -

func (*BlockTrackerMock) GetLastSelfNotarizedHeader

func (btm *BlockTrackerMock) GetLastSelfNotarizedHeader(shardID uint32) (data.HeaderHandler, []byte, error)

GetLastSelfNotarizedHeader -

func (*BlockTrackerMock) GetSelfNotarizedHeader

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

GetSelfNotarizedHeader -

func (*BlockTrackerMock) GetTrackedHeaders

func (btm *BlockTrackerMock) GetTrackedHeaders(shardID uint32) ([]data.HeaderHandler, [][]byte)

GetTrackedHeaders -

func (*BlockTrackerMock) GetTrackedHeadersForAllShards

func (btm *BlockTrackerMock) GetTrackedHeadersForAllShards() map[uint32][]data.HeaderHandler

GetTrackedHeadersForAllShards -

func (*BlockTrackerMock) GetTrackedHeadersWithNonce

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

GetTrackedHeadersWithNonce -

func (*BlockTrackerMock) InitNotarizedHeaders

func (btm *BlockTrackerMock) InitNotarizedHeaders(startHeaders map[uint32]data.HeaderHandler) error

InitNotarizedHeaders -

func (*BlockTrackerMock) IsInterfaceNil

func (btm *BlockTrackerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockTrackerMock) IsShardStuck

func (btm *BlockTrackerMock) IsShardStuck(shardId uint32) bool

IsShardStuck -

func (*BlockTrackerMock) RegisterCrossNotarizedHeadersHandler

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

RegisterCrossNotarizedHeadersHandler -

func (*BlockTrackerMock) RegisterFinalMetachainHeadersHandler

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

RegisterFinalMetachainHeadersHandler -

func (*BlockTrackerMock) RegisterSelfNotarizedFromCrossHeadersHandler

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

RegisterSelfNotarizedFromCrossHeadersHandler -

func (*BlockTrackerMock) RegisterSelfNotarizedHeadersHandler

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

RegisterSelfNotarizedHeadersHandler -

func (*BlockTrackerMock) RemoveLastNotarizedHeaders

func (btm *BlockTrackerMock) RemoveLastNotarizedHeaders()

RemoveLastNotarizedHeaders -

func (*BlockTrackerMock) RestoreToGenesis

func (btm *BlockTrackerMock) RestoreToGenesis()

RestoreToGenesis -

func (*BlockTrackerMock) ShouldAddHeader

func (btm *BlockTrackerMock) 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 BootstrapComponentsMock

type BootstrapComponentsMock struct {
	Coordinator          sharding.Coordinator
	HdrIntegrityVerifier factory.HeaderIntegrityVerifierHandler
}

BootstrapComponentsMock -

func (*BootstrapComponentsMock) HeaderIntegrityVerifier

func (bcm *BootstrapComponentsMock) HeaderIntegrityVerifier() factory.HeaderIntegrityVerifierHandler

HeaderIntegrityVerifier -

func (*BootstrapComponentsMock) IsInterfaceNil

func (bcm *BootstrapComponentsMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BootstrapComponentsMock) ShardCoordinator

func (bcm *BootstrapComponentsMock) ShardCoordinator() sharding.Coordinator

ShardCoordinator -

type BuiltInCostHandlerStub

type BuiltInCostHandlerStub struct {
}

BuiltInCostHandlerStub -

func (*BuiltInCostHandlerStub) ComputeBuiltInCost

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

ComputeBuiltInCost -

func (*BuiltInCostHandlerStub) IsBuiltInFuncCall

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

IsBuiltInFuncCall -

func (*BuiltInCostHandlerStub) IsInterfaceNil

func (b *BuiltInCostHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type BuiltInFunctionStub

type BuiltInFunctionStub struct {
	ProcessBuiltinFunctionCalled func(acntSnd, acntDst vmcommon.UserAccountHandler, vmInput *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)
	SetNewGasConfigCalled        func(gasCost *vmcommon.GasCost)
	IsActiveCalled               func() bool
}

BuiltInFunctionStub -

func (*BuiltInFunctionStub) IsActive

func (b *BuiltInFunctionStub) IsActive() bool

IsActive -

func (*BuiltInFunctionStub) IsInterfaceNil

func (b *BuiltInFunctionStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BuiltInFunctionStub) ProcessBuiltinFunction

func (b *BuiltInFunctionStub) ProcessBuiltinFunction(acntSnd, acntDst vmcommon.UserAccountHandler, vmInput *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error)

ProcessBuiltinFunction -

func (*BuiltInFunctionStub) SetNewGasConfig

func (b *BuiltInFunctionStub) SetNewGasConfig(gasCost *vmcommon.GasCost)

SetNewGasConfig -

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
	SetEpochForPutOperationCalled func(epoch uint32)
	GetAllStorersCalled           func() map[dataRetriever.UnitType]storage.Storer
}

ChainStorerMock is a mock implementation of the ChainStorer interface

func (*ChainStorerMock) AddStorer

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

AddStorer will add a new storer to the chain map

func (*ChainStorerMock) CloseAll

func (csm *ChainStorerMock) CloseAll() error

CloseAll -

func (*ChainStorerMock) Destroy

func (csm *ChainStorerMock) Destroy() error

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

func (*ChainStorerMock) Get

func (csm *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 (csm *ChainStorerMock) GetAll(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)

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

func (*ChainStorerMock) GetAllStorers

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

GetAllStorers -

func (*ChainStorerMock) GetStorer

func (csm *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 (csm *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 (csm *ChainStorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ChainStorerMock) Put

func (csm *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 (csm *ChainStorerMock) SetEpochForPutOperation(epoch uint32)

SetEpochForPutOperation -

type ChunkProcessorStub

type ChunkProcessorStub struct {
	CheckBatchCalled func(b *batch.Batch, w process.WhiteListHandler) (process.CheckedChunkResult, error)
	CloseCalled      func() error
}

ChunkProcessorStub -

func (*ChunkProcessorStub) CheckBatch

func (c *ChunkProcessorStub) CheckBatch(b *batch.Batch, w process.WhiteListHandler) (process.CheckedChunkResult, error)

CheckBatch -

func (*ChunkProcessorStub) Close

func (c *ChunkProcessorStub) Close() error

Close -

func (*ChunkProcessorStub) IsInterfaceNil

func (c *ChunkProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

type CloserStub

type CloserStub struct {
	CloseCalled func() error
}

CloserStub -

func (*CloserStub) Close

func (cs *CloserStub) Close() error

Close -

type CoordinatorStub

type CoordinatorStub struct {
	NumberOfShardsCalled          func() uint32
	ComputeIdCalled               func(address []byte) uint32
	SelfIdCalled                  func() uint32
	SameShardCalled               func(firstAddress, secondAddress []byte) bool
	CommunicationIdentifierCalled func(destShardID uint32) string
}

CoordinatorStub -

func (*CoordinatorStub) CommunicationIdentifier

func (coordinator *CoordinatorStub) CommunicationIdentifier(destShardID uint32) string

CommunicationIdentifier -

func (*CoordinatorStub) ComputeId

func (coordinator *CoordinatorStub) ComputeId(address []byte) uint32

ComputeId -

func (*CoordinatorStub) IsInterfaceNil

func (coordinator *CoordinatorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*CoordinatorStub) NumberOfShards

func (coordinator *CoordinatorStub) NumberOfShards() uint32

NumberOfShards -

func (*CoordinatorStub) SameShard

func (coordinator *CoordinatorStub) SameShard(firstAddress, secondAddress []byte) bool

SameShard -

func (*CoordinatorStub) SelfId

func (coordinator *CoordinatorStub) SelfId() uint32

SelfId -

type CoreComponentsMock

type CoreComponentsMock struct {
	IntMarsh                    marshal.Marshalizer
	TxMarsh                     marshal.Marshalizer
	Hash                        hashing.Hasher
	TxSignHasherField           hashing.Hasher
	UInt64ByteSliceConv         typeConverters.Uint64ByteSliceConverter
	AddrPubKeyConv              core.PubkeyConverter
	ValPubKeyConv               core.PubkeyConverter
	PathHdl                     storage.PathManagerHandler
	ChainIdCalled               func() string
	MinTransactionVersionCalled func() uint32
	GenesisNodesSetupCalled     func() sharding.GenesisNodesSetupHandler
	TxVersionCheckField         process.TxVersionCheckerHandler
	EpochNotifierField          process.EpochNotifier
	RoundField                  consensus.RoundHandler
	StatusField                 core.AppStatusHandler
	ChanStopNode                chan endProcess.ArgEndProcess
	NodeTypeProviderField       core.NodeTypeProviderHandler
}

CoreComponentsMock -

func (*CoreComponentsMock) AddressPubKeyConverter

func (ccm *CoreComponentsMock) AddressPubKeyConverter() core.PubkeyConverter

AddressPubKeyConverter -

func (*CoreComponentsMock) ChainID

func (ccm *CoreComponentsMock) ChainID() string

ChainID -

func (*CoreComponentsMock) ChanStopNodeProcess

func (ccm *CoreComponentsMock) ChanStopNodeProcess() chan endProcess.ArgEndProcess

ChanStopNodeProcess -

func (*CoreComponentsMock) EpochNotifier

func (ccm *CoreComponentsMock) EpochNotifier() process.EpochNotifier

EpochNotifier -

func (*CoreComponentsMock) GenesisNodesSetup

func (ccm *CoreComponentsMock) GenesisNodesSetup() sharding.GenesisNodesSetupHandler

GenesisNodesSetup -

func (*CoreComponentsMock) Hasher

func (ccm *CoreComponentsMock) Hasher() hashing.Hasher

Hasher -

func (*CoreComponentsMock) InternalMarshalizer

func (ccm *CoreComponentsMock) InternalMarshalizer() marshal.Marshalizer

InternalMarshalizer -

func (*CoreComponentsMock) IsInterfaceNil

func (ccm *CoreComponentsMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*CoreComponentsMock) MinTransactionVersion

func (ccm *CoreComponentsMock) MinTransactionVersion() uint32

MinTransactionVersion -

func (*CoreComponentsMock) NodeTypeProvider

func (ccm *CoreComponentsMock) NodeTypeProvider() core.NodeTypeProviderHandler

NodeTypeProvider -

func (*CoreComponentsMock) PathHandler

func (ccm *CoreComponentsMock) PathHandler() storage.PathManagerHandler

PathHandler -

func (*CoreComponentsMock) RoundHandler

func (ccm *CoreComponentsMock) RoundHandler() consensus.RoundHandler

RoundHandler -

func (*CoreComponentsMock) SetInternalMarshalizer

func (ccm *CoreComponentsMock) SetInternalMarshalizer(m marshal.Marshalizer) error

SetInternalMarshalizer -

func (*CoreComponentsMock) StatusHandler

func (ccm *CoreComponentsMock) StatusHandler() core.AppStatusHandler

StatusHandler -

func (*CoreComponentsMock) TxMarshalizer

func (ccm *CoreComponentsMock) TxMarshalizer() marshal.Marshalizer

TxMarshalizer -

func (*CoreComponentsMock) TxSignHasher

func (ccm *CoreComponentsMock) TxSignHasher() hashing.Hasher

TxSignHasher -

func (*CoreComponentsMock) TxVersionChecker

func (ccm *CoreComponentsMock) TxVersionChecker() process.TxVersionCheckerHandler

TxVersionChecker -

func (*CoreComponentsMock) Uint64ByteSliceConverter

func (ccm *CoreComponentsMock) Uint64ByteSliceConverter() typeConverters.Uint64ByteSliceConverter

Uint64ByteSliceConverter -

func (*CoreComponentsMock) ValidatorPubKeyConverter

func (ccm *CoreComponentsMock) ValidatorPubKeyConverter() core.PubkeyConverter

ValidatorPubKeyConverter -

type CryptoComponentsMock

type CryptoComponentsMock struct {
	BlockSig crypto.SingleSigner
	TxSig    crypto.SingleSigner
	MultiSig crypto.MultiSigner
	BlKeyGen crypto.KeyGenerator
	TxKeyGen crypto.KeyGenerator
	PubKey   crypto.PublicKey
	// contains filtered or unexported fields
}

CryptoComponentsMock -

func (*CryptoComponentsMock) BlockSignKeyGen

func (ccm *CryptoComponentsMock) BlockSignKeyGen() crypto.KeyGenerator

BlockSignKeyGen -

func (*CryptoComponentsMock) BlockSigner

func (ccm *CryptoComponentsMock) BlockSigner() crypto.SingleSigner

BlockSigner -

func (*CryptoComponentsMock) Clone

func (ccm *CryptoComponentsMock) Clone() interface{}

Clone -

func (*CryptoComponentsMock) IsInterfaceNil

func (ccm *CryptoComponentsMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*CryptoComponentsMock) MultiSigner

func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner

MultiSigner -

func (*CryptoComponentsMock) PublicKey

func (ccm *CryptoComponentsMock) PublicKey() crypto.PublicKey

PublicKey -

func (*CryptoComponentsMock) SetMultiSigner

func (ccm *CryptoComponentsMock) SetMultiSigner(multiSigner crypto.MultiSigner) error

SetMultiSigner -

func (*CryptoComponentsMock) TxSignKeyGen

func (ccm *CryptoComponentsMock) TxSignKeyGen() crypto.KeyGenerator

TxSignKeyGen -

func (*CryptoComponentsMock) TxSingleSigner

func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner

TxSingleSigner -

type CurrentNetworkEpochSetterStub

type CurrentNetworkEpochSetterStub struct {
	SetCurrentEpochCalled func(epoch uint32)
}

CurrentNetworkEpochSetterStub -

func (*CurrentNetworkEpochSetterStub) IsInterfaceNil

func (c *CurrentNetworkEpochSetterStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*CurrentNetworkEpochSetterStub) SetNetworkEpochAtBootstrap

func (c *CurrentNetworkEpochSetterStub) SetNetworkEpochAtBootstrap(epoch uint32)

SetNetworkEpochAtBootstrap -

type DataComponentsMock

type DataComponentsMock struct {
	Storage    dataRetriever.StorageService
	DataPool   dataRetriever.PoolsHolder
	BlockChain data.ChainHandler
}

DataComponentsMock -

func (*DataComponentsMock) Blockchain

func (dcm *DataComponentsMock) Blockchain() data.ChainHandler

Blockchain -

func (*DataComponentsMock) Clone

func (dcm *DataComponentsMock) Clone() interface{}

Clone -

func (*DataComponentsMock) Datapool

func (dcm *DataComponentsMock) Datapool() dataRetriever.PoolsHolder

Datapool -

func (*DataComponentsMock) IsInterfaceNil

func (dcm *DataComponentsMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*DataComponentsMock) StorageService

func (dcm *DataComponentsMock) StorageService() dataRetriever.StorageService

StorageService -

type DataTrieTrackerStub

type DataTrieTrackerStub struct {
	ClearDataCachesCalled func()
	DirtyDataCalled       func() map[string][]byte
	RetrieveValueCalled   func(key []byte) ([]byte, error)
	SaveKeyValueCalled    func(key []byte, value []byte) error
	SetDataTrieCalled     func(tr common.Trie)
	DataTrieCalled        func() common.Trie
}

DataTrieTrackerStub -

func (*DataTrieTrackerStub) ClearDataCaches

func (dtts *DataTrieTrackerStub) ClearDataCaches()

ClearDataCaches -

func (*DataTrieTrackerStub) DataTrie

func (dtts *DataTrieTrackerStub) DataTrie() common.Trie

DataTrie -

func (*DataTrieTrackerStub) DirtyData

func (dtts *DataTrieTrackerStub) DirtyData() map[string][]byte

DirtyData -

func (*DataTrieTrackerStub) IsInterfaceNil

func (dtts *DataTrieTrackerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*DataTrieTrackerStub) RetrieveValue

func (dtts *DataTrieTrackerStub) RetrieveValue(key []byte) ([]byte, error)

RetrieveValue -

func (*DataTrieTrackerStub) SaveKeyValue

func (dtts *DataTrieTrackerStub) SaveKeyValue(key []byte, value []byte) error

SaveKeyValue -

func (*DataTrieTrackerStub) SetDataTrie

func (dtts *DataTrieTrackerStub) SetDataTrie(tr common.Trie)

SetDataTrie -

type ESDTRoleHandlerStub

type ESDTRoleHandlerStub struct {
	CheckAllowedToExecuteCalled func(account state.UserAccountHandler, tokenID []byte, action []byte) error
}

ESDTRoleHandlerStub -

func (*ESDTRoleHandlerStub) CheckAllowedToExecute

func (e *ESDTRoleHandlerStub) CheckAllowedToExecute(account state.UserAccountHandler, tokenID []byte, action []byte) error

CheckAllowedToExecute -

func (*ESDTRoleHandlerStub) IsInterfaceNil

func (e *ESDTRoleHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type EpochEconomicsStub

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

EpochEconomicsStub -

func (*EpochEconomicsStub) ComputeEndOfEpochEconomics

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

ComputeEndOfEpochEconomics -

func (*EpochEconomicsStub) IsInterfaceNil

func (e *EpochEconomicsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochEconomicsStub) VerifyRewardsPerBlock

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

VerifyRewardsPerBlock -

type EpochNotifierStub

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

EpochNotifierStub -

func (*EpochNotifierStub) CheckEpoch

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

CheckEpoch -

func (*EpochNotifierStub) CurrentEpoch

func (ens *EpochNotifierStub) CurrentEpoch() uint32

CurrentEpoch -

func (*EpochNotifierStub) IsInterfaceNil

func (ens *EpochNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochNotifierStub) RegisterNotifyHandler

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

RegisterNotifyHandler -

type EpochRewardsCreatorStub

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

EpochRewardsCreatorStub -

func (*EpochRewardsCreatorStub) CreateMarshalizedData

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

CreateMarshalizedData -

func (*EpochRewardsCreatorStub) CreateRewardsMiniBlocks

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

CreateRewardsMiniBlocks -

func (*EpochRewardsCreatorStub) DeleteTxsFromStorage

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

DeleteTxsFromStorage -

func (*EpochRewardsCreatorStub) GetLocalTxCache

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

GetLocalTxCache -

func (*EpochRewardsCreatorStub) GetProtocolSustainabilityRewards

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

GetProtocolSustainabilityRewards -

func (*EpochRewardsCreatorStub) GetRewardsTxs

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

GetRewardsTxs --

func (*EpochRewardsCreatorStub) IsInterfaceNil

func (e *EpochRewardsCreatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochRewardsCreatorStub) RemoveBlockDataFromPools

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

RemoveBlockDataFromPools -

func (*EpochRewardsCreatorStub) SaveTxBlockToStorage

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

SaveTxBlockToStorage -

func (*EpochRewardsCreatorStub) VerifyRewardsMiniBlocks

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

VerifyRewardsMiniBlocks -

type EpochStartDataCreatorStub

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

EpochStartDataCreatorStub -

func (*EpochStartDataCreatorStub) CreateEpochStartData

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

CreateEpochStartData -

func (*EpochStartDataCreatorStub) IsInterfaceNil

func (e *EpochStartDataCreatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock

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

VerifyEpochStartDataForMetablock -

type EpochStartNotifierStub

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

EpochStartNotifierStub -

func (*EpochStartNotifierStub) IsInterfaceNil

func (esnm *EpochStartNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartNotifierStub) NotifyAll

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

NotifyAll -

func (*EpochStartNotifierStub) NotifyAllPrepare

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

NotifyAllPrepare -

func (*EpochStartNotifierStub) RegisterHandler

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

RegisterHandler -

func (*EpochStartNotifierStub) UnregisterHandler

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

UnregisterHandler -

type EpochStartSystemSCStub

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

EpochStartSystemSCStub -

func (*EpochStartSystemSCStub) IsInterfaceNil

func (e *EpochStartSystemSCStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartSystemSCStub) ProcessDelegationRewards

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

ProcessDelegationRewards -

func (*EpochStartSystemSCStub) ProcessSystemSmartContract

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

ProcessSystemSmartContract -

func (*EpochStartSystemSCStub) ToggleUnStakeUnBond

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

ToggleUnStakeUnBond -

type EpochStartTriggerStub

type EpochStartTriggerStub struct {
	ForceEpochStartCalled             func() error
	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
	EpochFinalityAttestingRoundCalled func() uint64
	EpochStartMetaHdrHashCalled       func() []byte
}

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

ForceEpochStart -

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

func (e *EpochStartTriggerStub) SetFinalityAttestingRound(_ uint64)

SetFinalityAttestingRound -

func (*EpochStartTriggerStub) SetProcessed

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

SetProcessed -

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 FeeAccumulatorStub

type FeeAccumulatorStub struct {
	CreateBlockStartedCalled    func()
	GetAccumulatedFeesCalled    func() *big.Int
	GetDeveloperFeesCalled      func() *big.Int
	ProcessTransactionFeeCalled func(cost *big.Int, devFee *big.Int, hash []byte)
	RevertFeesCalled            func(txHashes [][]byte)
}

FeeAccumulatorStub is a stub which implements TransactionFeeHandler interface

func (*FeeAccumulatorStub) CreateBlockStarted

func (f *FeeAccumulatorStub) CreateBlockStarted()

CreateBlockStarted -

func (*FeeAccumulatorStub) GetAccumulatedFees

func (f *FeeAccumulatorStub) GetAccumulatedFees() *big.Int

GetAccumulatedFees -

func (*FeeAccumulatorStub) GetDeveloperFees

func (f *FeeAccumulatorStub) GetDeveloperFees() *big.Int

GetDeveloperFees -

func (*FeeAccumulatorStub) IsInterfaceNil

func (f *FeeAccumulatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*FeeAccumulatorStub) ProcessTransactionFee

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

ProcessTransactionFee -

func (*FeeAccumulatorStub) RevertFees

func (f *FeeAccumulatorStub) RevertFees(txHashes [][]byte)

RevertFees -

type FeeHandlerStub

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

FeeHandlerStub -

func (*FeeHandlerStub) CheckValidityTxValues

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

CheckValidityTxValues -

func (*FeeHandlerStub) ComputeFeeForProcessing

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

ComputeFeeForProcessing -

func (*FeeHandlerStub) ComputeGasLimit

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

ComputeGasLimit -

func (*FeeHandlerStub) ComputeGasLimitBasedOnBalance

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

ComputeGasLimitBasedOnBalance -

func (*FeeHandlerStub) ComputeGasUsedAndFeeBasedOnRefundValue

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

ComputeGasUsedAndFeeBasedOnRefundValue -

func (*FeeHandlerStub) ComputeMoveBalanceFee

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

ComputeMoveBalanceFee -

func (*FeeHandlerStub) ComputeTxFee

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

ComputeTxFee -

func (*FeeHandlerStub) ComputeTxFeeBasedOnGasUsed

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

ComputeTxFeeBasedOnGasUsed -

func (*FeeHandlerStub) DeveloperPercentage

func (fhs *FeeHandlerStub) DeveloperPercentage() float64

DeveloperPercentage -

func (*FeeHandlerStub) GasPerDataByte

func (fhs *FeeHandlerStub) GasPerDataByte() uint64

GasPerDataByte -

func (*FeeHandlerStub) GasPriceForMove

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

GasPriceForMove -

func (*FeeHandlerStub) GasPriceForProcessing

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

GasPriceForProcessing -

func (*FeeHandlerStub) GasPriceModifier

func (fhs *FeeHandlerStub) GasPriceModifier() float64

GasPriceModifier -

func (*FeeHandlerStub) GenesisTotalSupply

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

GenesisTotalSupply -

func (*FeeHandlerStub) IsInterfaceNil

func (fhs *FeeHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*FeeHandlerStub) MaxGasLimitPerBlock

func (fhs *FeeHandlerStub) MaxGasLimitPerBlock(uint32) uint64

MaxGasLimitPerBlock -

func (*FeeHandlerStub) MinGasLimit

func (fhs *FeeHandlerStub) MinGasLimit() uint64

MinGasLimit will return min gas limit

func (*FeeHandlerStub) MinGasPrice

func (fhs *FeeHandlerStub) MinGasPrice() uint64

MinGasPrice -

func (*FeeHandlerStub) MinGasPriceForProcessing

func (fhs *FeeHandlerStub) MinGasPriceForProcessing() uint64

MinGasPriceForProcessing -

func (*FeeHandlerStub) SetMaxGasLimitPerBlock

func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64)

SetMaxGasLimitPerBlock -

func (*FeeHandlerStub) SetMinGasLimit

func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64)

SetMinGasLimit -

func (*FeeHandlerStub) SetMinGasPrice

func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice uint64)

SetMinGasPrice -

func (*FeeHandlerStub) SplitTxGasInCategories

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

SplitTxGasInCategories -

type FloodPreventerStub

type FloodPreventerStub struct {
	IncreaseLoadCalled       func(pid core.PeerID, size uint64) error
	ApplyConsensusSizeCalled func(size int)
	ResetCalled              func()
}

FloodPreventerStub -

func (*FloodPreventerStub) ApplyConsensusSize

func (fps *FloodPreventerStub) ApplyConsensusSize(size int)

ApplyConsensusSize -

func (*FloodPreventerStub) IncreaseLoad

func (fps *FloodPreventerStub) IncreaseLoad(pid core.PeerID, size uint64) error

IncreaseLoad -

func (*FloodPreventerStub) IsInterfaceNil

func (fps *FloodPreventerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*FloodPreventerStub) Reset

func (fps *FloodPreventerStub) Reset()

Reset -

type ForkDetectorMock

type ForkDetectorMock 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
	SetRollBackNonceCalled          func(nonce uint64)
	RestoreToGenesisCalled          func()
	ResetProbableHighestNonceCalled func()
	SetFinalToLastCheckpointCalled  func()
}

ForkDetectorMock -

func (*ForkDetectorMock) AddHeader

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

AddHeader -

func (*ForkDetectorMock) CheckFork

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

CheckFork -

func (*ForkDetectorMock) GetHighestFinalBlockHash

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

GetHighestFinalBlockHash -

func (*ForkDetectorMock) GetHighestFinalBlockNonce

func (fdm *ForkDetectorMock) GetHighestFinalBlockNonce() uint64

GetHighestFinalBlockNonce -

func (*ForkDetectorMock) GetNotarizedHeaderHash

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

GetNotarizedHeaderHash -

func (*ForkDetectorMock) IsInterfaceNil

func (fdm *ForkDetectorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ForkDetectorMock) ProbableHighestNonce

func (fdm *ForkDetectorMock) ProbableHighestNonce() uint64

ProbableHighestNonce -

func (*ForkDetectorMock) RemoveHeader

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

RemoveHeader -

func (*ForkDetectorMock) ResetFork

func (fdm *ForkDetectorMock) ResetFork()

ResetFork -

func (*ForkDetectorMock) ResetProbableHighestNonce

func (fdm *ForkDetectorMock) ResetProbableHighestNonce()

ResetProbableHighestNonce -

func (*ForkDetectorMock) RestoreToGenesis

func (fdm *ForkDetectorMock) RestoreToGenesis()

RestoreToGenesis -

func (*ForkDetectorMock) SetFinalToLastCheckpoint

func (fdm *ForkDetectorMock) SetFinalToLastCheckpoint()

SetFinalToLastCheckpoint -

func (*ForkDetectorMock) SetRollBackNonce

func (fdm *ForkDetectorMock) 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
	RegisterNotifyHandlerCalled func(handler core.GasScheduleSubscribeHandler)
}

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 GetHdrHandlerStub

type GetHdrHandlerStub struct {
	HeaderHandlerCalled func() data.HeaderHandler
}

GetHdrHandlerStub -

func (*GetHdrHandlerStub) HeaderHandler

func (ghhs *GetHdrHandlerStub) HeaderHandler() data.HeaderHandler

HeaderHandler -

type HasherMock

type HasherMock struct {
}

HasherMock that will be used for testing

func (HasherMock) Compute

func (sha HasherMock) Compute(s string) []byte

Compute will output the SHA's equivalent of the input string

func (HasherMock) EmptyHash

func (sha HasherMock) EmptyHash() []byte

EmptyHash will return the equivalent of empty string SHA's

func (HasherMock) IsInterfaceNil

func (sha HasherMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (HasherMock) Size

func (HasherMock) Size() int

Size returns the required size in bytes

type HasherStub

type HasherStub struct {
	ComputeCalled   func(s string) []byte
	EmptyHashCalled func() []byte
}

HasherStub -

func (*HasherStub) Compute

func (hash *HasherStub) Compute(s string) []byte

Compute -

func (*HasherStub) EmptyHash

func (hash *HasherStub) EmptyHash() []byte

EmptyHash -

func (*HasherStub) IsInterfaceNil

func (hash *HasherStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*HasherStub) Size

func (hash *HasherStub) Size() int

Size -

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
}

HeaderResolverMock -

func (*HeaderResolverMock) IsInterfaceNil

func (hrm *HeaderResolverMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

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 -

type HeaderSigVerifierStub

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

HeaderSigVerifierStub -

func (*HeaderSigVerifierStub) IsInterfaceNil

func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeaderSigVerifierStub) VerifyLeaderSignature

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

VerifyLeaderSignature -

func (*HeaderSigVerifierStub) VerifyRandSeed

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

VerifyRandSeed -

func (*HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature

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

VerifyRandSeedAndLeaderSignature -

func (*HeaderSigVerifierStub) VerifySignature

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

VerifySignature -

type HeaderValidatorStub

type HeaderValidatorStub struct {
	HeaderValidForProcessingCalled func(headerHandler process.HdrValidatorHandler) error
}

HeaderValidatorStub -

func (*HeaderValidatorStub) HeaderValidForProcessing

func (h *HeaderValidatorStub) HeaderValidForProcessing(headerHandler process.HdrValidatorHandler) error

HeaderValidForProcessing -

func (*HeaderValidatorStub) IsInterfaceNil

func (h *HeaderValidatorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

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(header data.HeaderHandler, shardHeaderHash []byte))
	NoncesCalled                        func(shardId uint32) []uint64
	LenCalled                           func() int
	MaxSizeCalled                       func() int
	GetNumHeadersCalled                 func(shardId uint32) 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) GetNumHeaders

func (hcs *HeadersCacherStub) GetNumHeaders(shardId uint32) int

GetNumHeaders -

func (*HeadersCacherStub) IsInterfaceNil

func (hcs *HeadersCacherStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeadersCacherStub) Len

func (hcs *HeadersCacherStub) Len() int

Len -

func (*HeadersCacherStub) MaxSize

func (hcs *HeadersCacherStub) MaxSize() int

MaxSize -

func (*HeadersCacherStub) Nonces

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

Nonces -

func (*HeadersCacherStub) RegisterHandler

func (hcs *HeadersCacherStub) RegisterHandler(handler func(header data.HeaderHandler, shardHeaderHash []byte))

RegisterHandler -

func (*HeadersCacherStub) RemoveHeaderByHash

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

RemoveHeaderByHash -

func (*HeadersCacherStub) RemoveHeaderByNonceAndShardId

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

RemoveHeaderByNonceAndShardId -

type InterceptedDataFactoryStub

type InterceptedDataFactoryStub struct {
	CreateCalled func(buff []byte) (process.InterceptedData, error)
}

InterceptedDataFactoryStub -

func (*InterceptedDataFactoryStub) Create

func (idfs *InterceptedDataFactoryStub) Create(buff []byte) (process.InterceptedData, error)

Create -

func (*InterceptedDataFactoryStub) IsInterfaceNil

func (idfs *InterceptedDataFactoryStub) IsInterfaceNil() bool

IsInterfaceNil -

type InterceptedDataVerifierMock

type InterceptedDataVerifierMock struct {
}

InterceptedDataVerifierMock -

func (*InterceptedDataVerifierMock) IsForCurrentShard

func (i *InterceptedDataVerifierMock) IsForCurrentShard(_ process.InterceptedData) bool

IsForCurrentShard -

func (*InterceptedDataVerifierMock) IsInterfaceNil

func (i *InterceptedDataVerifierMock) IsInterfaceNil() bool

IsInterfaceNil returns true if underlying object is

type InterceptedDebugHandlerStub

type InterceptedDebugHandlerStub struct {
	LogReceivedHashesCalled  func(topic string, hashes [][]byte)
	LogProcessedHashesCalled func(topic string, hashes [][]byte, err error)
}

InterceptedDebugHandlerStub -

func (*InterceptedDebugHandlerStub) IsInterfaceNil

func (idhs *InterceptedDebugHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*InterceptedDebugHandlerStub) LogProcessedHashes

func (idhs *InterceptedDebugHandlerStub) LogProcessedHashes(topic string, hashes [][]byte, err error)

LogProcessedHashes -

func (*InterceptedDebugHandlerStub) LogReceivedHashes

func (idhs *InterceptedDebugHandlerStub) LogReceivedHashes(topic string, hashes [][]byte)

LogReceivedHashes -

type InterceptedTrieNodeStub

type InterceptedTrieNodeStub struct {
	CheckValidityCalled     func() error
	IsForCurrentShardCalled func() bool
	SizeInBytesCalled       func() int
	HashField               []byte
	StringField             string
	IdentifiersField        [][]byte
	TypeField               string
}

InterceptedTrieNodeStub -

func (*InterceptedTrieNodeStub) CheckValidity

func (ins *InterceptedTrieNodeStub) CheckValidity() error

CheckValidity -

func (*InterceptedTrieNodeStub) Hash

func (ins *InterceptedTrieNodeStub) Hash() []byte

Hash -

func (*InterceptedTrieNodeStub) Identifiers

func (ins *InterceptedTrieNodeStub) Identifiers() [][]byte

Identifiers -

func (*InterceptedTrieNodeStub) IsForCurrentShard

func (ins *InterceptedTrieNodeStub) IsForCurrentShard() bool

IsForCurrentShard -

func (*InterceptedTrieNodeStub) IsInterfaceNil

func (ins *InterceptedTrieNodeStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*InterceptedTrieNodeStub) SizeInBytes

func (ins *InterceptedTrieNodeStub) SizeInBytes() int

SizeInBytes -

func (*InterceptedTrieNodeStub) String

func (ins *InterceptedTrieNodeStub) String() string

String -

func (*InterceptedTrieNodeStub) Type

func (ins *InterceptedTrieNodeStub) Type() string

Type -

type InterceptedTxHandlerStub

type InterceptedTxHandlerStub struct {
	SenderShardIdCalled   func() uint32
	ReceiverShardIdCalled func() uint32
	NonceCalled           func() uint64
	SenderAddressCalled   func() []byte
	FeeCalled             func() *big.Int
	TransactionCalled     func() data.TransactionHandler
}

InterceptedTxHandlerStub -

func (*InterceptedTxHandlerStub) Fee

func (iths *InterceptedTxHandlerStub) Fee() *big.Int

Fee -

func (*InterceptedTxHandlerStub) Nonce

func (iths *InterceptedTxHandlerStub) Nonce() uint64

Nonce -

func (*InterceptedTxHandlerStub) ReceiverShardId

func (iths *InterceptedTxHandlerStub) ReceiverShardId() uint32

ReceiverShardId -

func (*InterceptedTxHandlerStub) SenderAddress

func (iths *InterceptedTxHandlerStub) SenderAddress() []byte

SenderAddress -

func (*InterceptedTxHandlerStub) SenderShardId

func (iths *InterceptedTxHandlerStub) SenderShardId() uint32

SenderShardId -

func (*InterceptedTxHandlerStub) Transaction

func (iths *InterceptedTxHandlerStub) Transaction() data.TransactionHandler

Transaction -

type InterceptorProcessorStub

type InterceptorProcessorStub struct {
	ValidateCalled        func(data process.InterceptedData) error
	SaveCalled            func(data process.InterceptedData) error
	RegisterHandlerCalled func(handler func(topic string, hash []byte, data interface{}))
}

InterceptorProcessorStub -

func (*InterceptorProcessorStub) IsInterfaceNil

func (ips *InterceptorProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*InterceptorProcessorStub) RegisterHandler

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

RegisterHandler -

func (*InterceptorProcessorStub) Save

func (ips *InterceptorProcessorStub) Save(data process.InterceptedData, _ core.PeerID, _ string) error

Save -

func (*InterceptorProcessorStub) Validate

func (ips *InterceptorProcessorStub) Validate(data process.InterceptedData, _ core.PeerID) error

Validate -

type InterceptorThrottlerStub

type InterceptorThrottlerStub struct {
	CanProcessCalled func() bool
	// contains filtered or unexported fields
}

InterceptorThrottlerStub -

func (*InterceptorThrottlerStub) CanProcess

func (its *InterceptorThrottlerStub) CanProcess() bool

CanProcess -

func (*InterceptorThrottlerStub) EndProcessing

func (its *InterceptorThrottlerStub) EndProcessing()

EndProcessing -

func (*InterceptorThrottlerStub) EndProcessingCount

func (its *InterceptorThrottlerStub) EndProcessingCount() int32

EndProcessingCount -

func (*InterceptorThrottlerStub) IsInterfaceNil

func (its *InterceptorThrottlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*InterceptorThrottlerStub) StartProcessing

func (its *InterceptorThrottlerStub) StartProcessing()

StartProcessing -

func (*InterceptorThrottlerStub) StartProcessingCount

func (its *InterceptorThrottlerStub) StartProcessingCount() int32

StartProcessingCount -

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(_ block.Type, _ process.IntermediateTransactionHandler) error

Add -

func (*InterimProcessorContainerMock) AddMultiple

func (ipcm *InterimProcessorContainerMock) AddMultiple(_ []block.Type, _ []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(_ block.Type)

Remove -

func (*InterimProcessorContainerMock) Replace

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

Replace -

type IntermProcessorContainerStub

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

IntermProcessorContainerStub -

func (*IntermProcessorContainerStub) Add

func (ipcm *IntermProcessorContainerStub) Add(_ block.Type, _ process.IntermediateTransactionHandler) error

Add -

func (*IntermProcessorContainerStub) AddMultiple

func (ipcm *IntermProcessorContainerStub) AddMultiple(_ []block.Type, _ []process.IntermediateTransactionHandler) error

AddMultiple -

func (*IntermProcessorContainerStub) Get

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

Get -

func (*IntermProcessorContainerStub) IsInterfaceNil

func (ipcm *IntermProcessorContainerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*IntermProcessorContainerStub) Keys

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

Keys -

func (*IntermProcessorContainerStub) Len

func (ipcm *IntermProcessorContainerStub) Len() int

Len -

func (*IntermProcessorContainerStub) Remove

func (ipcm *IntermProcessorContainerStub) Remove(_ block.Type)

Remove -

func (*IntermProcessorContainerStub) Replace

func (ipcm *IntermProcessorContainerStub) Replace(_ block.Type, _ 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)
	GetCreatedInShardMiniBlockCalled         func() *block.MiniBlock
	// contains filtered or unexported fields
}

IntermediateTransactionHandlerMock -

func (*IntermediateTransactionHandlerMock) AddIntermediateTransactions

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

AddIntermediateTransactions -

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 IntermediateTransactionHandlerStub

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

IntermediateTransactionHandlerStub -

func (*IntermediateTransactionHandlerStub) AddIntermediateTransactions

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

AddIntermediateTransactions -

func (*IntermediateTransactionHandlerStub) CreateAllInterMiniBlocks

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

CreateAllInterMiniBlocks -

func (*IntermediateTransactionHandlerStub) CreateBlockStarted

func (ith *IntermediateTransactionHandlerStub) CreateBlockStarted()

CreateBlockStarted -

func (*IntermediateTransactionHandlerStub) CreateMarshalizedData

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

CreateMarshalizedData -

func (*IntermediateTransactionHandlerStub) GetAllCurrentFinishedTxs

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

GetAllCurrentFinishedTxs -

func (*IntermediateTransactionHandlerStub) GetCreatedInShardMiniBlock

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

GetCreatedInShardMiniBlock -

func (*IntermediateTransactionHandlerStub) GetIntermediateTransactions

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

GetIntermediateTransactions -

func (*IntermediateTransactionHandlerStub) GetNumOfCrossInterMbsAndTxs

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

GetNumOfCrossInterMbsAndTxs -

func (*IntermediateTransactionHandlerStub) IsInterfaceNil

func (ith *IntermediateTransactionHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*IntermediateTransactionHandlerStub) RemoveProcessedResultsFor

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

RemoveProcessedResultsFor -

func (*IntermediateTransactionHandlerStub) SaveCurrentIntermediateTxToStorage

func (ith *IntermediateTransactionHandlerStub) SaveCurrentIntermediateTxToStorage() error

SaveCurrentIntermediateTxToStorage -

func (*IntermediateTransactionHandlerStub) VerifyInterMiniBlocks

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

VerifyInterMiniBlocks -

type MarshalizerMock

type MarshalizerMock struct {
	Fail bool
}

MarshalizerMock that will be used for testing

func (*MarshalizerMock) IsInterfaceNil

func (mm *MarshalizerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MarshalizerMock) Marshal

func (mm *MarshalizerMock) Marshal(obj interface{}) ([]byte, error)

Marshal converts the input object in a slice of bytes

func (*MarshalizerMock) Unmarshal

func (mm *MarshalizerMock) Unmarshal(obj interface{}, buff []byte) error

Unmarshal applies the serialized values over an instantiated object

type MarshalizerStub

type MarshalizerStub struct {
	MarshalCalled   func(obj interface{}) ([]byte, error)
	UnmarshalCalled func(obj interface{}, buff []byte) error
}

MarshalizerStub -

func (*MarshalizerStub) IsInterfaceNil

func (ms *MarshalizerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MarshalizerStub) Marshal

func (ms *MarshalizerStub) Marshal(obj interface{}) ([]byte, error)

Marshal -

func (*MarshalizerStub) Unmarshal

func (ms *MarshalizerStub) Unmarshal(obj interface{}, buff []byte) error

Unmarshal -

type MessageHandlerStub

type MessageHandlerStub struct {
	ConnectedPeersOnTopicCalled func(topic string) []core.PeerID
	SendToConnectedPeerCalled   func(topic string, buff []byte, peerID core.PeerID) error
}

MessageHandlerStub -

func (*MessageHandlerStub) ConnectedPeersOnTopic

func (mhs *MessageHandlerStub) ConnectedPeersOnTopic(topic string) []core.PeerID

ConnectedPeersOnTopic -

func (*MessageHandlerStub) IsInterfaceNil

func (mhs *MessageHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MessageHandlerStub) SendToConnectedPeer

func (mhs *MessageHandlerStub) SendToConnectedPeer(topic string, buff []byte, peerID core.PeerID) error

SendToConnectedPeer -

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 MessengerStub

type MessengerStub struct {
	CloseCalled                       func() error
	IDCalled                          func() core.PeerID
	PeersCalled                       func() []core.PeerID
	AddressesCalled                   func() []string
	ConnectToPeerCalled               func(address string) error
	TrimConnectionsCalled             func()
	IsConnectedCalled                 func(peerID core.PeerID) bool
	ConnectedPeersCalled              func() []core.PeerID
	CreateTopicCalled                 func(name string, createChannelForTopic bool) error
	HasTopicCalled                    func(name string) bool
	HasTopicValidatorCalled           func(name string) bool
	BroadcastOnChannelCalled          func(channel string, topic string, buff []byte)
	BroadcastCalled                   func(topic string, buff []byte)
	RegisterMessageProcessorCalled    func(topic string, handler p2p.MessageProcessor) error
	UnregisterMessageProcessorCalled  func(topic string) error
	SendToConnectedPeerCalled         func(topic string, buff []byte, peerID core.PeerID) error
	OutgoingChannelLoadBalancerCalled func() p2p.ChannelLoadBalancer
	BootstrapCalled                   func() error
}

MessengerStub -

func (*MessengerStub) Addresses

func (ms *MessengerStub) Addresses() []string

Addresses -

func (*MessengerStub) Bootstrap

func (ms *MessengerStub) Bootstrap() error

Bootstrap -

func (*MessengerStub) Broadcast

func (ms *MessengerStub) Broadcast(topic string, buff []byte)

Broadcast -

func (*MessengerStub) BroadcastOnChannel

func (ms *MessengerStub) BroadcastOnChannel(channel string, topic string, buff []byte)

BroadcastOnChannel -

func (*MessengerStub) Close

func (ms *MessengerStub) Close() error

Close -

func (*MessengerStub) ConnectToPeer

func (ms *MessengerStub) ConnectToPeer(address string) error

ConnectToPeer -

func (*MessengerStub) ConnectedPeers

func (ms *MessengerStub) ConnectedPeers() []core.PeerID

ConnectedPeers -

func (*MessengerStub) ConnectedPeersOnTopic

func (ms *MessengerStub) ConnectedPeersOnTopic(_ string) []core.PeerID

ConnectedPeersOnTopic -

func (*MessengerStub) CreateTopic

func (ms *MessengerStub) CreateTopic(name string, createChannelForTopic bool) error

CreateTopic -

func (*MessengerStub) HasTopic

func (ms *MessengerStub) HasTopic(name string) bool

HasTopic -

func (*MessengerStub) HasTopicValidator

func (ms *MessengerStub) HasTopicValidator(name string) bool

HasTopicValidator -

func (*MessengerStub) ID

func (ms *MessengerStub) ID() core.PeerID

ID -

func (*MessengerStub) IsConnected

func (ms *MessengerStub) IsConnected(peerID core.PeerID) bool

IsConnected -

func (*MessengerStub) IsInterfaceNil

func (ms *MessengerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MessengerStub) OutgoingChannelLoadBalancer

func (ms *MessengerStub) OutgoingChannelLoadBalancer() p2p.ChannelLoadBalancer

OutgoingChannelLoadBalancer -

func (*MessengerStub) Peers

func (ms *MessengerStub) Peers() []core.PeerID

Peers -

func (*MessengerStub) RegisterMessageProcessor

func (ms *MessengerStub) RegisterMessageProcessor(topic string, handler p2p.MessageProcessor) error

RegisterMessageProcessor -

func (*MessengerStub) SendToConnectedPeer

func (ms *MessengerStub) SendToConnectedPeer(topic string, buff []byte, peerID core.PeerID) error

SendToConnectedPeer -

func (*MessengerStub) TrimConnections

func (ms *MessengerStub) TrimConnections()

TrimConnections -

func (*MessengerStub) UnjoinAllTopics

func (ms *MessengerStub) UnjoinAllTopics() error

UnjoinAllTopics -

func (*MessengerStub) UnregisterAllMessageProcessors

func (ms *MessengerStub) UnregisterAllMessageProcessors() error

UnregisterAllMessageProcessors -

func (*MessengerStub) UnregisterMessageProcessor

func (ms *MessengerStub) UnregisterMessageProcessor(topic string) error

UnregisterMessageProcessor -

type MiniBlocksProviderStub

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

MiniBlocksProviderStub -

func (*MiniBlocksProviderStub) GetMiniBlocks

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

GetMiniBlocks -

func (*MiniBlocksProviderStub) GetMiniBlocksFromPool

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

GetMiniBlocksFromPool -

func (*MiniBlocksProviderStub) IsInterfaceNil

func (mbps *MiniBlocksProviderStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type NetworkConnectionWatcherStub

type NetworkConnectionWatcherStub struct {
	IsConnectedToTheNetworkCalled func() bool
}

NetworkConnectionWatcherStub -

func (*NetworkConnectionWatcherStub) IsConnectedToTheNetwork

func (cws *NetworkConnectionWatcherStub) IsConnectedToTheNetwork() bool

IsConnectedToTheNetwork -

func (*NetworkConnectionWatcherStub) IsInterfaceNil

func (cws *NetworkConnectionWatcherStub) IsInterfaceNil() bool

IsInterfaceNil -

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 NodesConfigProviderStub

type NodesConfigProviderStub struct {
	MinNumberOfNodesCalled               func() uint32
	MinNumberOfNodesWithHysteresisCalled func() uint32
}

NodesConfigProviderStub -

func (*NodesConfigProviderStub) IsInterfaceNil

func (n *NodesConfigProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*NodesConfigProviderStub) MinNumberOfNodes

func (n *NodesConfigProviderStub) MinNumberOfNodes() uint32

MinNumberOfNodes -

func (*NodesConfigProviderStub) MinNumberOfNodesWithHysteresis

func (n *NodesConfigProviderStub) MinNumberOfNodesWithHysteresis() uint32

MinNumberOfNodesWithHysteresis -

type NodesCoordinatorMock

type NodesCoordinatorMock struct {
	Validators                               map[uint32][]sharding.Validator
	ShardConsensusSize                       uint32
	MetaConsensusSize                        uint32
	ShardId                                  uint32
	NbShards                                 uint32
	GetSelectedPublicKeysCalled              func(selection []byte, shardId uint32, epoch uint32) (publicKeys []string, err 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)
	SetNodesPerShardsCalled                  func(nodes map[uint32][]sharding.Validator, epoch uint32) error
	ComputeValidatorsGroupCalled             func(randomness []byte, round uint64, shardId uint32, epoch uint32) (validatorsGroup []sharding.Validator, err error)
	GetValidatorWithPublicKeyCalled          func(publicKey []byte) (validator sharding.Validator, shardId uint32, err error)
	GetAllEligibleValidatorsPublicKeysCalled func() (map[uint32][][]byte, error)
	GetAllWaitingValidatorsPublicKeysCalled  func() (map[uint32][][]byte, error)
	GetAllLeavingValidatorsPublicKeysCalled  func() (map[uint32][][]byte, error)
	ConsensusGroupSizeCalled                 func(uint32) int
}

NodesCoordinatorMock defines the behaviour of a struct able to do validator group selection

func NewNodesCoordinatorMock

func NewNodesCoordinatorMock() *NodesCoordinatorMock

NewNodesCoordinatorMock -

func (*NodesCoordinatorMock) ComputeAdditionalLeaving

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

ComputeAdditionalLeaving -

func (*NodesCoordinatorMock) ComputeConsensusGroup

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

ComputeConsensusGroup -

func (*NodesCoordinatorMock) ConsensusGroupSize

func (ncm *NodesCoordinatorMock) ConsensusGroupSize(shardId 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(selection []byte, shardId uint32, epoch uint32) (publicKeys []string, err 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 -

func (*NodesCoordinatorMock) LoadState

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

LoadState -

func (*NodesCoordinatorMock) SetNodesPerShards

func (ncm *NodesCoordinatorMock) SetNodesPerShards(
	eligible map[uint32][]sharding.Validator,
	_ map[uint32][]sharding.Validator,
	epoch 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
	GetShardConsensusGroupSizeCalled          func() uint32
	GetMetaConsensusGroupSizeCalled           func() uint32
	NumberOfShardsCalled                      func() uint32
	MinNumberOfNodesCalled                    func() uint32
	AllInitialNodesCalled                     func() []sharding.GenesisNodeInfoHandler
	GetAdaptivityCalled                       func() bool
	GetHysteresisCalled                       func() float32
	GetShardIDForPubKeyCalled                 func(pubkey []byte) (uint32, error)
	InitialEligibleNodesPubKeysForShardCalled func(shardId uint32) ([]string, error)
	InitialNodesPubKeysCalled                 func() map[uint32][]string
	MinNumberOfMetaNodesCalled                func() uint32
	MinNumberOfShardNodesCalled               func() uint32
	MinNumberOfNodesWithHysteresisCalled      func() uint32
}

NodesSetupStub -

func (*NodesSetupStub) AllInitialNodes

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

AllInitialNodes -

func (*NodesSetupStub) GetAdaptivity

func (n *NodesSetupStub) GetAdaptivity() bool

GetAdaptivity -

func (*NodesSetupStub) GetHysteresis

func (n *NodesSetupStub) GetHysteresis() float32

GetHysteresis -

func (*NodesSetupStub) GetMetaConsensusGroupSize

func (n *NodesSetupStub) GetMetaConsensusGroupSize() uint32

GetMetaConsensusGroupSize -

func (*NodesSetupStub) GetRoundDuration

func (n *NodesSetupStub) GetRoundDuration() uint64

GetRoundDuration -

func (*NodesSetupStub) GetShardConsensusGroupSize

func (n *NodesSetupStub) GetShardConsensusGroupSize() uint32

func (*NodesSetupStub) GetShardIDForPubKey

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

GetShardIDForPubKey -

func (*NodesSetupStub) GetStartTime

func (n *NodesSetupStub) GetStartTime() int64

GetStartTime -

func (*NodesSetupStub) InitialEligibleNodesPubKeysForShard

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

InitialEligibleNodesPubKeysForShard -

func (*NodesSetupStub) InitialNodesInfo

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

InitialNodesInfo -

func (*NodesSetupStub) InitialNodesInfoForShard

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

InitialNodesInfoForShard -

func (*NodesSetupStub) InitialNodesPubKeys

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

InitialNodesPubKeys -

func (*NodesSetupStub) IsInterfaceNil

func (n *NodesSetupStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*NodesSetupStub) MinNumberOfMetaNodes

func (n *NodesSetupStub) MinNumberOfMetaNodes() uint32

MinNumberOfMetaNodes -

func (*NodesSetupStub) MinNumberOfNodes

func (n *NodesSetupStub) MinNumberOfNodes() uint32

MinNumberOfNodes -

func (*NodesSetupStub) MinNumberOfNodesWithHysteresis

func (n *NodesSetupStub) MinNumberOfNodesWithHysteresis() uint32

MinNumberOfNodesWithHysteresis -

func (*NodesSetupStub) MinNumberOfShardNodes

func (n *NodesSetupStub) MinNumberOfShardNodes() uint32

MinNumberOfShardNodes -

func (*NodesSetupStub) NumberOfShards

func (n *NodesSetupStub) NumberOfShards() uint32

NumberOfShards -

type ObjectsContainerStub

type ObjectsContainerStub struct {
	GetCalled     func(key string) (interface{}, error)
	AddCalled     func(key string, val interface{}) error
	ReplaceCalled func(key string, val interface{}) error
	RemoveCalled  func(key string)
	LenCalled     func() int
}

ObjectsContainerStub -

func (*ObjectsContainerStub) Add

func (ocs *ObjectsContainerStub) Add(key string, val interface{}) error

Add -

func (*ObjectsContainerStub) Get

func (ocs *ObjectsContainerStub) Get(key string) (interface{}, error)

Get -

func (*ObjectsContainerStub) Len

func (ocs *ObjectsContainerStub) Len() int

Len -

func (*ObjectsContainerStub) Remove

func (ocs *ObjectsContainerStub) Remove(key string)

Remove -

func (*ObjectsContainerStub) Replace

func (ocs *ObjectsContainerStub) Replace(key string, val interface{}) error

Replace -

type P2PAntifloodHandlerStub

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

P2PAntifloodHandlerStub -

func (*P2PAntifloodHandlerStub) ApplyConsensusSize

func (p2pahs *P2PAntifloodHandlerStub) ApplyConsensusSize(size int)

ApplyConsensusSize -

func (*P2PAntifloodHandlerStub) BlacklistPeer

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

BlacklistPeer -

func (*P2PAntifloodHandlerStub) CanProcessMessage

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

CanProcessMessage -

func (*P2PAntifloodHandlerStub) CanProcessMessagesOnTopic

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

CanProcessMessagesOnTopic -

func (*P2PAntifloodHandlerStub) Close

func (af *P2PAntifloodHandlerStub) Close() error

Close -

func (*P2PAntifloodHandlerStub) IsInterfaceNil

func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic

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

IsOriginatorEligibleForTopic -

func (*P2PAntifloodHandlerStub) SetDebugger

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

SetDebugger -

type P2PMessageMock

type P2PMessageMock struct {
	FromField      []byte
	DataField      []byte
	SeqNoField     []byte
	TopicField     string
	SignatureField []byte
	KeyField       []byte
	PeerField      core.PeerID
	PayloadField   []byte
	TimestampField int64
}

P2PMessageMock -

func (*P2PMessageMock) Data

func (msg *P2PMessageMock) Data() []byte

Data -

func (*P2PMessageMock) From

func (msg *P2PMessageMock) From() []byte

From -

func (*P2PMessageMock) IsInterfaceNil

func (msg *P2PMessageMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*P2PMessageMock) Key

func (msg *P2PMessageMock) Key() []byte

Key -

func (*P2PMessageMock) Payload

func (msg *P2PMessageMock) Payload() []byte

Payload -

func (*P2PMessageMock) Peer

func (msg *P2PMessageMock) Peer() core.PeerID

Peer -

func (*P2PMessageMock) SeqNo

func (msg *P2PMessageMock) SeqNo() []byte

SeqNo -

func (*P2PMessageMock) Signature

func (msg *P2PMessageMock) Signature() []byte

Signature -

func (*P2PMessageMock) Timestamp

func (msg *P2PMessageMock) Timestamp() int64

Timestamp -

func (*P2PMessageMock) Topic

func (msg *P2PMessageMock) Topic() string

Topic -

type PauseHandlerStub

type PauseHandlerStub struct {
	IsPausedCalled func(token []byte) bool
}

PauseHandlerStub -

func (*PauseHandlerStub) IsInterfaceNil

func (p *PauseHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PauseHandlerStub) IsPaused

func (p *PauseHandlerStub) IsPaused(token []byte) bool

IsPaused -

type PayableHandlerStub

type PayableHandlerStub struct {
	IsPayableCalled func(address []byte) (bool, error)
}

PayableHandlerStub -

func (*PayableHandlerStub) IsInterfaceNil

func (p *PayableHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PayableHandlerStub) IsPayable

func (p *PayableHandlerStub) IsPayable(address []byte) (bool, error)

IsPayable -

type PeerAccountHandlerMock

type PeerAccountHandlerMock struct {
	IncreaseLeaderSuccessRateValue          uint32
	DecreaseLeaderSuccessRateValue          uint32
	IncreaseValidatorSuccessRateValue       uint32
	DecreaseValidatorSuccessRateValue       uint32
	IncreaseValidatorIgnoredSignaturesValue uint32

	IncreaseLeaderSuccessRateCalled              func(uint32)
	DecreaseLeaderSuccessRateCalled              func(uint32)
	IncreaseValidatorSuccessRateCalled           func(uint32)
	DecreaseValidatorSuccessRateCalled           func(uint32)
	IncreaseValidatorIgnoredSignaturesRateCalled func(uint32)
	SetTempRatingCalled                          func(uint32)
	GetTempRatingCalled                          func() uint32
	SetAccumulatedFeesCalled                     func(*big.Int)
	GetAccumulatedFeesCalled                     func() *big.Int
	GetConsecutiveProposerMissesCalled           func() uint32
	SetConsecutiveProposerMissesCalled           func(rating uint32)
	SetListAndIndexCalled                        func(shardID uint32, list string, index uint32)
	GetListCalled                                func() string
	GetUnStakedEpochCalled                       func() uint32
}

PeerAccountHandlerMock -

func (*PeerAccountHandlerMock) AddToAccumulatedFees

func (p *PeerAccountHandlerMock) AddToAccumulatedFees(val *big.Int)

AddToAccumulatedFees -

func (*PeerAccountHandlerMock) AddressBytes

func (p *PeerAccountHandlerMock) AddressBytes() []byte

AddressBytes -

func (*PeerAccountHandlerMock) DataTrie

func (p *PeerAccountHandlerMock) DataTrie() common.Trie

DataTrie -

func (*PeerAccountHandlerMock) DataTrieTracker

func (p *PeerAccountHandlerMock) DataTrieTracker() state.DataTrieTracker

DataTrieTracker -

func (*PeerAccountHandlerMock) DecreaseLeaderSuccessRate

func (p *PeerAccountHandlerMock) DecreaseLeaderSuccessRate(val uint32)

DecreaseLeaderSuccessRate -

func (*PeerAccountHandlerMock) DecreaseValidatorSuccessRate

func (p *PeerAccountHandlerMock) DecreaseValidatorSuccessRate(val uint32)

DecreaseValidatorSuccessRate -

func (*PeerAccountHandlerMock) GetAccumulatedFees

func (p *PeerAccountHandlerMock) GetAccumulatedFees() *big.Int

GetAccumulatedFees -

func (*PeerAccountHandlerMock) GetBLSPublicKey

func (p *PeerAccountHandlerMock) GetBLSPublicKey() []byte

GetBLSPublicKey -

func (*PeerAccountHandlerMock) GetCode

func (p *PeerAccountHandlerMock) GetCode() []byte

GetCode -

func (*PeerAccountHandlerMock) GetCodeHash

func (p *PeerAccountHandlerMock) GetCodeHash() []byte

GetCodeHash -

func (*PeerAccountHandlerMock) GetConsecutiveProposerMisses

func (p *PeerAccountHandlerMock) GetConsecutiveProposerMisses() uint32

GetConsecutiveProposerMisses -

func (*PeerAccountHandlerMock) GetIndexInList

func (p *PeerAccountHandlerMock) GetIndexInList() uint32

GetIndexInList -

func (*PeerAccountHandlerMock) GetLeaderSuccessRate

func (p *PeerAccountHandlerMock) GetLeaderSuccessRate() state.SignRate

GetLeaderSuccessRate -

func (*PeerAccountHandlerMock) GetList

func (p *PeerAccountHandlerMock) GetList() string

GetList -

func (*PeerAccountHandlerMock) GetNonce

func (p *PeerAccountHandlerMock) GetNonce() uint64

GetNonce -

func (*PeerAccountHandlerMock) GetNumSelectedInSuccessBlocks

func (p *PeerAccountHandlerMock) GetNumSelectedInSuccessBlocks() uint32

GetNumSelectedInSuccessBlocks -

func (*PeerAccountHandlerMock) GetRating

func (p *PeerAccountHandlerMock) GetRating() uint32

GetRating -

func (*PeerAccountHandlerMock) GetRewardAddress

func (p *PeerAccountHandlerMock) GetRewardAddress() []byte

GetRewardAddress -

func (*PeerAccountHandlerMock) GetRootHash

func (p *PeerAccountHandlerMock) GetRootHash() []byte

GetRootHash -

func (*PeerAccountHandlerMock) GetShardId

func (p *PeerAccountHandlerMock) GetShardId() uint32

GetShardId -

func (*PeerAccountHandlerMock) GetStake

func (p *PeerAccountHandlerMock) GetStake() *big.Int

GetStake -

func (*PeerAccountHandlerMock) GetTempRating

func (p *PeerAccountHandlerMock) GetTempRating() uint32

GetTempRating -

func (*PeerAccountHandlerMock) GetTotalLeaderSuccessRate

func (p *PeerAccountHandlerMock) GetTotalLeaderSuccessRate() state.SignRate

GetTotalLeaderSuccessRate -

func (*PeerAccountHandlerMock) GetTotalValidatorIgnoredSignaturesRate

func (p *PeerAccountHandlerMock) GetTotalValidatorIgnoredSignaturesRate() uint32

GetTotalValidatorIgnoredSignaturesRate -

func (*PeerAccountHandlerMock) GetTotalValidatorSuccessRate

func (p *PeerAccountHandlerMock) GetTotalValidatorSuccessRate() state.SignRate

GetTotalValidatorSuccessRate -

func (*PeerAccountHandlerMock) GetUnStakedEpoch

func (p *PeerAccountHandlerMock) GetUnStakedEpoch() uint32

GetUnStakedEpoch -

func (*PeerAccountHandlerMock) GetValidatorIgnoredSignaturesRate

func (p *PeerAccountHandlerMock) GetValidatorIgnoredSignaturesRate() uint32

GetValidatorIgnoredSignaturesRate -

func (*PeerAccountHandlerMock) GetValidatorSuccessRate

func (p *PeerAccountHandlerMock) GetValidatorSuccessRate() state.SignRate

GetValidatorSuccessRate -

func (*PeerAccountHandlerMock) IncreaseLeaderSuccessRate

func (p *PeerAccountHandlerMock) IncreaseLeaderSuccessRate(val uint32)

IncreaseLeaderSuccessRate -

func (*PeerAccountHandlerMock) IncreaseNonce

func (p *PeerAccountHandlerMock) IncreaseNonce(_ uint64)

IncreaseNonce -

func (*PeerAccountHandlerMock) IncreaseNumSelectedInSuccessBlocks

func (p *PeerAccountHandlerMock) IncreaseNumSelectedInSuccessBlocks()

IncreaseNumSelectedInSuccessBlocks -

func (*PeerAccountHandlerMock) IncreaseValidatorIgnoredSignaturesRate

func (p *PeerAccountHandlerMock) IncreaseValidatorIgnoredSignaturesRate(val uint32)

IncreaseValidatorIgnoredSignaturesRate -

func (*PeerAccountHandlerMock) IncreaseValidatorSuccessRate

func (p *PeerAccountHandlerMock) IncreaseValidatorSuccessRate(val uint32)

IncreaseValidatorSuccessRate -

func (*PeerAccountHandlerMock) IsInterfaceNil

func (p *PeerAccountHandlerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerAccountHandlerMock) ResetAtNewEpoch

func (p *PeerAccountHandlerMock) ResetAtNewEpoch()

ResetAtNewEpoch -

func (*PeerAccountHandlerMock) SetBLSPublicKey

func (p *PeerAccountHandlerMock) SetBLSPublicKey([]byte) error

SetBLSPublicKey -

func (*PeerAccountHandlerMock) SetCode

func (p *PeerAccountHandlerMock) SetCode(_ []byte)

SetCode -

func (*PeerAccountHandlerMock) SetCodeHash

func (p *PeerAccountHandlerMock) SetCodeHash(_ []byte)

SetCodeHash -

func (*PeerAccountHandlerMock) SetConsecutiveProposerMisses

func (p *PeerAccountHandlerMock) SetConsecutiveProposerMisses(consecutiveMisses uint32)

SetConsecutiveProposerMisses -

func (*PeerAccountHandlerMock) SetDataTrie

func (p *PeerAccountHandlerMock) SetDataTrie(_ common.Trie)

SetDataTrie -

func (*PeerAccountHandlerMock) SetListAndIndex

func (p *PeerAccountHandlerMock) SetListAndIndex(shardID uint32, list string, index uint32)

SetListAndIndex -

func (*PeerAccountHandlerMock) SetRating

func (p *PeerAccountHandlerMock) SetRating(uint32)

SetRating -

func (*PeerAccountHandlerMock) SetRewardAddress

func (p *PeerAccountHandlerMock) SetRewardAddress([]byte) error

SetRewardAddress -

func (*PeerAccountHandlerMock) SetRootHash

func (p *PeerAccountHandlerMock) SetRootHash([]byte)

SetRootHash -

func (*PeerAccountHandlerMock) SetStake

func (p *PeerAccountHandlerMock) SetStake(_ *big.Int) error

SetStake -

func (*PeerAccountHandlerMock) SetTempRating

func (p *PeerAccountHandlerMock) SetTempRating(val uint32)

SetTempRating -

func (*PeerAccountHandlerMock) SetUnStakedEpoch

func (p *PeerAccountHandlerMock) SetUnStakedEpoch(_ uint32)

SetUnStakedEpoch -

type PeerBlackListHandlerStub

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

PeerBlackListHandlerStub -

func (*PeerBlackListHandlerStub) Has

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

Has -

func (*PeerBlackListHandlerStub) IsInterfaceNil

func (pblhs *PeerBlackListHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerBlackListHandlerStub) Sweep

func (pblhs *PeerBlackListHandlerStub) Sweep()

Sweep -

func (*PeerBlackListHandlerStub) Upsert

func (pblhs *PeerBlackListHandlerStub) 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 PeerShardMapperStub

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

PeerShardMapperStub -

func (*PeerShardMapperStub) GetPeerInfo

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

GetPeerInfo -

func (*PeerShardMapperStub) IsInterfaceNil

func (psms *PeerShardMapperStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PeerShardMapperStub) UpdatePeerIdPublicKey

func (psms *PeerShardMapperStub) UpdatePeerIdPublicKey(pid core.PeerID, pk []byte)

UpdatePeerIdPublicKey -

func (*PeerShardMapperStub) UpdatePeerIdShardId

func (psms *PeerShardMapperStub) UpdatePeerIdShardId(pid core.PeerID, shardId uint32)

UpdatePeerIdShardId -

func (*PeerShardMapperStub) UpdatePublicKeyShardId

func (psms *PeerShardMapperStub) UpdatePublicKeyShardId(pk []byte, shardId uint32)

UpdatePublicKeyShardId -

type PeerShardResolverStub

type PeerShardResolverStub struct {
	GetPeerInfoCalled func(pid core.PeerID) core.P2PPeerInfo
}

PeerShardResolverStub -

func (*PeerShardResolverStub) GetPeerInfo

func (psrs *PeerShardResolverStub) GetPeerInfo(pid core.PeerID) core.P2PPeerInfo

GetPeerInfo -

func (*PeerShardResolverStub) IsInterfaceNil

func (psrs *PeerShardResolverStub) 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 PreProcessorContainerMock

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

PreProcessorContainerMock -

func (*PreProcessorContainerMock) Add

func (ppcm *PreProcessorContainerMock) Add(_ block.Type, _ process.PreProcessor) error

Add -

func (*PreProcessorContainerMock) AddMultiple

func (ppcm *PreProcessorContainerMock) AddMultiple(_ []block.Type, _ []process.PreProcessor) error

AddMultiple -

func (*PreProcessorContainerMock) Get

func (ppcm *PreProcessorContainerMock) Get(key block.Type) (process.PreProcessor, error)

Get -

func (*PreProcessorContainerMock) IsInterfaceNil

func (ppcm *PreProcessorContainerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PreProcessorContainerMock) Keys

func (ppcm *PreProcessorContainerMock) Keys() []block.Type

Keys -

func (*PreProcessorContainerMock) Len

func (ppcm *PreProcessorContainerMock) Len() int

Len -

func (*PreProcessorContainerMock) Remove

func (ppcm *PreProcessorContainerMock) Remove(_ block.Type)

Remove -

func (*PreProcessorContainerMock) Replace

func (ppcm *PreProcessorContainerMock) Replace(_ block.Type, _ process.PreProcessor) error

Replace -

type PreProcessorMock

type PreProcessorMock struct {
	CreateBlockStartedCalled              func()
	IsDataPreparedCalled                  func(requestedTxs int, haveTime func() time.Duration) error
	RemoveBlockDataFromPoolsCalled        func(body *block.Body, miniBlockPool storage.Cacher) error
	RemoveTxsFromPoolsCalled              func(body *block.Body) error
	RestoreBlockDataIntoPoolsCalled       func(body *block.Body, miniBlockPool storage.Cacher) (int, error)
	SaveTxsToStorageCalled                func(body *block.Body) error
	ProcessBlockTransactionsCalled        func(body *block.Body, haveTime func() bool) error
	RequestBlockTransactionsCalled        func(body *block.Body) int
	CreateMarshalizedDataCalled           func(txHashes [][]byte) ([][]byte, error)
	RequestTransactionsForMiniBlockCalled func(miniBlock *block.MiniBlock) int
	ProcessMiniBlockCalled                func(miniBlock *block.MiniBlock, haveTime func() bool, getNumOfCrossInterMbsAndTxs func() (int, int)) ([][]byte, int, error)
	CreateAndProcessMiniBlocksCalled      func(haveTime func() bool) (block.MiniBlockSlice, error)
	GetAllCurrentUsedTxsCalled            func() map[string]data.TransactionHandler
}

PreProcessorMock -

func (*PreProcessorMock) CreateAndProcessMiniBlocks

func (ppm *PreProcessorMock) CreateAndProcessMiniBlocks(haveTime func() bool) (block.MiniBlockSlice, error)

CreateAndProcessMiniBlocks creates miniblocks from storage and processes the reward transactions added into the miniblocks as long as it has time

func (*PreProcessorMock) CreateBlockStarted

func (ppm *PreProcessorMock) CreateBlockStarted()

CreateBlockStarted -

func (*PreProcessorMock) CreateMarshalizedData

func (ppm *PreProcessorMock) CreateMarshalizedData(txHashes [][]byte) ([][]byte, error)

CreateMarshalizedData -

func (*PreProcessorMock) GetAllCurrentUsedTxs

func (ppm *PreProcessorMock) GetAllCurrentUsedTxs() map[string]data.TransactionHandler

GetAllCurrentUsedTxs -

func (*PreProcessorMock) IsDataPrepared

func (ppm *PreProcessorMock) IsDataPrepared(requestedTxs int, haveTime func() time.Duration) error

IsDataPrepared -

func (*PreProcessorMock) IsInterfaceNil

func (ppm *PreProcessorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PreProcessorMock) ProcessBlockTransactions

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

ProcessBlockTransactions -

func (*PreProcessorMock) ProcessMiniBlock

func (ppm *PreProcessorMock) ProcessMiniBlock(miniBlock *block.MiniBlock, haveTime func() bool, getNumOfCrossInterMbsAndTxs func() (int, int)) ([][]byte, int, error)

ProcessMiniBlock -

func (*PreProcessorMock) RemoveBlockDataFromPools

func (ppm *PreProcessorMock) RemoveBlockDataFromPools(body *block.Body, miniBlockPool storage.Cacher) error

RemoveBlockDataFromPools -

func (*PreProcessorMock) RemoveTxsFromPools

func (ppm *PreProcessorMock) RemoveTxsFromPools(body *block.Body) error

RemoveTxsFromPools -

func (*PreProcessorMock) RequestBlockTransactions

func (ppm *PreProcessorMock) RequestBlockTransactions(body *block.Body) int

RequestBlockTransactions -

func (*PreProcessorMock) RequestTransactionsForMiniBlock

func (ppm *PreProcessorMock) RequestTransactionsForMiniBlock(miniBlock *block.MiniBlock) int

RequestTransactionsForMiniBlock -

func (*PreProcessorMock) RestoreBlockDataIntoPools

func (ppm *PreProcessorMock) RestoreBlockDataIntoPools(body *block.Body, miniBlockPool storage.Cacher) (int, error)

RestoreBlockDataIntoPools -

func (*PreProcessorMock) SaveTxsToStorage

func (ppm *PreProcessorMock) SaveTxsToStorage(body *block.Body) error

SaveTxsToStorage -

type ProtobufMarshalizerMock

type ProtobufMarshalizerMock struct {
}

ProtobufMarshalizerMock implements marshaling with protobuf

func (*ProtobufMarshalizerMock) IsInterfaceNil

func (x *ProtobufMarshalizerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ProtobufMarshalizerMock) Marshal

func (x *ProtobufMarshalizerMock) Marshal(obj interface{}) ([]byte, error)

Marshal does the actual serialization of an object through protobuf

func (*ProtobufMarshalizerMock) Unmarshal

func (x *ProtobufMarshalizerMock) Unmarshal(obj interface{}, buff []byte) error

Unmarshal does the actual deserialization of an object through protobuf

type PubkeyConverterMock

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

PubkeyConverterMock -

func NewPubkeyConverterMock

func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock

NewPubkeyConverterMock -

func (*PubkeyConverterMock) Decode

func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error)

Decode -

func (*PubkeyConverterMock) Encode

func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string

Encode -

func (*PubkeyConverterMock) IsInterfaceNil

func (pcm *PubkeyConverterMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*PubkeyConverterMock) Len

func (pcm *PubkeyConverterMock) Len() int

Len -

type PubkeyConverterStub

type PubkeyConverterStub struct {
	LenCalled    func() int
	DecodeCalled func(humanReadable string) ([]byte, error)
	EncodeCalled func(pkBytes []byte) string
}

PubkeyConverterStub -

func (*PubkeyConverterStub) Decode

func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error)

Decode -

func (*PubkeyConverterStub) Encode

func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string

Encode -

func (*PubkeyConverterStub) IsInterfaceNil

func (pcs *PubkeyConverterStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PubkeyConverterStub) Len

func (pcs *PubkeyConverterStub) Len() int

Len -

type QuotaStatusHandlerStub

type QuotaStatusHandlerStub struct {
	ResetStatisticsCalled func()
	AddQuotaCalled        func(pid core.PeerID, numReceivedMessages uint32, sizeReceivedMessages uint64,
		numProcessedMessages uint32, sizeProcessedMessages uint64)
}

QuotaStatusHandlerStub -

func (*QuotaStatusHandlerStub) AddQuota

func (qshs *QuotaStatusHandlerStub) AddQuota(
	pid core.PeerID,
	numReceived uint32,
	sizeReceived uint64,
	numProcessed uint32,
	sizeProcessed uint64,
)

AddQuota -

func (*QuotaStatusHandlerStub) IsInterfaceNil

func (qshs *QuotaStatusHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*QuotaStatusHandlerStub) ResetStatistics

func (qshs *QuotaStatusHandlerStub) ResetStatistics()

ResetStatistics -

type RaterMock

type RaterMock struct {
	StartRating           uint32
	MinRating             uint32
	MaxRating             uint32
	Chance                uint32
	IncreaseProposer      int32
	DecreaseProposer      int32
	IncreaseValidator     int32
	DecreaseValidator     int32
	MetaIncreaseProposer  int32
	MetaDecreaseProposer  int32
	MetaIncreaseValidator int32
	MetaDecreaseValidator int32

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

RaterMock -

func GetNewMockRater

func GetNewMockRater() *RaterMock

GetNewMockRater -

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

type RatingStepMock struct {
	ProposerIncreaseRatingStepProperty     int32
	ProposerDecreaseRatingStepProperty     int32
	ValidatorIncreaseRatingStepProperty    int32
	ValidatorDecreaseRatingStepProperty    int32
	ConsecutiveMissedBlocksPenaltyProperty float32
}

RatingStepMock will store information about ratingsComputation specific for a shard or metachain

func (*RatingStepMock) ConsecutiveMissedBlocksPenalty

func (rd *RatingStepMock) ConsecutiveMissedBlocksPenalty() float32

ConsecutiveMissedBlocksPenalty will return the penalty increase for consecutive block misses

func (*RatingStepMock) ProposerDecreaseRatingStep

func (rd *RatingStepMock) ProposerDecreaseRatingStep() int32

ProposerDecreaseRatingStep will return the rating step decrease for proposer

func (*RatingStepMock) ProposerIncreaseRatingStep

func (rd *RatingStepMock) ProposerIncreaseRatingStep() int32

ProposerIncreaseRatingStep will return the rating step increase for validator

func (*RatingStepMock) ValidatorDecreaseRatingStep

func (rd *RatingStepMock) ValidatorDecreaseRatingStep() int32

ValidatorDecreaseRatingStep will return the rating step decrease for validator

func (*RatingStepMock) ValidatorIncreaseRatingStep

func (rd *RatingStepMock) ValidatorIncreaseRatingStep() int32

ValidatorIncreaseRatingStep will return the rating step increase for validator

type RatingsInfoMock

type RatingsInfoMock struct {
	StartRatingProperty           uint32
	MaxRatingProperty             uint32
	MinRatingProperty             uint32
	SignedBlocksThresholdProperty float32
	MetaRatingsStepDataProperty   process.RatingsStepHandler
	ShardRatingsStepDataProperty  process.RatingsStepHandler
	SelectionChancesProperty      []process.SelectionChance
}

RatingsInfoMock -

func (*RatingsInfoMock) IsInterfaceNil

func (rd *RatingsInfoMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*RatingsInfoMock) MaxRating

func (rd *RatingsInfoMock) MaxRating() uint32

MaxRating -

func (*RatingsInfoMock) MetaChainRatingsStepHandler

func (rd *RatingsInfoMock) MetaChainRatingsStepHandler() process.RatingsStepHandler

MetaChainRatingsStepHandler -

func (*RatingsInfoMock) MinRating

func (rd *RatingsInfoMock) MinRating() uint32

MinRating -

func (*RatingsInfoMock) SelectionChances

func (rd *RatingsInfoMock) SelectionChances() []process.SelectionChance

SelectionChances -

func (*RatingsInfoMock) ShardChainRatingsStepHandler

func (rd *RatingsInfoMock) ShardChainRatingsStepHandler() process.RatingsStepHandler

ShardChainRatingsStepHandler -

func (*RatingsInfoMock) SignedBlocksThreshold

func (rd *RatingsInfoMock) SignedBlocksThreshold() float32

SignedBlocksThreshold -

func (*RatingsInfoMock) StartRating

func (rd *RatingsInfoMock) StartRating() uint32

StartRating -

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 ResolverStub

type ResolverStub struct {
	RequestDataFromHashCalled    func(hash []byte, epoch uint32) error
	ProcessReceivedMessageCalled func(message p2p.MessageP2P) error
}

ResolverStub -

func (*ResolverStub) IsInterfaceNil

func (rs *ResolverStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ResolverStub) ProcessReceivedMessage

func (rs *ResolverStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error

ProcessReceivedMessage -

func (*ResolverStub) RequestDataFromHash

func (rs *ResolverStub) RequestDataFromHash(hash []byte, epoch uint32) error

RequestDataFromHash -

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
}

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

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

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 -

type RewardsHandlerMock

type RewardsHandlerMock struct {
	MaxInflationRateCalled                 func() float64
	MinInflationRateCalled                 func() float64
	LeaderPercentageCalled                 func() float64
	ProtocolSustainabilityPercentageCalled func() float64
	ProtocolSustainabilityAddressCalled    func() string
	RewardsTopUpGradientPointCalled        func() *big.Int
	RewardsTopUpFactorCalled               func() float64
}

RewardsHandlerMock -

func (*RewardsHandlerMock) IsInterfaceNil

func (rhm *RewardsHandlerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*RewardsHandlerMock) LeaderPercentage

func (rhm *RewardsHandlerMock) LeaderPercentage() float64

LeaderPercentage -

func (*RewardsHandlerMock) MaxInflationRate

func (rhm *RewardsHandlerMock) MaxInflationRate(uint32) float64

MaxInflationRate -

func (*RewardsHandlerMock) MinInflationRate

func (rhm *RewardsHandlerMock) MinInflationRate() float64

MinInflationRate -

func (*RewardsHandlerMock) ProtocolSustainabilityAddress

func (rhm *RewardsHandlerMock) ProtocolSustainabilityAddress() string

ProtocolSustainabilityAddress will return the protocol sustainability address

func (*RewardsHandlerMock) ProtocolSustainabilityPercentage

func (rhm *RewardsHandlerMock) ProtocolSustainabilityPercentage() float64

ProtocolSustainabilityPercentage will return the protocol sustainability percentage value

func (*RewardsHandlerMock) RewardsTopUpFactor

func (rhm *RewardsHandlerMock) RewardsTopUpFactor() float64

RewardsTopUpFactor -

func (*RewardsHandlerMock) RewardsTopUpGradientPoint

func (rhm *RewardsHandlerMock) RewardsTopUpGradientPoint() *big.Int

RewardsTopUpGradientPoint -

type RoundHandlerMock

type RoundHandlerMock struct {
	RoundIndex          int64
	RoundTimeStamp      time.Time
	RoundTimeDuration   time.Duration
	BeforeGenesisCalled func() bool
}

RoundHandlerMock -

func (*RoundHandlerMock) BeforeGenesis

func (rndm *RoundHandlerMock) BeforeGenesis() bool

BeforeGenesis -

func (*RoundHandlerMock) Index

func (rndm *RoundHandlerMock) Index() int64

Index -

func (*RoundHandlerMock) IsInterfaceNil

func (rndm *RoundHandlerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*RoundHandlerMock) RemainingTime

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

RemainingTime -

func (*RoundHandlerMock) TimeDuration

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

TimeDuration -

func (*RoundHandlerMock) TimeStamp

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

TimeStamp -

func (*RoundHandlerMock) UpdateRound

func (rndm *RoundHandlerMock) UpdateRound(genesisRoundTimeStamp time.Time, timeStamp time.Time)

UpdateRound -

type RoundStub

type RoundStub struct {
	IndexCalled         func() int64
	TimeDurationCalled  func() time.Duration
	TimeStampCalled     func() time.Time
	UpdateRoundCalled   func(time.Time, time.Time)
	RemainingTimeCalled func(time.Time, time.Duration) time.Duration
}

RoundStub -

func (*RoundStub) Index

func (rnds *RoundStub) Index() int64

Index -

func (*RoundStub) IsInterfaceNil

func (rnds *RoundStub) IsInterfaceNil() bool

IsInterfaceNil --

func (*RoundStub) RemainingTime

func (rnds *RoundStub) RemainingTime(startTime time.Time, maxTime time.Duration) time.Duration

RemainingTime -

func (*RoundStub) TimeDuration

func (rnds *RoundStub) TimeDuration() time.Duration

TimeDuration -

func (*RoundStub) TimeStamp

func (rnds *RoundStub) TimeStamp() time.Time

TimeStamp -

func (*RoundStub) UpdateRound

func (rnds *RoundStub) UpdateRound(genesisRoundTimeStamp time.Time, timeStamp time.Time)

UpdateRound -

type SCToProtocolStub

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

SCToProtocolStub -

func (*SCToProtocolStub) IsInterfaceNil

func (s *SCToProtocolStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*SCToProtocolStub) UpdateProtocol

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

UpdateProtocol -

type ScQueryStub

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

ScQueryStub -

func (*ScQueryStub) Close

func (s *ScQueryStub) Close() error

Close -

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 ShardCoordinatorStub

type ShardCoordinatorStub struct {
	NumberOfShardsCalled          func() uint32
	ComputeIdCalled               func(address []byte) uint32
	SelfIdCalled                  func() uint32
	SameShardCalled               func(firstAddress, secondAddress []byte) bool
	CommunicationIdentifierCalled func(destShardID uint32) string
}

ShardCoordinatorStub -

func (*ShardCoordinatorStub) CommunicationIdentifier

func (coordinator *ShardCoordinatorStub) CommunicationIdentifier(destShardID uint32) string

CommunicationIdentifier -

func (*ShardCoordinatorStub) ComputeId

func (coordinator *ShardCoordinatorStub) ComputeId(address []byte) uint32

ComputeId -

func (*ShardCoordinatorStub) IsInterfaceNil

func (coordinator *ShardCoordinatorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ShardCoordinatorStub) NumberOfShards

func (coordinator *ShardCoordinatorStub) NumberOfShards() uint32

NumberOfShards -

func (*ShardCoordinatorStub) SameShard

func (coordinator *ShardCoordinatorStub) SameShard(firstAddress, secondAddress []byte) bool

SameShard -

func (*ShardCoordinatorStub) SelfId

func (coordinator *ShardCoordinatorStub) SelfId() uint32

SelfId -

type ShardIdHasMapMock

type ShardIdHasMapMock struct {
	LoadCalled   func(shardId uint32) ([]byte, bool)
	StoreCalled  func(shardId uint32, hash []byte)
	RangeCalled  func(f func(shardId uint32, hash []byte) bool)
	DeleteCalled func(shardId uint32)
}

ShardIdHasMapMock -

func (*ShardIdHasMapMock) Delete

func (sihsm *ShardIdHasMapMock) Delete(shardId uint32)

Delete -

func (*ShardIdHasMapMock) IsInterfaceNil

func (sihsm *ShardIdHasMapMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ShardIdHasMapMock) Load

func (sihsm *ShardIdHasMapMock) Load(shardId uint32) ([]byte, bool)

Load -

func (*ShardIdHasMapMock) Range

func (sihsm *ShardIdHasMapMock) Range(f func(shardId uint32, hash []byte) bool)

Range -

func (*ShardIdHasMapMock) Store

func (sihsm *ShardIdHasMapMock) Store(shardId uint32, hash []byte)

Store -

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 SingleSignKeyGenMock

type SingleSignKeyGenMock struct {
	PublicKeyFromByteArrayCalled func(b []byte) (crypto.PublicKey, error)
	SuiteCalled                  func() crypto.Suite
}

SingleSignKeyGenMock -

func (*SingleSignKeyGenMock) CheckPublicKeyValid

func (sskgm *SingleSignKeyGenMock) CheckPublicKeyValid(_ []byte) error

CheckPublicKeyValid -

func (*SingleSignKeyGenMock) GeneratePair

func (sskgm *SingleSignKeyGenMock) GeneratePair() (crypto.PrivateKey, crypto.PublicKey)

GeneratePair -

func (*SingleSignKeyGenMock) IsInterfaceNil

func (sskgm *SingleSignKeyGenMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SingleSignKeyGenMock) PrivateKeyFromByteArray

func (sskgm *SingleSignKeyGenMock) PrivateKeyFromByteArray(_ []byte) (crypto.PrivateKey, error)

PrivateKeyFromByteArray -

func (*SingleSignKeyGenMock) PublicKeyFromByteArray

func (sskgm *SingleSignKeyGenMock) PublicKeyFromByteArray(b []byte) (crypto.PublicKey, error)

PublicKeyFromByteArray -

func (*SingleSignKeyGenMock) Suite

func (sskgm *SingleSignKeyGenMock) Suite() crypto.Suite

Suite -

type SingleSignPublicKey

type SingleSignPublicKey struct {
	SuiteCalled func() crypto.Suite
	PointCalled func() crypto.Point
}

SingleSignPublicKey -

func (*SingleSignPublicKey) IsInterfaceNil

func (sspk *SingleSignPublicKey) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SingleSignPublicKey) Point

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

Point -

func (*SingleSignPublicKey) Suite

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

Suite -

func (*SingleSignPublicKey) ToByteArray

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

ToByteArray -

type StatusComponentsMock

type StatusComponentsMock struct {
	Outport outport.OutportHandler
}

StatusComponentsMock -

func (*StatusComponentsMock) IsInterfaceNil

func (scm *StatusComponentsMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*StatusComponentsMock) OutportHandler

func (scm *StatusComponentsMock) OutportHandler() outport.OutportHandler

OutportHandler -

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

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

GetOldestEpoch -

func (*StorerMock) Has

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

Has -

func (*StorerMock) IsInterfaceNil

func (sm *StorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*StorerMock) Put

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

Put -

func (*StorerMock) PutInEpoch

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

PutInEpoch -

func (*StorerMock) RangeKeys

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

RangeKeys -

func (*StorerMock) Remove

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

Remove -

func (*StorerMock) SearchFirst

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

SearchFirst -

type SyncStarterStub

type SyncStarterStub struct {
	SyncBlockCalled func() error
}

SyncStarterStub -

func (*SyncStarterStub) SyncBlock

func (sss *SyncStarterStub) SyncBlock() error

SyncBlock -

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
	ResetForTopicCalled          func(topic string)
	SetMaxMessagesForTopicCalled func(topic string, num uint32)
}

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(topic string)

ResetForTopic -

func (*TopicAntiFloodStub) SetMaxMessagesForTopic

func (t *TopicAntiFloodStub) SetMaxMessagesForTopic(topic string, num uint32)

SetMaxMessagesForTopic -

type TopicHandlerStub

type TopicHandlerStub struct {
	HasTopicCalled                 func(name string) bool
	CreateTopicCalled              func(name string, createChannelForTopic bool) error
	RegisterMessageProcessorCalled func(topic string, identifier string, handler p2p.MessageProcessor) error
	IDCalled                       func() core.PeerID
}

TopicHandlerStub -

func (*TopicHandlerStub) CreateTopic

func (ths *TopicHandlerStub) CreateTopic(name string, createChannelForTopic bool) error

CreateTopic -

func (*TopicHandlerStub) HasTopic

func (ths *TopicHandlerStub) HasTopic(name string) bool

HasTopic -

func (*TopicHandlerStub) ID

func (ths *TopicHandlerStub) ID() core.PeerID

ID -

func (*TopicHandlerStub) IsInterfaceNil

func (ths *TopicHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TopicHandlerStub) RegisterMessageProcessor

func (ths *TopicHandlerStub) RegisterMessageProcessor(topic string, identifier string, handler p2p.MessageProcessor) error

RegisterMessageProcessor -

type TransactionCoordinatorMock

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

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

TransactionCoordinatorMock -

func (*TransactionCoordinatorMock) ComputeTransactionType

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

ComputeTransactionType -

func (*TransactionCoordinatorMock) CreateBlockStarted

func (tcm *TransactionCoordinatorMock) CreateBlockStarted()

CreateBlockStarted -

func (*TransactionCoordinatorMock) CreateMarshalizedData

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

CreateMarshalizedData -

func (*TransactionCoordinatorMock) CreateMarshalizedReceipts

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

CreateMarshalizedReceipts -

func (*TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe

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

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

CreateMbsAndProcessCrossShardTransactionsDstMe -

func (*TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe

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

CreateMbsAndProcessTransactionsFromMe -

func (*TransactionCoordinatorMock) CreatePostProcessMiniBlocks

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

CreatePostProcessMiniBlocks -

func (*TransactionCoordinatorMock) CreateReceiptsHash

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

CreateReceiptsHash -

func (*TransactionCoordinatorMock) GetAllCurrentLogs

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

GetAllCurrentLogs -

func (*TransactionCoordinatorMock) GetAllCurrentUsedTxs

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

GetAllCurrentUsedTxs -

func (*TransactionCoordinatorMock) IsDataPreparedForProcessing

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

IsDataPreparedForProcessing -

func (*TransactionCoordinatorMock) IsInterfaceNil

func (tcm *TransactionCoordinatorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TransactionCoordinatorMock) ProcessBlockTransaction

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

ProcessBlockTransaction -

func (*TransactionCoordinatorMock) RemoveBlockDataFromPool

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

RemoveBlockDataFromPool -

func (*TransactionCoordinatorMock) RemoveTxsFromPool

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

RemoveTxsFromPool -

func (*TransactionCoordinatorMock) RequestBlockTransactions

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

RequestBlockTransactions -

func (*TransactionCoordinatorMock) RequestMiniBlocks

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

RequestMiniBlocks -

func (*TransactionCoordinatorMock) RestoreBlockDataFromStorage

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

RestoreBlockDataFromStorage -

func (*TransactionCoordinatorMock) SaveTxsToStorage

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

SaveTxsToStorage -

func (*TransactionCoordinatorMock) VerifyCreatedBlockTransactions

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

VerifyCreatedBlockTransactions -

func (*TransactionCoordinatorMock) VerifyCreatedMiniBlocks

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

VerifyCreatedMiniBlocks -

type TransactionInterceptorMock

type TransactionInterceptorMock struct {
	IsChecked                   bool
	IsVerified                  bool
	RcvShardVal                 uint32
	SndShardVal                 uint32
	IsAddressedToOtherShardsVal bool

	Tx *transaction.Transaction
	// contains filtered or unexported fields
}

TransactionInterceptorMock -

func (*TransactionInterceptorMock) Check

func (tim *TransactionInterceptorMock) Check() bool

Check -

func (*TransactionInterceptorMock) GetTransaction

func (tim *TransactionInterceptorMock) GetTransaction() *transaction.Transaction

GetTransaction -

func (*TransactionInterceptorMock) Hash

func (tim *TransactionInterceptorMock) Hash() []byte

Hash -

func (*TransactionInterceptorMock) ID

func (tim *TransactionInterceptorMock) ID() string

ID -

func (*TransactionInterceptorMock) IsAddressedToOtherShards

func (tim *TransactionInterceptorMock) IsAddressedToOtherShards() bool

IsAddressedToOtherShards -

func (*TransactionInterceptorMock) IsInterfaceNil

func (tim *TransactionInterceptorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TransactionInterceptorMock) PubkeyConverter

func (tim *TransactionInterceptorMock) PubkeyConverter() core.PubkeyConverter

PubkeyConverter -

func (*TransactionInterceptorMock) RcvShard

func (tim *TransactionInterceptorMock) RcvShard() uint32

RcvShard -

func (*TransactionInterceptorMock) SetHash

func (tim *TransactionInterceptorMock) SetHash(hash []byte)

SetHash -

func (*TransactionInterceptorMock) SetPubkeyConverter

func (tim *TransactionInterceptorMock) SetPubkeyConverter(converter core.PubkeyConverter)

SetPubkeyConverter -

func (*TransactionInterceptorMock) SndShard

func (tim *TransactionInterceptorMock) SndShard() uint32

SndShard -

func (*TransactionInterceptorMock) VerifySig

func (tim *TransactionInterceptorMock) VerifySig() bool

VerifySig -

type TransactionPoolMock

type TransactionPoolMock struct {
	RegisterTransactionHandlerCalled func(transactionHandler func(txHash []byte))
	RemoveTransactionsFromPoolCalled func(txHashes [][]byte, destShardID uint32)
	MiniPoolTxStoreCalled            func(shardID uint32) (c storage.Cacher)
}

TransactionPoolMock -

func (*TransactionPoolMock) MiniPoolTxStore

func (tpm *TransactionPoolMock) MiniPoolTxStore(shardID uint32) (c storage.Cacher)

MiniPoolTxStore -

func (*TransactionPoolMock) RegisterTransactionHandler

func (tpm *TransactionPoolMock) RegisterTransactionHandler(transactionHandler func(txHash []byte))

RegisterTransactionHandler -

func (*TransactionPoolMock) RemoveTransactionsFromPool

func (tpm *TransactionPoolMock) RemoveTransactionsFromPool(txHashes [][]byte, destShardID uint32)

RemoveTransactionsFromPool -

type TransactionSimulatorStub

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

TransactionSimulatorStub -

func (*TransactionSimulatorStub) IsInterfaceNil

func (tss *TransactionSimulatorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TransactionSimulatorStub) ProcessTx

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

ProcessTx -

type 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
	GetAllCurrentLogsCalled func() map[string]data.LogHandler
}

TxLogsProcessorStub -

func (*TxLogsProcessorStub) Clean

func (txls *TxLogsProcessorStub) Clean()

Clean -

func (*TxLogsProcessorStub) GetAllCurrentLogs

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

GetAllCurrentLogs -

func (*TxLogsProcessorStub) GetLog

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

GetLog -

func (*TxLogsProcessorStub) IsInterfaceNil

func (txls *TxLogsProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*TxLogsProcessorStub) SaveLog

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

SaveLog -

type TxValidatorHandlerStub

type TxValidatorHandlerStub struct {
	SenderShardIdCalled   func() uint32
	ReceiverShardIdCalled func() uint32
	NonceCalled           func() uint64
	SenderAddressCalled   func() []byte
	FeeCalled             func() *big.Int
}

TxValidatorHandlerStub -

func (*TxValidatorHandlerStub) Fee

func (tvhs *TxValidatorHandlerStub) Fee() *big.Int

Fee -

func (*TxValidatorHandlerStub) Nonce

func (tvhs *TxValidatorHandlerStub) Nonce() uint64

Nonce -

func (*TxValidatorHandlerStub) ReceiverShardId

func (tvhs *TxValidatorHandlerStub) ReceiverShardId() uint32

ReceiverShardId -

func (*TxValidatorHandlerStub) SenderAddress

func (tvhs *TxValidatorHandlerStub) SenderAddress() []byte

SenderAddress -

func (*TxValidatorHandlerStub) SenderShardId

func (tvhs *TxValidatorHandlerStub) SenderShardId() uint32

SenderShardId -

type TxValidatorStub

type TxValidatorStub struct {
	CheckTxValidityCalled  func(txValidatorHandler process.TxValidatorHandler) error
	CheckTxWhiteListCalled func(data process.InterceptedData) error
	RejectedTxsCalled      func() uint64
}

TxValidatorStub -

func (*TxValidatorStub) CheckTxValidity

func (t *TxValidatorStub) CheckTxValidity(txValidatorHandler process.TxValidatorHandler) error

CheckTxValidity -

func (*TxValidatorStub) CheckTxWhiteList

func (t *TxValidatorStub) CheckTxWhiteList(data process.InterceptedData) error

CheckTxWhiteList -

func (*TxValidatorStub) IsInterfaceNil

func (t *TxValidatorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

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 Uint64SyncMapCacherStub

type Uint64SyncMapCacherStub struct {
	ClearCalled             func()
	GetCalled               func(nonce uint64) (dataRetriever.ShardIdHashMap, bool)
	MergeCalled             func(nonce uint64, src dataRetriever.ShardIdHashMap)
	RemoveCalled            func(nonce uint64, shardId uint32)
	RegisterHandlerCalled   func(handler func(nonce uint64, shardId uint32, value []byte))
	HasCalled               func(nonce uint64, shardId uint32) bool
	UnRegisterHandlerCalled func(func(key []byte, value interface{}))
}

Uint64SyncMapCacherStub -

func (*Uint64SyncMapCacherStub) Clear

func (usmcs *Uint64SyncMapCacherStub) Clear()

Clear -

func (*Uint64SyncMapCacherStub) Get

func (usmcs *Uint64SyncMapCacherStub) Get(nonce uint64) (dataRetriever.ShardIdHashMap, bool)

Get -

func (*Uint64SyncMapCacherStub) Has

func (usmcs *Uint64SyncMapCacherStub) Has(nonce uint64, shardId uint32) bool

Has -

func (*Uint64SyncMapCacherStub) IsInterfaceNil

func (usmcs *Uint64SyncMapCacherStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*Uint64SyncMapCacherStub) Merge

func (usmcs *Uint64SyncMapCacherStub) Merge(nonce uint64, src dataRetriever.ShardIdHashMap)

Merge -

func (*Uint64SyncMapCacherStub) RegisterHandler

func (usmcs *Uint64SyncMapCacherStub) RegisterHandler(handler func(nonce uint64, shardId uint32, value []byte))

RegisterHandler -

func (*Uint64SyncMapCacherStub) Remove

func (usmcs *Uint64SyncMapCacherStub) Remove(nonce uint64, shardId uint32)

Remove -

func (*Uint64SyncMapCacherStub) UnRegisterHandler

func (usmcs *Uint64SyncMapCacherStub) UnRegisterHandler(handler func(key []byte, value interface{}))

UnRegisterHandler -

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
	CloseCalled       func() error
}

VMContainerMock -

func (*VMContainerMock) Add

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

Add -

func (*VMContainerMock) AddMultiple

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

AddMultiple -

func (*VMContainerMock) Close

func (v *VMContainerMock) Close() error

Close -

func (*VMContainerMock) Get

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

Get -

func (*VMContainerMock) IsInterfaceNil

func (v *VMContainerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*VMContainerMock) Keys

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

Keys -

func (*VMContainerMock) Len

func (v *VMContainerMock) Len() int

Len -

func (*VMContainerMock) Remove

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

Remove -

func (*VMContainerMock) Replace

func (v *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 -

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 ValidatorMock

type ValidatorMock struct {
	PubKeyCalled func() []byte
	// contains filtered or unexported fields
}

ValidatorMock -

func NewValidatorMock

func NewValidatorMock(pubkey []byte) *ValidatorMock

NewValidatorMock -

func (*ValidatorMock) Chances

func (vm *ValidatorMock) Chances() uint32

Chances -

func (*ValidatorMock) Index

func (vm *ValidatorMock) Index() uint32

Index -

func (*ValidatorMock) PubKey

func (vm *ValidatorMock) PubKey() []byte

PubKey -

func (*ValidatorMock) Size

func (vm *ValidatorMock) Size() int

Size -

type ValidatorSettingsStub

type ValidatorSettingsStub struct {
}

ValidatorSettingsStub -

func (*ValidatorSettingsStub) GenesisNodePrice

func (v *ValidatorSettingsStub) GenesisNodePrice() *big.Int

GenesisNodePrice -

func (*ValidatorSettingsStub) IsInterfaceNil

func (v *ValidatorSettingsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorSettingsStub) UnBondPeriod

func (v *ValidatorSettingsStub) UnBondPeriod() uint64

UnBondPeriod -

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)
	LastFinalizedRootHashCalled              func() []byte
	ResetValidatorStatisticsAtNewEpochCalled func(vInfos map[uint32][]*state.ValidatorInfo) error
	GetValidatorInfoForRootHashCalled        func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)
	ProcessRatingsEndOfEpochCalled           func(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error
	ProcessCalled                            func(validatorInfo data.ShardValidatorInfoHandler) error
	CommitCalled                             func() ([]byte, error)
	PeerAccountToValidatorInfoCalled         func(peerAccount state.PeerAccountHandler) *state.ValidatorInfo
	SaveNodesCoordinatorUpdatesCalled        func(epoch uint32) (bool, error)
}

ValidatorStatisticsProcessorStub -

func (*ValidatorStatisticsProcessorStub) Commit

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

Commit -

func (*ValidatorStatisticsProcessorStub) DisplayRatings

func (vsp *ValidatorStatisticsProcessorStub) DisplayRatings(_ uint32)

DisplayRatings -

func (*ValidatorStatisticsProcessorStub) GetExistingPeerAccount

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

GetExistingPeerAccount -

func (*ValidatorStatisticsProcessorStub) GetValidatorInfoForRootHash

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

GetValidatorInfoForRootHash -

func (*ValidatorStatisticsProcessorStub) IsInterfaceNil

func (vsp *ValidatorStatisticsProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorStatisticsProcessorStub) LastFinalizedRootHash

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

LastFinalizedRootHash -

func (*ValidatorStatisticsProcessorStub) PeerAccountToValidatorInfo

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

PeerAccountToValidatorInfo -

func (*ValidatorStatisticsProcessorStub) Process

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

Process -

func (*ValidatorStatisticsProcessorStub) ProcessRatingsEndOfEpoch

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

ProcessRatingsEndOfEpoch -

func (*ValidatorStatisticsProcessorStub) ResetValidatorStatisticsAtNewEpoch

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

ResetValidatorStatisticsAtNewEpoch -

func (*ValidatorStatisticsProcessorStub) RevertPeerState

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

RevertPeerState -

func (*ValidatorStatisticsProcessorStub) RootHash

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

RootHash -

func (*ValidatorStatisticsProcessorStub) SaveNodesCoordinatorUpdates

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

SaveNodesCoordinatorUpdates -

func (*ValidatorStatisticsProcessorStub) SetLastFinalizedRootHash

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

SetLastFinalizedRootHash -

func (*ValidatorStatisticsProcessorStub) UpdatePeerState

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

UpdatePeerState -

type ValidatorsProviderStub

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

ValidatorsProviderStub -

func (*ValidatorsProviderStub) Close

func (vp *ValidatorsProviderStub) Close() error

Close -

func (*ValidatorsProviderStub) GetLatestValidators

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

GetLatestValidators -

func (*ValidatorsProviderStub) IsInterfaceNil

func (vp *ValidatorsProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

type ValidityAttesterStub

type ValidityAttesterStub struct {
	CheckBlockAgainstRoundHandlerCalled func(headerHandler data.HeaderHandler) error
	CheckBlockAgainstFinalCalled        func(headerHandler data.HeaderHandler) error
	CheckBlockAgainstWhitelistCalled    func(interceptedData process.InterceptedData) bool
}

ValidityAttesterStub -

func (*ValidityAttesterStub) CheckBlockAgainstFinal

func (vas *ValidityAttesterStub) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error

CheckBlockAgainstFinal -

func (*ValidityAttesterStub) CheckBlockAgainstRoundHandler

func (vas *ValidityAttesterStub) CheckBlockAgainstRoundHandler(headerHandler data.HeaderHandler) error

CheckBlockAgainstRoundHandler -

func (*ValidityAttesterStub) CheckBlockAgainstWhitelist

func (vas *ValidityAttesterStub) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool

CheckBlockAgainstWhitelist -

func (*ValidityAttesterStub) IsInterfaceNil

func (vas *ValidityAttesterStub) IsInterfaceNil() bool

IsInterfaceNil -