types

package

Go to main page

Versions in this module

v0

v0.11.0

Mar 24, 2026

Changes in this version

type EmbeddedWallet

+ BLSPairByWavesPK func(publicKey crypto.PublicKey) (bls.SecretKey, bls.PublicKey, error)

+ FindPublicKeyByAddress func(address proto.WavesAddress, scheme proto.Scheme) (crypto.PublicKey, error)

+ KeyPairsBLS func() ([]bls.PublicKey, []bls.SecretKey, error)

+ type EndorsementPool interface

+ Add func(e *proto.EndorseBlock, endorserPublicKey bls.PublicKey, ...) (bool, error)

+ BlockGenerator func() (crypto.PublicKey, error)

+ CleanAll func()

+ FormFinalization func(lastFinalizationHeight proto.Height) (proto.FinalizationVoting, error)

+ GetAll func() []proto.EndorseBlock

+ GetEndorsers func() []bls.PublicKey

+ Len func() int

+ SaveBlockGenerator func(blockGenerator *crypto.PublicKey)

+ Verify func() (bool, error)

+ type EnrichedSmartState interface

+ NewestAssetBalanceByAddressID func(id proto.AddressID, asset crypto.Digest) (uint64, error)

+ WavesBalanceProfile func(id proto.AddressID) (*WavesBalanceProfile, error)

+ type MockEnrichedSmartState struct

+ func NewMockEnrichedSmartState(t interface{ ... }) *MockEnrichedSmartState

+ func (_m *MockEnrichedSmartState) EXPECT() *MockEnrichedSmartState_Expecter

+ func (_mock *MockEnrichedSmartState) AddingBlockHeight() (uint64, error)

+ func (_mock *MockEnrichedSmartState) EstimatorVersion() (int, error)

+ func (_mock *MockEnrichedSmartState) IsNotFound(err error) bool

+ func (_mock *MockEnrichedSmartState) IsStateUntouched(account proto.Recipient) (bool, error)

+ func (_mock *MockEnrichedSmartState) NewestAddrByAlias(alias proto.Alias) (proto.WavesAddress, error)

+ func (_mock *MockEnrichedSmartState) NewestAssetBalance(account proto.Recipient, assetID crypto.Digest) (uint64, error)

+ func (_mock *MockEnrichedSmartState) NewestAssetBalanceByAddressID(id proto.AddressID, asset crypto.Digest) (uint64, error)

+ func (_mock *MockEnrichedSmartState) NewestAssetConstInfo(assetID proto.AssetID) (*proto.AssetConstInfo, error)

+ func (_mock *MockEnrichedSmartState) NewestAssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error)

+ func (_mock *MockEnrichedSmartState) NewestAssetIsSponsored(assetID crypto.Digest) (bool, error)

+ func (_mock *MockEnrichedSmartState) NewestBlockInfoByHeight(height proto.Height) (*proto.BlockInfo, error)

+ func (_mock *MockEnrichedSmartState) NewestFullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error)

+ func (_mock *MockEnrichedSmartState) NewestFullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error)

+ func (_mock *MockEnrichedSmartState) NewestLeasingInfo(id crypto.Digest) (*proto.LeaseInfo, error)

+ func (_mock *MockEnrichedSmartState) NewestRecipientToAddress(recipient proto.Recipient) (proto.WavesAddress, error)

+ func (_mock *MockEnrichedSmartState) NewestScriptByAccount(account proto.Recipient) (*ast.Tree, error)

+ func (_mock *MockEnrichedSmartState) NewestScriptByAsset(assetID crypto.Digest) (*ast.Tree, error)

+ func (_mock *MockEnrichedSmartState) NewestScriptBytesByAccount(account proto.Recipient) (proto.Script, error)

+ func (_mock *MockEnrichedSmartState) NewestScriptPKByAddr(addr proto.WavesAddress) (crypto.PublicKey, error)

+ func (_mock *MockEnrichedSmartState) NewestTransactionByID(bytes []byte) (proto.Transaction, error)

+ func (_mock *MockEnrichedSmartState) NewestTransactionHeightByID(bytes []byte) (uint64, error)

+ func (_mock *MockEnrichedSmartState) NewestWavesBalance(account proto.Recipient) (uint64, error)

+ func (_mock *MockEnrichedSmartState) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error)

+ func (_mock *MockEnrichedSmartState) RetrieveNewestBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

+ func (_mock *MockEnrichedSmartState) RetrieveNewestBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)

+ func (_mock *MockEnrichedSmartState) RetrieveNewestIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)

+ func (_mock *MockEnrichedSmartState) RetrieveNewestStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error)

+ func (_mock *MockEnrichedSmartState) WavesBalanceProfile(id proto.AddressID) (*WavesBalanceProfile, error)

+ type MockEnrichedSmartState_AddingBlockHeight_Call struct

+ func (_c *MockEnrichedSmartState_AddingBlockHeight_Call) Return(v uint64, err error) *MockEnrichedSmartState_AddingBlockHeight_Call

+ func (_c *MockEnrichedSmartState_AddingBlockHeight_Call) Run(run func()) *MockEnrichedSmartState_AddingBlockHeight_Call

+ func (_c *MockEnrichedSmartState_AddingBlockHeight_Call) RunAndReturn(run func() (uint64, error)) *MockEnrichedSmartState_AddingBlockHeight_Call

+ type MockEnrichedSmartState_EstimatorVersion_Call struct

+ func (_c *MockEnrichedSmartState_EstimatorVersion_Call) Return(n int, err error) *MockEnrichedSmartState_EstimatorVersion_Call

+ func (_c *MockEnrichedSmartState_EstimatorVersion_Call) Run(run func()) *MockEnrichedSmartState_EstimatorVersion_Call

+ func (_c *MockEnrichedSmartState_EstimatorVersion_Call) RunAndReturn(run func() (int, error)) *MockEnrichedSmartState_EstimatorVersion_Call

+ type MockEnrichedSmartState_Expecter struct

+ func (_e *MockEnrichedSmartState_Expecter) AddingBlockHeight() *MockEnrichedSmartState_AddingBlockHeight_Call

+ func (_e *MockEnrichedSmartState_Expecter) EstimatorVersion() *MockEnrichedSmartState_EstimatorVersion_Call

+ func (_e *MockEnrichedSmartState_Expecter) IsNotFound(err interface{}) *MockEnrichedSmartState_IsNotFound_Call

+ func (_e *MockEnrichedSmartState_Expecter) IsStateUntouched(account interface{}) *MockEnrichedSmartState_IsStateUntouched_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAddrByAlias(alias interface{}) *MockEnrichedSmartState_NewestAddrByAlias_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAssetBalance(account interface{}, assetID interface{}) *MockEnrichedSmartState_NewestAssetBalance_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAssetBalanceByAddressID(id interface{}, asset interface{}) *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAssetConstInfo(assetID interface{}) *MockEnrichedSmartState_NewestAssetConstInfo_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAssetInfo(assetID interface{}) *MockEnrichedSmartState_NewestAssetInfo_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestAssetIsSponsored(assetID interface{}) *MockEnrichedSmartState_NewestAssetIsSponsored_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestBlockInfoByHeight(height interface{}) *MockEnrichedSmartState_NewestBlockInfoByHeight_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestFullAssetInfo(assetID interface{}) *MockEnrichedSmartState_NewestFullAssetInfo_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestFullWavesBalance(account interface{}) *MockEnrichedSmartState_NewestFullWavesBalance_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestLeasingInfo(id interface{}) *MockEnrichedSmartState_NewestLeasingInfo_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestRecipientToAddress(recipient interface{}) *MockEnrichedSmartState_NewestRecipientToAddress_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestScriptByAccount(account interface{}) *MockEnrichedSmartState_NewestScriptByAccount_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestScriptByAsset(assetID interface{}) *MockEnrichedSmartState_NewestScriptByAsset_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestScriptBytesByAccount(account interface{}) *MockEnrichedSmartState_NewestScriptBytesByAccount_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestScriptPKByAddr(addr interface{}) *MockEnrichedSmartState_NewestScriptPKByAddr_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestTransactionByID(bytes interface{}) *MockEnrichedSmartState_NewestTransactionByID_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestTransactionHeightByID(bytes interface{}) *MockEnrichedSmartState_NewestTransactionHeightByID_Call

+ func (_e *MockEnrichedSmartState_Expecter) NewestWavesBalance(account interface{}) *MockEnrichedSmartState_NewestWavesBalance_Call

+ func (_e *MockEnrichedSmartState_Expecter) RetrieveEntries(account interface{}) *MockEnrichedSmartState_RetrieveEntries_Call

+ func (_e *MockEnrichedSmartState_Expecter) RetrieveNewestBinaryEntry(account interface{}, key interface{}) *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call

+ func (_e *MockEnrichedSmartState_Expecter) RetrieveNewestBooleanEntry(account interface{}, key interface{}) *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call

+ func (_e *MockEnrichedSmartState_Expecter) RetrieveNewestIntegerEntry(account interface{}, key interface{}) *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call

+ func (_e *MockEnrichedSmartState_Expecter) RetrieveNewestStringEntry(account interface{}, key interface{}) *MockEnrichedSmartState_RetrieveNewestStringEntry_Call

+ func (_e *MockEnrichedSmartState_Expecter) WavesBalanceProfile(id interface{}) *MockEnrichedSmartState_WavesBalanceProfile_Call

+ type MockEnrichedSmartState_IsNotFound_Call struct

+ func (_c *MockEnrichedSmartState_IsNotFound_Call) Return(b bool) *MockEnrichedSmartState_IsNotFound_Call

+ func (_c *MockEnrichedSmartState_IsNotFound_Call) Run(run func(err error)) *MockEnrichedSmartState_IsNotFound_Call

+ func (_c *MockEnrichedSmartState_IsNotFound_Call) RunAndReturn(run func(err error) bool) *MockEnrichedSmartState_IsNotFound_Call

+ type MockEnrichedSmartState_IsStateUntouched_Call struct

+ func (_c *MockEnrichedSmartState_IsStateUntouched_Call) Return(b bool, err error) *MockEnrichedSmartState_IsStateUntouched_Call

+ func (_c *MockEnrichedSmartState_IsStateUntouched_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_IsStateUntouched_Call

+ func (_c *MockEnrichedSmartState_IsStateUntouched_Call) RunAndReturn(run func(account proto.Recipient) (bool, error)) *MockEnrichedSmartState_IsStateUntouched_Call

+ type MockEnrichedSmartState_NewestAddrByAlias_Call struct

+ func (_c *MockEnrichedSmartState_NewestAddrByAlias_Call) Return(wavesAddress proto.WavesAddress, err error) *MockEnrichedSmartState_NewestAddrByAlias_Call

+ func (_c *MockEnrichedSmartState_NewestAddrByAlias_Call) Run(run func(alias proto.Alias)) *MockEnrichedSmartState_NewestAddrByAlias_Call

+ func (_c *MockEnrichedSmartState_NewestAddrByAlias_Call) RunAndReturn(run func(alias proto.Alias) (proto.WavesAddress, error)) *MockEnrichedSmartState_NewestAddrByAlias_Call

+ type MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call struct

+ func (_c *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call) Return(v uint64, err error) *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call

+ func (_c *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call) Run(run func(id proto.AddressID, asset crypto.Digest)) *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call

+ func (_c *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call) RunAndReturn(run func(id proto.AddressID, asset crypto.Digest) (uint64, error)) *MockEnrichedSmartState_NewestAssetBalanceByAddressID_Call

+ type MockEnrichedSmartState_NewestAssetBalance_Call struct

+ func (_c *MockEnrichedSmartState_NewestAssetBalance_Call) Return(v uint64, err error) *MockEnrichedSmartState_NewestAssetBalance_Call

+ func (_c *MockEnrichedSmartState_NewestAssetBalance_Call) Run(run func(account proto.Recipient, assetID crypto.Digest)) *MockEnrichedSmartState_NewestAssetBalance_Call

+ func (_c *MockEnrichedSmartState_NewestAssetBalance_Call) RunAndReturn(run func(account proto.Recipient, assetID crypto.Digest) (uint64, error)) *MockEnrichedSmartState_NewestAssetBalance_Call

+ type MockEnrichedSmartState_NewestAssetConstInfo_Call struct

+ func (_c *MockEnrichedSmartState_NewestAssetConstInfo_Call) Return(assetConstInfo *proto.AssetConstInfo, err error) *MockEnrichedSmartState_NewestAssetConstInfo_Call

+ func (_c *MockEnrichedSmartState_NewestAssetConstInfo_Call) Run(run func(assetID proto.AssetID)) *MockEnrichedSmartState_NewestAssetConstInfo_Call

+ func (_c *MockEnrichedSmartState_NewestAssetConstInfo_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.AssetConstInfo, error)) *MockEnrichedSmartState_NewestAssetConstInfo_Call

+ type MockEnrichedSmartState_NewestAssetInfo_Call struct

+ func (_c *MockEnrichedSmartState_NewestAssetInfo_Call) Return(assetInfo *proto.AssetInfo, err error) *MockEnrichedSmartState_NewestAssetInfo_Call

+ func (_c *MockEnrichedSmartState_NewestAssetInfo_Call) Run(run func(assetID crypto.Digest)) *MockEnrichedSmartState_NewestAssetInfo_Call

+ func (_c *MockEnrichedSmartState_NewestAssetInfo_Call) RunAndReturn(run func(assetID crypto.Digest) (*proto.AssetInfo, error)) *MockEnrichedSmartState_NewestAssetInfo_Call

+ type MockEnrichedSmartState_NewestAssetIsSponsored_Call struct

+ func (_c *MockEnrichedSmartState_NewestAssetIsSponsored_Call) Return(b bool, err error) *MockEnrichedSmartState_NewestAssetIsSponsored_Call

+ func (_c *MockEnrichedSmartState_NewestAssetIsSponsored_Call) Run(run func(assetID crypto.Digest)) *MockEnrichedSmartState_NewestAssetIsSponsored_Call

+ func (_c *MockEnrichedSmartState_NewestAssetIsSponsored_Call) RunAndReturn(run func(assetID crypto.Digest) (bool, error)) *MockEnrichedSmartState_NewestAssetIsSponsored_Call

+ type MockEnrichedSmartState_NewestBlockInfoByHeight_Call struct

+ func (_c *MockEnrichedSmartState_NewestBlockInfoByHeight_Call) Return(blockInfo *proto.BlockInfo, err error) *MockEnrichedSmartState_NewestBlockInfoByHeight_Call

+ func (_c *MockEnrichedSmartState_NewestBlockInfoByHeight_Call) Run(run func(height proto.Height)) *MockEnrichedSmartState_NewestBlockInfoByHeight_Call

+ func (_c *MockEnrichedSmartState_NewestBlockInfoByHeight_Call) RunAndReturn(run func(height proto.Height) (*proto.BlockInfo, error)) *MockEnrichedSmartState_NewestBlockInfoByHeight_Call

+ type MockEnrichedSmartState_NewestFullAssetInfo_Call struct

+ func (_c *MockEnrichedSmartState_NewestFullAssetInfo_Call) Return(fullAssetInfo *proto.FullAssetInfo, err error) *MockEnrichedSmartState_NewestFullAssetInfo_Call

+ func (_c *MockEnrichedSmartState_NewestFullAssetInfo_Call) Run(run func(assetID crypto.Digest)) *MockEnrichedSmartState_NewestFullAssetInfo_Call

+ func (_c *MockEnrichedSmartState_NewestFullAssetInfo_Call) RunAndReturn(run func(assetID crypto.Digest) (*proto.FullAssetInfo, error)) *MockEnrichedSmartState_NewestFullAssetInfo_Call

+ type MockEnrichedSmartState_NewestFullWavesBalance_Call struct

+ func (_c *MockEnrichedSmartState_NewestFullWavesBalance_Call) Return(fullWavesBalance *proto.FullWavesBalance, err error) *MockEnrichedSmartState_NewestFullWavesBalance_Call

+ func (_c *MockEnrichedSmartState_NewestFullWavesBalance_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_NewestFullWavesBalance_Call

+ func (_c *MockEnrichedSmartState_NewestFullWavesBalance_Call) RunAndReturn(run func(account proto.Recipient) (*proto.FullWavesBalance, error)) *MockEnrichedSmartState_NewestFullWavesBalance_Call

+ type MockEnrichedSmartState_NewestLeasingInfo_Call struct

+ func (_c *MockEnrichedSmartState_NewestLeasingInfo_Call) Return(leaseInfo *proto.LeaseInfo, err error) *MockEnrichedSmartState_NewestLeasingInfo_Call

+ func (_c *MockEnrichedSmartState_NewestLeasingInfo_Call) Run(run func(id crypto.Digest)) *MockEnrichedSmartState_NewestLeasingInfo_Call

+ func (_c *MockEnrichedSmartState_NewestLeasingInfo_Call) RunAndReturn(run func(id crypto.Digest) (*proto.LeaseInfo, error)) *MockEnrichedSmartState_NewestLeasingInfo_Call

+ type MockEnrichedSmartState_NewestRecipientToAddress_Call struct

+ func (_c *MockEnrichedSmartState_NewestRecipientToAddress_Call) Return(wavesAddress proto.WavesAddress, err error) *MockEnrichedSmartState_NewestRecipientToAddress_Call

+ func (_c *MockEnrichedSmartState_NewestRecipientToAddress_Call) Run(run func(recipient proto.Recipient)) *MockEnrichedSmartState_NewestRecipientToAddress_Call

+ func (_c *MockEnrichedSmartState_NewestRecipientToAddress_Call) RunAndReturn(run func(recipient proto.Recipient) (proto.WavesAddress, error)) *MockEnrichedSmartState_NewestRecipientToAddress_Call

+ type MockEnrichedSmartState_NewestScriptByAccount_Call struct

+ func (_c *MockEnrichedSmartState_NewestScriptByAccount_Call) Return(tree *ast.Tree, err error) *MockEnrichedSmartState_NewestScriptByAccount_Call

+ func (_c *MockEnrichedSmartState_NewestScriptByAccount_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_NewestScriptByAccount_Call

+ func (_c *MockEnrichedSmartState_NewestScriptByAccount_Call) RunAndReturn(run func(account proto.Recipient) (*ast.Tree, error)) *MockEnrichedSmartState_NewestScriptByAccount_Call

+ type MockEnrichedSmartState_NewestScriptByAsset_Call struct

+ func (_c *MockEnrichedSmartState_NewestScriptByAsset_Call) Return(tree *ast.Tree, err error) *MockEnrichedSmartState_NewestScriptByAsset_Call

+ func (_c *MockEnrichedSmartState_NewestScriptByAsset_Call) Run(run func(assetID crypto.Digest)) *MockEnrichedSmartState_NewestScriptByAsset_Call

+ func (_c *MockEnrichedSmartState_NewestScriptByAsset_Call) RunAndReturn(run func(assetID crypto.Digest) (*ast.Tree, error)) *MockEnrichedSmartState_NewestScriptByAsset_Call

+ type MockEnrichedSmartState_NewestScriptBytesByAccount_Call struct

+ func (_c *MockEnrichedSmartState_NewestScriptBytesByAccount_Call) Return(script proto.Script, err error) *MockEnrichedSmartState_NewestScriptBytesByAccount_Call

+ func (_c *MockEnrichedSmartState_NewestScriptBytesByAccount_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_NewestScriptBytesByAccount_Call

+ func (_c *MockEnrichedSmartState_NewestScriptBytesByAccount_Call) RunAndReturn(run func(account proto.Recipient) (proto.Script, error)) *MockEnrichedSmartState_NewestScriptBytesByAccount_Call

+ type MockEnrichedSmartState_NewestScriptPKByAddr_Call struct

+ func (_c *MockEnrichedSmartState_NewestScriptPKByAddr_Call) Return(publicKey crypto.PublicKey, err error) *MockEnrichedSmartState_NewestScriptPKByAddr_Call

+ func (_c *MockEnrichedSmartState_NewestScriptPKByAddr_Call) Run(run func(addr proto.WavesAddress)) *MockEnrichedSmartState_NewestScriptPKByAddr_Call

+ func (_c *MockEnrichedSmartState_NewestScriptPKByAddr_Call) RunAndReturn(run func(addr proto.WavesAddress) (crypto.PublicKey, error)) *MockEnrichedSmartState_NewestScriptPKByAddr_Call

+ type MockEnrichedSmartState_NewestTransactionByID_Call struct

+ func (_c *MockEnrichedSmartState_NewestTransactionByID_Call) Return(transaction proto.Transaction, err error) *MockEnrichedSmartState_NewestTransactionByID_Call

+ func (_c *MockEnrichedSmartState_NewestTransactionByID_Call) Run(run func(bytes []byte)) *MockEnrichedSmartState_NewestTransactionByID_Call

+ func (_c *MockEnrichedSmartState_NewestTransactionByID_Call) RunAndReturn(run func(bytes []byte) (proto.Transaction, error)) *MockEnrichedSmartState_NewestTransactionByID_Call

+ type MockEnrichedSmartState_NewestTransactionHeightByID_Call struct

+ func (_c *MockEnrichedSmartState_NewestTransactionHeightByID_Call) Return(v uint64, err error) *MockEnrichedSmartState_NewestTransactionHeightByID_Call

+ func (_c *MockEnrichedSmartState_NewestTransactionHeightByID_Call) Run(run func(bytes []byte)) *MockEnrichedSmartState_NewestTransactionHeightByID_Call

+ func (_c *MockEnrichedSmartState_NewestTransactionHeightByID_Call) RunAndReturn(run func(bytes []byte) (uint64, error)) *MockEnrichedSmartState_NewestTransactionHeightByID_Call

+ type MockEnrichedSmartState_NewestWavesBalance_Call struct

+ func (_c *MockEnrichedSmartState_NewestWavesBalance_Call) Return(v uint64, err error) *MockEnrichedSmartState_NewestWavesBalance_Call

+ func (_c *MockEnrichedSmartState_NewestWavesBalance_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_NewestWavesBalance_Call

+ func (_c *MockEnrichedSmartState_NewestWavesBalance_Call) RunAndReturn(run func(account proto.Recipient) (uint64, error)) *MockEnrichedSmartState_NewestWavesBalance_Call

+ type MockEnrichedSmartState_RetrieveEntries_Call struct

+ func (_c *MockEnrichedSmartState_RetrieveEntries_Call) Return(dataEntrys []proto.DataEntry, err error) *MockEnrichedSmartState_RetrieveEntries_Call

+ func (_c *MockEnrichedSmartState_RetrieveEntries_Call) Run(run func(account proto.Recipient)) *MockEnrichedSmartState_RetrieveEntries_Call

+ func (_c *MockEnrichedSmartState_RetrieveEntries_Call) RunAndReturn(run func(account proto.Recipient) ([]proto.DataEntry, error)) *MockEnrichedSmartState_RetrieveEntries_Call

+ type MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call struct

+ func (_c *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call) Return(binaryDataEntry *proto.BinaryDataEntry, err error) *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call) Run(run func(account proto.Recipient, key string)) *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)) *MockEnrichedSmartState_RetrieveNewestBinaryEntry_Call

+ type MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call struct

+ func (_c *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call) Return(booleanDataEntry *proto.BooleanDataEntry, err error) *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call) Run(run func(account proto.Recipient, key string)) *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)) *MockEnrichedSmartState_RetrieveNewestBooleanEntry_Call

+ type MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call struct

+ func (_c *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call) Return(integerDataEntry *proto.IntegerDataEntry, err error) *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call) Run(run func(account proto.Recipient, key string)) *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)) *MockEnrichedSmartState_RetrieveNewestIntegerEntry_Call

+ type MockEnrichedSmartState_RetrieveNewestStringEntry_Call struct

+ func (_c *MockEnrichedSmartState_RetrieveNewestStringEntry_Call) Return(stringDataEntry *proto.StringDataEntry, err error) *MockEnrichedSmartState_RetrieveNewestStringEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestStringEntry_Call) Run(run func(account proto.Recipient, key string)) *MockEnrichedSmartState_RetrieveNewestStringEntry_Call

+ func (_c *MockEnrichedSmartState_RetrieveNewestStringEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.StringDataEntry, error)) *MockEnrichedSmartState_RetrieveNewestStringEntry_Call

+ type MockEnrichedSmartState_WavesBalanceProfile_Call struct

+ func (_c *MockEnrichedSmartState_WavesBalanceProfile_Call) Return(wavesBalanceProfile *WavesBalanceProfile, err error) *MockEnrichedSmartState_WavesBalanceProfile_Call

+ func (_c *MockEnrichedSmartState_WavesBalanceProfile_Call) Run(run func(id proto.AddressID)) *MockEnrichedSmartState_WavesBalanceProfile_Call

+ func (_c *MockEnrichedSmartState_WavesBalanceProfile_Call) RunAndReturn(run func(id proto.AddressID) (*WavesBalanceProfile, error)) *MockEnrichedSmartState_WavesBalanceProfile_Call

+ type MockSmartState struct

+ func NewMockSmartState(t interface{ ... }) *MockSmartState

+ func (_m *MockSmartState) EXPECT() *MockSmartState_Expecter

+ func (_mock *MockSmartState) AddingBlockHeight() (uint64, error)

+ func (_mock *MockSmartState) EstimatorVersion() (int, error)

+ func (_mock *MockSmartState) IsNotFound(err error) bool

+ func (_mock *MockSmartState) IsStateUntouched(account proto.Recipient) (bool, error)

+ func (_mock *MockSmartState) NewestAddrByAlias(alias proto.Alias) (proto.WavesAddress, error)

+ func (_mock *MockSmartState) NewestAssetBalance(account proto.Recipient, assetID crypto.Digest) (uint64, error)

+ func (_mock *MockSmartState) NewestAssetConstInfo(assetID proto.AssetID) (*proto.AssetConstInfo, error)

+ func (_mock *MockSmartState) NewestAssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error)

+ func (_mock *MockSmartState) NewestAssetIsSponsored(assetID crypto.Digest) (bool, error)

+ func (_mock *MockSmartState) NewestBlockInfoByHeight(height proto.Height) (*proto.BlockInfo, error)

+ func (_mock *MockSmartState) NewestFullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error)

+ func (_mock *MockSmartState) NewestFullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error)

+ func (_mock *MockSmartState) NewestLeasingInfo(id crypto.Digest) (*proto.LeaseInfo, error)

+ func (_mock *MockSmartState) NewestRecipientToAddress(recipient proto.Recipient) (proto.WavesAddress, error)

+ func (_mock *MockSmartState) NewestScriptByAccount(account proto.Recipient) (*ast.Tree, error)

+ func (_mock *MockSmartState) NewestScriptByAsset(assetID crypto.Digest) (*ast.Tree, error)

+ func (_mock *MockSmartState) NewestScriptBytesByAccount(account proto.Recipient) (proto.Script, error)

+ func (_mock *MockSmartState) NewestScriptPKByAddr(addr proto.WavesAddress) (crypto.PublicKey, error)

+ func (_mock *MockSmartState) NewestTransactionByID(bytes []byte) (proto.Transaction, error)

+ func (_mock *MockSmartState) NewestTransactionHeightByID(bytes []byte) (uint64, error)

+ func (_mock *MockSmartState) NewestWavesBalance(account proto.Recipient) (uint64, error)

+ func (_mock *MockSmartState) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error)

+ func (_mock *MockSmartState) RetrieveNewestBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

+ func (_mock *MockSmartState) RetrieveNewestBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)

+ func (_mock *MockSmartState) RetrieveNewestIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)

+ func (_mock *MockSmartState) RetrieveNewestStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error)

+ type MockSmartState_AddingBlockHeight_Call struct

+ func (_c *MockSmartState_AddingBlockHeight_Call) Return(v uint64, err error) *MockSmartState_AddingBlockHeight_Call

+ func (_c *MockSmartState_AddingBlockHeight_Call) Run(run func()) *MockSmartState_AddingBlockHeight_Call

+ func (_c *MockSmartState_AddingBlockHeight_Call) RunAndReturn(run func() (uint64, error)) *MockSmartState_AddingBlockHeight_Call

+ type MockSmartState_EstimatorVersion_Call struct

+ func (_c *MockSmartState_EstimatorVersion_Call) Return(n int, err error) *MockSmartState_EstimatorVersion_Call

+ func (_c *MockSmartState_EstimatorVersion_Call) Run(run func()) *MockSmartState_EstimatorVersion_Call

+ func (_c *MockSmartState_EstimatorVersion_Call) RunAndReturn(run func() (int, error)) *MockSmartState_EstimatorVersion_Call

+ type MockSmartState_Expecter struct

+ func (_e *MockSmartState_Expecter) AddingBlockHeight() *MockSmartState_AddingBlockHeight_Call

+ func (_e *MockSmartState_Expecter) EstimatorVersion() *MockSmartState_EstimatorVersion_Call

+ func (_e *MockSmartState_Expecter) IsNotFound(err interface{}) *MockSmartState_IsNotFound_Call

+ func (_e *MockSmartState_Expecter) IsStateUntouched(account interface{}) *MockSmartState_IsStateUntouched_Call

+ func (_e *MockSmartState_Expecter) NewestAddrByAlias(alias interface{}) *MockSmartState_NewestAddrByAlias_Call

+ func (_e *MockSmartState_Expecter) NewestAssetBalance(account interface{}, assetID interface{}) *MockSmartState_NewestAssetBalance_Call

+ func (_e *MockSmartState_Expecter) NewestAssetConstInfo(assetID interface{}) *MockSmartState_NewestAssetConstInfo_Call

+ func (_e *MockSmartState_Expecter) NewestAssetInfo(assetID interface{}) *MockSmartState_NewestAssetInfo_Call

+ func (_e *MockSmartState_Expecter) NewestAssetIsSponsored(assetID interface{}) *MockSmartState_NewestAssetIsSponsored_Call

+ func (_e *MockSmartState_Expecter) NewestBlockInfoByHeight(height interface{}) *MockSmartState_NewestBlockInfoByHeight_Call

+ func (_e *MockSmartState_Expecter) NewestFullAssetInfo(assetID interface{}) *MockSmartState_NewestFullAssetInfo_Call

+ func (_e *MockSmartState_Expecter) NewestFullWavesBalance(account interface{}) *MockSmartState_NewestFullWavesBalance_Call

+ func (_e *MockSmartState_Expecter) NewestLeasingInfo(id interface{}) *MockSmartState_NewestLeasingInfo_Call

+ func (_e *MockSmartState_Expecter) NewestRecipientToAddress(recipient interface{}) *MockSmartState_NewestRecipientToAddress_Call

+ func (_e *MockSmartState_Expecter) NewestScriptByAccount(account interface{}) *MockSmartState_NewestScriptByAccount_Call

+ func (_e *MockSmartState_Expecter) NewestScriptByAsset(assetID interface{}) *MockSmartState_NewestScriptByAsset_Call

+ func (_e *MockSmartState_Expecter) NewestScriptBytesByAccount(account interface{}) *MockSmartState_NewestScriptBytesByAccount_Call

+ func (_e *MockSmartState_Expecter) NewestScriptPKByAddr(addr interface{}) *MockSmartState_NewestScriptPKByAddr_Call

+ func (_e *MockSmartState_Expecter) NewestTransactionByID(bytes interface{}) *MockSmartState_NewestTransactionByID_Call

+ func (_e *MockSmartState_Expecter) NewestTransactionHeightByID(bytes interface{}) *MockSmartState_NewestTransactionHeightByID_Call

+ func (_e *MockSmartState_Expecter) NewestWavesBalance(account interface{}) *MockSmartState_NewestWavesBalance_Call

+ func (_e *MockSmartState_Expecter) RetrieveEntries(account interface{}) *MockSmartState_RetrieveEntries_Call

+ func (_e *MockSmartState_Expecter) RetrieveNewestBinaryEntry(account interface{}, key interface{}) *MockSmartState_RetrieveNewestBinaryEntry_Call

+ func (_e *MockSmartState_Expecter) RetrieveNewestBooleanEntry(account interface{}, key interface{}) *MockSmartState_RetrieveNewestBooleanEntry_Call

+ func (_e *MockSmartState_Expecter) RetrieveNewestIntegerEntry(account interface{}, key interface{}) *MockSmartState_RetrieveNewestIntegerEntry_Call

+ func (_e *MockSmartState_Expecter) RetrieveNewestStringEntry(account interface{}, key interface{}) *MockSmartState_RetrieveNewestStringEntry_Call

+ type MockSmartState_IsNotFound_Call struct

+ func (_c *MockSmartState_IsNotFound_Call) Return(b bool) *MockSmartState_IsNotFound_Call

+ func (_c *MockSmartState_IsNotFound_Call) Run(run func(err error)) *MockSmartState_IsNotFound_Call

+ func (_c *MockSmartState_IsNotFound_Call) RunAndReturn(run func(err error) bool) *MockSmartState_IsNotFound_Call

+ type MockSmartState_IsStateUntouched_Call struct

+ func (_c *MockSmartState_IsStateUntouched_Call) Return(b bool, err error) *MockSmartState_IsStateUntouched_Call

+ func (_c *MockSmartState_IsStateUntouched_Call) Run(run func(account proto.Recipient)) *MockSmartState_IsStateUntouched_Call

+ func (_c *MockSmartState_IsStateUntouched_Call) RunAndReturn(run func(account proto.Recipient) (bool, error)) *MockSmartState_IsStateUntouched_Call

+ type MockSmartState_NewestAddrByAlias_Call struct

+ func (_c *MockSmartState_NewestAddrByAlias_Call) Return(wavesAddress proto.WavesAddress, err error) *MockSmartState_NewestAddrByAlias_Call

+ func (_c *MockSmartState_NewestAddrByAlias_Call) Run(run func(alias proto.Alias)) *MockSmartState_NewestAddrByAlias_Call

+ func (_c *MockSmartState_NewestAddrByAlias_Call) RunAndReturn(run func(alias proto.Alias) (proto.WavesAddress, error)) *MockSmartState_NewestAddrByAlias_Call

+ type MockSmartState_NewestAssetBalance_Call struct

+ func (_c *MockSmartState_NewestAssetBalance_Call) Return(v uint64, err error) *MockSmartState_NewestAssetBalance_Call

+ func (_c *MockSmartState_NewestAssetBalance_Call) Run(run func(account proto.Recipient, assetID crypto.Digest)) *MockSmartState_NewestAssetBalance_Call

+ func (_c *MockSmartState_NewestAssetBalance_Call) RunAndReturn(run func(account proto.Recipient, assetID crypto.Digest) (uint64, error)) *MockSmartState_NewestAssetBalance_Call

+ type MockSmartState_NewestAssetConstInfo_Call struct

+ func (_c *MockSmartState_NewestAssetConstInfo_Call) Return(assetConstInfo *proto.AssetConstInfo, err error) *MockSmartState_NewestAssetConstInfo_Call

+ func (_c *MockSmartState_NewestAssetConstInfo_Call) Run(run func(assetID proto.AssetID)) *MockSmartState_NewestAssetConstInfo_Call

+ func (_c *MockSmartState_NewestAssetConstInfo_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.AssetConstInfo, error)) *MockSmartState_NewestAssetConstInfo_Call

+ type MockSmartState_NewestAssetInfo_Call struct

+ func (_c *MockSmartState_NewestAssetInfo_Call) Return(assetInfo *proto.AssetInfo, err error) *MockSmartState_NewestAssetInfo_Call

+ func (_c *MockSmartState_NewestAssetInfo_Call) Run(run func(assetID crypto.Digest)) *MockSmartState_NewestAssetInfo_Call

+ func (_c *MockSmartState_NewestAssetInfo_Call) RunAndReturn(run func(assetID crypto.Digest) (*proto.AssetInfo, error)) *MockSmartState_NewestAssetInfo_Call

+ type MockSmartState_NewestAssetIsSponsored_Call struct

+ func (_c *MockSmartState_NewestAssetIsSponsored_Call) Return(b bool, err error) *MockSmartState_NewestAssetIsSponsored_Call

+ func (_c *MockSmartState_NewestAssetIsSponsored_Call) Run(run func(assetID crypto.Digest)) *MockSmartState_NewestAssetIsSponsored_Call

+ func (_c *MockSmartState_NewestAssetIsSponsored_Call) RunAndReturn(run func(assetID crypto.Digest) (bool, error)) *MockSmartState_NewestAssetIsSponsored_Call

+ type MockSmartState_NewestBlockInfoByHeight_Call struct

+ func (_c *MockSmartState_NewestBlockInfoByHeight_Call) Return(blockInfo *proto.BlockInfo, err error) *MockSmartState_NewestBlockInfoByHeight_Call

+ func (_c *MockSmartState_NewestBlockInfoByHeight_Call) Run(run func(height proto.Height)) *MockSmartState_NewestBlockInfoByHeight_Call

+ func (_c *MockSmartState_NewestBlockInfoByHeight_Call) RunAndReturn(run func(height proto.Height) (*proto.BlockInfo, error)) *MockSmartState_NewestBlockInfoByHeight_Call

+ type MockSmartState_NewestFullAssetInfo_Call struct

+ func (_c *MockSmartState_NewestFullAssetInfo_Call) Return(fullAssetInfo *proto.FullAssetInfo, err error) *MockSmartState_NewestFullAssetInfo_Call

+ func (_c *MockSmartState_NewestFullAssetInfo_Call) Run(run func(assetID crypto.Digest)) *MockSmartState_NewestFullAssetInfo_Call

+ func (_c *MockSmartState_NewestFullAssetInfo_Call) RunAndReturn(run func(assetID crypto.Digest) (*proto.FullAssetInfo, error)) *MockSmartState_NewestFullAssetInfo_Call

+ type MockSmartState_NewestFullWavesBalance_Call struct

+ func (_c *MockSmartState_NewestFullWavesBalance_Call) Return(fullWavesBalance *proto.FullWavesBalance, err error) *MockSmartState_NewestFullWavesBalance_Call

+ func (_c *MockSmartState_NewestFullWavesBalance_Call) Run(run func(account proto.Recipient)) *MockSmartState_NewestFullWavesBalance_Call

+ func (_c *MockSmartState_NewestFullWavesBalance_Call) RunAndReturn(run func(account proto.Recipient) (*proto.FullWavesBalance, error)) *MockSmartState_NewestFullWavesBalance_Call

+ type MockSmartState_NewestLeasingInfo_Call struct

+ func (_c *MockSmartState_NewestLeasingInfo_Call) Return(leaseInfo *proto.LeaseInfo, err error) *MockSmartState_NewestLeasingInfo_Call

+ func (_c *MockSmartState_NewestLeasingInfo_Call) Run(run func(id crypto.Digest)) *MockSmartState_NewestLeasingInfo_Call

+ func (_c *MockSmartState_NewestLeasingInfo_Call) RunAndReturn(run func(id crypto.Digest) (*proto.LeaseInfo, error)) *MockSmartState_NewestLeasingInfo_Call

+ type MockSmartState_NewestRecipientToAddress_Call struct

+ func (_c *MockSmartState_NewestRecipientToAddress_Call) Return(wavesAddress proto.WavesAddress, err error) *MockSmartState_NewestRecipientToAddress_Call

+ func (_c *MockSmartState_NewestRecipientToAddress_Call) Run(run func(recipient proto.Recipient)) *MockSmartState_NewestRecipientToAddress_Call

+ func (_c *MockSmartState_NewestRecipientToAddress_Call) RunAndReturn(run func(recipient proto.Recipient) (proto.WavesAddress, error)) *MockSmartState_NewestRecipientToAddress_Call

+ type MockSmartState_NewestScriptByAccount_Call struct

+ func (_c *MockSmartState_NewestScriptByAccount_Call) Return(tree *ast.Tree, err error) *MockSmartState_NewestScriptByAccount_Call

+ func (_c *MockSmartState_NewestScriptByAccount_Call) Run(run func(account proto.Recipient)) *MockSmartState_NewestScriptByAccount_Call

+ func (_c *MockSmartState_NewestScriptByAccount_Call) RunAndReturn(run func(account proto.Recipient) (*ast.Tree, error)) *MockSmartState_NewestScriptByAccount_Call

+ type MockSmartState_NewestScriptByAsset_Call struct

+ func (_c *MockSmartState_NewestScriptByAsset_Call) Return(tree *ast.Tree, err error) *MockSmartState_NewestScriptByAsset_Call

+ func (_c *MockSmartState_NewestScriptByAsset_Call) Run(run func(assetID crypto.Digest)) *MockSmartState_NewestScriptByAsset_Call

+ func (_c *MockSmartState_NewestScriptByAsset_Call) RunAndReturn(run func(assetID crypto.Digest) (*ast.Tree, error)) *MockSmartState_NewestScriptByAsset_Call

+ type MockSmartState_NewestScriptBytesByAccount_Call struct

+ func (_c *MockSmartState_NewestScriptBytesByAccount_Call) Return(script proto.Script, err error) *MockSmartState_NewestScriptBytesByAccount_Call

+ func (_c *MockSmartState_NewestScriptBytesByAccount_Call) Run(run func(account proto.Recipient)) *MockSmartState_NewestScriptBytesByAccount_Call

+ func (_c *MockSmartState_NewestScriptBytesByAccount_Call) RunAndReturn(run func(account proto.Recipient) (proto.Script, error)) *MockSmartState_NewestScriptBytesByAccount_Call

+ type MockSmartState_NewestScriptPKByAddr_Call struct

+ func (_c *MockSmartState_NewestScriptPKByAddr_Call) Return(publicKey crypto.PublicKey, err error) *MockSmartState_NewestScriptPKByAddr_Call

+ func (_c *MockSmartState_NewestScriptPKByAddr_Call) Run(run func(addr proto.WavesAddress)) *MockSmartState_NewestScriptPKByAddr_Call

+ func (_c *MockSmartState_NewestScriptPKByAddr_Call) RunAndReturn(run func(addr proto.WavesAddress) (crypto.PublicKey, error)) *MockSmartState_NewestScriptPKByAddr_Call

+ type MockSmartState_NewestTransactionByID_Call struct

+ func (_c *MockSmartState_NewestTransactionByID_Call) Return(transaction proto.Transaction, err error) *MockSmartState_NewestTransactionByID_Call

+ func (_c *MockSmartState_NewestTransactionByID_Call) Run(run func(bytes []byte)) *MockSmartState_NewestTransactionByID_Call

+ func (_c *MockSmartState_NewestTransactionByID_Call) RunAndReturn(run func(bytes []byte) (proto.Transaction, error)) *MockSmartState_NewestTransactionByID_Call

+ type MockSmartState_NewestTransactionHeightByID_Call struct

+ func (_c *MockSmartState_NewestTransactionHeightByID_Call) Return(v uint64, err error) *MockSmartState_NewestTransactionHeightByID_Call

+ func (_c *MockSmartState_NewestTransactionHeightByID_Call) Run(run func(bytes []byte)) *MockSmartState_NewestTransactionHeightByID_Call

+ func (_c *MockSmartState_NewestTransactionHeightByID_Call) RunAndReturn(run func(bytes []byte) (uint64, error)) *MockSmartState_NewestTransactionHeightByID_Call

+ type MockSmartState_NewestWavesBalance_Call struct

+ func (_c *MockSmartState_NewestWavesBalance_Call) Return(v uint64, err error) *MockSmartState_NewestWavesBalance_Call

+ func (_c *MockSmartState_NewestWavesBalance_Call) Run(run func(account proto.Recipient)) *MockSmartState_NewestWavesBalance_Call

+ func (_c *MockSmartState_NewestWavesBalance_Call) RunAndReturn(run func(account proto.Recipient) (uint64, error)) *MockSmartState_NewestWavesBalance_Call

+ type MockSmartState_RetrieveEntries_Call struct

+ func (_c *MockSmartState_RetrieveEntries_Call) Return(dataEntrys []proto.DataEntry, err error) *MockSmartState_RetrieveEntries_Call

+ func (_c *MockSmartState_RetrieveEntries_Call) Run(run func(account proto.Recipient)) *MockSmartState_RetrieveEntries_Call

+ func (_c *MockSmartState_RetrieveEntries_Call) RunAndReturn(run func(account proto.Recipient) ([]proto.DataEntry, error)) *MockSmartState_RetrieveEntries_Call

+ type MockSmartState_RetrieveNewestBinaryEntry_Call struct

+ func (_c *MockSmartState_RetrieveNewestBinaryEntry_Call) Return(binaryDataEntry *proto.BinaryDataEntry, err error) *MockSmartState_RetrieveNewestBinaryEntry_Call

+ func (_c *MockSmartState_RetrieveNewestBinaryEntry_Call) Run(run func(account proto.Recipient, key string)) *MockSmartState_RetrieveNewestBinaryEntry_Call

+ func (_c *MockSmartState_RetrieveNewestBinaryEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)) *MockSmartState_RetrieveNewestBinaryEntry_Call

+ type MockSmartState_RetrieveNewestBooleanEntry_Call struct

+ func (_c *MockSmartState_RetrieveNewestBooleanEntry_Call) Return(booleanDataEntry *proto.BooleanDataEntry, err error) *MockSmartState_RetrieveNewestBooleanEntry_Call

+ func (_c *MockSmartState_RetrieveNewestBooleanEntry_Call) Run(run func(account proto.Recipient, key string)) *MockSmartState_RetrieveNewestBooleanEntry_Call

+ func (_c *MockSmartState_RetrieveNewestBooleanEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)) *MockSmartState_RetrieveNewestBooleanEntry_Call

+ type MockSmartState_RetrieveNewestIntegerEntry_Call struct

+ func (_c *MockSmartState_RetrieveNewestIntegerEntry_Call) Return(integerDataEntry *proto.IntegerDataEntry, err error) *MockSmartState_RetrieveNewestIntegerEntry_Call

+ func (_c *MockSmartState_RetrieveNewestIntegerEntry_Call) Run(run func(account proto.Recipient, key string)) *MockSmartState_RetrieveNewestIntegerEntry_Call

+ func (_c *MockSmartState_RetrieveNewestIntegerEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)) *MockSmartState_RetrieveNewestIntegerEntry_Call

+ type MockSmartState_RetrieveNewestStringEntry_Call struct

+ func (_c *MockSmartState_RetrieveNewestStringEntry_Call) Return(stringDataEntry *proto.StringDataEntry, err error) *MockSmartState_RetrieveNewestStringEntry_Call

+ func (_c *MockSmartState_RetrieveNewestStringEntry_Call) Run(run func(account proto.Recipient, key string)) *MockSmartState_RetrieveNewestStringEntry_Call

+ func (_c *MockSmartState_RetrieveNewestStringEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (*proto.StringDataEntry, error)) *MockSmartState_RetrieveNewestStringEntry_Call

type SmartState

+ NewestAssetConstInfo func(assetID proto.AssetID) (*proto.AssetConstInfo, error)

+ RetrieveEntries func(account proto.Recipient) ([]proto.DataEntry, error)

type UtxPool

+ AddWithBytesRaw func(t proto.Transaction, b []byte) error

+ Clean func(ctx context.Context, shouldDrop func(tx proto.Transaction) bool) (int, int)

+ Len func() int

+ type UtxPoolValidatorState interface

+ TopBlock func() *proto.Block

+ TxValidation func(func(validation nextTxValidator) error) error

type WavesBalanceProfile

+ Challenged bool

+ func (bp *WavesBalanceProfile) EffectiveBalance() (uint64, error)

+ func (bp *WavesBalanceProfile) SpendableBalance() (uint64, error)

+ func (bp *WavesBalanceProfile) ToFullWavesBalance() (*proto.FullWavesBalance, error)

v0.10.6

Jun 15, 2023

Changes in this version

type SmartState

+ NewestBlockInfoByHeight func(height proto.Height) (*proto.BlockInfo, error)

v0.10.5

May 23, 2023

Changes in this version

type SmartState

+ BlockRewards func(blockHeader *proto.BlockHeader, height proto.Height) (proto.Rewards, error)

v0.10.4

Mar 3, 2023

Changes in this version

type EmbeddedWallet

+ AccountSeeds func() [][]byte

v0.10.3

Dec 14, 2022

v0.10.2

Oct 19, 2022

v0.10.1

Aug 10, 2022

v0.10.0

Aug 2, 2022

Changes in this version

type SmartState

+ NewestAssetBalance func(account proto.Recipient, assetID crypto.Digest) (uint64, error)

+ NewestAssetBalanceByAddressID func(id proto.AddressID, asset crypto.Digest) (uint64, error)

+ NewestScriptByAccount func(account proto.Recipient) (*ast.Tree, error)

+ NewestScriptBytesByAccount func(account proto.Recipient) (proto.Script, error)

+ NewestScriptVersionByAddressID func(id proto.AddressID) (ast.LibraryVersion, error)

+ NewestWavesBalance func(account proto.Recipient) (uint64, error)

+ WavesBalanceProfile func(id proto.AddressID) (*WavesBalanceProfile, error)

+ type WavesBalanceProfile struct

+ Balance uint64

+ Generating uint64

+ LeaseIn int64

+ LeaseOut int64

v0.9.0

Jun 15, 2021

Changes in this version

type SmartState

+ GetByteTree func(recipient proto.Recipient) (proto.Script, error)

+ IsStateUntouched func(account proto.Recipient) (bool, error)

+ NewestLeasingInfo func(id crypto.Digest) (*proto.LeaseInfo, error)

+ NewestRecipientToAddress func(recipient proto.Recipient) (*proto.Address, error)

+ NewestScriptByAsset func(asset proto.OptionalAsset) (proto.Script, error)

+ NewestScriptPKByAddr func(addr proto.Address) (crypto.PublicKey, error)

v0.8.8

Mar 18, 2021

v0.8.7

Jan 5, 2021

v0.8.6

Dec 28, 2020

v0.8.5

Dec 16, 2020

v0.8.4

Dec 4, 2020

v0.8.3

Dec 2, 2020

v0.8.2

Nov 25, 2020

v0.8.1

Oct 20, 2020

v0.8.0

Oct 12, 2020

Changes in this version

type SmartState

+ EstimatorVersion func() (int, error)

v0.7.0

Jun 8, 2020

Changes in this version

type SmartState

+ NewestFullAssetInfo func(assetID crypto.Digest) (*proto.FullAssetInfo, error)

+ NewestFullWavesBalance func(account proto.Recipient) (*proto.FullWavesBalance, error)

v0.6.0

Apr 23, 2020

Changes in this version

type Miner

+ MineKeyBlock func(ctx context.Context, t proto.Timestamp, k proto.KeyPair, parent proto.BlockID, ...) (*proto.Block, proto.MiningLimits, error)

type UtxPool

+ Add func(t proto.Transaction) error

v0.5.0

Apr 3, 2020

Changes in this version

+ type BaseTarget = uint64

+ type BlocksApplier interface

+ Apply func(block []*proto.Block) error

+ type EmbeddedWallet interface

+ Load func(password []byte) error

+ Seeds func() [][]byte

+ SignTransactionWith func(pk crypto.PublicKey, tx proto.Transaction) error

+ type ID interface

+ ID func() string

+ type InvRequester interface

+ Request func(MessageSender, proto.BlockID)

+ type MessageSender interface

+ SendMessage func(proto.Message)

+ type Miner interface

+ Mine func(ctx context.Context, t proto.Timestamp, k proto.KeyPair, parent proto.BlockID, ...)

+ type MinerConsensus interface

+ IsMiningAllowed func() bool

+ type ScoreSender interface

+ NonPriority func()

+ Priority func()

type SmartState

+ BlockVRF func(blockHeader *proto.BlockHeader, height proto.Height) ([]byte, error)

+ type StateSync interface

+ Close func()

+ Run func(ctx context.Context)

+ SetEnabled func(enabled bool)

+ Sync func()

+ type Subscribe interface

+ Receive func(p ID, responseMessage proto.Message) bool

+ Subscribe func(p ID, responseMessage proto.Message) (chan proto.Message, func(), error)

+ type Time interface

+ Now func() time.Time

type UtxPool

+ AllTransactions func() []*TransactionWithBytes

+ Count func() int

+ ExistsByID func(id []byte) bool

v0.3.0

Nov 13, 2019

Changes in this version

+ type BlockApplier interface

+ Apply func(block *proto.Block) error

+ ApplyBytes func([]byte) error

+ type Handler interface

+ Handle func()

+ type MinerInterrupter interface

+ Interrupt func()

+ type Scheduler interface

+ Reschedule func()

+ type SmartState interface

+ AddingBlockHeight func() (uint64, error)

+ IsNotFound func(err error) bool

+ NewestAccountBalance func(account proto.Recipient, asset []byte) (uint64, error)

+ NewestAddrByAlias func(alias proto.Alias) (proto.Address, error)

+ NewestAssetInfo func(assetID crypto.Digest) (*proto.AssetInfo, error)

+ NewestAssetIsSponsored func(assetID crypto.Digest) (bool, error)

+ NewestHeaderByHeight func(height proto.Height) (*proto.BlockHeader, error)

+ NewestTransactionByID func([]byte) (proto.Transaction, error)

+ NewestTransactionHeightByID func([]byte) (uint64, error)

+ RetrieveNewestBinaryEntry func(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

+ RetrieveNewestBooleanEntry func(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)

+ RetrieveNewestIntegerEntry func(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)

+ RetrieveNewestStringEntry func(account proto.Recipient, key string) (*proto.StringDataEntry, error)

+ type StateHistorySynchronizer interface

+ Sync func()

+ type TransactionWithBytes struct

+ B []byte

+ T proto.Transaction

+ type UtxPool interface

+ AddWithBytes func(t proto.Transaction, b []byte) (added bool)

+ Exists func(t proto.Transaction) bool

+ Pop func() *TransactionWithBytes

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