mock

package
v1.0.100 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 2, 2020 License: GPL-3.0 Imports: 34 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewAccumulatorMock 

func NewAccumulatorMock() *accumulatorMock

NewAccumulatorMock returns a mock implementation of the accumulator interface

func NewMultiShardsCoordinatorMock 

func NewMultiShardsCoordinatorMock(nrShard uint32) *multipleShardsCoordinatorMock

NewMultiShardsCoordinatorMock -

func NewNonceHashConverterMock 

func NewNonceHashConverterMock() *nonceHashConverterMock

NewNonceHashConverterMock -

func NewOneShardCoordinatorMock 

func NewOneShardCoordinatorMock() *oneShardCoordinatorMock

NewOneShardCoordinatorMock -

Types

type AccountsFactoryStub 

type AccountsFactoryStub struct {
	CreateAccountCalled func(address state.AddressContainer) (state.AccountHandler, error)
}

AccountsFactoryStub -

func (*AccountsFactoryStub) CreateAccount 

func (afs *AccountsFactoryStub) CreateAccount(address state.AddressContainer) (state.AccountHandler, error)

CreateAccount -

func (*AccountsFactoryStub) IsInterfaceNil 

func (afs *AccountsFactoryStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type AccountsStub 

type AccountsStub struct {
	GetExistingAccountCalled func(addressContainer state.AddressContainer) (state.AccountHandler, error)
	LoadAccountCalled        func(container state.AddressContainer) (state.AccountHandler, error)
	SaveAccountCalled        func(account state.AccountHandler) error
	RemoveAccountCalled      func(addressContainer state.AddressContainer) error
	CommitCalled             func() ([]byte, error)
	JournalLenCalled         func() int
	RevertToSnapshotCalled   func(snapshot int) error
	RootHashCalled           func() ([]byte, error)
	RecreateTrieCalled       func(rootHash []byte) error
	PruneTrieCalled          func(rootHash []byte, identifier data.TriePruningIdentifier)
	CancelPruneCalled        func(rootHash []byte, identifier data.TriePruningIdentifier)
	SnapshotStateCalled      func(rootHash []byte)
	SetStateCheckpointCalled func(rootHash []byte)
	IsPruningEnabledCalled   func() bool
	GetAllLeavesCalled       func(rootHash []byte) (map[string][]byte, error)
}

AccountsStub -

func (*AccountsStub) CancelPrune 

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

CancelPrune -

func (*AccountsStub) Commit 

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

Commit -

func (*AccountsStub) GetAllLeaves 

func (as *AccountsStub) GetAllLeaves(rootHash []byte) (map[string][]byte, error)

GetAllLeaves -

func (*AccountsStub) GetExistingAccount 

func (as *AccountsStub) GetExistingAccount(addressContainer state.AddressContainer) (state.AccountHandler, error)

GetExistingAccount -

func (*AccountsStub) IsInterfaceNil 

func (as *AccountsStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*AccountsStub) IsPruningEnabled 

func (as *AccountsStub) IsPruningEnabled() bool

IsPruningEnabled -

func (*AccountsStub) JournalLen 

func (as *AccountsStub) JournalLen() int

JournalLen -

func (*AccountsStub) LoadAccount 

func (as *AccountsStub) LoadAccount(address state.AddressContainer) (state.AccountHandler, error)

LoadAccount -

func (*AccountsStub) PruneTrie 

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

PruneTrie -

func (*AccountsStub) RecreateTrie 

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

RecreateTrie -

func (*AccountsStub) RemoveAccount 

func (as *AccountsStub) RemoveAccount(addressContainer state.AddressContainer) error

RemoveAccount -

func (*AccountsStub) RevertToSnapshot 

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

RevertToSnapshot -

func (*AccountsStub) RootHash 

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

RootHash -

func (*AccountsStub) SaveAccount 

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

SaveAccount -

func (*AccountsStub) SetStateCheckpoint 

func (as *AccountsStub) SetStateCheckpoint(rootHash []byte)

SetStateCheckpoint -

func (*AccountsStub) SnapshotState 

func (as *AccountsStub) SnapshotState(rootHash []byte)

SnapshotState -

type AddressConverterFake 

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

AddressConverterFake -

func NewAddressConverterFake 

func NewAddressConverterFake(addressLen int, prefix string) *AddressConverterFake

NewAddressConverterFake -

func (*AddressConverterFake) AddressLen 

func (acf *AddressConverterFake) AddressLen() int

AddressLen -

func (*AddressConverterFake) ConvertToHex 

func (acf *AddressConverterFake) ConvertToHex(addressContainer state.AddressContainer) (string, error)

ConvertToHex -

func (*AddressConverterFake) CreateAddressFromHex 

func (acf *AddressConverterFake) CreateAddressFromHex(hexAddress string) (state.AddressContainer, error)

CreateAddressFromHex -

func (*AddressConverterFake) CreateAddressFromPublicKeyBytes 

func (acf *AddressConverterFake) CreateAddressFromPublicKeyBytes(pubKey []byte) (state.AddressContainer, error)

CreateAddressFromPublicKeyBytes -

func (*AddressConverterFake) IsInterfaceNil 

func (acf *AddressConverterFake) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*AddressConverterFake) PrepareAddressBytes 

func (acf *AddressConverterFake) PrepareAddressBytes(addressBytes []byte) ([]byte, error)

PrepareAddressBytes -

type AddressConverterStub 

type AddressConverterStub struct {
	CreateAddressFromPublicKeyBytesHandler func(pubKey []byte) (state.AddressContainer, error)
	ConvertToHexHandler                    func(addressContainer state.AddressContainer) (string, error)
	CreateAddressFromHexHandler            func(hexAddress string) (state.AddressContainer, error)
	PrepareAddressBytesHandler             func(addressBytes []byte) ([]byte, error)
	AddressLenHandler                      func() int
}

AddressConverterStub -

func (AddressConverterStub) AddressLen 

func (ac AddressConverterStub) AddressLen() int

AddressLen -

func (AddressConverterStub) ConvertToHex 

func (ac AddressConverterStub) ConvertToHex(addressContainer state.AddressContainer) (string, error)

ConvertToHex -

func (AddressConverterStub) CreateAddressFromHex 

func (ac AddressConverterStub) CreateAddressFromHex(hexAddress string) (state.AddressContainer, error)

CreateAddressFromHex -

func (AddressConverterStub) CreateAddressFromPublicKeyBytes 

func (ac AddressConverterStub) CreateAddressFromPublicKeyBytes(pubKey []byte) (state.AddressContainer, error)

CreateAddressFromPublicKeyBytes -

func (*AddressConverterStub) IsInterfaceNil 

func (ac *AddressConverterStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (AddressConverterStub) PrepareAddressBytes 

func (ac AddressConverterStub) PrepareAddressBytes(addressBytes []byte) ([]byte, error)

PrepareAddressBytes -

type AddressMock 

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

AddressMock implements a mock address generator used in testing

func NewAddressMock 

func NewAddressMock() *AddressMock

NewAddressMock generates a new address

func (*AddressMock) Bytes 

func (address *AddressMock) Bytes() []byte

Bytes returns the address' bytes

func (*AddressMock) IsInterfaceNil 

func (address *AddressMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type AppStatusHandlerStub 

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

AppStatusHandlerStub is a stub implementation of AppStatusHandler

func (*AppStatusHandlerStub) AddUint64 

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

AddUint64 will call the handler of the stub for incrementing

func (*AppStatusHandlerStub) Close 

func (ashs *AppStatusHandlerStub) Close()

Close will call the handler of the stub for closing

func (*AppStatusHandlerStub) Decrement 

func (ashs *AppStatusHandlerStub) Decrement(key string)

Decrement will call the handler of the stub for decrementing

func (*AppStatusHandlerStub) Increment 

func (ashs *AppStatusHandlerStub) Increment(key string)

Increment will call the handler of the stub for incrementing

func (*AppStatusHandlerStub) IsInterfaceNil 

func (ashs *AppStatusHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*AppStatusHandlerStub) SetInt64Value 

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

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

func (*AppStatusHandlerStub) SetStringValue 

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

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

func (*AppStatusHandlerStub) SetUInt64Value 

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

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

type BlackListHandlerStub 

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

func (*BlackListHandlerStub) Add 

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

func (*BlackListHandlerStub) Has 

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

func (*BlackListHandlerStub) IsInterfaceNil 

func (blhs *BlackListHandlerStub) IsInterfaceNil() bool

func (*BlackListHandlerStub) Sweep 

func (blhs *BlackListHandlerStub) Sweep()

type BlockChainMock 

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

BlockChainMock is a mock implementation of the blockchain interface

func (*BlockChainMock) CreateNewHeader 

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

CreateNewHeader -

func (*BlockChainMock) GetCurrentBlockBody 

func (bc *BlockChainMock) GetCurrentBlockBody() data.BodyHandler

GetCurrentBlockBody returns the tx block body pointer

func (*BlockChainMock) GetCurrentBlockHeader 

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

GetCurrentBlockHeader returns current block header pointer

func (*BlockChainMock) GetCurrentBlockHeaderHash 

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

GetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) GetGenesisHeader 

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

GetGenesisHeader returns the genesis block header pointer

func (*BlockChainMock) GetGenesisHeaderHash 

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

GetGenesisHeaderHash returns the genesis block header hash

func (*BlockChainMock) IsInterfaceNil 

func (bc *BlockChainMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockChainMock) SetCurrentBlockBody 

func (bc *BlockChainMock) SetCurrentBlockBody(body data.BodyHandler) error

SetCurrentBlockBody sets the tx block body pointer

func (*BlockChainMock) SetCurrentBlockHeader 

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

SetCurrentBlockHeader sets current block header pointer

func (*BlockChainMock) SetCurrentBlockHeaderHash 

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

SetCurrentBlockHeaderHash returns the current block header hash

func (*BlockChainMock) SetGenesisHeader 

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

SetGenesisHeader sets the genesis block header pointer

func (*BlockChainMock) SetGenesisHeaderHash 

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

SetGenesisHeaderHash sets the genesis block header hash

type BlockProcessorStub 

type BlockProcessorStub struct {
	ProcessBlockCalled               func(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error
	CommitBlockCalled                func(header data.HeaderHandler, body data.BodyHandler) error
	RevertAccountStateCalled         func(header data.HeaderHandler)
	CreateGenesisBlockCalled         func(balances map[string]*big.Int) (data.HeaderHandler, error)
	CreateBlockCalled                func(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)
	RestoreBlockIntoPoolsCalled      func(header data.HeaderHandler, body data.BodyHandler) error
	SetOnRequestTransactionCalled    func(f func(destShardID uint32, txHash []byte))
	MarshalizedDataToBroadcastCalled func(header data.HeaderHandler, body data.BodyHandler) (map[uint32][]byte, map[string][][]byte, error)
	DecodeBlockBodyCalled            func(dta []byte) data.BodyHandler
	DecodeBlockHeaderCalled          func(dta []byte) data.HeaderHandler
	AddLastNotarizedHdrCalled        func(shardId uint32, processedHdr data.HeaderHandler)
	CreateNewHeaderCalled            func(round uint64, nonce uint64) data.HeaderHandler
	PruneStateOnRollbackCalled       func(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)
	RevertStateToBlockCalled         func(header data.HeaderHandler) error
}

BlockProcessorStub mocks the implementation for a blockProcessor

func (*BlockProcessorStub) AddLastNotarizedHdr 

func (bps *BlockProcessorStub) AddLastNotarizedHdr(shardId uint32, processedHdr data.HeaderHandler)

AddLastNotarizedHdr -

func (*BlockProcessorStub) ApplyProcessedMiniBlocks 

func (bps *BlockProcessorStub) ApplyProcessedMiniBlocks(_ *processedMb.ProcessedMiniBlockTracker)

ApplyProcessedMiniBlocks -

func (*BlockProcessorStub) CommitBlock 

func (bps *BlockProcessorStub) CommitBlock(header data.HeaderHandler, body data.BodyHandler) error

CommitBlock mocks the commit of a block

func (*BlockProcessorStub) CreateBlock 

func (bps *BlockProcessorStub) CreateBlock(initialHdrData data.HeaderHandler, haveTime func() bool) (data.HeaderHandler, data.BodyHandler, error)

CreateBlock mocks the creation of a new block with header and body

func (*BlockProcessorStub) CreateGenesisBlock 

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

CreateGenesisBlock mocks the creation of a genesis block body

func (*BlockProcessorStub) CreateNewHeader 

func (bps *BlockProcessorStub) CreateNewHeader(round uint64, nonce uint64) data.HeaderHandler

CreateNewHeader creates a new header

func (*BlockProcessorStub) DecodeBlockBody 

func (bps *BlockProcessorStub) DecodeBlockBody(dta []byte) data.BodyHandler

DecodeBlockBody -

func (*BlockProcessorStub) DecodeBlockHeader 

func (bps *BlockProcessorStub) DecodeBlockHeader(dta []byte) data.HeaderHandler

DecodeBlockHeader -

func (*BlockProcessorStub) IsInterfaceNil 

func (bps *BlockProcessorStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*BlockProcessorStub) MarshalizedDataToBroadcast 

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

MarshalizedDataToBroadcast -

func (*BlockProcessorStub) ProcessBlock 

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

ProcessBlock mocks pocessing a block

func (*BlockProcessorStub) PruneStateOnRollback 

func (bps *BlockProcessorStub) PruneStateOnRollback(currHeader data.HeaderHandler, prevHeader data.HeaderHandler)

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

func (*BlockProcessorStub) RestoreBlockIntoPools 

func (bps *BlockProcessorStub) RestoreBlockIntoPools(header data.HeaderHandler, body data.BodyHandler) error

RestoreBlockIntoPools -

func (*BlockProcessorStub) RestoreLastNotarizedHrdsToGenesis 

func (bps *BlockProcessorStub) RestoreLastNotarizedHrdsToGenesis()

RestoreLastNotarizedHrdsToGenesis -

func (*BlockProcessorStub) RevertAccountState 

func (bps *BlockProcessorStub) RevertAccountState(header data.HeaderHandler)

RevertAccountState mocks revert of the accounts state

func (*BlockProcessorStub) RevertStateToBlock 

func (bps *BlockProcessorStub) RevertStateToBlock(header data.HeaderHandler) error

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

func (*BlockProcessorStub) SetNumProcessedObj 

func (bps *BlockProcessorStub) SetNumProcessedObj(_ uint64)

SetNumProcessedObj -

type BlockTrackerStub 

type BlockTrackerStub struct {
	AddTrackedHeaderCalled                            func(header data.HeaderHandler, hash []byte)
	AddCrossNotarizedHeaderCalled                     func(shardID uint32, crossNotarizedHeader data.HeaderHandler, crossNotarizedHeaderHash []byte)
	AddSelfNotarizedHeaderCalled                      func(shardID uint32, selfNotarizedHeader data.HeaderHandler, selfNotarizedHeaderHash []byte)
	CheckBlockAgainstRounderCalled                    func(headerHandler data.HeaderHandler) error
	CheckBlockAgainstFinalCalled                      func(headerHandler data.HeaderHandler) error
	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)
	GetFinalHeaderCalled                              func(shardID uint32) (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)
	GetNumPendingMiniBlocksCalled                     func(shardID uint32) uint32
	GetTrackedHeadersCalled                           func(shardID uint32) ([]data.HeaderHandler, [][]byte)
	GetTrackedHeadersForAllShardsCalled               func() map[uint32][]data.HeaderHandler
	GetTrackedHeadersWithNonceCalled                  func(shardID uint32, nonce uint64) ([]data.HeaderHandler, [][]byte)
	IsShardStuckCalled                                func(shardId uint32) bool
	RegisterCrossNotarizedHeadersHandlerCalled        func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RegisterSelfNotarizedHeadersHandlerCalled         func(handler func(shardID uint32, headers []data.HeaderHandler, headersHashes [][]byte))
	RemoveLastNotarizedHeadersCalled                  func()
	RestoreToGenesisCalled                            func()
	ShouldAddHeaderCalled                             func(headerHandler data.HeaderHandler) bool
}

BlockTrackerStub -

func (*BlockTrackerStub) AddCrossNotarizedHeader 

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

AddCrossNotarizedHeader -

func (*BlockTrackerStub) AddSelfNotarizedHeader 

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

AddSelfNotarizedHeader -

func (*BlockTrackerStub) AddTrackedHeader 

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

AddTrackedHeader -

func (*BlockTrackerStub) CheckBlockAgainstFinal 

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

CheckBlockAgainstFinal -

func (*BlockTrackerStub) CheckBlockAgainstRounder 

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

CheckBlockAgainstRounder -

func (*BlockTrackerStub) CleanupHeadersBehindNonce 

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

CleanupHeadersBehindNonce -

func (*BlockTrackerStub) CleanupInvalidCrossHeaders 

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

CleanupInvalidCrossHeaders -

func (*BlockTrackerStub) ComputeLongestChain 

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

ComputeLongestChain -

func (*BlockTrackerStub) ComputeLongestMetaChainFromLastNotarized 

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

ComputeLongestMetaChainFromLastNotarized -

func (*BlockTrackerStub) ComputeLongestShardsChainsFromLastNotarized 

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

ComputeLongestShardsChainsFromLastNotarized -

func (*BlockTrackerStub) DisplayTrackedHeaders 

func (bts *BlockTrackerStub) DisplayTrackedHeaders()

DisplayTrackedHeaders -

func (*BlockTrackerStub) GetCrossNotarizedHeader 

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

GetCrossNotarizedHeader -

func (*BlockTrackerStub) GetFinalHeader 

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

GetFinalHeader -

func (*BlockTrackerStub) GetLastCrossNotarizedHeader 

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

GetLastCrossNotarizedHeader -

func (*BlockTrackerStub) GetLastCrossNotarizedHeadersForAllShards 

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

GetLastCrossNotarizedHeadersForAllShards -

func (*BlockTrackerStub) GetLastSelfNotarizedHeader 

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

GetLastSelfNotarizedHeader -

func (*BlockTrackerStub) GetNumPendingMiniBlocks added in v0.0.5 

func (bts *BlockTrackerStub) GetNumPendingMiniBlocks(shardID uint32) uint32

GetNumPendingMiniBlocks -

func (*BlockTrackerStub) GetTrackedHeaders 

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

GetTrackedHeaders -

func (*BlockTrackerStub) GetTrackedHeadersForAllShards 

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

GetTrackedHeadersForAllShards -

func (*BlockTrackerStub) GetTrackedHeadersWithNonce 

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

GetTrackedHeadersWithNonce -

func (*BlockTrackerStub) IsInterfaceNil 

func (bts *BlockTrackerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*BlockTrackerStub) IsShardStuck 

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

IsShardStuck -

func (*BlockTrackerStub) RegisterCrossNotarizedHeadersHandler 

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

RegisterCrossNotarizedHeadersHandler -

func (*BlockTrackerStub) RegisterSelfNotarizedHeadersHandler 

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

RegisterSelfNotarizedHeadersHandler -

func (*BlockTrackerStub) RemoveLastNotarizedHeaders 

func (bts *BlockTrackerStub) RemoveLastNotarizedHeaders()

RemoveLastNotarizedHeaders -

func (*BlockTrackerStub) RestoreToGenesis 

func (bts *BlockTrackerStub) RestoreToGenesis()

RestoreToGenesis -

func (*BlockTrackerStub) ShouldAddHeader 

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

ShouldAddHeader -

type BoostrapStorerMock 

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

BoostrapStorerMock -

func (*BoostrapStorerMock) Get 

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

Get -

func (*BoostrapStorerMock) GetHighestRound 

func (bsm *BoostrapStorerMock) GetHighestRound() int64

GetHighestRound -

func (*BoostrapStorerMock) IsInterfaceNil 

func (bsm *BoostrapStorerMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*BoostrapStorerMock) Put 

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

Put -

func (*BoostrapStorerMock) SaveLastRound 

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

SaveLastRound -

type CacherStub 

type CacherStub struct {
	ClearCalled           func()
	PutCalled             func(key []byte, value interface{}) (evicted bool)
	GetCalled             func(key []byte) (value interface{}, ok bool)
	HasCalled             func(key []byte) bool
	PeekCalled            func(key []byte) (value interface{}, ok bool)
	HasOrAddCalled        func(key []byte, value interface{}) (ok, evicted bool)
	RemoveCalled          func(key []byte)
	RemoveOldestCalled    func()
	KeysCalled            func() [][]byte
	LenCalled             func() int
	MaxSizeCalled         func() int
	RegisterHandlerCalled func(func(key []byte))
}

CacherStub -

func (*CacherStub) Clear 

func (cs *CacherStub) Clear()

Clear -

func (*CacherStub) Get 

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

Get -

func (*CacherStub) Has 

func (cs *CacherStub) Has(key []byte) bool

Has -

func (*CacherStub) HasOrAdd 

func (cs *CacherStub) HasOrAdd(key []byte, value interface{}) (ok, evicted bool)

HasOrAdd -

func (*CacherStub) IsInterfaceNil 

func (cs *CacherStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*CacherStub) Keys 

func (cs *CacherStub) Keys() [][]byte

Keys -

func (*CacherStub) Len 

func (cs *CacherStub) Len() int

Len -

func (*CacherStub) MaxSize 

func (cs *CacherStub) MaxSize() int

MaxSize -

func (*CacherStub) Peek 

func (cs *CacherStub) Peek(key []byte) (value interface{}, ok bool)

Peek -

func (*CacherStub) Put 

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

Put -

func (*CacherStub) RegisterHandler 

func (cs *CacherStub) RegisterHandler(handler func(key []byte))

RegisterHandler -

func (*CacherStub) Remove 

func (cs *CacherStub) Remove(key []byte)

Remove -

func (*CacherStub) RemoveOldest 

func (cs *CacherStub) RemoveOldest()

RemoveOldest -

type ChainHandlerStub 

type ChainHandlerStub struct {
	GetGenesisHeaderCalled      func() data.HeaderHandler
	GetGenesisHeaderHashCalled  func() []byte
	SetGenesisHeaderCalled      func(gb data.HeaderHandler) error
	SetGenesisHeaderHashCalled  func(hash []byte)
	SetCurrentBlockHeaderCalled func(bh data.HeaderHandler) error
	SetCurrentBlockBodyCalled   func(body data.BodyHandler) error
	CreateNewHeaderCalled       func() data.HeaderHandler
}

ChainHandlerStub -

func (*ChainHandlerStub) CreateNewHeader 

func (chs *ChainHandlerStub) CreateNewHeader() data.HeaderHandler

CreateNewHeader -

func (*ChainHandlerStub) GetCurrentBlockBody 

func (chs *ChainHandlerStub) GetCurrentBlockBody() data.BodyHandler

GetCurrentBlockBody -

func (*ChainHandlerStub) GetCurrentBlockHeader 

func (chs *ChainHandlerStub) GetCurrentBlockHeader() data.HeaderHandler

GetCurrentBlockHeader -

func (*ChainHandlerStub) GetCurrentBlockHeaderHash 

func (chs *ChainHandlerStub) GetCurrentBlockHeaderHash() []byte

GetCurrentBlockHeaderHash -

func (*ChainHandlerStub) GetGenesisHeader 

func (chs *ChainHandlerStub) GetGenesisHeader() data.HeaderHandler

GetGenesisHeader -

func (*ChainHandlerStub) GetGenesisHeaderHash 

func (chs *ChainHandlerStub) GetGenesisHeaderHash() []byte

GetGenesisHeaderHash -

func (*ChainHandlerStub) IsInterfaceNil 

func (chs *ChainHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ChainHandlerStub) SetCurrentBlockBody 

func (chs *ChainHandlerStub) SetCurrentBlockBody(body data.BodyHandler) error

SetCurrentBlockBody -

func (*ChainHandlerStub) SetCurrentBlockHeader 

func (chs *ChainHandlerStub) SetCurrentBlockHeader(bh data.HeaderHandler) error

SetCurrentBlockHeader -

func (*ChainHandlerStub) SetCurrentBlockHeaderHash 

func (chs *ChainHandlerStub) SetCurrentBlockHeaderHash(_ []byte)

SetCurrentBlockHeaderHash -

func (*ChainHandlerStub) SetGenesisHeader 

func (chs *ChainHandlerStub) SetGenesisHeader(gb data.HeaderHandler) error

SetGenesisHeader -

func (*ChainHandlerStub) SetGenesisHeaderHash 

func (chs *ChainHandlerStub) SetGenesisHeaderHash(hash []byte)

SetGenesisHeaderHash -

type ChainStorerMock 

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

ChainStorerMock is a mock implementation of the ChianStorer interface

func (*ChainStorerMock) AddStorer 

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

AddStorer will add a new storer to the chain map

func (*ChainStorerMock) CloseAll 

func (bc *ChainStorerMock) CloseAll() error

CloseAll -

func (*ChainStorerMock) Destroy 

func (bc *ChainStorerMock) Destroy() error

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

func (*ChainStorerMock) Get 

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

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

func (*ChainStorerMock) GetAll 

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

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

func (*ChainStorerMock) GetStorer 

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

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

func (*ChainStorerMock) Has 

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

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

func (*ChainStorerMock) IsInterfaceNil 

func (bc *ChainStorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ChainStorerMock) Put 

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

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

type EpochStartNotifierStub 

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

EpochStartNotifierStub -

func (*EpochStartNotifierStub) IsInterfaceNil 

func (esnm *EpochStartNotifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartNotifierStub) NotifyAll 

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

NotifyAll -

func (*EpochStartNotifierStub) NotifyAllPrepare 

func (esnm *EpochStartNotifierStub) NotifyAllPrepare(metaHeader data.HeaderHandler)

NotifyAllPrepare -

func (*EpochStartNotifierStub) RegisterHandler 

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

RegisterHandler -

func (*EpochStartNotifierStub) UnregisterHandler 

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

UnregisterHandler -

type EpochStartTriggerStub 

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

EpochStartTriggerStub -

func (*EpochStartTriggerStub) Epoch 

func (e *EpochStartTriggerStub) Epoch() uint32

Epoch -

func (*EpochStartTriggerStub) EpochFinalityAttestingRound 

func (e *EpochStartTriggerStub) EpochFinalityAttestingRound() uint64

EpochFinalityAttestingRound -

func (*EpochStartTriggerStub) EpochStartMetaHdrHash 

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

EpochStartMetaHdrHash -

func (*EpochStartTriggerStub) EpochStartRound 

func (e *EpochStartTriggerStub) EpochStartRound() uint64

EpochStartRound -

func (*EpochStartTriggerStub) ForceEpochStart 

func (e *EpochStartTriggerStub) ForceEpochStart(round uint64) error

ForceEpochStart -

func (*EpochStartTriggerStub) GetSavedStateKey 

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

GetSavedStateKey -

func (*EpochStartTriggerStub) IsEpochStart 

func (e *EpochStartTriggerStub) IsEpochStart() bool

IsEpochStart -

func (*EpochStartTriggerStub) IsInterfaceNil 

func (e *EpochStartTriggerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*EpochStartTriggerStub) LoadState 

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

LoadState -

func (*EpochStartTriggerStub) NotifyAll 

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

NotifyAll -

func (*EpochStartTriggerStub) ReceivedHeader 

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

ReceivedHeader -

func (*EpochStartTriggerStub) RequestEpochStartIfNeeded 

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

RequestEpochStartIfNeeded -

func (*EpochStartTriggerStub) Revert 

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

Revert -

func (*EpochStartTriggerStub) RevertStateToBlock 

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

RevertStateToBlock -

func (*EpochStartTriggerStub) SetAppStatusHandler added in v0.0.5 

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

SetAppStatusHandler -

func (*EpochStartTriggerStub) SetCurrentEpochStartRound 

func (e *EpochStartTriggerStub) SetCurrentEpochStartRound(_ uint64)

SetCurrentEpochStartRound -

func (*EpochStartTriggerStub) SetFinalityAttestingRound 

func (e *EpochStartTriggerStub) SetFinalityAttestingRound(_ uint64)

SetFinalityAttestingRound -

func (*EpochStartTriggerStub) SetProcessed 

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

SetProcessed -

func (*EpochStartTriggerStub) Update 

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

Update -

type FeeHandlerStub 

type FeeHandlerStub struct {
	MaxGasLimitPerBlockCalled   func() uint64
	SetMinGasPriceCalled        func(minasPrice uint64)
	SetMinGasLimitCalled        func(minGasLimit uint64)
	ComputeGasLimitCalled       func(tx process.TransactionWithFeeHandler) uint64
	ComputeFeeCalled            func(tx process.TransactionWithFeeHandler) *big.Int
	CheckValidityTxValuesCalled func(tx process.TransactionWithFeeHandler) error
	DeveloperPercentageCalled   func() float64
	MinGasPriceCalled           func() uint64
}

FeeHandlerStub -

func (*FeeHandlerStub) CheckValidityTxValues 

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

CheckValidityTxValues -

func (*FeeHandlerStub) ComputeFee 

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

ComputeFee -

func (*FeeHandlerStub) ComputeGasLimit 

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

ComputeGasLimit -

func (*FeeHandlerStub) DeveloperPercentage 

func (fhs *FeeHandlerStub) DeveloperPercentage() float64

DeveloperPercentage -

func (*FeeHandlerStub) IsInterfaceNil 

func (fhs *FeeHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*FeeHandlerStub) MaxGasLimitPerBlock 

func (fhs *FeeHandlerStub) MaxGasLimitPerBlock() uint64

MaxGasLimitPerBlock -

func (*FeeHandlerStub) MinGasPrice 

func (fhs *FeeHandlerStub) MinGasPrice() uint64

MinGasPrice -

type ForkDetectorMock 

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

ForkDetectorMock is a mock implementation for the ForkDetector interface

func (*ForkDetectorMock) AddHeader 

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

AddHeader is a mock implementation for AddHeader

func (*ForkDetectorMock) CheckFork 

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

CheckFork is a mock implementation for CheckFork

func (*ForkDetectorMock) GetHighestFinalBlockHash 

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

GetHighestFinalBlockHash -

func (*ForkDetectorMock) GetHighestFinalBlockNonce 

func (fdm *ForkDetectorMock) GetHighestFinalBlockNonce() uint64

GetHighestFinalBlockNonce is a mock implementation for GetHighestFinalBlockNonce

func (*ForkDetectorMock) GetNotarizedHeaderHash 

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

GetNotarizedHeaderHash -

func (*ForkDetectorMock) IsInterfaceNil 

func (fdm *ForkDetectorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ForkDetectorMock) ProbableHighestNonce 

func (fdm *ForkDetectorMock) ProbableHighestNonce() uint64

ProbableHighestNonce is a mock implementation for GetProbableHighestNonce

func (*ForkDetectorMock) RemoveHeader 

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

RemoveHeader is a mock implementation for RemoveHeader

func (*ForkDetectorMock) ResetFork 

func (fdm *ForkDetectorMock) ResetFork()

ResetFork -

func (*ForkDetectorMock) ResetProbableHighestNonce 

func (fdm *ForkDetectorMock) ResetProbableHighestNonce()

ResetProbableHighestNonce -

func (*ForkDetectorMock) RestoreToGenesis 

func (fdm *ForkDetectorMock) RestoreToGenesis()

RestoreToGenesis -

func (*ForkDetectorMock) SetRollBackNonce 

func (fdm *ForkDetectorMock) SetRollBackNonce(nonce uint64)

SetRollBackNonce -

type GeneratorSuite 

type GeneratorSuite struct {
	SuiteMock
	CreateKeyStub func(cipher.Stream) crypto.Scalar
}

GeneratorSuite -

func (*GeneratorSuite) CreateKey 

func (gs *GeneratorSuite) CreateKey(c cipher.Stream) crypto.Scalar

CreateKey -

type HasherFake 

type HasherFake struct {
}

HasherFake that will be used for testing

func (HasherFake) Compute 

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

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

func (HasherFake) EmptyHash 

func (sha HasherFake) EmptyHash() []byte

EmptyHash will return the equivalent of empty string SHA's

func (*HasherFake) IsInterfaceNil 

func (sha *HasherFake) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (HasherFake) Size 

func (HasherFake) Size() int

Size return the required size in bytes

type HasherMock 

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

HasherMock -

func (HasherMock) Compute 

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

Compute -

func (HasherMock) EmptyHash 

func (hash HasherMock) EmptyHash() []byte

EmptyHash -

func (HasherMock) IsInterfaceNil 

func (hash HasherMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (HasherMock) Size 

func (HasherMock) Size() int

Size -

type HeaderResolverStub 

type HeaderResolverStub struct {
	RequestDataFromHashCalled    func(hash []byte, epoch uint32) error
	ProcessReceivedMessageCalled func(message p2p.MessageP2P) error
	RequestDataFromNonceCalled   func(nonce uint64, epoch uint32) error
	RequestDataFromEpochCalled   func(identifier []byte) error
	SetEpochHandlerCalled        func(epochHandler dataRetriever.EpochHandler) error
}

HeaderResolverStub -

func (*HeaderResolverStub) IsInterfaceNil 

func (hrm *HeaderResolverStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*HeaderResolverStub) ProcessReceivedMessage 

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

ProcessReceivedMessage -

func (*HeaderResolverStub) RequestDataFromEpoch 

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

RequestDataFromEpoch -

func (*HeaderResolverStub) RequestDataFromHash 

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

RequestDataFromHash -

func (*HeaderResolverStub) RequestDataFromNonce 

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

RequestDataFromNonce -

func (*HeaderResolverStub) SetEpochHandler 

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

SetEpochHandler -

type HeaderSigVerifierStub 

type HeaderSigVerifierStub struct {
	VerifyRandSeedCaller func(header data.HeaderHandler) error
}

HeaderSigVerifierStub -

func (*HeaderSigVerifierStub) IsInterfaceNil 

func (hsvm *HeaderSigVerifierStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeaderSigVerifierStub) VerifyRandSeed 

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

VerifyRandSeed -

type HeadersCacherStub 

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

HeadersCacherStub -

func (*HeadersCacherStub) AddHeader 

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

AddHeader -

func (*HeadersCacherStub) Clear 

func (hcs *HeadersCacherStub) Clear()

Clear -

func (*HeadersCacherStub) GetHeaderByHash 

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

GetHeaderByHash -

func (*HeadersCacherStub) GetHeadersByNonceAndShardId 

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

GetHeadersByNonceAndShardId -

func (*HeadersCacherStub) GetNumHeaders 

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

GetNumHeaders -

func (*HeadersCacherStub) IsInterfaceNil 

func (hcs *HeadersCacherStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeadersCacherStub) Len 

func (hcs *HeadersCacherStub) Len() int

Len -

func (*HeadersCacherStub) MaxSize 

func (hcs *HeadersCacherStub) MaxSize() int

MaxSize -

func (*HeadersCacherStub) Nonces 

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

Nonces -

func (*HeadersCacherStub) RegisterHandler 

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

RegisterHandler -

func (*HeadersCacherStub) RemoveHeaderByHash 

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

RemoveHeaderByHash -

func (*HeadersCacherStub) RemoveHeaderByNonceAndShardId 

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

RemoveHeaderByNonceAndShardId -

type HeartbeatStorerStub 

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

HeartbeatStorerStub -

func (*HeartbeatStorerStub) IsInterfaceNil 

func (hss *HeartbeatStorerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*HeartbeatStorerStub) LoadGenesisTime 

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

LoadGenesisTime -

func (*HeartbeatStorerStub) LoadHbmiDTO 

func (hss *HeartbeatStorerStub) LoadHbmiDTO(pubKey string) (*heartbeat.HeartbeatDTO, error)

LoadHbmiDTO -

func (*HeartbeatStorerStub) LoadKeys 

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

LoadKeys -

func (*HeartbeatStorerStub) SaveKeys 

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

SaveKeys -

func (*HeartbeatStorerStub) SavePubkeyData 

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

SavePubkeyData -

func (*HeartbeatStorerStub) UpdateGenesisTime 

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

UpdateGenesisTime -

type IndexerMock 

type IndexerMock struct {
	SaveBlockCalled func(body *block.Body, header *block.Header)
}

IndexerMock is a mock implementation fot the Indexer interface

func (*IndexerMock) IsInterfaceNil 

func (im *IndexerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*IndexerMock) IsNilIndexer 

func (im *IndexerMock) IsNilIndexer() bool

IsNilIndexer -

func (*IndexerMock) SaveBlock 

func (im *IndexerMock) SaveBlock(body data.BodyHandler, header data.HeaderHandler, txPool map[string]data.TransactionHandler, signersIndexes []uint64)

SaveBlock -

func (*IndexerMock) SaveMetaBlock 

func (im *IndexerMock) SaveMetaBlock(header data.HeaderHandler, signersIndexes []uint64)

SaveMetaBlock -

func (*IndexerMock) SaveRoundInfo 

func (im *IndexerMock) SaveRoundInfo(roundInfo indexer.RoundInfo)

SaveRoundInfo -

func (*IndexerMock) SaveValidatorsPubKeys 

func (im *IndexerMock) SaveValidatorsPubKeys(validatorsPubKeys map[uint32][][]byte)

SaveValidatorsPubKeys -

func (*IndexerMock) UpdateTPS 

func (im *IndexerMock) UpdateTPS(tpsBenchmark statistics.TPSBenchmark)

UpdateTPS -

type InterceptorsContainerStub 

type InterceptorsContainerStub struct {
}

InterceptorsContainerStub -

func (*InterceptorsContainerStub) Add 

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

Add -

func (*InterceptorsContainerStub) AddMultiple 

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

AddMultiple -

func (*InterceptorsContainerStub) Get 

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

Get -

func (*InterceptorsContainerStub) IsInterfaceNil 

func (ics *InterceptorsContainerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*InterceptorsContainerStub) Len 

func (ics *InterceptorsContainerStub) Len() int

Len -

func (*InterceptorsContainerStub) Remove 

func (ics *InterceptorsContainerStub) Remove(_ string)

Remove -

func (*InterceptorsContainerStub) Replace 

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

Replace -

type KeyGenMock 

type KeyGenMock struct {
	GeneratePairMock            func() (crypto.PrivateKey, crypto.PublicKey)
	PrivateKeyFromByteArrayMock func(b []byte) (crypto.PrivateKey, error)
	PublicKeyFromByteArrayMock  func(b []byte) (crypto.PublicKey, error)
	SuiteMock                   func() crypto.Suite
}

KeyGenMock -

func (*KeyGenMock) GeneratePair 

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

GeneratePair -

func (*KeyGenMock) IsInterfaceNil 

func (keyGen *KeyGenMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*KeyGenMock) PrivateKeyFromByteArray 

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

PrivateKeyFromByteArray -

func (*KeyGenMock) PublicKeyFromByteArray 

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

PublicKeyFromByteArray -

func (*KeyGenMock) Suite 

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

Suite -

type MarshalizerFake 

type MarshalizerFake struct {
	Fail bool
}

MarshalizerFake that will be used for testing

func (*MarshalizerFake) IsInterfaceNil 

func (mm *MarshalizerFake) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MarshalizerFake) Marshal 

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

Marshal converts the input object in a slice of bytes

func (*MarshalizerFake) Unmarshal 

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

Unmarshal applies the serialized values over an instantiated object

type MarshalizerMock 

type MarshalizerMock struct {
	MarshalHandler   func(obj interface{}) ([]byte, error)
	UnmarshalHandler func(obj interface{}, buff []byte) error
}

MarshalizerMock -

func (*MarshalizerMock) IsInterfaceNil 

func (j *MarshalizerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (MarshalizerMock) Marshal 

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

Marshal -

func (MarshalizerMock) Unmarshal 

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

Unmarshal -

type MessageHandlerStub 

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

MessageHandlerStub -

func (*MessageHandlerStub) CreateHeartbeatFromP2PMessage 

func (mhs *MessageHandlerStub) CreateHeartbeatFromP2PMessage(message p2p.MessageP2P) (*heartbeat.Heartbeat, error)

CreateHeartbeatFromP2pMessage -

func (*MessageHandlerStub) IsInterfaceNil 

func (mhs *MessageHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

type MessengerStub 

type MessengerStub struct {
	CloseCalled                      func() error
	CreateTopicCalled                func(name string, createChannelForTopic bool) error
	HasTopicCalled                   func(name string) bool
	HasTopicValidatorCalled          func(name string) bool
	BroadcastOnChannelCalled         func(channel string, topic string, buff []byte)
	BroadcastCalled                  func(topic string, buff []byte)
	RegisterMessageProcessorCalled   func(topic string, handler p2p.MessageProcessor) error
	BootstrapCalled                  func() error
	PeerAddressCalled                func(pid p2p.PeerID) string
	BroadcastOnChannelBlockingCalled func(channel string, topic string, buff []byte) error
	IsConnectedToTheNetworkCalled    func() bool
}

MessengerStub -

func (*MessengerStub) Bootstrap 

func (ms *MessengerStub) Bootstrap() error

Bootstrap -

func (*MessengerStub) Broadcast 

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

Broadcast -

func (*MessengerStub) BroadcastOnChannel 

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

BroadcastOnChannel -

func (*MessengerStub) BroadcastOnChannelBlocking 

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

BroadcastOnChannelBlocking -

func (*MessengerStub) Close 

func (ms *MessengerStub) Close() error

Close -

func (*MessengerStub) CreateTopic 

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

CreateTopic -

func (*MessengerStub) HasTopic 

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

HasTopic -

func (*MessengerStub) HasTopicValidator 

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

HasTopicValidator -

func (*MessengerStub) IsConnectedToTheNetwork 

func (ms *MessengerStub) IsConnectedToTheNetwork() bool

IsConnectedToTheNetwork -

func (*MessengerStub) IsInterfaceNil 

func (ms *MessengerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MessengerStub) PeerAddress 

func (ms *MessengerStub) PeerAddress(pid p2p.PeerID) string

PeerAddress -

func (*MessengerStub) RegisterMessageProcessor 

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

RegisterMessageProcessor -

type MiniBlocksResolverStub 

type MiniBlocksResolverStub struct {
	RequestDataFromHashCalled      func(hash []byte, epoch uint32) error
	RequestDataFromHashArrayCalled func(hashes [][]byte, epoch uint32) error
	ProcessReceivedMessageCalled   func(message p2p.MessageP2P) error
	GetMiniBlocksCalled            func(hashes [][]byte) (block.MiniBlockSlice, [][]byte)
	GetMiniBlocksFromPoolCalled    func(hashes [][]byte) (block.MiniBlockSlice, [][]byte)
}

MiniBlocksResolverStub -

func (*MiniBlocksResolverStub) GetMiniBlocks 

func (hrm *MiniBlocksResolverStub) GetMiniBlocks(hashes [][]byte) (block.MiniBlockSlice, [][]byte)

GetMiniBlocks -

func (*MiniBlocksResolverStub) GetMiniBlocksFromPool 

func (hrm *MiniBlocksResolverStub) GetMiniBlocksFromPool(hashes [][]byte) (block.MiniBlockSlice, [][]byte)

GetMiniBlocksFromPool -

func (*MiniBlocksResolverStub) IsInterfaceNil 

func (hrm *MiniBlocksResolverStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MiniBlocksResolverStub) ProcessReceivedMessage 

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

ProcessReceivedMessage -

func (*MiniBlocksResolverStub) RequestDataFromHash 

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

RequestDataFromHash -

func (*MiniBlocksResolverStub) RequestDataFromHashArray 

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

RequestDataFromHashArray -

type MockTimer 

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

MockTimer -

func NewMockTimer 

func NewMockTimer() *MockTimer

NewMockTimer -

func (*MockTimer) IncrementSeconds 

func (m *MockTimer) IncrementSeconds(value int)

IncrementSeconds -

func (*MockTimer) IsInterfaceNil 

func (m *MockTimer) IsInterfaceNil() bool

IsInterfaceNil -

func (*MockTimer) Now 

func (m *MockTimer) Now() time.Time

Now -

func (*MockTimer) SetSeconds 

func (m *MockTimer) SetSeconds(value int)

SetSeconds -

type MultisignMock 

type MultisignMock struct {
}

MultisignMock -

func (*MultisignMock) AggregateCommitments 

func (mm *MultisignMock) AggregateCommitments(_ []byte) error

AggregateCommitments -

func (*MultisignMock) AggregateSigs 

func (mm *MultisignMock) AggregateSigs(_ []byte) ([]byte, error)

AggregateSigs -

func (*MultisignMock) Commitment 

func (mm *MultisignMock) Commitment(_ uint16) ([]byte, error)

Commitment -

func (*MultisignMock) CommitmentHash 

func (mm *MultisignMock) CommitmentHash(_ uint16) ([]byte, error)

CommitmentHash -

func (*MultisignMock) Create 

func (mm *MultisignMock) Create(_ []string, _ uint16) (crypto.MultiSigner, error)

Create -

func (*MultisignMock) CreateCommitment 

func (mm *MultisignMock) CreateCommitment() (commSecret []byte, commitment []byte)

CreateCommitment -

func (*MultisignMock) CreateSignatureShare 

func (mm *MultisignMock) CreateSignatureShare(_ []byte, _ []byte) ([]byte, error)

CreateSignatureShare -

func (*MultisignMock) IsInterfaceNil 

func (mm *MultisignMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*MultisignMock) Reset 

func (mm *MultisignMock) Reset(_ []string, _ uint16) error

Reset -

func (*MultisignMock) SetAggregatedSig 

func (mm *MultisignMock) SetAggregatedSig([]byte) error

SetAggregatedSig -

func (*MultisignMock) SignatureShare 

func (mm *MultisignMock) SignatureShare(_ uint16) ([]byte, error)

SignatureShare -

func (*MultisignMock) StoreCommitment 

func (mm *MultisignMock) StoreCommitment(_ uint16, _ []byte) error

StoreCommitment -

func (*MultisignMock) StoreCommitmentHash 

func (mm *MultisignMock) StoreCommitmentHash(_ uint16, _ []byte) error

StoreCommitmentHash -

func (*MultisignMock) StoreSignatureShare 

func (mm *MultisignMock) StoreSignatureShare(_ uint16, _ []byte) error

StoreSignatureShare -

func (*MultisignMock) Verify 

func (mm *MultisignMock) Verify(_ []byte, _ []byte) error

Verify -

func (*MultisignMock) VerifySignatureShare 

func (mm *MultisignMock) VerifySignatureShare(_ uint16, _ []byte, _ []byte, _ []byte) error

VerifySignatureShare -

type NetworkShardingCollectorStub 

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

func (*NetworkShardingCollectorStub) IsInterfaceNil 

func (nscs *NetworkShardingCollectorStub) IsInterfaceNil() bool

func (*NetworkShardingCollectorStub) UpdatePeerIdPublicKey 

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

func (*NetworkShardingCollectorStub) UpdatePeerIdShardId 

func (ncsc *NetworkShardingCollectorStub) UpdatePeerIdShardId(pid p2p.PeerID, shardId uint32)

func (*NetworkShardingCollectorStub) UpdatePublicKeyShardId 

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

type NodesCoordinatorMock 

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

NodesCoordinatorMock -

func (*NodesCoordinatorMock) ComputeConsensusGroup 

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

ComputeConsensusGroup -

func (*NodesCoordinatorMock) ComputeLeaving 

func (ncm *NodesCoordinatorMock) ComputeLeaving([]sharding.Validator) []sharding.Validator

ComputeLeaving -

func (*NodesCoordinatorMock) ConsensusGroupSize 

func (ncm *NodesCoordinatorMock) ConsensusGroupSize(uint32) int

ConsensusGroupSize -

func (*NodesCoordinatorMock) GetAllEligibleValidatorsPublicKeys 

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

GetAllEligibleValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetAllWaitingValidatorsPublicKeys 

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

GetAllWaitingValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetConsensusValidatorsPublicKeys 

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

GetConsensusValidatorsPublicKeys -

func (*NodesCoordinatorMock) GetConsensusValidatorsRewardsAddresses 

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

GetConsensusValidatorsRewardsAddresses -

func (*NodesCoordinatorMock) GetConsensusWhitelistedNodes 

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

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

func (*NodesCoordinatorMock) GetNumTotalEligible 

func (ncm *NodesCoordinatorMock) GetNumTotalEligible() uint64

GetNumTotalEligible -

func (*NodesCoordinatorMock) GetOwnPublicKey 

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

GetOwnPublicKey -

func (*NodesCoordinatorMock) GetSavedStateKey 

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

GetSavedStateKey -

func (*NodesCoordinatorMock) GetSelectedPublicKeys 

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

GetSelectedPublicKeys -

func (*NodesCoordinatorMock) GetValidatorWithPublicKey 

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

GetValidatorWithPublicKey -

func (*NodesCoordinatorMock) GetValidatorsIndexes 

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

GetValidatorsIndexes -

func (*NodesCoordinatorMock) IsInterfaceNil 

func (ncm *NodesCoordinatorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*NodesCoordinatorMock) LoadState 

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

LoadState -

func (*NodesCoordinatorMock) SetConsensusGroupSize 

func (ncm *NodesCoordinatorMock) SetConsensusGroupSize(_ int) error

SetConsensusGroupSize -

func (*NodesCoordinatorMock) SetNodesPerShards 

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

SetNodesPerShards -

func (*NodesCoordinatorMock) ShardIdForEpoch 

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

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

func (*NodesCoordinatorMock) ValidatorsWeights added in v0.0.5 

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

ValidatorsWeights -

type P2PAntifloodHandlerStub 

type P2PAntifloodHandlerStub struct {
	CanProcessMessageCalled        func(message p2p.MessageP2P, fromConnectedPeer p2p.PeerID) error
	CanProcessMessageOnTopicCalled func(peer p2p.PeerID, topic string) error
}

P2PAntifloodHandlerStub -

func (*P2PAntifloodHandlerStub) CanProcessMessage 

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

CanProcessMessage -

func (*P2PAntifloodHandlerStub) CanProcessMessageOnTopic 

func (p2pahs *P2PAntifloodHandlerStub) CanProcessMessageOnTopic(peer p2p.PeerID, topic string) error

CanProcessMessageOnTopic -

func (*P2PAntifloodHandlerStub) IsInterfaceNil 

func (p2pahs *P2PAntifloodHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*P2PAntifloodHandlerStub) ResetForTopic 

func (p2pahs *P2PAntifloodHandlerStub) ResetForTopic(_ string)

ResetForTopic -

func (*P2PAntifloodHandlerStub) SetMaxMessagesForTopic 

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

SetMaxMessagesForTopic -

type P2PMessageMock 

type P2PMessageMock struct {
	FromField      []byte
	DataField      []byte
	SeqNoField     []byte
	TopicsField    []string
	SignatureField []byte
	KeyField       []byte
	PeerField      p2p.PeerID
}

P2PMessageMock -

func (*P2PMessageMock) Data 

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

Data -

func (*P2PMessageMock) From 

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

From -

func (*P2PMessageMock) IsInterfaceNil 

func (msg *P2PMessageMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*P2PMessageMock) Key 

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

Key -

func (*P2PMessageMock) Peer 

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

Peer -

func (*P2PMessageMock) SeqNo 

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

SeqNo -

func (*P2PMessageMock) Signature 

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

Signature -

func (*P2PMessageMock) Topics 

func (msg *P2PMessageMock) Topics() []string

Topics -

type P2PMessageStub 

type P2PMessageStub struct {
	FromField      []byte
	DataField      []byte
	SeqNoField     []byte
	TopicsField    []string
	SignatureField []byte
	KeyField       []byte
	PeerField      p2p.PeerID
}

P2PMessageStub -

func (*P2PMessageStub) Data 

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

Data -

func (*P2PMessageStub) From 

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

From -

func (*P2PMessageStub) IsInterfaceNil 

func (msg *P2PMessageStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*P2PMessageStub) Key 

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

Key -

func (*P2PMessageStub) Peer 

func (msg *P2PMessageStub) Peer() p2p.PeerID

Peer -

func (*P2PMessageStub) SeqNo 

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

SeqNo -

func (*P2PMessageStub) Signature 

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

Signature -

func (*P2PMessageStub) Topics 

func (msg *P2PMessageStub) Topics() []string

Topics -

type PeerTypeProviderStub 

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

PeerTypeProviderStub -

func (*PeerTypeProviderStub) ComputeForPubKey 

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

ComputeForPubKey -

func (*PeerTypeProviderStub) IsInterfaceNil 

func (p *PeerTypeProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

type PendingMiniBlocksHandlerStub 

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

PendingMiniBlocksHandlerStub -

func (*PendingMiniBlocksHandlerStub) AddProcessedHeader 

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

AddProcessedHeader -

func (*PendingMiniBlocksHandlerStub) GetPendingMiniBlocks 

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

GetPendingMiniBlocks -

func (*PendingMiniBlocksHandlerStub) IsInterfaceNil 

func (p *PendingMiniBlocksHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*PendingMiniBlocksHandlerStub) RevertHeader 

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

RevertHeader -

func (*PendingMiniBlocksHandlerStub) SetPendingMiniBlocks 

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

SetPendingMiniBlocks -

type PoolsHolderStub 

type PoolsHolderStub struct {
	HeadersCalled              func() dataRetriever.HeadersPool
	PeerChangesBlocksCalled    func() storage.Cacher
	TransactionsCalled         func() dataRetriever.ShardedDataCacherNotifier
	UnsignedTransactionsCalled func() dataRetriever.ShardedDataCacherNotifier
	RewardTransactionsCalled   func() dataRetriever.ShardedDataCacherNotifier
	MiniBlocksCalled           func() storage.Cacher
	CurrBlockTxsCalled         func() dataRetriever.TransactionCacher
	TrieNodesCalled            func() storage.Cacher
}

PoolsHolderStub -

func (*PoolsHolderStub) CurrentBlockTxs 

func (phs *PoolsHolderStub) CurrentBlockTxs() dataRetriever.TransactionCacher

CurrentBlockTxs -

func (*PoolsHolderStub) Headers 

func (phs *PoolsHolderStub) Headers() dataRetriever.HeadersPool

Headers -

func (*PoolsHolderStub) IsInterfaceNil 

func (phs *PoolsHolderStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PoolsHolderStub) MiniBlocks 

func (phs *PoolsHolderStub) MiniBlocks() storage.Cacher

MiniBlocks -

func (*PoolsHolderStub) PeerChangesBlocks 

func (phs *PoolsHolderStub) PeerChangesBlocks() storage.Cacher

PeerChangesBlocks -

func (*PoolsHolderStub) RewardTransactions 

func (phs *PoolsHolderStub) RewardTransactions() dataRetriever.ShardedDataCacherNotifier

RewardTransactions -

func (*PoolsHolderStub) Transactions 

func (phs *PoolsHolderStub) Transactions() dataRetriever.ShardedDataCacherNotifier

Transactions -

func (*PoolsHolderStub) TrieNodes 

func (phs *PoolsHolderStub) TrieNodes() storage.Cacher

TrieNodes -

func (*PoolsHolderStub) UnsignedTransactions 

func (phs *PoolsHolderStub) UnsignedTransactions() dataRetriever.ShardedDataCacherNotifier

UnsignedTransactions -

type PrivateKeyStub 

type PrivateKeyStub struct {
	ToByteArrayHandler    func() ([]byte, error)
	GeneratePublicHandler func() crypto.PublicKey
	SuiteHandler          func() crypto.Suite
	ScalarHandler         func() crypto.Scalar
}

PrivateKeyStub -

func (*PrivateKeyStub) GeneratePublic 

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

GeneratePublic -

func (*PrivateKeyStub) IsInterfaceNil 

func (sk *PrivateKeyStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PrivateKeyStub) Scalar 

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

Scalar -

func (*PrivateKeyStub) Suite 

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

Suite -

func (*PrivateKeyStub) ToByteArray 

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

ToByteArray -

type PublicKeyMock 

type PublicKeyMock struct {
	ToByteArrayHandler func() ([]byte, error)
	SuiteCalled        func() crypto.Suite
	PointCalled        func() crypto.Point
}

PublicKeyMock -

func (*PublicKeyMock) IsInterfaceNil 

func (sspk *PublicKeyMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*PublicKeyMock) Point 

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

Point -

func (*PublicKeyMock) Suite 

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

Suite -

func (*PublicKeyMock) ToByteArray 

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

ToByteArray -

type RequestHandlerStub 

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

RequestHandlerStub -

func (*RequestHandlerStub) IsInterfaceNil 

func (rhs *RequestHandlerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*RequestHandlerStub) RequestMetaHeader 

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

RequestMetaHeader -

func (*RequestHandlerStub) RequestMetaHeaderByNonce 

func (rhs *RequestHandlerStub) RequestMetaHeaderByNonce(nonce uint64)

RequestMetaHeaderByNonce -

func (*RequestHandlerStub) RequestMiniBlock 

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

RequestMiniBlock -

func (*RequestHandlerStub) RequestMiniBlocks 

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

RequestMiniBlocks -

func (*RequestHandlerStub) RequestRewardTransactions 

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

RequestRewardTransactions -

func (*RequestHandlerStub) RequestShardHeader 

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

RequestShardHeader -

func (*RequestHandlerStub) RequestShardHeaderByNonce 

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

RequestShardHeaderByNonce -

func (*RequestHandlerStub) RequestStartOfEpochMetaBlock 

func (rhs *RequestHandlerStub) RequestStartOfEpochMetaBlock(epoch uint32)

RequestStartOfEpochMetaBlock -

func (*RequestHandlerStub) RequestTransaction 

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

RequestTransaction -

func (*RequestHandlerStub) RequestTrieNodes 

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

RequestTrieNodes -

func (*RequestHandlerStub) RequestUnsignedTransactions 

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

RequestUnsignedTransactions -

func (*RequestHandlerStub) SetEpoch 

func (rhs *RequestHandlerStub) SetEpoch(epoch uint32)

SetEpoch -

type RequestedItemsHandlerStub 

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

RequestedItemsHandlerStub -

func (*RequestedItemsHandlerStub) Add 

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

Add -

func (*RequestedItemsHandlerStub) Has 

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

Has -

func (*RequestedItemsHandlerStub) IsInterfaceNil 

func (rihs *RequestedItemsHandlerStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*RequestedItemsHandlerStub) Sweep 

func (rihs *RequestedItemsHandlerStub) Sweep()

Sweep -

type ResolversFinderStub 

type ResolversFinderStub struct {
	GetCalled                func(key string) (dataRetriever.Resolver, error)
	AddCalled                func(key string, val dataRetriever.Resolver) error
	ReplaceCalled            func(key string, val dataRetriever.Resolver) error
	RemoveCalled             func(key string)
	LenCalled                func() int
	IntraShardResolverCalled func(baseTopic string) (dataRetriever.Resolver, error)
	MetaChainResolverCalled  func(baseTopic string) (dataRetriever.Resolver, error)
	CrossShardResolverCalled func(baseTopic string, crossShard uint32) (dataRetriever.Resolver, error)
	ResolverKeysCalled       func() string
}

ResolversFinderStub -

func (*ResolversFinderStub) Add 

func (rfs *ResolversFinderStub) Add(key string, val dataRetriever.Resolver) error

Add -

func (*ResolversFinderStub) AddMultiple 

func (rfs *ResolversFinderStub) AddMultiple(_ []string, _ []dataRetriever.Resolver) error

AddMultiple -

func (*ResolversFinderStub) CrossShardResolver 

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

CrossShardResolver -

func (*ResolversFinderStub) Get 

func (rfs *ResolversFinderStub) Get(key string) (dataRetriever.Resolver, error)

Get -

func (*ResolversFinderStub) IntraShardResolver 

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

IntraShardResolver -

func (*ResolversFinderStub) IsInterfaceNil 

func (rfs *ResolversFinderStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ResolversFinderStub) Len 

func (rfs *ResolversFinderStub) Len() int

Len -

func (*ResolversFinderStub) MetaChainResolver 

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

MetaChainResolver -

func (*ResolversFinderStub) Remove 

func (rfs *ResolversFinderStub) Remove(key string)

Remove -

func (*ResolversFinderStub) Replace 

func (rfs *ResolversFinderStub) Replace(key string, val dataRetriever.Resolver) error

Replace -

func (*ResolversFinderStub) ResolverKeys 

func (rcs *ResolversFinderStub) ResolverKeys() string

ResolverKeys -

type RounderMock 

type RounderMock struct {
	IndexCalled         func() int64
	TimeDurationCalled  func() time.Duration
	TimeStampCalled     func() time.Time
	UpdateRoundCalled   func(time.Time, time.Time)
	RemainingTimeCalled func(startTime time.Time, maxTime time.Duration) time.Duration
	// contains filtered or unexported fields
}

RounderMock -

func (*RounderMock) Index 

func (rndm *RounderMock) Index() int64

Index -

func (*RounderMock) IsInterfaceNil 

func (rndm *RounderMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*RounderMock) RemainingTime 

func (rndm *RounderMock) RemainingTime(startTime time.Time, maxTime time.Duration) time.Duration

RemainingTime -

func (*RounderMock) TimeDuration 

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

TimeDuration -

func (*RounderMock) TimeStamp 

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

TimeStamp -

func (*RounderMock) UpdateRound 

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

UpdateRound -

type SCQueryServiceStub 

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

SCQueryServiceStub -

func (*SCQueryServiceStub) ComputeScCallGasLimit 

func (serviceStub *SCQueryServiceStub) ComputeScCallGasLimit(tx *transaction.Transaction) (uint64, error)

ComputeScCallGasLimit -

func (*SCQueryServiceStub) ExecuteQuery 

func (serviceStub *SCQueryServiceStub) ExecuteQuery(query *process.SCQuery) (*vmcommon.VMOutput, error)

ExecuteQuery -

func (*SCQueryServiceStub) IsInterfaceNil 

func (serviceStub *SCQueryServiceStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

type ShardCoordinatorMock 

type ShardCoordinatorMock struct {
	SelfShardId uint32
}

ShardCoordinatorMock -

func (ShardCoordinatorMock) CommunicationIdentifier 

func (scm ShardCoordinatorMock) CommunicationIdentifier(destShardID uint32) string

CommunicationIdentifier -

func (ShardCoordinatorMock) ComputeId 

func (scm ShardCoordinatorMock) ComputeId(_ state.AddressContainer) uint32

ComputeId -

func (*ShardCoordinatorMock) IsInterfaceNil 

func (scm *ShardCoordinatorMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (ShardCoordinatorMock) NumberOfShards 

func (scm ShardCoordinatorMock) NumberOfShards() uint32

NumberOfShards -

func (ShardCoordinatorMock) SameShard 

func (scm ShardCoordinatorMock) SameShard(_, _ state.AddressContainer) bool

SameShard -

func (ShardCoordinatorMock) SelfId 

func (scm ShardCoordinatorMock) SelfId() uint32

SelfId -

func (ShardCoordinatorMock) SetSelfShardId 

func (scm ShardCoordinatorMock) SetSelfShardId(shardId uint32) error

SetSelfShardId -

type ShardedDataStub 

type ShardedDataStub struct {
	RegisterHandlerCalled         func(func(key []byte))
	ShardDataStoreCalled          func(cacheId string) (c storage.Cacher)
	AddDataCalled                 func(key []byte, data interface{}, cacheId string)
	SearchFirstDataCalled         func(key []byte) (value interface{}, ok bool)
	RemoveDataCalled              func(key []byte, cacheId string)
	RemoveDataFromAllShardsCalled func(key []byte)
	MergeShardStoresCalled        func(sourceCacheId, destCacheId string)
	MoveDataCalled                func(sourceCacheId, destCacheId string, key [][]byte)
	ClearCalled                   func()
	ClearShardStoreCalled         func(cacheId string)
	RemoveSetOfDataFromPoolCalled func(keys [][]byte, destCacheId string)
	CreateShardStoreCalled        func(destCacheId string)
}

ShardedDataStub -

func (*ShardedDataStub) AddData 

func (sd *ShardedDataStub) AddData(key []byte, data interface{}, cacheId string)

AddData -

func (*ShardedDataStub) Clear 

func (sd *ShardedDataStub) Clear()

Clear -

func (*ShardedDataStub) ClearShardStore 

func (sd *ShardedDataStub) ClearShardStore(cacheId string)

ClearShardStore -

func (*ShardedDataStub) CreateShardStore 

func (sd *ShardedDataStub) CreateShardStore(cacheId string)

CreateShardStore -

func (*ShardedDataStub) IsInterfaceNil 

func (sd *ShardedDataStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ShardedDataStub) MergeShardStores 

func (sd *ShardedDataStub) MergeShardStores(sourceCacheId, destCacheId string)

MergeShardStores -

func (*ShardedDataStub) RegisterHandler 

func (sd *ShardedDataStub) RegisterHandler(handler func(key []byte))

RegisterHandler -

func (*ShardedDataStub) RemoveData 

func (sd *ShardedDataStub) RemoveData(key []byte, cacheId string)

RemoveData -

func (*ShardedDataStub) RemoveDataFromAllShards 

func (sd *ShardedDataStub) RemoveDataFromAllShards(key []byte)

RemoveDataFromAllShards -

func (*ShardedDataStub) RemoveSetOfDataFromPool 

func (sd *ShardedDataStub) RemoveSetOfDataFromPool(keys [][]byte, cacheId string)

RemoveSetOfDataFromPool -

func (*ShardedDataStub) SearchFirstData 

func (sd *ShardedDataStub) SearchFirstData(key []byte) (value interface{}, ok bool)

SearchFirstData -

func (*ShardedDataStub) ShardDataStore 

func (sd *ShardedDataStub) ShardDataStore(cacheId string) (c storage.Cacher)

ShardDataStore -

type SingleSignerMock 

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

SingleSignerMock -

func (*SingleSignerMock) IsInterfaceNil 

func (s *SingleSignerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SingleSignerMock) Sign 

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

Sign -

func (*SingleSignerMock) Verify 

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

Verify -

type SinglesignFailMock 

type SinglesignFailMock struct {
}

SinglesignFailMock -

func (*SinglesignFailMock) IsInterfaceNil 

func (s *SinglesignFailMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SinglesignFailMock) Sign 

func (s *SinglesignFailMock) Sign(_ crypto.PrivateKey, _ []byte) ([]byte, error)

Sign Signs a message with using a single signature schnorr scheme

func (*SinglesignFailMock) Verify 

func (s *SinglesignFailMock) Verify(_ crypto.PublicKey, _ []byte, _ []byte) error

Verify verifies a signature using a single signature schnorr scheme

type SinglesignMock 

type SinglesignMock struct {
}

SinglesignMock -

func (*SinglesignMock) IsInterfaceNil 

func (s *SinglesignMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SinglesignMock) Sign 

func (s *SinglesignMock) Sign(_ crypto.PrivateKey, _ []byte) ([]byte, error)

Sign Signs a message with using a single signature schnorr scheme

func (*SinglesignMock) Verify 

func (s *SinglesignMock) Verify(_ crypto.PublicKey, _ []byte, sig []byte) error

Verify verifies a signature using a single signature schnorr scheme

type SinglesignStub 

type SinglesignStub struct {
	SignCalled   func(private crypto.PrivateKey, msg []byte) ([]byte, error)
	VerifyCalled func(public crypto.PublicKey, msg []byte, sig []byte) error
}

SinglesignStub -

func (*SinglesignStub) IsInterfaceNil 

func (s *SinglesignStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SinglesignStub) Sign 

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

Sign Signs a message with using a single signature schnorr scheme

func (*SinglesignStub) Verify 

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

Verify verifies a signature using a single signature schnorr scheme

type StatusMetricsStub 

type StatusMetricsStub struct {
	StatusMetricsMapWithoutP2PCalled func() map[string]interface{}
	StatusP2pMetricsMapCalled        func() map[string]interface{}
	EpochMetricsCalled               func() map[string]interface{}
	IsInterfaceNilCalled             func() bool
}

StatusMetricsStub -

func (*StatusMetricsStub) EpochMetrics added in v0.0.5 

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

EpochMetrics -

func (*StatusMetricsStub) IsInterfaceNil 

func (sms *StatusMetricsStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*StatusMetricsStub) StatusMetricsMapWithoutP2P 

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

StatusMetricsMapWithoutP2P -

func (*StatusMetricsStub) StatusP2pMetricsMap 

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

StatusP2pMetricsMap -

type StorerMock 

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

StorerMock -

func NewStorerMock 

func NewStorerMock() *StorerMock

NewStorerMock -

func (*StorerMock) ClearCache 

func (sm *StorerMock) ClearCache()

ClearCache -

func (*StorerMock) Close 

func (sm *StorerMock) Close() error

Close -

func (*StorerMock) DestroyUnit 

func (sm *StorerMock) DestroyUnit() error

DestroyUnit -

func (*StorerMock) Get 

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

Get -

func (*StorerMock) GetFromEpoch 

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

GetFromEpoch -

func (*StorerMock) Has 

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

Has -

func (*StorerMock) HasInEpoch 

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

HasInEpoch -

func (*StorerMock) IsInterfaceNil 

func (sm *StorerMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*StorerMock) Put 

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

Put -

func (*StorerMock) Remove 

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

Remove -

func (*StorerMock) SearchFirst 

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

SearchFirst -

type StorerStub 

type StorerStub struct {
	PutCalled          func(key, data []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
	SearchFirstCalled  func(key []byte) ([]byte, error)
	RemoveCalled       func(key []byte) error
	ClearCacheCalled   func()
	DestroyUnitCalled  func() error
}

StorerStub -

func (*StorerStub) ClearCache 

func (ss *StorerStub) ClearCache()

ClearCache -

func (*StorerStub) Close 

func (ss *StorerStub) Close() error

Close -

func (*StorerStub) DestroyUnit 

func (ss *StorerStub) DestroyUnit() error

DestroyUnit -

func (*StorerStub) Get 

func (ss *StorerStub) Get(key []byte) ([]byte, error)

Get -

func (*StorerStub) GetFromEpoch 

func (ss *StorerStub) GetFromEpoch(key []byte, epoch uint32) ([]byte, error)

GetFromEpoch -

func (*StorerStub) Has 

func (ss *StorerStub) Has(key []byte) error

Has -

func (*StorerStub) HasInEpoch 

func (ss *StorerStub) HasInEpoch(key []byte, epoch uint32) error

HasInEpoch -

func (*StorerStub) IsInterfaceNil 

func (ss *StorerStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*StorerStub) Put 

func (ss *StorerStub) Put(key, data []byte) error

Put -

func (*StorerStub) Remove 

func (ss *StorerStub) Remove(key []byte) error

Remove -

func (*StorerStub) SearchFirst 

func (ss *StorerStub) SearchFirst(key []byte) ([]byte, error)

SearchFirst -

type Streamer 

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

Streamer -

func NewStreamer 

func NewStreamer() *Streamer

NewStreamer -

func (*Streamer) XORKeyStream 

func (stream *Streamer) XORKeyStream(dst, src []byte)

XORKeyStream -

type SuiteMock 

type SuiteMock struct {
	StringStub               func() string
	ScalarLenStub            func() int
	CreateScalarStub         func() crypto.Scalar
	PointLenStub             func() int
	CreatePointStub          func() crypto.Point
	CreatePointForScalarStub func(scalar crypto.Scalar) crypto.Point
	RandomStreamStub         func() cipher.Stream
	GetUnderlyingSuiteStub   func() interface{}
}

SuiteMock -

func (*SuiteMock) CreatePoint 

func (s *SuiteMock) CreatePoint() crypto.Point

CreatePoint -

func (*SuiteMock) CreateScalar 

func (s *SuiteMock) CreateScalar() crypto.Scalar

CreateScalar -

func (*SuiteMock) GetUnderlyingSuite 

func (s *SuiteMock) GetUnderlyingSuite() interface{}

GetUnderlyingSuite -

func (*SuiteMock) IsInterfaceNil 

func (s *SuiteMock) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SuiteMock) PointLen 

func (s *SuiteMock) PointLen() int

PointLen -

func (*SuiteMock) RandomStream 

func (s *SuiteMock) RandomStream() cipher.Stream

RandomStream -

func (*SuiteMock) ScalarLen 

func (s *SuiteMock) ScalarLen() int

ScalarLen -

func (*SuiteMock) String 

func (s *SuiteMock) String() string

String -

type SyncStub 

type SyncStub struct {
}

SyncStub -

func (*SyncStub) ClockOffset 

func (ss *SyncStub) ClockOffset() time.Duration

ClockOffset -

func (*SyncStub) CurrentTime 

func (ss *SyncStub) CurrentTime() time.Time

CurrentTime -

func (*SyncStub) FormattedCurrentTime 

func (ss *SyncStub) FormattedCurrentTime() string

FormattedCurrentTime -

func (*SyncStub) IsInterfaceNil 

func (ss *SyncStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*SyncStub) StartSync 

func (ss *SyncStub) StartSync()

StartSync -

type TransactionCostEstimatorMock 

type TransactionCostEstimatorMock struct {
	ComputeTransactionGasLimitCalled func(tx *transaction.Transaction) (uint64, error)
}

TransactionCostEstimatorMock --

func (*TransactionCostEstimatorMock) ComputeTransactionGasLimit 

func (tcem *TransactionCostEstimatorMock) ComputeTransactionGasLimit(tx *transaction.Transaction) (uint64, error)

ComputeTransactionGasLimit --

func (*TransactionCostEstimatorMock) IsInterfaceNil 

func (tcem *TransactionCostEstimatorMock) IsInterfaceNil() bool

IsInterfaceNil --

type TrieStub 

type TrieStub struct {
	GetCalled                func(key []byte) ([]byte, error)
	UpdateCalled             func(key, value []byte) error
	DeleteCalled             func(key []byte) error
	RootCalled               func() ([]byte, error)
	CommitCalled             func() error
	RecreateCalled           func(root []byte) (data.Trie, error)
	CancelPruneCalled        func(rootHash []byte, identifier data.TriePruningIdentifier)
	PruneCalled              func(rootHash []byte, identifier data.TriePruningIdentifier)
	ResetOldHashesCalled     func() [][]byte
	AppendToOldHashesCalled  func([][]byte)
	GetSerializedNodesCalled func([]byte, uint64) ([][]byte, error)
	DatabaseCalled           func() data.DBWriteCacher
}

TrieStub -

func (*TrieStub) AppendToOldHashes 

func (ts *TrieStub) AppendToOldHashes(hashes [][]byte)

AppendToOldHashes appends the given hashes to the trie's oldHashes variable

func (*TrieStub) CancelPrune 

func (ts *TrieStub) CancelPrune(rootHash []byte, identifier data.TriePruningIdentifier)

CancelPrune invalidates the hashes that correspond to the given root hash from the eviction waiting list

func (*TrieStub) ClosePersister 

func (ts *TrieStub) ClosePersister() error

ClosePersister -

func (*TrieStub) Commit 

func (ts *TrieStub) Commit() error

Commit -

func (*TrieStub) Database 

func (ts *TrieStub) Database() data.DBWriteCacher

Database -

func (*TrieStub) Delete 

func (ts *TrieStub) Delete(key []byte) error

Delete -

func (*TrieStub) Get 

func (ts *TrieStub) Get(key []byte) ([]byte, error)

Get -

func (*TrieStub) GetAllLeaves 

func (ts *TrieStub) GetAllLeaves() (map[string][]byte, error)

GetAllLeaves -

func (*TrieStub) GetSerializedNodes 

func (ts *TrieStub) GetSerializedNodes(hash []byte, maxBuffToSend uint64) ([][]byte, error)

GetSerializedNodes -

func (*TrieStub) IsInterfaceNil 

func (ts *TrieStub) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*TrieStub) IsPruningEnabled 

func (ts *TrieStub) IsPruningEnabled() bool

IsPruningEnabled -

func (*TrieStub) Prune 

func (ts *TrieStub) Prune(rootHash []byte, identifier data.TriePruningIdentifier)

Prune removes from the database all the old hashes that correspond to the given root hash

func (*TrieStub) Recreate 

func (ts *TrieStub) Recreate(root []byte) (data.Trie, error)

Recreate -

func (*TrieStub) ResetOldHashes 

func (ts *TrieStub) ResetOldHashes() [][]byte

ResetOldHashes resets the oldHashes and oldRoot variables and returns the old hashes

func (*TrieStub) Root 

func (ts *TrieStub) Root() ([]byte, error)

Root -

func (*TrieStub) SetCheckpoint 

func (ts *TrieStub) SetCheckpoint(_ []byte)

SetCheckpoint -

func (*TrieStub) String 

func (ts *TrieStub) String() string

String -

func (*TrieStub) TakeSnapshot 

func (ts *TrieStub) TakeSnapshot(_ []byte)

TakeSnapshot -

func (*TrieStub) Update 

func (ts *TrieStub) Update(key, value []byte) error

Update -

type Uint64CacherStub 

type Uint64CacherStub struct {
	ClearCalled           func()
	PutCalled             func(uint64, []byte) bool
	GetCalled             func(uint64) ([]byte, bool)
	HasCalled             func(uint64) bool
	PeekCalled            func(uint64) ([]byte, bool)
	HasOrAddCalled        func(uint64, []byte) (bool, bool)
	RemoveCalled          func(uint64)
	RemoveOldestCalled    func()
	KeysCalled            func() []uint64
	LenCalled             func() int
	RegisterHandlerCalled func(handler func(nonce uint64))
}

Uint64CacherStub -

func (*Uint64CacherStub) Clear 

func (ucs *Uint64CacherStub) Clear()

Clear -

func (*Uint64CacherStub) Get 

func (ucs *Uint64CacherStub) Get(nonce uint64) ([]byte, bool)

Get -

func (*Uint64CacherStub) Has 

func (ucs *Uint64CacherStub) Has(nonce uint64) bool

Has -

func (*Uint64CacherStub) HasOrAdd 

func (ucs *Uint64CacherStub) HasOrAdd(nonce uint64, value []byte) (bool, bool)

HasOrAdd -

func (*Uint64CacherStub) Keys 

func (ucs *Uint64CacherStub) Keys() []uint64

Keys -

func (*Uint64CacherStub) Len 

func (ucs *Uint64CacherStub) Len() int

Len -

func (*Uint64CacherStub) Peek 

func (ucs *Uint64CacherStub) Peek(nonce uint64) ([]byte, bool)

Peek -

func (*Uint64CacherStub) Put 

func (ucs *Uint64CacherStub) Put(nonce uint64, value []byte) bool

Put -

func (*Uint64CacherStub) RegisterHandler 

func (ucs *Uint64CacherStub) RegisterHandler(handler func(nonce uint64))

RegisterHandler -

func (*Uint64CacherStub) Remove 

func (ucs *Uint64CacherStub) Remove(nonce uint64)

Remove -

func (*Uint64CacherStub) RemoveOldest 

func (ucs *Uint64CacherStub) RemoveOldest()

RemoveOldest -

type ValidatorMock 

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

ValidatorMock -

func NewValidatorMock 

func NewValidatorMock(pubKey []byte, address []byte) *ValidatorMock

NewValidatorMock -

func (*ValidatorMock) Address 

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

Address -

func (*ValidatorMock) Chances added in v0.0.5 

func (vm *ValidatorMock) Chances() uint32

Chances -

func (*ValidatorMock) Clone added in v0.0.5 

func (vm *ValidatorMock) Clone() (interface{}, error)

Clone clones the validator

func (*ValidatorMock) PubKey 

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

PubKey -

func (*ValidatorMock) SetChances added in v0.0.5 

func (vm *ValidatorMock) SetChances(chances uint32)

SetChances -

type ValidatorStatisticsProcessorMock 

type ValidatorStatisticsProcessorMock struct {
	UpdatePeerStateCalled func(header data.HeaderHandler) ([]byte, error)
	RevertPeerStateCalled func(header data.HeaderHandler) error
	IsInterfaceNilCalled  func() bool

	GetPeerAccountCalled                     func(address []byte) (state.PeerAccountHandler, error)
	RootHashCalled                           func() ([]byte, error)
	ResetValidatorStatisticsAtNewEpochCalled func(vInfos map[uint32][]*state.ValidatorInfo) error
	GetValidatorInfoForRootHashCalled        func(rootHash []byte) (map[uint32][]*state.ValidatorInfo, error)
	ProcessCalled                            func(validatorInfo data.ShardValidatorInfoHandler) error
	CommitCalled                             func() ([]byte, error)
	ProcessRatingsEndOfEpochCalled           func(validatorInfos map[uint32][]*state.ValidatorInfo) error
}

ValidatorStatisticsProcessorMock -

func (*ValidatorStatisticsProcessorMock) Commit added in v0.0.5 

func (pm *ValidatorStatisticsProcessorMock) Commit() ([]byte, error)

Commit -

func (*ValidatorStatisticsProcessorMock) GetPeerAccount 

func (vsp *ValidatorStatisticsProcessorMock) GetPeerAccount(address []byte) (state.PeerAccountHandler, error)

GetPeerAccount -

func (*ValidatorStatisticsProcessorMock) GetValidatorInfoForRootHash 

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

GetValidatorInfoForRootHash -

func (*ValidatorStatisticsProcessorMock) IsInterfaceNil 

func (vsp *ValidatorStatisticsProcessorMock) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorStatisticsProcessorMock) Process 

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

Process -

func (*ValidatorStatisticsProcessorMock) ProcessRatingsEndOfEpoch added in v0.0.5 

func (vsp *ValidatorStatisticsProcessorMock) ProcessRatingsEndOfEpoch(validatorInfos map[uint32][]*state.ValidatorInfo) error

ProcessRatingsEndOfEpoch -

func (*ValidatorStatisticsProcessorMock) ResetValidatorStatisticsAtNewEpoch 

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

ResetValidatorStatisticsAtNewEpoch -

func (*ValidatorStatisticsProcessorMock) RevertPeerState 

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

RevertPeerState -

func (*ValidatorStatisticsProcessorMock) RootHash 

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

RootHash -

func (*ValidatorStatisticsProcessorMock) UpdatePeerState 

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

UpdatePeerState -

type ValidatorStatisticsProcessorStub 

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

ValidatorStatisticsProcessorStub -

func (*ValidatorStatisticsProcessorStub) Commit added in v0.0.5 

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

Commit -

func (*ValidatorStatisticsProcessorStub) GetPeerAccount 

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

GetPeerAccount -

func (*ValidatorStatisticsProcessorStub) GetValidatorInfoForRootHash 

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

GetValidatorInfoForRootHash -

func (*ValidatorStatisticsProcessorStub) IsInterfaceNil 

func (vsp *ValidatorStatisticsProcessorStub) IsInterfaceNil() bool

IsInterfaceNil -

func (*ValidatorStatisticsProcessorStub) Process 

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

Process -

func (*ValidatorStatisticsProcessorStub) ProcessRatingsEndOfEpoch added in v0.0.5 

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

ProcessRatingsEndOfEpoch -

func (*ValidatorStatisticsProcessorStub) ResetValidatorStatisticsAtNewEpoch 

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

ResetValidatorStatisticsAtNewEpoch -

func (*ValidatorStatisticsProcessorStub) RevertPeerState 

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

RevertPeerState -

func (*ValidatorStatisticsProcessorStub) RootHash 

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

RootHash -

func (*ValidatorStatisticsProcessorStub) UpdatePeerState 

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

UpdatePeerState -

type ValidatorsProviderStub added in v0.0.5 

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

ValidatorsProviderStub -

func (*ValidatorsProviderStub) GetLatestValidators added in v0.0.5 

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

GetLatestValidators -

func (*ValidatorsProviderStub) IsInterfaceNil added in v0.0.5 

func (vp *ValidatorsProviderStub) IsInterfaceNil() bool

IsInterfaceNil -

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.