mock

package

Go to main page

Versions in this module

v0

v0.0.2

Oct 31, 2023

Changes in this version

type AccountsStub

+ GetNumCheckpointsCalled func() uint32

+ func (as *AccountsStub) GetNumCheckpoints() uint32

type BlockChainHookHandlerMock

+ IsPayableCalled func(address []byte) (bool, error)

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

type GenesisNodeInfoHandlerMock

+ InitialRatingValue uint32

+ func (gnihm *GenesisNodeInfoHandlerMock) GetInitialRating() uint32

type NodeInfoMock

+ func (n *NodeInfoMock) GetInitialRating() uint32

type StorageManagerStub

+ func (sms *StorageManagerStub) GetSnapshotDbBatchDelay() int

type StorerMock

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

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

v0.0.1

Oct 30, 2023

Changes in this version

+ var ErrNegativeValue = errors.New("negative value provided")

+ type AccountsParserStub struct

+ GetInitialAccountsForDelegatedCalled func(addressBytes []byte) []genesis.InitialAccountHandler

+ GetTotalStakedForDelegationAddressCalled func(delegationAddress string) *big.Int

+ InitialAccountsCalled func() []genesis.InitialAccountHandler

+ InitialAccountsSplitOnAddressesShardsCalled func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)

+ InitialAccountsSplitOnDelegationAddressesShardsCalled func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialAccountHandler, error)

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

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

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

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

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

+ func (aps *AccountsParserStub) IsInterfaceNil() bool

+ type AccountsStub struct

+ AddJournalEntryCalled func(je state.JournalEntry)

+ CancelPruneCalled func(rootHash []byte, identifier data.TriePruningIdentifier)

+ CommitCalled func() ([]byte, error)

+ GetAllLeavesCalled func(rootHash []byte) (map[string][]byte, error)

+ GetExistingAccountCalled func(addressContainer []byte) (state.AccountHandler, error)

+ IsPruningEnabledCalled func() bool

+ JournalLenCalled func() int

+ LoadAccountCalled func(container []byte) (state.AccountHandler, error)

+ PruneTrieCalled func(rootHash []byte, identifier data.TriePruningIdentifier)

+ RecreateAllTriesCalled func(rootHash []byte) (map[string]data.Trie, error)

+ RecreateTrieCalled func(rootHash []byte) error

+ RemoveAccountCalled func(addressContainer []byte) error

+ RevertToSnapshotCalled func(snapshot int) error

+ RootHashCalled func() ([]byte, error)

+ SaveAccountCalled func(account state.AccountHandler) error

+ SetStateCheckpointCalled func(rootHash []byte)

+ SnapshotStateCalled func(rootHash []byte)

+ func (as *AccountsStub) AddJournalEntry(je state.JournalEntry)

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

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

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

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

+ func (as *AccountsStub) IsInterfaceNil() bool

+ func (as *AccountsStub) IsPruningEnabled() bool

+ func (as *AccountsStub) JournalLen() int

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

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

+ func (as *AccountsStub) RecreateAllTries(rootHash []byte) (map[string]data.Trie, error)

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

+ func (as *AccountsStub) RemoveAccount(addressContainer []byte) error

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

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

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

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

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

+ type BaseAccountMock struct

+ AddressBytesField []byte

+ Nonce uint64

+ func (bam *BaseAccountMock) AddressBytes() []byte

+ func (bam *BaseAccountMock) GetNonce() uint64

+ func (bam *BaseAccountMock) IncreaseNonce(nonce uint64)

+ func (bam *BaseAccountMock) IsInterfaceNil() bool

+ type BlockChainHookHandlerMock struct

+ AddTempAccountCalled func(address []byte, balance *big.Int, nonce uint64)

+ CleanTempAccountsCalled func()

+ NewAddressCalled func(creatorAddress []byte, creatorNonce uint64, vmType []byte) ([]byte, error)

+ SetCurrentHeaderCalled func(hdr data.HeaderHandler)

+ TempAccountCalled func(address []byte) state.AccountHandler

+ func (e *BlockChainHookHandlerMock) AddTempAccount(address []byte, balance *big.Int, nonce uint64)

+ func (e *BlockChainHookHandlerMock) CleanTempAccounts()

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

+ func (e *BlockChainHookHandlerMock) IsInterfaceNil() bool

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

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

+ func (e *BlockChainHookHandlerMock) TempAccount(address []byte) state.AccountHandler

+ type BlockChainStub struct

+ CreateNewHeaderCalled func() data.HeaderHandler

+ GetCurrentBlockHeaderCalled func() data.HeaderHandler

+ GetCurrentBlockHeaderHashCalled func() []byte

+ GetGenesisHeaderCalled func() data.HeaderHandler

+ GetGenesisHeaderHashCalled func() []byte

+ SetCurrentBlockHeaderCalled func(data.HeaderHandler) error

+ SetCurrentBlockHeaderHashCalled func([]byte)

+ SetGenesisHeaderCalled func(handler data.HeaderHandler) error

+ SetGenesisHeaderHashCalled func([]byte)

+ func (bcs *BlockChainStub) CreateNewHeader() data.HeaderHandler

+ func (bcs *BlockChainStub) GetCurrentBlockHeader() data.HeaderHandler

+ func (bcs *BlockChainStub) GetCurrentBlockHeaderHash() []byte

+ func (bcs *BlockChainStub) GetGenesisHeader() data.HeaderHandler

+ func (bcs *BlockChainStub) GetGenesisHeaderHash() []byte

+ func (bcs *BlockChainStub) IsInterfaceNil() bool

+ func (bcs *BlockChainStub) SetCurrentBlockHeader(header data.HeaderHandler) error

+ func (bcs *BlockChainStub) SetCurrentBlockHeaderHash(hash []byte)

+ func (bcs *BlockChainStub) SetGenesisHeader(genesisBlock data.HeaderHandler) error

+ func (bcs *BlockChainStub) SetGenesisHeaderHash(hash []byte)

+ type ChainStorerMock struct

+ AddStorerCalled func(key dataRetriever.UnitType, s storage.Storer)

+ CloseAllCalled func() error

+ DestroyCalled func() error

+ GetAllCalled func(unitType dataRetriever.UnitType, keys [][]byte) (map[string][]byte, error)

+ GetCalled func(unitType dataRetriever.UnitType, key []byte) ([]byte, error)

+ GetStorerCalled func(unitType dataRetriever.UnitType) storage.Storer

+ HasCalled func(unitType dataRetriever.UnitType, key []byte) error

+ PutCalled func(unitType dataRetriever.UnitType, key []byte, value []byte) error

+ SetEpochForPutOperationCalled func(epoch uint32)

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

+ func (csm *ChainStorerMock) CloseAll() error

+ func (csm *ChainStorerMock) Destroy() error

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

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

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

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

+ func (csm *ChainStorerMock) IsInterfaceNil() bool

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

+ func (csm *ChainStorerMock) SetEpochForPutOperation(epoch uint32)

+ type CoordinatorStub struct

+ CommunicationIdentifierCalled func(destShardID uint32) string

+ ComputeIdCalled func(address []byte) uint32

+ NumberOfShardsCalled func() uint32

+ SameShardCalled func(firstAddress, secondAddress []byte) bool

+ SelfIdCalled func() uint32

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

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

+ func (coordinator *CoordinatorStub) IsInterfaceNil() bool

+ func (coordinator *CoordinatorStub) NumberOfShards() uint32

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

+ func (coordinator *CoordinatorStub) SelfId() uint32

+ type DeployProcessorStub struct

+ DeployCalled func(sc genesis.InitialSmartContractHandler) error

+ SetReplacePlaceholdersCalled func(handler func(txData string, scResultingAddressBytes []byte) (string, error))

+ func (dps *DeployProcessorStub) Deploy(sc genesis.InitialSmartContractHandler) error

+ func (dps *DeployProcessorStub) IsInterfaceNil() bool

+ type GenesisNodeInfoHandlerMock struct

+ AddressBytesValue []byte

+ AssignedShardValue uint32

+ PubKeyBytesValue []byte

+ func (gnihm *GenesisNodeInfoHandlerMock) AddressBytes() []byte

+ func (gnihm *GenesisNodeInfoHandlerMock) AssignedShard() uint32

+ func (gnihm *GenesisNodeInfoHandlerMock) IsInterfaceNil() bool

+ func (gnihm *GenesisNodeInfoHandlerMock) PubKeyBytes() []byte

+ type HasherMock struct

+ func (HasherMock) Size() int

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

+ func (sha HasherMock) EmptyHash() []byte

+ func (sha HasherMock) IsInterfaceNil() bool

+ type ImportStartHandlerStub struct

+ IsAfterExportBeforeImportCalled func() bool

+ ResetStartImportCalled func() error

+ SetStartImportCalled func() error

+ ShouldStartImportCalled func() bool

+ func (ish *ImportStartHandlerStub) IsAfterExportBeforeImport() bool

+ func (ish *ImportStartHandlerStub) IsInterfaceNil() bool

+ func (ish *ImportStartHandlerStub) ResetStartImport() error

+ func (ish *ImportStartHandlerStub) SetStartImport() error

+ func (ish *ImportStartHandlerStub) ShouldStartImport() bool

+ type InitialNodesHandlerStub struct

+ InitialNodesInfoCalled func() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)

+ MinNumberOfNodesCalled func() uint32

+ func (inhs *InitialNodesHandlerStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)

+ func (inhs *InitialNodesHandlerStub) IsInterfaceNil() bool

+ func (inhs *InitialNodesHandlerStub) MinNumberOfNodes() uint32

+ type InitialNodesSetupHandlerStub struct

+ InitialNodesInfoCalled func() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)

+ MinNumberOfNodesCalled func() uint32

+ func (inshs *InitialNodesSetupHandlerStub) InitialNodesInfo() (map[uint32][]sharding.GenesisNodeInfoHandler, ...)

+ func (inshs *InitialNodesSetupHandlerStub) IsInterfaceNil() bool

+ func (inshs *InitialNodesSetupHandlerStub) MinNumberOfNodes() uint32

+ type KeyGenMock struct

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

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

+ func (keyGen *KeyGenMock) IsInterfaceNil() bool

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

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

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

+ type KeyGeneratorStub struct

+ CheckPublicKeyValidCalled func(b []byte) error

+ GeneratePairCalled func() (crypto.PrivateKey, crypto.PublicKey)

+ PrivateKeyFromByteArrayCalled func(b []byte) (crypto.PrivateKey, error)

+ PublicKeyFromByteArrayCalled func(b []byte) (crypto.PublicKey, error)

+ SuiteCalled func() crypto.Suite

+ func (kgs *KeyGeneratorStub) CheckPublicKeyValid(b []byte) error

+ func (kgs *KeyGeneratorStub) GeneratePair() (crypto.PrivateKey, crypto.PublicKey)

+ func (kgs *KeyGeneratorStub) IsInterfaceNil() bool

+ func (kgs *KeyGeneratorStub) PrivateKeyFromByteArray(b []byte) (crypto.PrivateKey, error)

+ func (kgs *KeyGeneratorStub) PublicKeyFromByteArray(b []byte) (crypto.PublicKey, error)

+ func (kgs *KeyGeneratorStub) Suite() crypto.Suite

+ type MarshalizerMock struct

+ Fail bool

+ func (mm *MarshalizerMock) IsInterfaceNil() bool

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

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

+ type MemDbMock struct

+ func NewMemDbMock() *MemDbMock

+ func (s *MemDbMock) Close() error

+ func (s *MemDbMock) Destroy() error

+ func (s *MemDbMock) DestroyClosed() error

+ func (s *MemDbMock) Get(key []byte) ([]byte, error)

+ func (s *MemDbMock) Has(key []byte) error

+ func (s *MemDbMock) Init() error

+ func (s *MemDbMock) IsInterfaceNil() bool

+ func (s *MemDbMock) Put(key, val []byte) error

+ func (s *MemDbMock) Remove(key []byte) error

+ type NodeInfoMock struct

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

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

+ func (n *NodeInfoMock) AssignedShard() uint32

+ func (n *NodeInfoMock) IsInterfaceNil() bool

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

+ type NodesListSplitterStub struct

+ GetAllNodesCalled func() []sharding.GenesisNodeInfoHandler

+ GetDelegatedNodesCalled func(delegationScAddress []byte) []sharding.GenesisNodeInfoHandler

+ func (nlss *NodesListSplitterStub) GetAllNodes() []sharding.GenesisNodeInfoHandler

+ func (nlss *NodesListSplitterStub) GetDelegatedNodes(delegationScAddress []byte) []sharding.GenesisNodeInfoHandler

+ func (nlss *NodesListSplitterStub) IsInterfaceNil() bool

+ type PrivateKeyMock struct

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

+ func (sk *PrivateKeyMock) IsInterfaceNil() bool

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

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

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

+ type PubkeyConverterMock struct

+ func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock

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

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

+ func (pcm *PubkeyConverterMock) IsInterfaceNil() bool

+ func (pcm *PubkeyConverterMock) Len() int

+ type PubkeyConverterStub struct

+ DecodeCalled func(humanReadable string) ([]byte, error)

+ EncodeCalled func(pkBytes []byte) string

+ LenCalled func() int

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

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

+ func (pcs *PubkeyConverterStub) IsInterfaceNil() bool

+ func (pcs *PubkeyConverterStub) Len() int

+ type PublicKeyMock struct

+ func (sspk *PublicKeyMock) IsInterfaceNil() bool

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

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

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

+ type QueryServiceStub struct

+ ComputeScCallGasLimitCalled func(tx *transaction.Transaction) (uint64, error)

+ ExecuteQueryCalled func(query *process.SCQuery) (*vmcommon.VMOutput, error)

+ func (qss *QueryServiceStub) ComputeScCallGasLimit(tx *transaction.Transaction) (uint64, error)

+ func (qss *QueryServiceStub) ExecuteQuery(query *process.SCQuery) (*vmcommon.VMOutput, error)

+ func (qss *QueryServiceStub) IsInterfaceNil() bool

+ type ShardCoordinatorMock struct

+ NumOfShards uint32

+ SelfShardId uint32

+ func (scm *ShardCoordinatorMock) CommunicationIdentifier(_ uint32) string

+ func (scm *ShardCoordinatorMock) ComputeId(address []byte) uint32

+ func (scm *ShardCoordinatorMock) IsInterfaceNil() bool

+ func (scm *ShardCoordinatorMock) NumberOfShards() uint32

+ func (scm *ShardCoordinatorMock) SameShard(address1, address2 []byte) bool

+ func (scm *ShardCoordinatorMock) SelfId() uint32

+ type SmartContractParserStub struct

+ GetDeployedSCAddressesCalled func(scType string) (map[string]struct{}, error)

+ InitialSmartContractsCalled func() []genesis.InitialSmartContractHandler

+ InitialSmartContractsSplitOnOwnersShardsCalled func(shardCoordinator sharding.Coordinator) (map[uint32][]genesis.InitialSmartContractHandler, error)

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

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

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

+ func (scps *SmartContractParserStub) IsInterfaceNil() bool

+ type StorageManagerStub struct

+ CancelPruneCalled func([]byte)

+ DatabaseCalled func() data.DBWriteCacher

+ EnterSnapshotModeCalled func()

+ ExitSnapshotModeCalled func()

+ GetDbThatContainsHashCalled func([]byte) data.DBWriteCacher

+ GetSnapshotThatContainsHashCalled func(rootHash []byte) data.SnapshotDbHandler

+ IsInterfaceNilCalled func() bool

+ IsPruningEnabledCalled func() bool

+ MarkForEvictionCalled func([]byte, data.ModifiedHashes) error

+ PruneCalled func([]byte)

+ SetCheckpointCalled func([]byte)

+ TakeSnapshotCalled func([]byte)

+ func (sms *StorageManagerStub) CancelPrune([]byte, data.TriePruningIdentifier)

+ func (sms *StorageManagerStub) Database() data.DBWriteCacher

+ func (sms *StorageManagerStub) EnterSnapshotMode()

+ func (sms *StorageManagerStub) ExitSnapshotMode()

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

+ func (sms *StorageManagerStub) IsInterfaceNil() bool

+ func (sms *StorageManagerStub) IsPruningEnabled() bool

+ func (sms *StorageManagerStub) MarkForEviction(d []byte, m data.ModifiedHashes) error

+ func (sms *StorageManagerStub) Prune([]byte, data.TriePruningIdentifier)

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

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

+ type StorerMock struct

+ func NewStorerMock() *StorerMock

+ func (sm *StorerMock) ClearCache()

+ func (sm *StorerMock) Close() error

+ func (sm *StorerMock) DestroyUnit() error

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

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

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

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

+ func (sm *StorerMock) IsInterfaceNil() bool

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

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

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

+ type TxExecutionProcessorStub struct

+ AccountExistsCalled func(address []byte) bool

+ AddBalanceCalled func(senderBytes []byte, value *big.Int) error

+ AddNonceCalled func(senderBytes []byte, nonce uint64) error

+ ExecuteTransactionCalled func(nonce uint64, sndAddr []byte, rcvAddress []byte, value *big.Int, data []byte) error

+ GetNonceCalled func(senderBytes []byte) (uint64, error)

+ func (teps *TxExecutionProcessorStub) AddBalance(senderBytes []byte, value *big.Int) error

+ func (teps *TxExecutionProcessorStub) AddNonce(senderBytes []byte, nonce uint64) error

+ func (teps *TxExecutionProcessorStub) ExecuteTransaction(nonce uint64, sndAddr []byte, rcvAddress []byte, value *big.Int, data []byte) error

+ func (teps *TxExecutionProcessorStub) GetAccount(address []byte) (state.UserAccountHandler, bool)

+ func (teps *TxExecutionProcessorStub) GetNonce(senderBytes []byte) (uint64, error)

+ func (teps *TxExecutionProcessorStub) IsInterfaceNil() bool

+ type TxLogProcessorMock struct

+ func (tlpm *TxLogProcessorMock) GetLog(_ []byte) (data.LogHandler, error)

+ func (tlpm *TxLogProcessorMock) IsInterfaceNil() bool

+ func (tlpm *TxLogProcessorMock) SaveLog(_ []byte, _ data.TransactionHandler, _ []*vmcommon.LogEntry) error

+ type TxProcessorStub struct

+ ProcessTransactionCalled func(transaction *transaction.Transaction) (vmcommon.ReturnCode, error)

+ func (tps *TxProcessorStub) IsInterfaceNil() bool

+ func (tps *TxProcessorStub) ProcessTransaction(transaction *transaction.Transaction) (vmcommon.ReturnCode, error)

+ type Uint64ByteSliceConverterMock struct

+ func (u *Uint64ByteSliceConverterMock) IsInterfaceNil() bool

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

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

+ type UserAccountMock struct

+ BalanceField *big.Int

+ func (uam *UserAccountMock) AddToBalance(value *big.Int) error

+ func (uam *UserAccountMock) AddToDeveloperReward(_ *big.Int)

+ func (uam *UserAccountMock) ChangeOwnerAddress(_ []byte, _ []byte) error

+ func (uam *UserAccountMock) ClaimDeveloperRewards(_ []byte) (*big.Int, error)

+ func (uam *UserAccountMock) DataTrie() data.Trie

+ func (uam *UserAccountMock) DataTrieTracker() state.DataTrieTracker

+ func (uam *UserAccountMock) GetBalance() *big.Int

+ func (uam *UserAccountMock) GetCode() []byte

+ func (uam *UserAccountMock) GetCodeMetadata() []byte

+ func (uam *UserAccountMock) GetDeveloperReward() *big.Int

+ func (uam *UserAccountMock) GetOwnerAddress() []byte

+ func (uam *UserAccountMock) GetRootHash() []byte

+ func (uam *UserAccountMock) GetUserName() []byte

+ func (uam *UserAccountMock) SetCode(code []byte)

+ func (uam *UserAccountMock) SetCodeHash(bytes []byte)

+ func (uam *UserAccountMock) SetCodeMetadata(codeMetadata []byte)

+ func (uam *UserAccountMock) SetDataTrie(_ data.Trie)

+ func (uam *UserAccountMock) SetOwnerAddress(_ []byte)

+ func (uam *UserAccountMock) SetRootHash(bytes []byte)

+ func (uam *UserAccountMock) SetUserName(_ []byte)

+ func (uam *UserAccountMock) SubFromBalance(value *big.Int) error

+ func (uam UserAccountMock) GetCodeHash() []byte

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL