Versions in this module Expand all Collapse all v1 v1.1.66 Jun 17, 2021 v1.1.65 Jun 17, 2021 Changes in this version + func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock + func NewMultipleShardsCoordinatorMock() *multipleShardsCoordinatorMock + func NewNilTxValidator() (*nilTxValidator, error) + func NewNonceHashConverterMock() *nonceHashConverterMock + func NewOneShardCoordinatorMock() *oneShardCoordinatorMock + type AccountWrapMock struct + MockValue int + SetCodeHashWithJournalCalled func(codeHash []byte) error + SetCodeWithJournalCalled func(codeHash []byte) error + SetNonceWithJournalCalled func(nonce uint64) error + func NewAccountWrapMock(adr []byte) *AccountWrapMock + 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() data.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) SetCode(code []byte) + func (awm *AccountWrapMock) SetCodeHash(codeHash []byte) + func (awm *AccountWrapMock) SetCodeMetadata(codeMetadata []byte) + func (awm *AccountWrapMock) SetDataTrie(trie data.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 AccountsStub struct + AddJournalEntryCalled func(je state.JournalEntry) + CancelPruneCalled func(rootHash []byte, identifier data.TriePruningIdentifier) + CommitCalled func() ([]byte, error) + GetAllLeavesCalled func(rootHash []byte) (chan core.KeyValueHolder, error) + GetCodeCalled func([]byte) []byte + GetExistingAccountCalled func(address []byte) (state.AccountHandler, error) + GetNumCheckpointsCalled func() uint32 + IsPruningEnabledCalled func() bool + JournalLenCalled func() int + LoadAccountCalled func(address []byte) (state.AccountHandler, error) + PruneTrieCalled func(rootHash []byte, identifier data.TriePruningIdentifier) + RecreateAllTriesCalled func(rootHash []byte) (map[string]data.Trie, error) + RecreateTrieCalled func(rootHash []byte) error + RemoveAccountCalled func(address []byte) error + RevertToSnapshotCalled func(snapshot int) error + RootHashCalled func() ([]byte, error) + SaveAccountCalled func(account state.AccountHandler) error + SetStateCheckpointCalled func(rootHash []byte) + SnapshotStateCalled func(rootHash []byte) + func (as *AccountsStub) AddJournalEntry(je state.JournalEntry) + func (as *AccountsStub) CancelPrune(rootHash []byte, identifier data.TriePruningIdentifier) + func (as *AccountsStub) Commit() ([]byte, error) + func (as *AccountsStub) GetAllLeaves(rootHash []byte, _ context.Context) (chan core.KeyValueHolder, error) + func (as *AccountsStub) GetCode(codeHash []byte) []byte + func (as *AccountsStub) GetExistingAccount(address []byte) (state.AccountHandler, error) + func (as *AccountsStub) GetNumCheckpoints() uint32 + func (as *AccountsStub) IsInterfaceNil() bool + func (as *AccountsStub) IsPruningEnabled() bool + func (as *AccountsStub) JournalLen() int + func (as *AccountsStub) LoadAccount(address []byte) (state.AccountHandler, error) + func (as *AccountsStub) PruneTrie(rootHash []byte, identifier data.TriePruningIdentifier) + func (as *AccountsStub) RecreateAllTries(rootHash []byte, _ context.Context) (map[string]data.Trie, error) + func (as *AccountsStub) RecreateTrie(rootHash []byte) error + func (as *AccountsStub) RemoveAccount(address []byte) error + func (as *AccountsStub) RevertToSnapshot(snapshot int) error + func (as *AccountsStub) RootHash() ([]byte, error) + func (as *AccountsStub) SaveAccount(account state.AccountHandler) error + func (as *AccountsStub) SetStateCheckpoint(rootHash []byte, _ context.Context) + func (as *AccountsStub) SnapshotState(rootHash []byte, _ context.Context) + type AntifloodDebuggerStub struct + AddDataCalled func(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, ...) + CloseCalled func() error + func (ads *AntifloodDebuggerStub) AddData(pid core.PeerID, topic string, numRejected uint32, sizeRejected uint64, ...) + func (ads *AntifloodDebuggerStub) Close() error + func (ads *AntifloodDebuggerStub) IsInterfaceNil() bool + type AppStatusHandlerStub struct + AddUint64Handler func(key string, value uint64) + CloseHandler func() + DecrementHandler func(key string) + IncrementHandler func(key string) + SetInt64ValueHandler func(key string, value int64) + SetStringValueHandler func(key string, value string) + SetUInt64ValueHandler func(key string, value uint64) + func (ashs *AppStatusHandlerStub) AddUint64(key string, value uint64) + func (ashs *AppStatusHandlerStub) Close() + func (ashs *AppStatusHandlerStub) Decrement(key string) + func (ashs *AppStatusHandlerStub) Increment(key string) + func (ashs *AppStatusHandlerStub) IsInterfaceNil() bool + func (ashs *AppStatusHandlerStub) SetInt64Value(key string, value int64) + func (ashs *AppStatusHandlerStub) SetStringValue(key string, value string) + func (ashs *AppStatusHandlerStub) SetUInt64Value(key string, value uint64) + type ArgumentParserMock struct + CreateDataFromStorageUpdateCalled func(storageUpdates []*vmcommon.StorageUpdate) string + GetStorageUpdatesCalled func(data string) ([]*vmcommon.StorageUpdate, error) + ParseCallDataCalled func(data string) (string, [][]byte, error) + ParseDeployDataCalled func(data string) (*parsers.DeployArgs, error) + 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 struct + AddBalanceToAddressCalled func(address []byte, value *big.Int) bool + AddressHasEnoughBalanceCalled func(address []byte, value *big.Int) bool + InitCalled func() + IsAddressSetCalled func(address []byte) bool + SetBalanceToAddressCalled func(address []byte, value *big.Int) + SubBalanceFromAddressCalled func(address []byte, value *big.Int) bool + 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 BelNevMock struct + AggregateCommitmentsMock func(bitmap []byte) error + AggregateSigsMock func(bitmap []byte) ([]byte, error) + CommitmentHashMock func(index uint16) ([]byte, error) + CommitmentMock func(uint16) ([]byte, error) + CreateCommitmentMock func() ([]byte, []byte) + CreateMock func(pubKeys []string, index uint16) (crypto.MultiSigner, error) + CreateSignatureShareMock func(msg []byte, bitmap []byte) ([]byte, error) + StoreCommitmentHashMock func(uint16, []byte) error + StoreCommitmentMock func(index uint16, value []byte) error + VerifyMock func(msg []byte, bitmap []byte) error + VerifySignatureShareMock func(index uint16, sig []byte, msg []byte, bitmap []byte) error + func NewMultiSigner() *BelNevMock + func (bnm *BelNevMock) AggregateCommitments(bitmap []byte) error + func (bnm *BelNevMock) AggregateSigs(bitmap []byte) ([]byte, error) + func (bnm *BelNevMock) Commitment(index uint16) ([]byte, error) + func (bnm *BelNevMock) CommitmentHash(index uint16) ([]byte, error) + func (bnm *BelNevMock) Create(pubKeys []string, index uint16) (crypto.MultiSigner, error) + func (bnm *BelNevMock) CreateCommitment() (commSecret []byte, commitment []byte) + func (bnm *BelNevMock) CreateSignatureShare(msg []byte, bitmap []byte) ([]byte, error) + func (bnm *BelNevMock) IsInterfaceNil() bool + func (bnm *BelNevMock) Reset(pubKeys []string, index uint16) error + func (bnm *BelNevMock) SetAggregatedSig(aggSig []byte) error + func (bnm *BelNevMock) SetMessage(msg []byte) error + func (bnm *BelNevMock) SignatureShare(index uint16) ([]byte, error) + func (bnm *BelNevMock) StoreCommitment(index uint16, value []byte) error + func (bnm *BelNevMock) StoreCommitmentHash(index uint16, commHash []byte) error + func (bnm *BelNevMock) StoreSignatureShare(index uint16, sig []byte) error + func (bnm *BelNevMock) Verify(msg []byte, bitmap []byte) error + func (bnm *BelNevMock) VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error + type BlackListHandlerStub struct + AddCalled func(key string) error + HasCalled func(key string) bool + LenCalled func() int + SweepCalled func() + UpsertCalled func(key string, span time.Duration) error + 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 struct + DeleteCompiledCodeCalled func(codeHash []byte) + IsPayableCalled func(address []byte) (bool, error) + NewAddressCalled func(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error) + SetCurrentHeaderCalled func(hdr data.HeaderHandler) + func (e *BlockChainHookHandlerMock) DeleteCompiledCode(codeHash []byte) + func (e *BlockChainHookHandlerMock) GetBuiltInFunctions() process.BuiltInFunctionContainer + func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool + func (e *BlockChainHookHandlerMock) IsPayable(address []byte) (bool, error) + func (e *BlockChainHookHandlerMock) NewAddress(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error) + func (e *BlockChainHookHandlerMock) SetCurrentHeader(hdr data.HeaderHandler) + type BlockChainMock struct + CreateNewHeaderCalled func() data.HeaderHandler + GetCurrentBlockHeaderCalled func() data.HeaderHandler + GetCurrentBlockHeaderHashCalled func() []byte + GetGenesisHeaderCalled func() data.HeaderHandler + GetGenesisHeaderHashCalled func() []byte + GetLocalHeightCalled func() int64 + GetNetworkHeightCalled func() int64 + HasBadBlockCalled func([]byte) bool + PutBadBlockCalled func([]byte) + SetCurrentBlockHeaderCalled func(data.HeaderHandler) error + SetCurrentBlockHeaderHashCalled func([]byte) + SetGenesisHeaderCalled func(handler data.HeaderHandler) error + SetGenesisHeaderHashCalled func([]byte) + SetLocalHeightCalled func(int64) + SetNetworkHeightCalled func(int64) + 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 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() + 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 struct + CallHandlersCalled func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte) + GetNumRegisteredHandlersCalled func() int + RegisterHandlerCalled func(...) + 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 struct + AddLastNotarizedHdrCalled func(shardId uint32, processedHdr data.HeaderHandler) + CommitBlockCalled func(header data.HeaderHandler, body data.BodyHandler) error + CreateBlockCalled func(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error) + CreateGenesisBlockCalled func(balances map[string]*big.Int) (data.HeaderHandler, error) + CreateNewHeaderCalled func(round uint64, nonce uint64) data.HeaderHandler + DecodeBlockBodyCalled func(dta []byte) data.BodyHandler + DecodeBlockHeaderCalled func(dta []byte) data.HeaderHandler + MarshalizedDataToBroadcastCalled func(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error) + ProcessBlockCalled func(header data.HeaderHandler, body data.BodyHandler, ...) error + PruneStateOnRollbackCalled func(currHeader data.HeaderHandler, prevHeader data.HeaderHandler) + RestoreBlockIntoPoolsCalled func(header data.HeaderHandler, body data.BodyHandler) error + RevertAccountStateCalled func(header data.HeaderHandler) + RevertIndexedBlockCalled func(header data.HeaderHandler) + RevertStateToBlockCalled func(header data.HeaderHandler) error + SetOnRequestTransactionCalled func(f func(destShardID uint32, txHash []byte)) + func (bpm *BlockProcessorMock) AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler) + func (bpm *BlockProcessorMock) ApplyProcessedMiniBlocks(*processedMb.ProcessedMiniBlockTracker) + func (bpm *BlockProcessorMock) CommitBlock(header data.HeaderHandler, body data.BodyHandler) error + func (bpm *BlockProcessorMock) CreateBlock(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error) + func (bpm *BlockProcessorMock) 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 struct + AddNumMiniBlocksCalled func(int) + AddNumTxsCalled func(int) + InitCalled func() + IsMaxBlockSizeReachedCalled func(int, int) bool + IsMaxBlockSizeWithoutThrottleReachedCalled func(int, int) bool + 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 struct + AddCalled func(round uint64, size uint32) + ComputeCurrentMaxSizeCalled func() + GetCurrentMaxSizeCalled func() uint32 + SucceedCalled func(round uint64) + 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 struct + AddHeaderFromPoolCalled func(shardID uint32, nonce uint64) + ComputeCrossInfoCalled func(headers []data.HeaderHandler) + ComputeLongestSelfChainCalled func() (data.HeaderHandler, []byte, []data.HeaderHandler, [][]byte) + GetSelfHeadersCalled func(headerHandler data.HeaderHandler) []*track.HeaderInfo + SortHeadersFromNonceCalled func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte) + 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 struct + AddCrossNotarizedHeaderCalled func(shardID uint32, crossNotarizedHeader data.HeaderHandler, ...) + AddSelfNotarizedHeaderCalled func(shardID uint32, selfNotarizedHeader data.HeaderHandler, ...) + AddTrackedHeaderCalled func(header data.HeaderHandler, hash []byte) + CheckBlockAgainstFinalCalled func(headerHandler data.HeaderHandler) error + CheckBlockAgainstRounderCalled func(headerHandler data.HeaderHandler) error + CheckBlockAgainstWhitelistCalled func(interceptedData process.InterceptedData) bool + CleanupHeadersBehindNonceCalled func(shardID uint32, selfNotarizedNonce uint64, crossNotarizedNonce uint64) + ComputeLongestChainCalled func(shardID uint32, header data.HeaderHandler) ([]data.HeaderHandler, [][]byte) + ComputeLongestMetaChainFromLastNotarizedCalled func() ([]data.HeaderHandler, [][]byte, error) + ComputeLongestShardsChainsFromLastNotarizedCalled func() ([]data.HeaderHandler, [][]byte, map[uint32][]data.HeaderHandler, error) + DisplayTrackedHeadersCalled func() + GetCrossNotarizedHeaderCalled func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error) + GetLastCrossNotarizedHeaderCalled func(shardID uint32) (data.HeaderHandler, []byte, error) + GetLastCrossNotarizedHeadersForAllShardsCalled func() (map[uint32]data.HeaderHandler, error) + GetLastSelfNotarizedHeaderCalled func(shardID uint32) (data.HeaderHandler, []byte, error) + GetSelfNotarizedHeaderCalled func(shardID uint32, offset uint64) (data.HeaderHandler, []byte, error) + GetTrackedHeadersCalled func(shardID uint32) ([]data.HeaderHandler, [][]byte) + GetTrackedHeadersForAllShardsCalled func() map[uint32][]data.HeaderHandler + GetTrackedHeadersWithNonceCalled func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte) + IsShardStuckCalled func(shardId uint32) bool + RegisterCrossNotarizedHeadersHandlerCalled func(...) + RegisterFinalMetachainHeadersHandlerCalled func(...) + RegisterSelfNotarizedFromCrossHeadersHandlerCalled func(...) + RegisterSelfNotarizedHeadersHandlerCalled func(...) + RemoveLastNotarizedHeadersCalled func() + RestoreToGenesisCalled func() + ShouldAddHeaderCalled func(headerHandler data.HeaderHandler) bool + 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) CheckBlockAgainstRounder(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 struct + GetCalled func(round int64) (bootstrapStorage.BootstrapData, error) + GetHighestRoundCalled func() int64 + PutCalled func(round int64, bootData bootstrapStorage.BootstrapData) error + func (bsm *BoostrapStorerMock) Get(round int64) (bootstrapStorage.BootstrapData, error) + func (bsm *BoostrapStorerMock) GetHighestRound() int64 + func (bsm *BoostrapStorerMock) IsInterfaceNil() bool + func (bsm *BoostrapStorerMock) Put(round int64, bootData bootstrapStorage.BootstrapData) error + func (bsm *BoostrapStorerMock) SaveLastRound(_ int64) error + type BuiltInCostHandlerStub struct + func (b *BuiltInCostHandlerStub) ComputeBuiltInCost(_ process.TransactionWithFeeHandler) uint64 + func (b *BuiltInCostHandlerStub) IsBuiltInFuncCall(_ process.TransactionWithFeeHandler) bool + func (b *BuiltInCostHandlerStub) IsInterfaceNil() bool + type BuiltInFunctionStub struct + ProcessBuiltinFunctionCalled func(acntSnd, acntDst state.UserAccountHandler, vmInput *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error) + SetNewGasConfigCalled func(gasCost *process.GasCost) + func (b *BuiltInFunctionStub) IsInterfaceNil() bool + func (b *BuiltInFunctionStub) ProcessBuiltinFunction(acntSnd, acntDst state.UserAccountHandler, vmInput *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error) + func (b *BuiltInFunctionStub) SetNewGasConfig(gasCost *process.GasCost) + type ChainStorerMock struct + AddStorerCalled func(key dataRetriever.UnitType, s storage.Storer) + CloseAllCalled func() error + DestroyCalled func() error + GetAllCalled func(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error) + GetCalled func(unitType dataRetriever.UnitType, key []byte) ([]byte, error) + GetStorerCalled func(unitType dataRetriever.UnitType) storage.Storer + HasCalled func(unitType dataRetriever.UnitType, key []byte) error + PutCalled func(unitType dataRetriever.UnitType, key []byte, value []byte) error + 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) 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(_ uint32) + type CoordinatorStub struct + CommunicationIdentifierCalled func(destShardID uint32) string + ComputeIdCalled func(address []byte) uint32 + NumberOfShardsCalled func() uint32 + SameShardCalled func(firstAddress, secondAddress []byte) bool + SelfIdCalled func() uint32 + 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 DataTrieTrackerStub struct + ClearDataCachesCalled func() + DataTrieCalled func() data.Trie + DirtyDataCalled func() map[string][]byte + RetrieveValueCalled func(key []byte) ([]byte, error) + SaveKeyValueCalled func(key []byte, value []byte) error + SetDataTrieCalled func(tr data.Trie) + func (dtts *DataTrieTrackerStub) ClearDataCaches() + func (dtts *DataTrieTrackerStub) DataTrie() data.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 data.Trie) + type ESDTRoleHandlerStub struct + CheckAllowedToExecuteCalled func(account state.UserAccountHandler, tokenID []byte, action []byte) error + func (e *ESDTRoleHandlerStub) CheckAllowedToExecute(account state.UserAccountHandler, tokenID []byte, action []byte) error + func (e *ESDTRoleHandlerStub) IsInterfaceNil() bool + type EpochEconomicsStub struct + ComputeEndOfEpochEconomicsCalled func(metaBlock *block.MetaBlock) (*block.Economics, error) + VerifyRewardsPerBlockCalled func(metaBlock *block.MetaBlock, correctedProtocolSustainability *big.Int, ...) error + 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 struct + CheckEpochCalled func(epoch uint32) + CurrentEpochCalled func() uint32 + RegisterNotifyHandlerCalled func(handler core.EpochSubscriberHandler) + func (ens *EpochNotifierStub) CheckEpoch(epoch uint32) + func (ens *EpochNotifierStub) CurrentEpoch() uint32 + func (ens *EpochNotifierStub) IsInterfaceNil() bool + func (ens *EpochNotifierStub) RegisterNotifyHandler(handler core.EpochSubscriberHandler) + type EpochRewardsCreatorStub struct + CreateMarshalizedDataCalled func(body *block.Body) map[string][][]byte + CreateRewardsMiniBlocksCalled func(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) (block.MiniBlockSlice, error) + DeleteTxsFromStorageCalled func(metaBlock *block.MetaBlock, body *block.Body) + GetLocalTxCacheCalled func() epochStart.TransactionCacher + GetProtocolSustainCalled func() *big.Int + GetRewardsTxsCalled func(body *block.Body) map[string]data.TransactionHandler + RemoveBlockDataFromPoolsCalled func(metaBlock *block.MetaBlock, body *block.Body) + SaveTxBlockToStorageCalled func(metaBlock *block.MetaBlock, body *block.Body) + VerifyRewardsMiniBlocksCalled func(metaBlock *block.MetaBlock, validatorsInfo map[uint32][]*state.ValidatorInfo, ...) error + 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 struct + CreateEpochStartDataCalled func() (*block.EpochStart, error) + VerifyEpochStartDataForMetablockCalled func(metaBlock *block.MetaBlock) error + func (e *EpochStartDataCreatorStub) CreateEpochStartData() (*block.EpochStart, error) + func (e *EpochStartDataCreatorStub) IsInterfaceNil() bool + func (e *EpochStartDataCreatorStub) VerifyEpochStartDataForMetablock(metaBlock *block.MetaBlock) error + type EpochStartNotifierStub struct + NotifyAllCalled func(hdr data.HeaderHandler) + NotifyAllPrepareCalled func(hdr data.HeaderHandler, body data.BodyHandler) + RegisterHandlerCalled func(handler epochStart.ActionHandler) + UnregisterHandlerCalled func(handler epochStart.ActionHandler) + 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 struct + ProcessDelegationRewardsCalled func(miniBlocks block.MiniBlockSlice, txCache epochStart.TransactionCacher) error + ProcessSystemSmartContractCalled func(validatorInfos map[uint32][]*state.ValidatorInfo, nonce uint64, epoch uint32) error + ToggleUnStakeUnBondCalled func(value bool) error + 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 struct + EpochCalled func() uint32 + EpochFinalityAttestingRoundCalled func() uint64 + EpochStartMetaHdrHashCalled func() []byte + EpochStartRoundCalled func() uint64 + ForceEpochStartCalled func() error + IsEpochStartCalled func() bool + MetaEpochCalled func() uint32 + ProcessedCalled func(header data.HeaderHandler) + ReceivedHeaderCalled func(handler data.HeaderHandler) + UpdateCalled func(round uint64, nonce uint64) + 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 struct + CreateMarshalizedDataCalled func(body block.Body) map[string][][]byte + CreateValidatorInfoMiniBlocksCalled func(validatorsInfo map[uint32][]*state.ValidatorInfo) (block.MiniBlockSlice, error) + DeleteTxsFromStorageCalled func(metaBlock *block.MetaBlock) + RemoveBlockDataFromPoolsCalled func(metaBlock *block.MetaBlock, body *block.Body) + SaveTxBlockToStorageCalled func(metaBlock *block.MetaBlock, body *block.Body) + VerifyValidatorInfoMiniBlocksCalled func(miniblocks []*block.MiniBlock, ...) error + 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 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) + 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 struct + CheckValidityTxValuesCalled func(tx process.TransactionWithFeeHandler) error + ComputeFeeForProcessingCalled func(tx process.TransactionWithFeeHandler, gasToUse uint64) *big.Int + ComputeGasLimitCalled func(tx process.TransactionWithFeeHandler) uint64 + ComputeMoveBalanceFeeCalled func(tx process.TransactionWithFeeHandler) *big.Int + ComputeTxFeeCalled func(tx process.TransactionWithFeeHandler) *big.Int + DeveloperPercentageCalled func() float64 + GasPriceModifierCalled func() float64 + GenesisTotalSupplyCalled func() *big.Int + MaxGasLimitPerBlockCalled func() uint64 + MinGasPriceCalled func() uint64 + SetMaxGasLimitPerBlockCalled func(maxGasLimitPerBlock uint64) + SetMinGasLimitCalled func(minGasLimit uint64) + SetMinGasPriceCalled func(minGasPrice uint64) + func (fhs *FeeHandlerStub) CheckValidityTxValues(tx process.TransactionWithFeeHandler) error + func (fhs *FeeHandlerStub) ComputeFeeForProcessing(tx process.TransactionWithFeeHandler, gasToUse uint64) *big.Int + func (fhs *FeeHandlerStub) ComputeGasLimit(tx process.TransactionWithFeeHandler) uint64 + func (fhs *FeeHandlerStub) ComputeMoveBalanceFee(tx process.TransactionWithFeeHandler) *big.Int + func (fhs *FeeHandlerStub) ComputeTxFee(tx process.TransactionWithFeeHandler) *big.Int + func (fhs *FeeHandlerStub) DeveloperPercentage() float64 + func (fhs *FeeHandlerStub) GasPriceModifier() float64 + func (fhs *FeeHandlerStub) GenesisTotalSupply() *big.Int + func (fhs *FeeHandlerStub) IsInterfaceNil() bool + func (fhs *FeeHandlerStub) MaxGasLimitPerBlock(uint32) uint64 + func (fhs *FeeHandlerStub) MinGasPrice() uint64 + func (fhs *FeeHandlerStub) SetMaxGasLimitPerBlock(maxGasLimitPerBlock uint64) + func (fhs *FeeHandlerStub) SetMinGasLimit(minGasLimit uint64) + func (fhs *FeeHandlerStub) SetMinGasPrice(minGasPrice uint64) + type FloodPreventerStub struct + ApplyConsensusSizeCalled func(size int) + IncreaseLoadCalled func(pid core.PeerID, size uint64) error + ResetCalled func() + 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 struct + AddHeaderCalled func(header data.HeaderHandler, hash []byte, state process.BlockHeaderState, ...) error + CheckForkCalled func() *process.ForkInfo + GetHighestFinalBlockHashCalled func() []byte + GetHighestFinalBlockNonceCalled func() uint64 + GetNotarizedHeaderHashCalled func(nonce uint64) []byte + ProbableHighestNonceCalled func() uint64 + RemoveHeaderCalled func(nonce uint64, hash []byte) + ResetForkCalled func() + ResetProbableHighestNonceCalled func() + RestoreToGenesisCalled func() + SetFinalToLastCheckpointCalled func() + SetRollBackNonceCalled func(nonce uint64) + 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 struct + ComputeGasConsumedByMiniBlockCalled func(miniBlock *block.MiniBlock, mapHashTx map[string]data.TransactionHandler) (uint64, uint64, error) + ComputeGasConsumedByTxCalled func(txSenderShardId uint32, txReceiverSharedId uint32, ...) (uint64, uint64, error) + GasConsumedCalled func(hash []byte) uint64 + GasRefundedCalled func(hash []byte) uint64 + InitCalled func() + RemoveGasConsumedCalled func(hashes [][]byte) + RemoveGasRefundedCalled func(hashes [][]byte) + SetGasConsumedCalled func(gasConsumed uint64, hash []byte) + SetGasRefundedCalled func(gasRefunded uint64, hash []byte) + TotalGasConsumedCalled func() uint64 + TotalGasRefundedCalled func() uint64 + 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 struct + GasSchedule map[string]map[string]uint64 + RegisterNotifyHandlerCalled func(handler core.GasScheduleSubscribeHandler) + 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 struct + HeaderHandlerCalled func() data.HeaderHandler + func (ghhs *GetHdrHandlerStub) HeaderHandler() data.HeaderHandler + type HasherMock struct + func (HasherMock) Size() int + func (sha HasherMock) Compute(s string) []byte + func (sha HasherMock) EmptyHash() []byte + func (sha HasherMock) IsInterfaceNil() bool + type HasherStub struct + ComputeCalled func(s string) []byte + EmptyHashCalled func() []byte + func (hash *HasherStub) Compute(s string) []byte + func (hash *HasherStub) EmptyHash() []byte + func (hash *HasherStub) IsInterfaceNil() bool + func (hash *HasherStub) Size() int + type HeaderHandlerStub struct + CheckChainIDCalled func(reference []byte) error + CloneCalled func() data.HeaderHandler + GetAccumulatedFeesCalled func() *big.Int + GetChainIDCalled func() []byte + GetDeveloperFeesCalled func() *big.Int + GetMiniBlockHeadersWithDstCalled func(destId uint32) map[string]uint32 + GetOrderedCrossMiniblocksWithDstCalled func(destId uint32) []*data.MiniBlockInfo + GetPrevHashCalled func() []byte + GetPrevRandSeedCalled func() []byte + GetPubKeysBitmapCalled func() []byte + GetRandSeedCalled func() []byte + GetReservedCalled func() []byte + GetRootHashCalled func() []byte + GetSignatureCalled func() []byte + func (hhs *HeaderHandlerStub) Clone() data.HeaderHandler + func (hhs *HeaderHandlerStub) GetAccumulatedFees() *big.Int + func (hhs *HeaderHandlerStub) GetChainID() []byte + func (hhs *HeaderHandlerStub) GetDeveloperFees() *big.Int + func (hhs *HeaderHandlerStub) GetEpoch() uint32 + func (hhs *HeaderHandlerStub) GetEpochStartMetaHash() []byte + func (hhs *HeaderHandlerStub) GetLeaderSignature() []byte + func (hhs *HeaderHandlerStub) GetMiniBlockHeadersHashes() [][]byte + func (hhs *HeaderHandlerStub) GetMiniBlockHeadersWithDst(destId uint32) map[string]uint32 + func (hhs *HeaderHandlerStub) GetNonce() uint64 + func (hhs *HeaderHandlerStub) GetOrderedCrossMiniblocksWithDst(destId uint32) []*data.MiniBlockInfo + func (hhs *HeaderHandlerStub) GetPrevHash() []byte + func (hhs *HeaderHandlerStub) GetPrevRandSeed() []byte + func (hhs *HeaderHandlerStub) GetPubKeysBitmap() []byte + func (hhs *HeaderHandlerStub) GetRandSeed() []byte + func (hhs *HeaderHandlerStub) GetReceiptsHash() []byte + func (hhs *HeaderHandlerStub) GetReserved() []byte + func (hhs *HeaderHandlerStub) GetRootHash() []byte + func (hhs *HeaderHandlerStub) GetRound() uint64 + func (hhs *HeaderHandlerStub) GetShardID() uint32 + func (hhs *HeaderHandlerStub) GetSignature() []byte + func (hhs *HeaderHandlerStub) GetSoftwareVersion() []byte + func (hhs *HeaderHandlerStub) GetTimeStamp() uint64 + func (hhs *HeaderHandlerStub) GetTxCount() uint32 + func (hhs *HeaderHandlerStub) GetValidatorStatsRootHash() []byte + func (hhs *HeaderHandlerStub) IsInterfaceNil() bool + func (hhs *HeaderHandlerStub) IsStartOfEpochBlock() bool + func (hhs *HeaderHandlerStub) SetAccumulatedFees(_ *big.Int) + func (hhs *HeaderHandlerStub) SetChainID(_ []byte) + func (hhs *HeaderHandlerStub) SetDeveloperFees(_ *big.Int) + func (hhs *HeaderHandlerStub) SetEpoch(_ uint32) + func (hhs *HeaderHandlerStub) SetLeaderSignature(_ []byte) + func (hhs *HeaderHandlerStub) SetNonce(_ uint64) + func (hhs *HeaderHandlerStub) SetPrevHash(_ []byte) + func (hhs *HeaderHandlerStub) SetPrevRandSeed(_ []byte) + func (hhs *HeaderHandlerStub) SetPubKeysBitmap(_ []byte) + func (hhs *HeaderHandlerStub) SetRandSeed(_ []byte) + func (hhs *HeaderHandlerStub) SetRootHash(_ []byte) + func (hhs *HeaderHandlerStub) SetRound(_ uint64) + func (hhs *HeaderHandlerStub) SetShardID(_ uint32) + func (hhs *HeaderHandlerStub) SetSignature(_ []byte) + func (hhs *HeaderHandlerStub) SetSoftwareVersion(_ []byte) + func (hhs *HeaderHandlerStub) SetTimeStamp(_ uint64) + func (hhs *HeaderHandlerStub) SetTxCount(_ uint32) + func (hhs *HeaderHandlerStub) SetValidatorStatsRootHash(_ []byte) + type HeaderIntegrityVerifierStub struct + GetVersionCalled func(epoch uint32) string + VerifyCalled func(header data.HeaderHandler) error + func (h *HeaderIntegrityVerifierStub) GetVersion(epoch uint32) string + func (h *HeaderIntegrityVerifierStub) IsInterfaceNil() bool + func (h *HeaderIntegrityVerifierStub) Verify(header data.HeaderHandler) error + type HeaderResolverMock struct + ProcessReceivedMessageCalled func(message p2p.MessageP2P) error + RequestDataFromEpochCalled func(identifier []byte) error + RequestDataFromHashCalled func(hash []byte, epoch uint32) error + RequestDataFromNonceCalled func(nonce uint64, epoch uint32) error + SetEpochHandlerCalled func(epochHandler dataRetriever.EpochHandler) error + 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 struct + VerifyRandSeedAndLeaderSignatureCalled func(header data.HeaderHandler) error + VerifySignatureCalled func(header data.HeaderHandler) error + func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool + func (hsvm *HeaderSigVerifierStub) VerifyRandSeedAndLeaderSignature(header data.HeaderHandler) error + func (hsvm *HeaderSigVerifierStub) VerifySignature(header data.HeaderHandler) error + type HeaderValidatorStub struct + HeaderValidForProcessingCalled func(headerHandler process.HdrValidatorHandler) error + func (h *HeaderValidatorStub) HeaderValidForProcessing(headerHandler process.HdrValidatorHandler) error + func (h *HeaderValidatorStub) IsInterfaceNil() bool + type HeadersCacherStub struct + AddCalled func(headerHash []byte, header data.HeaderHandler) + ClearCalled func() + GetHeaderByHashCalled func(hash []byte) (data.HeaderHandler, error) + GetHeaderByNonceAndShardIdCalled func(hdrNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error) + GetNumHeadersCalled func(shardId uint32) int + LenCalled func() int + MaxSizeCalled func() int + NoncesCalled func(shardId uint32) []uint64 + RegisterHandlerCalled func(handler func(header data.HeaderHandler, shardHeaderHash []byte)) + RemoveHeaderByHashCalled func(headerHash []byte) + RemoveHeaderByNonceAndShardIdCalled func(hdrNonce uint64, shardId uint32) + 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 IndexerMock struct + SaveBlockCalled func(args *indexer.ArgsSaveBlockData) + func (im *IndexerMock) Close() error + func (im *IndexerMock) IsInterfaceNil() bool + func (im *IndexerMock) IsNilIndexer() bool + func (im *IndexerMock) RevertIndexedBlock(_ data.HeaderHandler, _ data.BodyHandler) + func (im *IndexerMock) SaveAccounts(_ uint64, _ []state.UserAccountHandler) + func (im *IndexerMock) SaveBlock(args *indexer.ArgsSaveBlockData) + func (im *IndexerMock) SaveMetaBlock(_ data.HeaderHandler, _ []uint64) + func (im *IndexerMock) SaveRoundsInfo(_ []*indexer.RoundInfo) + func (im *IndexerMock) SaveValidatorsPubKeys(_ map[uint32][][]byte, _ uint32) + func (im *IndexerMock) SaveValidatorsRating(_ string, _ []*indexer.ValidatorRatingInfo) + func (im *IndexerMock) SetTxLogsProcessor(_ process.TransactionLogProcessorDatabase) + func (im *IndexerMock) UpdateTPS(_ statistics.TPSBenchmark) + type InterceptedDataFactoryStub struct + CreateCalled func(buff []byte) (process.InterceptedData, error) + func (idfs *InterceptedDataFactoryStub) Create(buff []byte) (process.InterceptedData, error) + func (idfs *InterceptedDataFactoryStub) IsInterfaceNil() bool + type InterceptedDataStub struct + CheckValidityCalled func() error + HashCalled func() []byte + IdentifiersCalled func() [][]byte + IsForCurrentShardCalled func() bool + func (ids *InterceptedDataStub) CheckValidity() error + func (ids *InterceptedDataStub) Hash() []byte + func (ids *InterceptedDataStub) Identifiers() [][]byte + func (ids *InterceptedDataStub) IsForCurrentShard() bool + func (ids *InterceptedDataStub) IsInterfaceNil() bool + func (ids *InterceptedDataStub) String() string + func (ids *InterceptedDataStub) Type() string + type InterceptedDataVerifierMock struct + func (i *InterceptedDataVerifierMock) IsForCurrentShard(_ process.InterceptedData) bool + func (i *InterceptedDataVerifierMock) IsInterfaceNil() bool + type InterceptedDebugHandlerStub struct + LogProcessedHashesCalled func(topic string, hashes [][]byte, err error) + LogReceivedHashesCalled func(topic string, hashes [][]byte) + 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 struct + CheckValidityCalled func() error + HashField []byte + IdentifiersField [][]byte + IsForCurrentShardCalled func() bool + SizeInBytesCalled func() int + StringField string + TypeField string + 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 struct + FeeCalled func() *big.Int + NonceCalled func() uint64 + ReceiverShardIdCalled func() uint32 + SenderAddressCalled func() []byte + SenderShardIdCalled func() uint32 + TransactionCalled func() data.TransactionHandler + 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 struct + RegisterHandlerCalled func(handler func(topic string, hash []byte, data interface{})) + SaveCalled func(data process.InterceptedData) error + ValidateCalled func(data process.InterceptedData) error + 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 InterceptorStub struct + ProcessReceivedMessageCalled func(message p2p.MessageP2P) error + func (is *InterceptorStub) IsInterfaceNil() bool + func (is *InterceptorStub) ProcessReceivedMessage(message p2p.MessageP2P, _ core.PeerID) error + func (is *InterceptorStub) RegisterHandler(_ func(topic string, hash []byte, data interface{})) + func (is *InterceptorStub) SetInterceptedDebugHandler(_ process.InterceptedDebugger) error + type InterceptorThrottlerStub struct + CanProcessCalled func() bool + 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 struct + GetCalled func(key block.Type) (process.IntermediateTransactionHandler, error) + KeysCalled func() []block.Type + 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 IntermediateTransactionHandlerMock struct + AddIntermediateTransactionsCalled func(txs []data.TransactionHandler) error + CreateAllInterMiniBlocksCalled func() []*block.MiniBlock + CreateBlockStartedCalled func() + CreateMarshalizedDataCalled func(txHashes [][]byte) ([][]byte, error) + GetAllCurrentFinishedTxsCalled func() map[string]data.TransactionHandler + GetCreatedInShardMiniBlockCalled func() *block.MiniBlock + GetNumOfCrossInterMbsAndTxsCalled func() (int, int) + RemoveProcessedResultsForCalled func(txHashes [][]byte) + SaveCurrentIntermediateTxToStorageCalled func() error + VerifyInterMiniBlocksCalled func(body *block.Body) error + 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 MarshalizerMock struct + Fail bool + func (mm *MarshalizerMock) IsInterfaceNil() bool + func (mm *MarshalizerMock) Marshal(obj interface{}) ([]byte, error) + func (mm *MarshalizerMock) Unmarshal(obj interface{}, buff []byte) error + type MarshalizerStub struct + MarshalCalled func(obj interface{}) ([]byte, error) + UnmarshalCalled func(obj interface{}, buff []byte) error + func (ms *MarshalizerStub) IsInterfaceNil() bool + func (ms *MarshalizerStub) Marshal(obj interface{}) ([]byte, error) + func (ms *MarshalizerStub) Unmarshal(obj interface{}, buff []byte) error + type MessageHandlerStub struct + ConnectedPeersOnTopicCalled func(topic string) []core.PeerID + SendToConnectedPeerCalled func(topic string, buff []byte, peerID core.PeerID) error + 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 struct + func (m *MessageSignVerifierMock) IsInterfaceNil() bool + func (m *MessageSignVerifierMock) Verify(_ []byte, _ []byte, _ []byte) error + type MessengerStub struct + AddressesCalled func() []string + BootstrapCalled func() error + BroadcastCalled func(topic string, buff []byte) + BroadcastOnChannelCalled func(channel string, topic string, buff []byte) + CloseCalled func() error + ConnectToPeerCalled func(address string) error + ConnectedPeersCalled func() []core.PeerID + CreateTopicCalled func(name string, createChannelForTopic bool) error + HasTopicCalled func(name string) bool + HasTopicValidatorCalled func(name string) bool + IDCalled func() core.PeerID + IsConnectedCalled func(peerID core.PeerID) bool + OutgoingChannelLoadBalancerCalled func() p2p.ChannelLoadBalancer + PeersCalled func() []core.PeerID + RegisterMessageProcessorCalled func(topic string, handler p2p.MessageProcessor) error + SendToConnectedPeerCalled func(topic string, buff []byte, peerID core.PeerID) error + TrimConnectionsCalled func() + UnregisterMessageProcessorCalled func(topic string) error + 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) 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) UnregisterMessageProcessor(topic string) error + type MiniBlocksProviderStub struct + GetMiniBlocksCalled func(hashes [][]byte) ([]*process.MiniblockAndHash, [][]byte) + GetMiniBlocksFromPoolCalled func(hashes [][]byte) ([]*process.MiniblockAndHash, [][]byte) + func (mbps *MiniBlocksProviderStub) GetMiniBlocks(hashes [][]byte) ([]*process.MiniblockAndHash, [][]byte) + func (mbps *MiniBlocksProviderStub) GetMiniBlocksFromPool(hashes [][]byte) ([]*process.MiniblockAndHash, [][]byte) + func (mbps *MiniBlocksProviderStub) IsInterfaceNil() bool + type NetworkConnectionWatcherStub struct + IsConnectedToTheNetworkCalled func() bool + func (cws *NetworkConnectionWatcherStub) IsConnectedToTheNetwork() bool + func (cws *NetworkConnectionWatcherStub) IsInterfaceNil() bool + type NodeInfoMock struct + 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 struct + MinNumberOfNodesCalled func() uint32 + MinNumberOfNodesWithHysteresisCalled func() uint32 + func (n *NodesConfigProviderStub) IsInterfaceNil() bool + func (n *NodesConfigProviderStub) MinNumberOfNodes() uint32 + func (n *NodesConfigProviderStub) MinNumberOfNodesWithHysteresis() uint32 + type NodesCoordinatorMock struct + ComputeValidatorsGroupCalled func(randomness []byte, round uint64, shardId uint32, epoch uint32) (validatorsGroup []sharding.Validator, err error) + ConsensusGroupSizeCalled func(uint32) int + GetAllEligibleValidatorsPublicKeysCalled func() (map[uint32][][]byte, error) + GetAllLeavingValidatorsPublicKeysCalled func() (map[uint32][][]byte, error) + GetAllWaitingValidatorsPublicKeysCalled func() (map[uint32][][]byte, error) + GetSelectedPublicKeysCalled func(selection []byte, shardId uint32, epoch uint32) (publicKeys []string, err error) + GetValidatorWithPublicKeyCalled func(publicKey []byte) (validator sharding.Validator, shardId uint32, 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) + MetaConsensusSize uint32 + NbShards uint32 + SetNodesPerShardsCalled func(nodes map[uint32][]sharding.Validator, epoch uint32) error + ShardConsensusSize uint32 + ShardId uint32 + Validators map[uint32][]sharding.Validator + 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 struct + GetChainIdCalled func() string + GetMetaConsensusGroupSizeCalled func() uint32 + GetMinTransactionVersionCalled func() uint32 + GetRoundDurationCalled func() uint64 + GetShardConsensusGroupSizeCalled func() uint32 + GetStartTimeCalled func() int64 + InitialNodesInfoCalled func() (map[uint32][]sharding.GenesisNodeInfoHandler, ...) + InitialNodesInfoForShardCalled func(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error) + MinNumberOfNodesCalled func() uint32 + MinNumberOfNodesWithHysteresisCalled func() uint32 + NumberOfShardsCalled func() uint32 + func (n *NodesSetupStub) GetChainId() string + func (n *NodesSetupStub) GetMetaConsensusGroupSize() uint32 + func (n *NodesSetupStub) GetMinTransactionVersion() uint32 + func (n *NodesSetupStub) GetRoundDuration() uint64 + func (n *NodesSetupStub) GetShardConsensusGroupSize() uint32 + func (n *NodesSetupStub) GetStartTime() int64 + func (n *NodesSetupStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...) + func (n *NodesSetupStub) InitialNodesInfoForShard(shardId uint32) ([]sharding.GenesisNodeInfoHandler, []sharding.GenesisNodeInfoHandler, error) + func (n *NodesSetupStub) IsInterfaceNil() bool + func (n *NodesSetupStub) MinNumberOfNodes() uint32 + func (n *NodesSetupStub) MinNumberOfNodesWithHysteresis() uint32 + func (n *NodesSetupStub) NumberOfShards() uint32 + type ObjectsContainerStub struct + AddCalled func(key string, val interface{}) error + GetCalled func(key string) (interface{}, error) + LenCalled func() int + RemoveCalled func(key string) + ReplaceCalled func(key string, val interface{}) error + 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 struct + ApplyConsensusSizeCalled func(size int) + BlacklistPeerCalled func(peer core.PeerID, reason string, duration time.Duration) + CanProcessMessageCalled func(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error + CanProcessMessagesOnTopicCalled func(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, ...) error + IsOriginatorEligibleForTopicCalled func(pid core.PeerID, topic string) error + SetDebuggerCalled func(debugger process.AntifloodDebugger) error + func (p2pahs *P2PAntifloodHandlerStub) ApplyConsensusSize(size int) + func (p2pahs *P2PAntifloodHandlerStub) BlacklistPeer(peer core.PeerID, reason string, duration time.Duration) + func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error + func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessagesOnTopic(peer core.PeerID, topic string, numMessages uint32, totalSize uint64, ...) error + func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool + func (p2pahs *P2PAntifloodHandlerStub) IsOriginatorEligibleForTopic(pid core.PeerID, topic string) error + func (p2pahs *P2PAntifloodHandlerStub) SetDebugger(debugger process.AntifloodDebugger) error + type P2PMessageMock struct + DataField []byte + FromField []byte + KeyField []byte + PayloadField []byte + PeerField core.PeerID + SeqNoField []byte + SignatureField []byte + TimestampField int64 + TopicField string + 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 struct + IsPausedCalled func(token []byte) bool + func (p *PauseHandlerStub) IsInterfaceNil() bool + func (p *PauseHandlerStub) IsPaused(token []byte) bool + type PayableHandlerStub struct + IsPayableCalled func(address []byte) (bool, error) + func (p *PayableHandlerStub) IsInterfaceNil() bool + func (p *PayableHandlerStub) IsPayable(address []byte) (bool, error) + type PeerAccountHandlerMock struct + DecreaseLeaderSuccessRateCalled func(uint32) + DecreaseLeaderSuccessRateValue uint32 + DecreaseValidatorSuccessRateCalled func(uint32) + DecreaseValidatorSuccessRateValue uint32 + GetAccumulatedFeesCalled func() *big.Int + GetConsecutiveProposerMissesCalled func() uint32 + GetListCalled func() string + GetTempRatingCalled func() uint32 + GetUnStakedEpochCalled func() uint32 + IncreaseLeaderSuccessRateCalled func(uint32) + IncreaseLeaderSuccessRateValue uint32 + IncreaseValidatorIgnoredSignaturesRateCalled func(uint32) + IncreaseValidatorIgnoredSignaturesValue uint32 + IncreaseValidatorSuccessRateCalled func(uint32) + IncreaseValidatorSuccessRateValue uint32 + SetAccumulatedFeesCalled func(*big.Int) + SetConsecutiveProposerMissesCalled func(rating uint32) + SetListAndIndexCalled func(shardID uint32, list string, index uint32) + SetTempRatingCalled func(uint32) + func (p *PeerAccountHandlerMock) AddToAccumulatedFees(val *big.Int) + func (p *PeerAccountHandlerMock) AddressBytes() []byte + func (p *PeerAccountHandlerMock) DataTrie() data.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(_ data.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 struct + HasCalled func(pid core.PeerID) bool + SweepCalled func() + UpsertCalled func(pid core.PeerID, span time.Duration) error + 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 struct + PeerChangesCalled func() []block.PeerData + VerifyPeerChangesCalled func(peerChanges []block.PeerData) error + func (p *PeerChangesHandler) IsInterfaceNil() bool + func (p *PeerChangesHandler) PeerChanges() []block.PeerData + func (p *PeerChangesHandler) VerifyPeerChanges(peerChanges []block.PeerData) error + type PeerShardMapperStub struct + GetPeerInfoCalled func(pid core.PeerID) core.P2PPeerInfo + func (psms *PeerShardMapperStub) GetPeerInfo(pid core.PeerID) core.P2PPeerInfo + func (psms *PeerShardMapperStub) IsInterfaceNil() bool + type PeerShardResolverStub struct + GetPeerInfoCalled func(pid core.PeerID) core.P2PPeerInfo + func (psrs *PeerShardResolverStub) GetPeerInfo(pid core.PeerID) core.P2PPeerInfo + func (psrs *PeerShardResolverStub) IsInterfaceNil() bool + type PendingMiniBlocksHandlerStub struct + AddProcessedHeaderCalled func(handler data.HeaderHandler) error + GetPendingMiniBlocksCalled func(shardID uint32) [][]byte + RevertHeaderCalled func(handler data.HeaderHandler) error + SetPendingMiniBlocksCalled func(shardID uint32, mbHashes [][]byte) + 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 struct + GetCalled func(key block.Type) (process.PreProcessor, error) + KeysCalled func() []block.Type + 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 struct + CreateAndProcessMiniBlocksCalled func(haveTime func() bool) (block.MiniBlockSlice, error) + CreateBlockStartedCalled func() + CreateMarshalizedDataCalled func(txHashes [][]byte) ([][]byte, error) + GetAllCurrentUsedTxsCalled func() map[string]data.TransactionHandler + IsDataPreparedCalled func(requestedTxs int, haveTime func() time.Duration) error + ProcessBlockTransactionsCalled func(body *block.Body, haveTime func() bool) error + ProcessMiniBlockCalled func(miniBlock *block.MiniBlock, haveTime func() bool, ...) ([][]byte, int, error) + RemoveBlockDataFromPoolsCalled func(body *block.Body, miniBlockPool storage.Cacher) error + RemoveTxsFromPoolsCalled func(body *block.Body) error + RequestBlockTransactionsCalled func(body *block.Body) int + RequestTransactionsForMiniBlockCalled func(miniBlock *block.MiniBlock) int + RestoreBlockDataIntoPoolsCalled func(body *block.Body, miniBlockPool storage.Cacher) (int, error) + SaveTxsToStorageCalled func(body *block.Body) error + 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 struct + func (x *ProtobufMarshalizerMock) IsInterfaceNil() bool + func (x *ProtobufMarshalizerMock) Marshal(obj interface{}) ([]byte, error) + func (x *ProtobufMarshalizerMock) Unmarshal(obj interface{}, buff []byte) error + type PubkeyConverterMock struct + 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 struct + DecodeCalled func(humanReadable string) ([]byte, error) + EncodeCalled func(pkBytes []byte) string + LenCalled func() int + 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 struct + AddQuotaCalled func(pid core.PeerID, numReceivedMessages uint32, sizeReceivedMessages uint64, ...) + ResetStatisticsCalled func() + func (qshs *QuotaStatusHandlerStub) AddQuota(pid core.PeerID, numReceived uint32, sizeReceived uint64, numProcessed uint32, ...) + func (qshs *QuotaStatusHandlerStub) IsInterfaceNil() bool + func (qshs *QuotaStatusHandlerStub) ResetStatistics() + type RaterMock struct + Chance uint32 + ComputeDecreaseProposerCalled func(shardId uint32, rating uint32, consecutiveMissedBlocks uint32) uint32 + ComputeDecreaseValidatorCalled func(shardId uint32, rating uint32) uint32 + ComputeIncreaseProposerCalled func(shardId uint32, rating uint32) uint32 + ComputeIncreaseValidatorCalled func(shardId uint32, rating uint32) uint32 + DecreaseProposer int32 + DecreaseValidator int32 + GetChancesCalled func(val uint32) uint32 + GetRatingCalled func(string) uint32 + GetSignedBlocksThresholdCalled func() float32 + GetStartRatingCalled func() uint32 + IncreaseProposer int32 + IncreaseValidator int32 + MaxRating uint32 + MetaDecreaseProposer int32 + MetaDecreaseValidator int32 + MetaIncreaseProposer int32 + MetaIncreaseValidator int32 + MinRating uint32 + RevertIncreaseProposerCalled func(shardId uint32, rating uint32, nrReverts uint32) uint32 + StartRating uint32 + 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 struct + GetRatingCalled func(string) uint32 + RatingsMap map[string]uint32 + func (rrm *RatingReaderMock) GetRating(pk string) uint32 + func (rrm *RatingReaderMock) IsInterfaceNil() bool + type RatingStepMock struct + ConsecutiveMissedBlocksPenaltyProperty float32 + ProposerDecreaseRatingStepProperty int32 + ProposerIncreaseRatingStepProperty int32 + ValidatorDecreaseRatingStepProperty int32 + ValidatorIncreaseRatingStepProperty int32 + 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 struct + MaxRatingProperty uint32 + MetaRatingsStepDataProperty process.RatingsStepHandler + MinRatingProperty uint32 + SelectionChancesProperty []process.SelectionChance + ShardRatingsStepDataProperty process.RatingsStepHandler + SignedBlocksThresholdProperty float32 + StartRatingProperty uint32 + 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 RequestHandlerStub struct + GetNumPeersToQueryCalled func(key string) (int, int, error) + RequestMetaHeaderByNonceCalled func(nonce uint64) + RequestMetaHeaderCalled func(hash []byte) + RequestMiniBlockHandlerCalled func(destShardID uint32, miniblockHash []byte) + RequestMiniBlocksHandlerCalled func(destShardID uint32, miniblocksHashes [][]byte) + RequestRewardTxHandlerCalled func(destShardID uint32, txHashes [][]byte) + RequestScrHandlerCalled func(destShardID uint32, txHashes [][]byte) + RequestShardHeaderByNonceCalled func(shardID uint32, nonce uint64) + RequestShardHeaderCalled func(shardID uint32, hash []byte) + RequestStartOfEpochMetaBlockCalled func(epoch uint32) + RequestTransactionHandlerCalled func(destShardID uint32, txHashes [][]byte) + RequestTrieNodesCalled func(destShardID uint32, hashes [][]byte, topic string) + SetNumPeersToQueryCalled func(key string, intra int, cross int) error + func (rhs *RequestHandlerStub) GetNumPeersToQuery(key string) (int, int, error) + func (rhs *RequestHandlerStub) IsInterfaceNil() bool + func (rhs *RequestHandlerStub) RequestInterval() time.Duration + func (rhs *RequestHandlerStub) RequestMetaHeader(hash []byte) + func (rhs *RequestHandlerStub) RequestMetaHeaderByNonce(nonce uint64) + func (rhs *RequestHandlerStub) RequestMiniBlock(destShardID uint32, miniblockHash []byte) + func (rhs *RequestHandlerStub) RequestMiniBlocks(destShardID uint32, miniblocksHashes [][]byte) + func (rhs *RequestHandlerStub) RequestRewardTransactions(destShardID uint32, txHashes [][]byte) + func (rhs *RequestHandlerStub) RequestShardHeader(shardID uint32, hash []byte) + func (rhs *RequestHandlerStub) RequestShardHeaderByNonce(shardID uint32, nonce uint64) + func (rhs *RequestHandlerStub) RequestStartOfEpochMetaBlock(epoch uint32) + func (rhs *RequestHandlerStub) RequestTransaction(destShardID uint32, txHashes [][]byte) + func (rhs *RequestHandlerStub) RequestTrieNodes(destShardID uint32, hashes [][]byte, topic string) + func (rhs *RequestHandlerStub) RequestUnsignedTransactions(destShardID uint32, txHashes [][]byte) + func (rhs *RequestHandlerStub) SetEpoch(_ uint32) + func (rhs *RequestHandlerStub) SetNumPeersToQuery(key string, intra int, cross int) error + type RequestedItemsHandlerStub struct + AddCalled func(key string) error + HasCalled func(key string) bool + SweepCalled func() + 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 struct + ProcessReceivedMessageCalled func(message p2p.MessageP2P) error + RequestDataFromHashCalled func(hash []byte, epoch uint32) error + 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 struct + AddCalled func(key string, val dataRetriever.Resolver) error + GetCalled func(key string) (dataRetriever.Resolver, error) + LenCalled func() int + RemoveCalled func(key string) + ReplaceCalled func(key string, val dataRetriever.Resolver) error + 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 struct + CrossShardResolverCalled func(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error) + IntraShardResolverCalled func(baseTopic string) (dataRetriever.Resolver, error) + MetaChainResolverCalled func(baseTopic string) (dataRetriever.Resolver, error) + 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 RewardTxProcessorMock struct + ProcessRewardTransactionCalled func(rTx *rewardTx.RewardTx) error + func (scrp *RewardTxProcessorMock) IsInterfaceNil() bool + func (scrp *RewardTxProcessorMock) ProcessRewardTransaction(rTx *rewardTx.RewardTx) error + type RewardsHandlerMock struct + LeaderPercentageCalled func() float64 + MaxInflationRateCalled func() float64 + MinInflationRateCalled func() float64 + ProtocolSustainabilityAddressCalled func() string + ProtocolSustainabilityPercentageCalled func() float64 + RewardsTopUpFactorCalled func() float64 + RewardsTopUpGradientPointCalled func() *big.Int + 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 RoundStub struct + IndexCalled func() int64 + RemainingTimeCalled func(time.Time, time.Duration) time.Duration + TimeDurationCalled func() time.Duration + TimeStampCalled func() time.Time + UpdateRoundCalled func(time.Time, time.Time) + 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 RounderMock struct + BeforeGenesisCalled func() bool + RoundIndex int64 + RoundTimeDuration time.Duration + RoundTimeStamp time.Time + func (rndm *RounderMock) BeforeGenesis() bool + func (rndm *RounderMock) Index() int64 + func (rndm *RounderMock) IsInterfaceNil() bool + func (rndm *RounderMock) RemainingTime(_ time.Time, _ time.Duration) time.Duration + func (rndm *RounderMock) TimeDuration() time.Duration + func (rndm *RounderMock) TimeStamp() time.Time + func (rndm *RounderMock) UpdateRound(genesisRoundTimeStamp time.Time, timeStamp time.Time) + type SCProcessorMock struct + ComputeTransactionTypeCalled func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + DeploySmartContractCalled func(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error) + ExecuteBuiltInFunctionCalled func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + ExecuteSmartContractTransactionCalled func(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + IsPayableCalled func(address []byte) (bool, error) + ProcessIfErrorCalled func(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, ...) error + ProcessSmartContractResultCalled func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + func (sc *SCProcessorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + func (sc *SCProcessorMock) DeploySmartContract(tx data.TransactionHandler, acntSrc state.UserAccountHandler) (vmcommon.ReturnCode, error) + func (sc *SCProcessorMock) ExecuteBuiltInFunction(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + func (sc *SCProcessorMock) ExecuteSmartContractTransaction(tx data.TransactionHandler, acntSrc, acntDst state.UserAccountHandler) (vmcommon.ReturnCode, error) + func (sc *SCProcessorMock) IsInterfaceNil() bool + func (sc *SCProcessorMock) IsPayable(address []byte) (bool, error) + func (sc *SCProcessorMock) ProcessIfError(acntSnd state.UserAccountHandler, txHash []byte, tx data.TransactionHandler, ...) error + func (sc *SCProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + type SCToProtocolStub struct + UpdateProtocolCalled func(body *block.Body, nonce uint64) error + func (s *SCToProtocolStub) IsInterfaceNil() bool + func (s *SCToProtocolStub) UpdateProtocol(body *block.Body, nonce uint64) error + type ScQueryStub struct + ComputeScCallGasLimitHandler func(tx *transaction.Transaction) (uint64, error) + ExecuteQueryCalled func(query *process.SCQuery) (*vmcommon.VMOutput, 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 struct + CommunicationIdentifierCalled func(destShardID uint32) string + ComputeIdCalled func(address []byte) uint32 + NumberOfShardsCalled func() uint32 + SameShardCalled func(firstAddress, secondAddress []byte) bool + SelfIdCalled func() uint32 + 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 struct + DeleteCalled func(shardId uint32) + LoadCalled func(shardId uint32) ([]byte, bool) + RangeCalled func(f func(shardId uint32, hash []byte) bool) + StoreCalled func(shardId uint32, hash []byte) + 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 struct + SignStub func(private crypto.PrivateKey, msg []byte) ([]byte, error) + VerifyStub func(public crypto.PublicKey, msg []byte, sig []byte) error + 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 struct + PublicKeyFromByteArrayCalled func(b []byte) (crypto.PublicKey, error) + SuiteCalled func() crypto.Suite + 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 struct + PointCalled func() crypto.Point + SuiteCalled func() crypto.Suite + func (sspk *SingleSignPublicKey) IsInterfaceNil() bool + func (sspk *SingleSignPublicKey) Point() crypto.Point + func (sspk *SingleSignPublicKey) Suite() crypto.Suite + func (sspk *SingleSignPublicKey) ToByteArray() ([]byte, error) + type SmartContractResultsProcessorMock struct + ProcessSmartContractResultCalled func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + func (scrp *SmartContractResultsProcessorMock) IsInterfaceNil() bool + func (scrp *SmartContractResultsProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + type StorageBootstrapperMock struct + LoadFromStorageCalled func() error + func (sbm *StorageBootstrapperMock) GetHighestBlockNonce() uint64 + func (sbm *StorageBootstrapperMock) IsInterfaceNil() bool + func (sbm *StorageBootstrapperMock) LoadFromStorage() error + type StorerMock struct + func NewStorerMock() *StorerMock + func (sm *StorerMock) ClearCache() + func (sm *StorerMock) Close() error + func (sm *StorerMock) DestroyUnit() error + func (sm *StorerMock) Get(key []byte) ([]byte, error) + func (sm *StorerMock) GetBulkFromEpoch(keys [][]byte, _ uint32) (map[string][]byte, error) + func (sm *StorerMock) GetFromEpoch(key []byte, _ uint32) ([]byte, error) + func (sm *StorerMock) Has(_ []byte) error + func (sm *StorerMock) HasInEpoch(_ []byte, _ uint32) error + func (sm *StorerMock) IsInterfaceNil() bool + func (sm *StorerMock) Put(key, data []byte) error + func (sm *StorerMock) PutInEpoch(key, data []byte, _ uint32) error + func (sm *StorerMock) RangeKeys(_ func(key []byte, val []byte) bool) + func (sm *StorerMock) Remove(key []byte) error + func (sm *StorerMock) SearchFirst(_ []byte) ([]byte, error) + type StorerStub struct + ClearCacheCalled func() + DestroyUnitCalled func() error + GetBulkFromEpochCalled func(keys [][]byte, epoch uint32) (map[string][]byte, error) + GetCalled func(key []byte) ([]byte, error) + GetFromEpochCalled func(key []byte, epoch uint32) ([]byte, error) + HasCalled func(key []byte) error + HasInEpochCalled func(key []byte, epoch uint32) error + PutCalled func(key, data []byte) error + PutInEpochCalled func(key, data []byte, epoch uint32) error + RangeKeysCalled func(handler func(key []byte, val []byte) bool) + RemoveCalled func(key []byte) error + SearchFirstCalled func(key []byte) ([]byte, error) + func (ss *StorerStub) ClearCache() + func (ss *StorerStub) Close() error + func (ss *StorerStub) DestroyUnit() error + func (ss *StorerStub) Get(key []byte) ([]byte, error) + func (ss *StorerStub) GetBulkFromEpoch(keys [][]byte, epoch uint32) (map[string][]byte, error) + func (ss *StorerStub) GetFromEpoch(key []byte, epoch uint32) ([]byte, error) + func (ss *StorerStub) Has(key []byte) error + func (ss *StorerStub) HasInEpoch(key []byte, epoch uint32) error + func (ss *StorerStub) IsInterfaceNil() bool + func (ss *StorerStub) Put(key, data []byte) error + func (ss *StorerStub) PutInEpoch(key, data []byte, epoch uint32) error + func (ss *StorerStub) RangeKeys(handler func(key []byte, val []byte) bool) + func (ss *StorerStub) Remove(key []byte) error + func (ss *StorerStub) SearchFirst(key []byte) ([]byte, error) + type SyncStarterStub struct + SyncBlockCalled func() error + func (sss *SyncStarterStub) SyncBlock() error + type SyncTimerMock struct + ClockOffsetCalled func() time.Duration + CurrentTimeCalled func() time.Time + func (stm *SyncTimerMock) Close() error + func (stm *SyncTimerMock) IsInterfaceNil() bool + func (stm SyncTimerMock) ClockOffset() time.Duration + func (stm SyncTimerMock) CurrentTime() time.Time + func (stm SyncTimerMock) FormattedCurrentTime() string + func (stm SyncTimerMock) StartSyncingTime() + type TimeCacheStub struct + AddCalled func(key string) error + HasCalled func(key string) bool + LenCalled func() int + SweepCalled func() + UpsertCalled func(key string, span time.Duration) error + 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 struct + IncreaseLoadCalled func(pid core.PeerID, topic string, numMessages uint32) error + ResetForTopicCalled func(topic string) + SetMaxMessagesForTopicCalled func(topic string, num uint32) + 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 struct + CreateTopicCalled func(name string, createChannelForTopic bool) error + HasTopicCalled func(name string) bool + IDCalled func() core.PeerID + RegisterMessageProcessorCalled func(topic string, handler p2p.MessageProcessor) error + 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, handler p2p.MessageProcessor) error + type TransactionCoordinatorMock struct + ComputeTransactionTypeCalled func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + CreateBlockStartedCalled func() + CreateMarshalizedDataCalled func(body *block.Body) map[string][][]byte + CreateMarshalizedReceiptsCalled func() ([]byte, error) + CreateMbsAndProcessCrossShardTransactionsDstMeCalled func(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, ...) (block.MiniBlockSlice, uint32, bool, error) + CreateMbsAndProcessTransactionsFromMeCalled func(haveTime func() bool) block.MiniBlockSlice + CreatePostProcessMiniBlocksCalled func() block.MiniBlockSlice + GetAllCurrentUsedTxsCalled func(blockType block.Type) map[string]data.TransactionHandler + IsDataPreparedForProcessingCalled func(haveTime func() time.Duration) error + ProcessBlockTransactionCalled func(body *block.Body, haveTime func() time.Duration) error + RemoveBlockDataFromPoolCalled func(body *block.Body) error + RemoveTxsFromPoolCalled func(body *block.Body) error + RequestBlockTransactionsCalled func(body *block.Body) + RequestMiniBlocksCalled func(header data.HeaderHandler) + RestoreBlockDataFromStorageCalled func(body *block.Body) (int, error) + SaveTxsToStorageCalled func(body *block.Body) error + VerifyCreatedBlockTransactionsCalled func(hdr data.HeaderHandler, body *block.Body) error + VerifyCreatedMiniBlocksCalled func(hdr data.HeaderHandler, body *block.Body) error + func (tcm *TransactionCoordinatorMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + func (tcm *TransactionCoordinatorMock) CreateBlockStarted() + func (tcm *TransactionCoordinatorMock) CreateMarshalizedData(body *block.Body) map[string][][]byte + func (tcm *TransactionCoordinatorMock) CreateMarshalizedReceipts() ([]byte, error) + func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessCrossShardTransactionsDstMe(header data.HeaderHandler, processedMiniBlocksHashes map[string]struct{}, ...) (block.MiniBlockSlice, uint32, bool, error) + func (tcm *TransactionCoordinatorMock) CreateMbsAndProcessTransactionsFromMe(haveTime func() bool) block.MiniBlockSlice + func (tcm *TransactionCoordinatorMock) CreatePostProcessMiniBlocks() block.MiniBlockSlice + func (tcm *TransactionCoordinatorMock) CreateReceiptsHash() ([]byte, error) + func (tcm *TransactionCoordinatorMock) GetAllCurrentUsedTxs(blockType block.Type) map[string]data.TransactionHandler + func (tcm *TransactionCoordinatorMock) IsDataPreparedForProcessing(haveTime func() time.Duration) error + func (tcm *TransactionCoordinatorMock) IsInterfaceNil() bool + func (tcm *TransactionCoordinatorMock) ProcessBlockTransaction(body *block.Body, haveTime func() time.Duration) error + func (tcm *TransactionCoordinatorMock) RemoveBlockDataFromPool(body *block.Body) error + func (tcm *TransactionCoordinatorMock) RemoveTxsFromPool(body *block.Body) error + func (tcm *TransactionCoordinatorMock) RequestBlockTransactions(body *block.Body) + func (tcm *TransactionCoordinatorMock) RequestMiniBlocks(header data.HeaderHandler) + func (tcm *TransactionCoordinatorMock) RestoreBlockDataFromStorage(body *block.Body) (int, error) + func (tcm *TransactionCoordinatorMock) SaveTxsToStorage(body *block.Body) error + func (tcm *TransactionCoordinatorMock) VerifyCreatedBlockTransactions(hdr data.HeaderHandler, body *block.Body) error + func (tcm *TransactionCoordinatorMock) VerifyCreatedMiniBlocks(hdr data.HeaderHandler, body *block.Body) error + type TransactionInterceptorMock struct + IsAddressedToOtherShardsVal bool + IsChecked bool + IsVerified bool + RcvShardVal uint32 + SndShardVal uint32 + Tx *transaction.Transaction + 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 struct + MiniPoolTxStoreCalled func(shardID uint32) (c storage.Cacher) + RegisterTransactionHandlerCalled func(transactionHandler func(txHash []byte)) + RemoveTransactionsFromPoolCalled func(txHashes [][]byte, destShardID uint32) + 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 TrieStub struct + AppendToOldHashesCalled func([][]byte) + CommitCalled func() error + DeleteCalled func(key []byte) error + GetAllHashesCalled func() ([][]byte, error) + GetAllLeavesOnChannelCalled func(rootHash []byte) (chan core.KeyValueHolder, error) + GetCalled func(key []byte) ([]byte, error) + GetNumNodesCalled func() data.NumNodesDTO + GetProofCalled func(key []byte) ([][]byte, error) + GetSerializedNodeCalled func(bytes []byte) ([]byte, error) + GetSerializedNodesCalled func([]byte, uint64) ([][]byte, uint64, error) + GetStorageManagerCalled func() data.StorageManager + RecreateCalled func(root []byte) (data.Trie, error) + ResetOldHashesCalled func() [][]byte + RootCalled func() ([]byte, error) + UpdateCalled func(key, value []byte) error + VerifyProofCalled func(key []byte, proof [][]byte) (bool, error) + func (ts *TrieStub) AppendToOldHashes(hashes [][]byte) + func (ts *TrieStub) ClosePersister() error + func (ts *TrieStub) Commit() error + func (ts *TrieStub) Delete(key []byte) error + func (ts *TrieStub) Get(key []byte) ([]byte, error) + func (ts *TrieStub) GetAllHashes() ([][]byte, error) + func (ts *TrieStub) GetAllLeavesOnChannel(rootHash []byte, _ context.Context) (chan core.KeyValueHolder, error) + func (ts *TrieStub) GetDirtyHashes() (data.ModifiedHashes, error) + func (ts *TrieStub) GetNumNodes() data.NumNodesDTO + func (ts *TrieStub) GetProof(key []byte) ([][]byte, error) + func (ts *TrieStub) GetSerializedNode(bytes []byte) ([]byte, error) + func (ts *TrieStub) GetSerializedNodes(hash []byte, maxBuffToSend uint64) ([][]byte, uint64, error) + func (ts *TrieStub) GetStorageManager() data.StorageManager + func (ts *TrieStub) IsInterfaceNil() bool + func (ts *TrieStub) Recreate(root []byte) (data.Trie, error) + func (ts *TrieStub) ResetOldHashes() [][]byte + func (ts *TrieStub) RootHash() ([]byte, error) + func (ts *TrieStub) SetNewHashes(_ data.ModifiedHashes) + func (ts *TrieStub) String() string + func (ts *TrieStub) Update(key, value []byte) error + func (ts *TrieStub) VerifyProof(key []byte, proof [][]byte) (bool, error) + type TxForCurrentBlockStub struct + AddTxCalled func(txHash []byte, tx data.TransactionHandler) + CleanCalled func() + GetTxCalled func(txHash []byte) (data.TransactionHandler, error) + 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 struct + GetLogCalled func(txHash []byte) (data.LogHandler, error) + SaveLogCalled func(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error + func (txls *TxLogsProcessorStub) GetLog(txHash []byte) (data.LogHandler, error) + func (txls *TxLogsProcessorStub) IsInterfaceNil() bool + func (txls *TxLogsProcessorStub) SaveLog(txHash []byte, tx data.TransactionHandler, vmLogs []*vmcommon.LogEntry) error + type TxProcessorMock struct + ProcessSmartContractResultCalled func(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + ProcessTransactionCalled func(transaction *transaction.Transaction) (vmcommon.ReturnCode, error) + SetBalancesToTrieCalled func(accBalance map[string]*big.Int) (rootHash []byte, err error) + func (tp *TxProcessorMock) IsInterfaceNil() bool + func (tp *TxProcessorMock) ProcessSmartContractResult(scr *smartContractResult.SmartContractResult) (vmcommon.ReturnCode, error) + func (tp *TxProcessorMock) ProcessTransaction(transaction *transaction.Transaction) (vmcommon.ReturnCode, error) + func (tp *TxProcessorMock) SetBalancesToTrie(accBalance map[string]*big.Int) (rootHash []byte, err error) + type TxTypeHandlerMock struct + ComputeTransactionTypeCalled func(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + func (th *TxTypeHandlerMock) ComputeTransactionType(tx data.TransactionHandler) (process.TransactionType, process.TransactionType) + func (th *TxTypeHandlerMock) IsInterfaceNil() bool + type TxValidatorHandlerStub struct + FeeCalled func() *big.Int + NonceCalled func() uint64 + ReceiverShardIdCalled func() uint32 + SenderAddressCalled func() []byte + SenderShardIdCalled func() uint32 + 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 struct + CheckTxValidityCalled func(txValidatorHandler process.TxValidatorHandler) error + CheckTxWhiteListCalled func(data process.InterceptedData) error + RejectedTxsCalled func() uint64 + func (t *TxValidatorStub) CheckTxValidity(txValidatorHandler process.TxValidatorHandler) error + func (t *TxValidatorStub) CheckTxWhiteList(data process.InterceptedData) error + func (t *TxValidatorStub) IsInterfaceNil() bool + type Uint64ByteSliceConverterMock struct + ToByteSliceCalled func(uint64) []byte + ToUint64Called func([]byte) (uint64, error) + func (u *Uint64ByteSliceConverterMock) IsInterfaceNil() bool + func (u *Uint64ByteSliceConverterMock) ToByteSlice(p uint64) []byte + func (u *Uint64ByteSliceConverterMock) ToUint64(p []byte) (uint64, error) + type Uint64SyncMapCacherStub struct + ClearCalled func() + GetCalled func(nonce uint64) (dataRetriever.ShardIdHashMap, bool) + HasCalled func(nonce uint64, shardId uint32) bool + MergeCalled func(nonce uint64, src dataRetriever.ShardIdHashMap) + RegisterHandlerCalled func(handler func(nonce uint64, shardId uint32, value []byte)) + RemoveCalled func(nonce uint64, shardId uint32) + UnRegisterHandlerCalled func(func(key []byte, value interface{})) + 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 UnsignedTxHandlerMock struct + AddTxFeeFromBlockCalled func(tx data.TransactionHandler) + CleanProcessedUtxsCalled func() + CreateAllUTxsCalled func() []data.TransactionHandler + ProcessTransactionFeeCalled func(cost *big.Int, hash []byte) + VerifyCreatedUTxsCalled func() error + func (ut *UnsignedTxHandlerMock) AddRewardTxFromBlock(tx data.TransactionHandler) + func (ut *UnsignedTxHandlerMock) CleanProcessedUTxs() + func (ut *UnsignedTxHandlerMock) CreateAllUTxs() []data.TransactionHandler + func (ut *UnsignedTxHandlerMock) IsInterfaceNil() bool + func (ut *UnsignedTxHandlerMock) ProcessTransactionFee(cost *big.Int, hash []byte) + func (ut *UnsignedTxHandlerMock) VerifyCreatedUTxs() error + type UserAccountStub struct + AddToBalanceCalled func(value *big.Int) error + DataTrieTrackerCalled func() state.DataTrieTracker + func (u *UserAccountStub) AddToBalance(value *big.Int) error + func (u *UserAccountStub) AddToDeveloperReward(*big.Int) + func (u *UserAccountStub) AddressBytes() []byte + func (u *UserAccountStub) ChangeOwnerAddress([]byte, []byte) error + func (u *UserAccountStub) ClaimDeveloperRewards([]byte) (*big.Int, error) + func (u *UserAccountStub) DataTrie() data.Trie + func (u *UserAccountStub) DataTrieTracker() state.DataTrieTracker + func (u *UserAccountStub) GetBalance() *big.Int + func (u *UserAccountStub) GetCodeHash() []byte + func (u *UserAccountStub) GetCodeMetadata() []byte + func (u *UserAccountStub) GetDeveloperReward() *big.Int + func (u *UserAccountStub) GetNonce() uint64 + func (u *UserAccountStub) GetOwnerAddress() []byte + func (u *UserAccountStub) GetRootHash() []byte + func (u *UserAccountStub) GetUserName() []byte + func (u *UserAccountStub) HasNewCode() bool + func (u *UserAccountStub) IncreaseNonce(_ uint64) + func (u *UserAccountStub) IsInterfaceNil() bool + func (u *UserAccountStub) SetCode(_ []byte) + func (u *UserAccountStub) SetCodeHash([]byte) + func (u *UserAccountStub) SetCodeMetadata(_ []byte) + func (u *UserAccountStub) SetDataTrie(_ data.Trie) + func (u *UserAccountStub) SetOwnerAddress([]byte) + func (u *UserAccountStub) SetRootHash([]byte) + func (u *UserAccountStub) SetUserName(_ []byte) + func (u *UserAccountStub) SubFromBalance(_ *big.Int) error + type VMContainerMock struct + AddCalled func(key []byte, val vmcommon.VMExecutionHandler) error + AddMultipleCalled func(keys [][]byte, preprocessors []vmcommon.VMExecutionHandler) error + GetCalled func(key []byte) (vmcommon.VMExecutionHandler, error) + KeysCalled func() [][]byte + LenCalled func() int + RemoveCalled func(key []byte) + ReplaceCalled func(key []byte, val vmcommon.VMExecutionHandler) error + 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 struct + GasScheduleChangeCalled func(gasSchedule map[string]map[string]uint64) + GetVersionCalled func() string + RunSmartContractCallCalled func(input *vmcommon.ContractCallInput) (*vmcommon.VMOutput, error) + RunSmartContractCreateCalled func(input *vmcommon.ContractCreateInput) (*vmcommon.VMOutput, error) + 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 struct + PubKeyCalled func() []byte + 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 struct + func (v *ValidatorSettingsStub) GenesisNodePrice() *big.Int + func (v *ValidatorSettingsStub) IsInterfaceNil() bool + func (v *ValidatorSettingsStub) UnBondPeriod() uint64 + type ValidatorStatisticsProcessorStub struct + CommitCalled func() ([]byte, error) + GetPeerAccountCalled func(address []byte) (state.PeerAccountHandler, error) + GetValidatorInfoForRootHashCalled func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error) + LastFinalizedRootHashCalled func() []byte + PeerAccountToValidatorInfoCalled func(peerAccount state.PeerAccountHandler) *state.ValidatorInfo + ProcessCalled func(validatorInfo data.ShardValidatorInfoHandler) error + ProcessRatingsEndOfEpochCalled func(validatorInfos map[uint32][]*state.ValidatorInfo, epoch uint32) error + ResetValidatorStatisticsAtNewEpochCalled func(vInfos map[uint32][]*state.ValidatorInfo) error + RevertPeerStateCalled func(header data.HeaderHandler) error + RootHashCalled func() ([]byte, error) + SaveNodesCoordinatorUpdatesCalled func(epoch uint32) (bool, error) + UpdatePeerStateCalled func(header data.HeaderHandler) ([]byte, error) + 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 struct + GetLatestValidatorsCalled func() map[string]*state.ValidatorApiResponse + func (vp *ValidatorsProviderStub) GetLatestValidators() map[string]*state.ValidatorApiResponse + func (vp *ValidatorsProviderStub) IsInterfaceNil() bool + type ValidityAttesterStub struct + CheckBlockAgainstFinalCalled func(headerHandler data.HeaderHandler) error + CheckBlockAgainstRounderCalled func(headerHandler data.HeaderHandler) error + CheckBlockAgainstWhitelistCalled func(interceptedData process.InterceptedData) bool + func (vas *ValidityAttesterStub) CheckBlockAgainstFinal(headerHandler data.HeaderHandler) error + func (vas *ValidityAttesterStub) CheckBlockAgainstRounder(headerHandler data.HeaderHandler) error + func (vas *ValidityAttesterStub) CheckBlockAgainstWhitelist(interceptedData process.InterceptedData) bool + func (vas *ValidityAttesterStub) IsInterfaceNil() bool + type WhiteListHandlerStub struct + AddCalled func(keys [][]byte) + IsForCurrentShardCalled func(interceptedData process.InterceptedData) bool + IsWhiteListedCalled func(interceptedData process.InterceptedData) bool + RemoveCalled func(keys [][]byte) + func (w *WhiteListHandlerStub) Add(keys [][]byte) + func (w *WhiteListHandlerStub) IsForCurrentShard(interceptedData process.InterceptedData) bool + func (w *WhiteListHandlerStub) IsInterfaceNil() bool + func (w *WhiteListHandlerStub) IsWhiteListed(interceptedData process.InterceptedData) bool + func (w *WhiteListHandlerStub) Remove(keys [][]byte)