state

package
v0.11.0 Latest Latest
Warning

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

 Go to latest Published: Mar 24, 2026 License: MIT Imports: 56 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// Default values.
	// Cache parameters.
	// 500 MiB.
	DefaultCacheSize = 500 * 1024 * 1024

	// Bloom filter parameters.
	// Number of elements in Bloom Filter.
	DefaultBloomFilterSize = 2e8
	// Acceptable false positive for Bloom Filter (0.01%).
	DefaultBloomFilterFalsePositiveProbability = 0.0001

	// Db parameters.
	DefaultWriteBuffer         = 32 * 1024 * 1024
	DefaultCompactionTableSize = 8 * 1024 * 1024
	DefaultCompactionTotalSize = 10 * 1024 * 1024

	// Block storage parameters.
	// DefaultOffsetLen is the amount of bytes needed to store offset of transactions in blockchain file.
	DefaultOffsetLen = 8
	// DefaultHeaderOffsetLen is the amount of bytes needed to store offset of headers in headers file.
	DefaultHeaderOffsetLen = 8

	// StateVersion is current version of state internal storage formats.
	// It increases when backward compatibility with previous storage version is lost.
	StateVersion = 26

	// Memory limit for address transactions. flush() is called when this
	// limit is exceeded.
	AddressTransactionsMemLimit = 50 * 1024 * 1024
	// Number of keys per flush() call.
	AddressTransactionsMaxKeys = 4000

	// Maximum size of transactions by addresses file.
	// Then it is sorted and saved to DB.
	MaxAddressTransactionsFileSize = 2 * 1024 * 1024 * 1024 // 2 GiB.
)
View Source 
const (
	FailFreeInvokeComplexity           = 1000
	FreeVerifierComplexity             = 200
	MaxVerifierScriptComplexityReduced = 2000
	MaxVerifierScriptComplexity        = 4000
	MaxCallableScriptComplexityV12     = 2000
	MaxCallableScriptComplexityV34     = 4000
	MaxCallableScriptComplexityV5      = 10000
	MaxCallableScriptComplexityV6      = 52000
)
View Source 
const (
	FeeUnit = 100000

	CommitmentFeeInFeeUnits = 100 // 0.1 Waves.

)
View Source 
const Deposit = 100_0000_0000 // 100 WAVES.

Variables

View Source 
var (
	DefaultOpenFilesCacheCapacity = 500
)
View Source 
var ErrIncompatibleStateParams = stderrs.New("incompatible state params")
View Source 
var ErrNoCommitmentsForPeriod = errors.New("no commitments found for period")
View Source 
var ErrNoFinalization = errors.New("no finalized block recorded")
View Source 
var ErrNoFinalizationHistory = errors.New("no finalization in history")

Functions

func BuildBlockUpdatesInfoFromSnapshot added in v0.11.0 

func BuildBlockUpdatesInfoFromSnapshot(blockInfo *proto.BlockInfo, blockHeader *proto.BlockHeader,
	blockSnapshot proto.BlockSnapshot, l2ContractAddress proto.WavesAddress) (proto.BUpdatesInfo, error)

func CalculateScore added in v0.3.0 

func CalculateScore(baseTarget uint64) (*big.Int, error)

func CalculateSnapshotStateHash added in v0.11.0 

func CalculateSnapshotStateHash(
	scheme proto.Scheme,
	height proto.Height,
	initSh crypto.Digest,
	txs []proto.Transaction,
	txSnapshots [][]proto.AtomicSnapshot,
) (crypto.Digest, error)

func CurrentGenerationPeriodStart added in v0.11.0 

func CurrentGenerationPeriodStart(activationHeight, blockHeight, periodLength uint64) (uint32, error)

CurrentGenerationPeriodStart returns the start height of the current generation period for the given block height.

func NextGenerationPeriodStart added in v0.11.0 

func NextGenerationPeriodStart(activationHeight, blockHeight, periodLength uint64) (uint32, error)

NextGenerationPeriodStart returns the start height of the next generation period given the current block height, the feature activation height and the period length. If the block height is less than the activation height, an error is returned.

func NextRewardTerm added in v0.11.0 

func NextRewardTerm(
	height, activation proto.Height,
	set *settings.BlockchainSettings,
	isCappedRewardsActivated bool,
) uint64

func ReadMainnetBlocksToHeight added in v0.5.0 

func ReadMainnetBlocksToHeight(height proto.Height) ([]*proto.Block, error)

This function is used for testing in other packages. This is more convenient, because blocks are stored in state's subdir.

Types

type InternalAssetScriptComplexitySnapshot added in v0.11.0 

type InternalAssetScriptComplexitySnapshot struct {
	AssetID       crypto.Digest
	Estimation    ride.TreeEstimation
	ScriptIsEmpty bool
}

func (InternalAssetScriptComplexitySnapshot) ApplyInternal added in v0.11.0 

func (s InternalAssetScriptComplexitySnapshot) ApplyInternal(a internalSnapshotApplier) error

type InternalCancelledLeaseInfoSnapshot added in v0.11.0 

type InternalCancelledLeaseInfoSnapshot struct {
	LeaseID             crypto.Digest
	CancelHeight        proto.Height
	CancelTransactionID *crypto.Digest
}

func (InternalCancelledLeaseInfoSnapshot) ApplyInternal added in v0.11.0 

func (s InternalCancelledLeaseInfoSnapshot) ApplyInternal(a internalSnapshotApplier) error

type InternalDAppComplexitySnapshot added in v0.11.0 

type InternalDAppComplexitySnapshot struct {
	ScriptAddress proto.WavesAddress
	Estimation    ride.TreeEstimation
	ScriptIsEmpty bool
}

Below are internal snapshots only. They are not necessary and used for optimization, initialized in the full node mode only.

func (InternalDAppComplexitySnapshot) ApplyInternal added in v0.11.0 

func (s InternalDAppComplexitySnapshot) ApplyInternal(a internalSnapshotApplier) error

type InternalDAppUpdateComplexitySnapshot added in v0.11.0 

type InternalDAppUpdateComplexitySnapshot struct {
	ScriptAddress proto.WavesAddress
	Estimation    ride.TreeEstimation
	ScriptIsEmpty bool
}

func (InternalDAppUpdateComplexitySnapshot) ApplyInternal added in v0.11.0 

func (s InternalDAppUpdateComplexitySnapshot) ApplyInternal(a internalSnapshotApplier) error

type InternalNewLeaseInfoSnapshot added in v0.11.0 

type InternalNewLeaseInfoSnapshot struct {
	LeaseID             crypto.Digest
	OriginHeight        proto.Height
	OriginTransactionID *crypto.Digest
}

func (InternalNewLeaseInfoSnapshot) ApplyInternal added in v0.11.0 

func (s InternalNewLeaseInfoSnapshot) ApplyInternal(a internalSnapshotApplier) error

type InternalScriptResultSnapshot added in v0.11.0 

type InternalScriptResultSnapshot struct {
	ScriptResult *proto.ScriptResult
}

func (InternalScriptResultSnapshot) ApplyInternal added in v0.11.0 

func (s InternalScriptResultSnapshot) ApplyInternal(a internalSnapshotApplier) error

type LeaseStatus added in v0.9.0 

type LeaseStatus byte
const (
	LeaseActive LeaseStatus = iota
	LeaseCancelled
)

type MaxScriptsComplexityInBlock added in v0.9.0 

type MaxScriptsComplexityInBlock struct {
	BeforeActivationRideV5Feature int
	AfterActivationRideV5Feature  int
}

func NewMaxScriptsComplexityInBlock added in v0.9.0 

func NewMaxScriptsComplexityInBlock() MaxScriptsComplexityInBlock

func (MaxScriptsComplexityInBlock) GetMaxScriptsComplexityInBlock added in v0.9.0 

func (a MaxScriptsComplexityInBlock) GetMaxScriptsComplexityInBlock(isRideV5Activated bool) int

type MockState 

type MockState struct {
	mock.Mock
}

MockState is an autogenerated mock type for the State type

func NewMockState added in v0.11.0 

func NewMockState(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockState

NewMockState creates a new instance of MockState. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockState) ActivationHeight added in v0.11.0 

func (_mock *MockState) ActivationHeight(featureID int16) (proto.Height, error)

ActivationHeight provides a mock function for the type MockState

func (*MockState) AddBlock added in v0.11.0 

func (_mock *MockState) AddBlock(block []byte) (*proto.Block, error)

AddBlock provides a mock function for the type MockState

func (*MockState) AddBlocks added in v0.11.0 

func (_mock *MockState) AddBlocks(blocks [][]byte) error

AddBlocks provides a mock function for the type MockState

func (*MockState) AddBlocksWithSnapshots added in v0.11.0 

func (_mock *MockState) AddBlocksWithSnapshots(blocks [][]byte, snapshots []*proto.BlockSnapshot) error

AddBlocksWithSnapshots provides a mock function for the type MockState

func (*MockState) AddDeserializedBlock added in v0.11.0 

func (_mock *MockState) AddDeserializedBlock(block *proto.Block) (*proto.Block, error)

AddDeserializedBlock provides a mock function for the type MockState

func (*MockState) AddDeserializedBlocks added in v0.11.0 

func (_mock *MockState) AddDeserializedBlocks(blocks []*proto.Block) (*proto.Block, error)

AddDeserializedBlocks provides a mock function for the type MockState

func (*MockState) AddDeserializedBlocksWithSnapshots added in v0.11.0 

func (_mock *MockState) AddDeserializedBlocksWithSnapshots(blocks []*proto.Block, snapshots []*proto.BlockSnapshot) (*proto.Block, error)

AddDeserializedBlocksWithSnapshots provides a mock function for the type MockState

func (*MockState) AddrByAlias added in v0.11.0 

func (_mock *MockState) AddrByAlias(alias proto.Alias) (proto.WavesAddress, error)

AddrByAlias provides a mock function for the type MockState

func (*MockState) AliasesByAddr added in v0.11.0 

func (_mock *MockState) AliasesByAddr(addr proto.WavesAddress) ([]string, error)

AliasesByAddr provides a mock function for the type MockState

func (*MockState) AllFeatures added in v0.11.0 

func (_mock *MockState) AllFeatures() ([]int16, error)

AllFeatures provides a mock function for the type MockState

func (*MockState) ApprovalHeight added in v0.11.0 

func (_mock *MockState) ApprovalHeight(featureID int16) (proto.Height, error)

ApprovalHeight provides a mock function for the type MockState

func (*MockState) AssetBalance added in v0.11.0 

func (_mock *MockState) AssetBalance(account proto.Recipient, assetID proto.AssetID) (uint64, error)

AssetBalance provides a mock function for the type MockState

func (*MockState) AssetInfo added in v0.11.0 

func (_mock *MockState) AssetInfo(assetID proto.AssetID) (*proto.AssetInfo, error)

AssetInfo provides a mock function for the type MockState

func (*MockState) AssetIsSponsored added in v0.11.0 

func (_mock *MockState) AssetIsSponsored(assetID proto.AssetID) (bool, error)

AssetIsSponsored provides a mock function for the type MockState

func (*MockState) Block added in v0.11.0 

func (_mock *MockState) Block(blockID proto.BlockID) (*proto.Block, error)

Block provides a mock function for the type MockState

func (*MockState) BlockByHeight added in v0.11.0 

func (_mock *MockState) BlockByHeight(height proto.Height) (*proto.Block, error)

BlockByHeight provides a mock function for the type MockState

func (*MockState) BlockIDToHeight added in v0.11.0 

func (_mock *MockState) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error)

BlockIDToHeight provides a mock function for the type MockState

func (*MockState) BlockRewards added in v0.11.0 

func (_mock *MockState) BlockRewards(generator proto.WavesAddress, height proto.Height) (proto.Rewards, error)

BlockRewards provides a mock function for the type MockState

func (*MockState) BlockVRF added in v0.11.0 

func (_mock *MockState) BlockVRF(blockHeader *proto.BlockHeader, blockHeight proto.Height) ([]byte, error)

BlockVRF provides a mock function for the type MockState

func (*MockState) BlockchainSettings added in v0.11.0 

func (_mock *MockState) BlockchainSettings() (*settings.BlockchainSettings, error)

BlockchainSettings provides a mock function for the type MockState

func (*MockState) CalculateVotingFinalization added in v0.11.0 

func (_mock *MockState) CalculateVotingFinalization(endorsers []proto.WavesAddress, blockGeneratorAddress proto.WavesAddress, height proto.Height, allGenerators []proto.WavesAddress) (bool, error)

CalculateVotingFinalization provides a mock function for the type MockState

func (*MockState) CheckRollbackHeightAuto added in v0.11.0 

func (_mock *MockState) CheckRollbackHeightAuto(height proto.Height) error

CheckRollbackHeightAuto provides a mock function for the type MockState

func (*MockState) Close added in v0.11.0 

func (_mock *MockState) Close() error

Close provides a mock function for the type MockState

func (*MockState) CommittedGenerators added in v0.11.0 

func (_mock *MockState) CommittedGenerators(periodStart uint32) ([]proto.WavesAddress, error)

CommittedGenerators provides a mock function for the type MockState

func (*MockState) CreateNextSnapshotHash added in v0.11.0 

func (_mock *MockState) CreateNextSnapshotHash(block *proto.Block) (crypto.Digest, error)

CreateNextSnapshotHash provides a mock function for the type MockState

func (*MockState) CurrentScore added in v0.11.0 

func (_mock *MockState) CurrentScore() (*big.Int, error)

CurrentScore provides a mock function for the type MockState

func (*MockState) EXPECT added in v0.11.0 

func (_m *MockState) EXPECT() *MockState_Expecter

func (*MockState) EnrichedFullAssetInfo added in v0.11.0 

func (_mock *MockState) EnrichedFullAssetInfo(assetID proto.AssetID) (*proto.EnrichedFullAssetInfo, error)

EnrichedFullAssetInfo provides a mock function for the type MockState

func (*MockState) EstimatorVersion added in v0.11.0 

func (_mock *MockState) EstimatorVersion() (int, error)

EstimatorVersion provides a mock function for the type MockState

func (*MockState) FindEndorserPKByIndex added in v0.11.0 

func (_mock *MockState) FindEndorserPKByIndex(periodStart uint32, index int) (bls.PublicKey, error)

FindEndorserPKByIndex provides a mock function for the type MockState

func (*MockState) FindGeneratorPKByEndorserPK added in v0.11.0 

func (_mock *MockState) FindGeneratorPKByEndorserPK(periodStart uint32, endorserPK bls.PublicKey) (crypto.PublicKey, error)

FindGeneratorPKByEndorserPK provides a mock function for the type MockState

func (*MockState) FullAssetInfo added in v0.11.0 

func (_mock *MockState) FullAssetInfo(assetID proto.AssetID) (*proto.FullAssetInfo, error)

FullAssetInfo provides a mock function for the type MockState

func (*MockState) FullWavesBalance added in v0.11.0 

func (_mock *MockState) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error)

FullWavesBalance provides a mock function for the type MockState

func (*MockState) GeneratingBalance added in v0.11.0 

func (_mock *MockState) GeneratingBalance(account proto.Recipient, height proto.Height) (uint64, error)

GeneratingBalance provides a mock function for the type MockState

func (*MockState) Header added in v0.11.0 

func (_mock *MockState) Header(blockID proto.BlockID) (*proto.BlockHeader, error)

Header provides a mock function for the type MockState

func (*MockState) HeaderByHeight added in v0.11.0 

func (_mock *MockState) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error)

HeaderByHeight provides a mock function for the type MockState

func (*MockState) Height added in v0.11.0 

func (_mock *MockState) Height() (proto.Height, error)

Height provides a mock function for the type MockState

func (*MockState) HeightToBlockID added in v0.11.0 

func (_mock *MockState) HeightToBlockID(height proto.Height) (proto.BlockID, error)

HeightToBlockID provides a mock function for the type MockState

func (*MockState) HitSourceAtHeight added in v0.11.0 

func (_mock *MockState) HitSourceAtHeight(height proto.Height) ([]byte, error)

HitSourceAtHeight provides a mock function for the type MockState

func (*MockState) IndexByEndorserPK added in v0.11.0 

func (_mock *MockState) IndexByEndorserPK(periodStart uint32, pk bls.PublicKey) (uint32, error)

IndexByEndorserPK provides a mock function for the type MockState

func (*MockState) InvokeResultByID added in v0.11.0 

func (_mock *MockState) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error)

InvokeResultByID provides a mock function for the type MockState

func (*MockState) IsActivated added in v0.11.0 

func (_mock *MockState) IsActivated(featureID int16) (bool, error)

IsActivated provides a mock function for the type MockState

func (*MockState) IsActiveAtHeight added in v0.11.0 

func (_mock *MockState) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error)

IsActiveAtHeight provides a mock function for the type MockState

func (*MockState) IsActiveLeasing added in v0.11.0 

func (_mock *MockState) IsActiveLeasing(leaseID crypto.Digest) (bool, error)

IsActiveLeasing provides a mock function for the type MockState

func (*MockState) IsActiveLightNodeNewBlocksFields added in v0.11.0 

func (_mock *MockState) IsActiveLightNodeNewBlocksFields(blockHeight proto.Height) (bool, error)

IsActiveLightNodeNewBlocksFields provides a mock function for the type MockState

func (*MockState) IsApproved added in v0.11.0 

func (_mock *MockState) IsApproved(featureID int16) (bool, error)

IsApproved provides a mock function for the type MockState

func (*MockState) IsApprovedAtHeight added in v0.11.0 

func (_mock *MockState) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error)

IsApprovedAtHeight provides a mock function for the type MockState

func (*MockState) IsAssetExist added in v0.11.0 

func (_mock *MockState) IsAssetExist(assetID proto.AssetID) (bool, error)

IsAssetExist provides a mock function for the type MockState

func (*MockState) LastFinalizedBlock added in v0.11.0 

func (_mock *MockState) LastFinalizedBlock() (*proto.BlockHeader, error)

LastFinalizedBlock provides a mock function for the type MockState

func (*MockState) LastFinalizedHeight added in v0.11.0 

func (_mock *MockState) LastFinalizedHeight() (proto.Height, error)

LastFinalizedHeight provides a mock function for the type MockState

func (*MockState) LegacyStateHashAtHeight added in v0.11.0 

func (_mock *MockState) LegacyStateHashAtHeight(height proto.Height) (proto.StateHash, error)

LegacyStateHashAtHeight provides a mock function for the type MockState

func (*MockState) Map added in v0.11.0 

func (_mock *MockState) Map(fn func(state NonThreadSafeState) error) error

Map provides a mock function for the type MockState

func (*MockState) MapR added in v0.11.0 

func (_mock *MockState) MapR(fn func(StateInfo) (any, error)) (any, error)

MapR provides a mock function for the type MockState

func (*MockState) MapUnsafe added in v0.11.0 

func (_mock *MockState) MapUnsafe(fn func(state NonThreadSafeState) error) error

MapUnsafe provides a mock function for the type MockState

func (*MockState) NFTList added in v0.11.0 

func (_mock *MockState) NFTList(account proto.Recipient, limit uint64, afterAssetID *proto.AssetID) ([]*proto.FullAssetInfo, error)

NFTList provides a mock function for the type MockState

func (*MockState) NewAddrTransactionsIterator added in v0.11.0 

func (_mock *MockState) NewAddrTransactionsIterator(addr proto.Address) (TransactionIterator, error)

NewAddrTransactionsIterator provides a mock function for the type MockState

func (*MockState) NewestBlockInfoByHeight added in v0.11.0 

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

NewestBlockInfoByHeight provides a mock function for the type MockState

func (*MockState) NewestCommitedEndorsers added in v0.11.0 

func (_mock *MockState) NewestCommitedEndorsers(periodStart uint32) ([]bls.PublicKey, error)

NewestCommitedEndorsers provides a mock function for the type MockState

func (*MockState) NewestCommitmentExistsByEndorserPK added in v0.11.0 

func (_mock *MockState) NewestCommitmentExistsByEndorserPK(periodStart uint32, endorserPK bls.PublicKey) (bool, error)

NewestCommitmentExistsByEndorserPK provides a mock function for the type MockState

func (*MockState) NewestHeaderByHeight added in v0.11.0 

func (_mock *MockState) NewestHeaderByHeight(height uint64) (*proto.BlockHeader, error)

NewestHeaderByHeight provides a mock function for the type MockState

func (*MockState) NewestScriptByAccount added in v0.11.0 

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

NewestScriptByAccount provides a mock function for the type MockState

func (*MockState) NewestScriptBytesByAccount added in v0.11.0 

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

NewestScriptBytesByAccount provides a mock function for the type MockState

func (*MockState) PersistAddressTransactions added in v0.11.0 

func (_mock *MockState) PersistAddressTransactions() error

PersistAddressTransactions provides a mock function for the type MockState

func (*MockState) ProvidesExtendedApi added in v0.11.0 

func (_mock *MockState) ProvidesExtendedApi() (bool, error)

ProvidesExtendedApi provides a mock function for the type MockState

func (*MockState) ProvidesStateHashes added in v0.11.0 

func (_mock *MockState) ProvidesStateHashes() (bool, error)

ProvidesStateHashes provides a mock function for the type MockState

func (*MockState) ResetValidationList added in v0.11.0 

func (_mock *MockState) ResetValidationList()

ResetValidationList provides a mock function for the type MockState

func (*MockState) RetrieveBinaryEntry added in v0.11.0 

func (_mock *MockState) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

RetrieveBinaryEntry provides a mock function for the type MockState

func (*MockState) RetrieveBooleanEntry added in v0.11.0 

func (_mock *MockState) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)

RetrieveBooleanEntry provides a mock function for the type MockState

func (*MockState) RetrieveEntries added in v0.11.0 

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

RetrieveEntries provides a mock function for the type MockState

func (*MockState) RetrieveEntry added in v0.11.0 

func (_mock *MockState) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error)

RetrieveEntry provides a mock function for the type MockState

func (*MockState) RetrieveIntegerEntry added in v0.11.0 

func (_mock *MockState) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)

RetrieveIntegerEntry provides a mock function for the type MockState

func (*MockState) RetrieveStringEntry added in v0.11.0 

func (_mock *MockState) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error)

RetrieveStringEntry provides a mock function for the type MockState

func (*MockState) RewardAtHeight added in v0.11.0 

func (_mock *MockState) RewardAtHeight(height proto.Height) (uint64, error)

RewardAtHeight provides a mock function for the type MockState

func (*MockState) RewardVotes added in v0.11.0 

func (_mock *MockState) RewardVotes(height proto.Height) (proto.RewardVotes, error)

RewardVotes provides a mock function for the type MockState

func (*MockState) RollbackTo added in v0.11.0 

func (_mock *MockState) RollbackTo(removalEdge proto.BlockID, isAutoRollback bool) error

RollbackTo provides a mock function for the type MockState

func (*MockState) RollbackToHeight added in v0.11.0 

func (_mock *MockState) RollbackToHeight(height proto.Height, isAutoRollback bool) error

RollbackToHeight provides a mock function for the type MockState

func (*MockState) ScoreAtHeight added in v0.11.0 

func (_mock *MockState) ScoreAtHeight(height proto.Height) (*big.Int, error)

ScoreAtHeight provides a mock function for the type MockState

func (*MockState) ScriptBasicInfoByAccount added in v0.11.0 

func (_mock *MockState) ScriptBasicInfoByAccount(account proto.Recipient) (*proto.ScriptBasicInfo, error)

ScriptBasicInfoByAccount provides a mock function for the type MockState

func (*MockState) ScriptInfoByAccount added in v0.11.0 

func (_mock *MockState) ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error)

ScriptInfoByAccount provides a mock function for the type MockState

func (*MockState) ScriptInfoByAsset added in v0.11.0 

func (_mock *MockState) ScriptInfoByAsset(assetID proto.AssetID) (*proto.ScriptInfo, error)

ScriptInfoByAsset provides a mock function for the type MockState

func (*MockState) ShouldPersistAddressTransactions added in v0.11.0 

func (_mock *MockState) ShouldPersistAddressTransactions() (bool, error)

ShouldPersistAddressTransactions provides a mock function for the type MockState

func (*MockState) SnapshotStateHashAtHeight added in v0.11.0 

func (_mock *MockState) SnapshotStateHashAtHeight(height proto.Height) (crypto.Digest, error)

SnapshotStateHashAtHeight provides a mock function for the type MockState

func (*MockState) SnapshotsAtHeight added in v0.11.0 

func (_mock *MockState) SnapshotsAtHeight(height proto.Height) (proto.BlockSnapshot, error)

SnapshotsAtHeight provides a mock function for the type MockState

func (*MockState) StartProvidingExtendedApi added in v0.11.0 

func (_mock *MockState) StartProvidingExtendedApi() error

StartProvidingExtendedApi provides a mock function for the type MockState

func (*MockState) TopBlock added in v0.11.0 

func (_mock *MockState) TopBlock() *proto.Block

TopBlock provides a mock function for the type MockState

func (*MockState) TotalWavesAmount added in v0.11.0 

func (_mock *MockState) TotalWavesAmount(height proto.Height) (uint64, error)

TotalWavesAmount provides a mock function for the type MockState

func (*MockState) TransactionByID 

func (_mock *MockState) TransactionByID(id []byte) (proto.Transaction, error)

TransactionByID provides a mock function for the type MockState

func (*MockState) TransactionByIDWithStatus added in v0.11.0 

func (_mock *MockState) TransactionByIDWithStatus(id []byte) (proto.Transaction, proto.TransactionStatus, error)

TransactionByIDWithStatus provides a mock function for the type MockState

func (*MockState) TransactionHeightByID 

func (_mock *MockState) TransactionHeightByID(id []byte) (uint64, error)

TransactionHeightByID provides a mock function for the type MockState

func (*MockState) TxValidation added in v0.11.0 

func (_mock *MockState) TxValidation(fn func(validation TxValidation) error) error

TxValidation provides a mock function for the type MockState

func (*MockState) ValidateNextTx added in v0.11.0 

func (_mock *MockState) ValidateNextTx(tx proto.Transaction, currentTimestamp uint64, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) ([]proto.AtomicSnapshot, error)

ValidateNextTx provides a mock function for the type MockState

func (*MockState) VotesNum added in v0.11.0 

func (_mock *MockState) VotesNum(featureID int16) (uint64, error)

VotesNum provides a mock function for the type MockState

func (*MockState) VotesNumAtHeight added in v0.11.0 

func (_mock *MockState) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error)

VotesNumAtHeight provides a mock function for the type MockState

func (*MockState) WavesAddressesNumber added in v0.11.0 

func (_mock *MockState) WavesAddressesNumber() (uint64, error)

WavesAddressesNumber provides a mock function for the type MockState

func (*MockState) WavesBalance added in v0.11.0 

func (_mock *MockState) WavesBalance(account proto.Recipient) (uint64, error)

WavesBalance provides a mock function for the type MockState

type MockState_ActivationHeight_Call added in v0.11.0 

type MockState_ActivationHeight_Call struct {
	*mock.Call
}

MockState_ActivationHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivationHeight'

func (*MockState_ActivationHeight_Call) Return added in v0.11.0 

func (_c *MockState_ActivationHeight_Call) Return(v proto.Height, err error) *MockState_ActivationHeight_Call

func (*MockState_ActivationHeight_Call) Run added in v0.11.0 

func (_c *MockState_ActivationHeight_Call) Run(run func(featureID int16)) *MockState_ActivationHeight_Call

func (*MockState_ActivationHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ActivationHeight_Call) RunAndReturn(run func(featureID int16) (proto.Height, error)) *MockState_ActivationHeight_Call

type MockState_AddBlock_Call added in v0.11.0 

type MockState_AddBlock_Call struct {
	*mock.Call
}

MockState_AddBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBlock'

func (*MockState_AddBlock_Call) Return added in v0.11.0 

func (_c *MockState_AddBlock_Call) Return(block1 *proto.Block, err error) *MockState_AddBlock_Call

func (*MockState_AddBlock_Call) Run added in v0.11.0 

func (_c *MockState_AddBlock_Call) Run(run func(block []byte)) *MockState_AddBlock_Call

func (*MockState_AddBlock_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddBlock_Call) RunAndReturn(run func(block []byte) (*proto.Block, error)) *MockState_AddBlock_Call

type MockState_AddBlocksWithSnapshots_Call added in v0.11.0 

type MockState_AddBlocksWithSnapshots_Call struct {
	*mock.Call
}

MockState_AddBlocksWithSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBlocksWithSnapshots'

func (*MockState_AddBlocksWithSnapshots_Call) Return added in v0.11.0 

func (_c *MockState_AddBlocksWithSnapshots_Call) Return(err error) *MockState_AddBlocksWithSnapshots_Call

func (*MockState_AddBlocksWithSnapshots_Call) Run added in v0.11.0 

func (_c *MockState_AddBlocksWithSnapshots_Call) Run(run func(blocks [][]byte, snapshots []*proto.BlockSnapshot)) *MockState_AddBlocksWithSnapshots_Call

func (*MockState_AddBlocksWithSnapshots_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddBlocksWithSnapshots_Call) RunAndReturn(run func(blocks [][]byte, snapshots []*proto.BlockSnapshot) error) *MockState_AddBlocksWithSnapshots_Call

type MockState_AddBlocks_Call added in v0.11.0 

type MockState_AddBlocks_Call struct {
	*mock.Call
}

MockState_AddBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBlocks'

func (*MockState_AddBlocks_Call) Return added in v0.11.0 

func (_c *MockState_AddBlocks_Call) Return(err error) *MockState_AddBlocks_Call

func (*MockState_AddBlocks_Call) Run added in v0.11.0 

func (_c *MockState_AddBlocks_Call) Run(run func(blocks [][]byte)) *MockState_AddBlocks_Call

func (*MockState_AddBlocks_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddBlocks_Call) RunAndReturn(run func(blocks [][]byte) error) *MockState_AddBlocks_Call

type MockState_AddDeserializedBlock_Call added in v0.11.0 

type MockState_AddDeserializedBlock_Call struct {
	*mock.Call
}

MockState_AddDeserializedBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddDeserializedBlock'

func (*MockState_AddDeserializedBlock_Call) Return added in v0.11.0 

func (_c *MockState_AddDeserializedBlock_Call) Return(block1 *proto.Block, err error) *MockState_AddDeserializedBlock_Call

func (*MockState_AddDeserializedBlock_Call) Run added in v0.11.0 

func (_c *MockState_AddDeserializedBlock_Call) Run(run func(block *proto.Block)) *MockState_AddDeserializedBlock_Call

func (*MockState_AddDeserializedBlock_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddDeserializedBlock_Call) RunAndReturn(run func(block *proto.Block) (*proto.Block, error)) *MockState_AddDeserializedBlock_Call

type MockState_AddDeserializedBlocksWithSnapshots_Call added in v0.11.0 

type MockState_AddDeserializedBlocksWithSnapshots_Call struct {
	*mock.Call
}

MockState_AddDeserializedBlocksWithSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddDeserializedBlocksWithSnapshots'

func (*MockState_AddDeserializedBlocksWithSnapshots_Call) Return added in v0.11.0 

func (_c *MockState_AddDeserializedBlocksWithSnapshots_Call) Return(block *proto.Block, err error) *MockState_AddDeserializedBlocksWithSnapshots_Call

func (*MockState_AddDeserializedBlocksWithSnapshots_Call) Run added in v0.11.0 

func (_c *MockState_AddDeserializedBlocksWithSnapshots_Call) Run(run func(blocks []*proto.Block, snapshots []*proto.BlockSnapshot)) *MockState_AddDeserializedBlocksWithSnapshots_Call

func (*MockState_AddDeserializedBlocksWithSnapshots_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddDeserializedBlocksWithSnapshots_Call) RunAndReturn(run func(blocks []*proto.Block, snapshots []*proto.BlockSnapshot) (*proto.Block, error)) *MockState_AddDeserializedBlocksWithSnapshots_Call

type MockState_AddDeserializedBlocks_Call added in v0.11.0 

type MockState_AddDeserializedBlocks_Call struct {
	*mock.Call
}

MockState_AddDeserializedBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddDeserializedBlocks'

func (*MockState_AddDeserializedBlocks_Call) Return added in v0.11.0 

func (_c *MockState_AddDeserializedBlocks_Call) Return(block *proto.Block, err error) *MockState_AddDeserializedBlocks_Call

func (*MockState_AddDeserializedBlocks_Call) Run added in v0.11.0 

func (_c *MockState_AddDeserializedBlocks_Call) Run(run func(blocks []*proto.Block)) *MockState_AddDeserializedBlocks_Call

func (*MockState_AddDeserializedBlocks_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AddDeserializedBlocks_Call) RunAndReturn(run func(blocks []*proto.Block) (*proto.Block, error)) *MockState_AddDeserializedBlocks_Call

type MockState_AddrByAlias_Call added in v0.11.0 

type MockState_AddrByAlias_Call struct {
	*mock.Call
}

MockState_AddrByAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddrByAlias'

func (*MockState_AddrByAlias_Call) Return added in v0.11.0 

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

func (*MockState_AddrByAlias_Call) Run added in v0.11.0 

func (_c *MockState_AddrByAlias_Call) Run(run func(alias proto.Alias)) *MockState_AddrByAlias_Call

func (*MockState_AddrByAlias_Call) RunAndReturn added in v0.11.0 

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

type MockState_AliasesByAddr_Call added in v0.11.0 

type MockState_AliasesByAddr_Call struct {
	*mock.Call
}

MockState_AliasesByAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AliasesByAddr'

func (*MockState_AliasesByAddr_Call) Return added in v0.11.0 

func (_c *MockState_AliasesByAddr_Call) Return(strings []string, err error) *MockState_AliasesByAddr_Call

func (*MockState_AliasesByAddr_Call) Run added in v0.11.0 

func (_c *MockState_AliasesByAddr_Call) Run(run func(addr proto.WavesAddress)) *MockState_AliasesByAddr_Call

func (*MockState_AliasesByAddr_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AliasesByAddr_Call) RunAndReturn(run func(addr proto.WavesAddress) ([]string, error)) *MockState_AliasesByAddr_Call

type MockState_AllFeatures_Call added in v0.11.0 

type MockState_AllFeatures_Call struct {
	*mock.Call
}

MockState_AllFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllFeatures'

func (*MockState_AllFeatures_Call) Return added in v0.11.0 

func (_c *MockState_AllFeatures_Call) Return(int16s []int16, err error) *MockState_AllFeatures_Call

func (*MockState_AllFeatures_Call) Run added in v0.11.0 

func (_c *MockState_AllFeatures_Call) Run(run func()) *MockState_AllFeatures_Call

func (*MockState_AllFeatures_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AllFeatures_Call) RunAndReturn(run func() ([]int16, error)) *MockState_AllFeatures_Call

type MockState_ApprovalHeight_Call added in v0.11.0 

type MockState_ApprovalHeight_Call struct {
	*mock.Call
}

MockState_ApprovalHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApprovalHeight'

func (*MockState_ApprovalHeight_Call) Return added in v0.11.0 

func (_c *MockState_ApprovalHeight_Call) Return(v proto.Height, err error) *MockState_ApprovalHeight_Call

func (*MockState_ApprovalHeight_Call) Run added in v0.11.0 

func (_c *MockState_ApprovalHeight_Call) Run(run func(featureID int16)) *MockState_ApprovalHeight_Call

func (*MockState_ApprovalHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ApprovalHeight_Call) RunAndReturn(run func(featureID int16) (proto.Height, error)) *MockState_ApprovalHeight_Call

type MockState_AssetBalance_Call added in v0.11.0 

type MockState_AssetBalance_Call struct {
	*mock.Call
}

MockState_AssetBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssetBalance'

func (*MockState_AssetBalance_Call) Return added in v0.11.0 

func (_c *MockState_AssetBalance_Call) Return(v uint64, err error) *MockState_AssetBalance_Call

func (*MockState_AssetBalance_Call) Run added in v0.11.0 

func (_c *MockState_AssetBalance_Call) Run(run func(account proto.Recipient, assetID proto.AssetID)) *MockState_AssetBalance_Call

func (*MockState_AssetBalance_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AssetBalance_Call) RunAndReturn(run func(account proto.Recipient, assetID proto.AssetID) (uint64, error)) *MockState_AssetBalance_Call

type MockState_AssetInfo_Call added in v0.11.0 

type MockState_AssetInfo_Call struct {
	*mock.Call
}

MockState_AssetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssetInfo'

func (*MockState_AssetInfo_Call) Return added in v0.11.0 

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

func (*MockState_AssetInfo_Call) Run added in v0.11.0 

func (_c *MockState_AssetInfo_Call) Run(run func(assetID proto.AssetID)) *MockState_AssetInfo_Call

func (*MockState_AssetInfo_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AssetInfo_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.AssetInfo, error)) *MockState_AssetInfo_Call

type MockState_AssetIsSponsored_Call added in v0.11.0 

type MockState_AssetIsSponsored_Call struct {
	*mock.Call
}

MockState_AssetIsSponsored_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssetIsSponsored'

func (*MockState_AssetIsSponsored_Call) Return added in v0.11.0 

func (_c *MockState_AssetIsSponsored_Call) Return(b bool, err error) *MockState_AssetIsSponsored_Call

func (*MockState_AssetIsSponsored_Call) Run added in v0.11.0 

func (_c *MockState_AssetIsSponsored_Call) Run(run func(assetID proto.AssetID)) *MockState_AssetIsSponsored_Call

func (*MockState_AssetIsSponsored_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_AssetIsSponsored_Call) RunAndReturn(run func(assetID proto.AssetID) (bool, error)) *MockState_AssetIsSponsored_Call

type MockState_BlockByHeight_Call added in v0.11.0 

type MockState_BlockByHeight_Call struct {
	*mock.Call
}

MockState_BlockByHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByHeight'

func (*MockState_BlockByHeight_Call) Return added in v0.11.0 

func (_c *MockState_BlockByHeight_Call) Return(block *proto.Block, err error) *MockState_BlockByHeight_Call

func (*MockState_BlockByHeight_Call) Run added in v0.11.0 

func (_c *MockState_BlockByHeight_Call) Run(run func(height proto.Height)) *MockState_BlockByHeight_Call

func (*MockState_BlockByHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_BlockByHeight_Call) RunAndReturn(run func(height proto.Height) (*proto.Block, error)) *MockState_BlockByHeight_Call

type MockState_BlockIDToHeight_Call added in v0.11.0 

type MockState_BlockIDToHeight_Call struct {
	*mock.Call
}

MockState_BlockIDToHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockIDToHeight'

func (*MockState_BlockIDToHeight_Call) Return added in v0.11.0 

func (_c *MockState_BlockIDToHeight_Call) Return(v proto.Height, err error) *MockState_BlockIDToHeight_Call

func (*MockState_BlockIDToHeight_Call) Run added in v0.11.0 

func (_c *MockState_BlockIDToHeight_Call) Run(run func(blockID proto.BlockID)) *MockState_BlockIDToHeight_Call

func (*MockState_BlockIDToHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_BlockIDToHeight_Call) RunAndReturn(run func(blockID proto.BlockID) (proto.Height, error)) *MockState_BlockIDToHeight_Call

type MockState_BlockRewards_Call added in v0.11.0 

type MockState_BlockRewards_Call struct {
	*mock.Call
}

MockState_BlockRewards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockRewards'

func (*MockState_BlockRewards_Call) Return added in v0.11.0 

func (_c *MockState_BlockRewards_Call) Return(rewards proto.Rewards, err error) *MockState_BlockRewards_Call

func (*MockState_BlockRewards_Call) Run added in v0.11.0 

func (_c *MockState_BlockRewards_Call) Run(run func(generator proto.WavesAddress, height proto.Height)) *MockState_BlockRewards_Call

func (*MockState_BlockRewards_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_BlockRewards_Call) RunAndReturn(run func(generator proto.WavesAddress, height proto.Height) (proto.Rewards, error)) *MockState_BlockRewards_Call

type MockState_BlockVRF_Call added in v0.11.0 

type MockState_BlockVRF_Call struct {
	*mock.Call
}

MockState_BlockVRF_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockVRF'

func (*MockState_BlockVRF_Call) Return added in v0.11.0 

func (_c *MockState_BlockVRF_Call) Return(bytes []byte, err error) *MockState_BlockVRF_Call

func (*MockState_BlockVRF_Call) Run added in v0.11.0 

func (_c *MockState_BlockVRF_Call) Run(run func(blockHeader *proto.BlockHeader, blockHeight proto.Height)) *MockState_BlockVRF_Call

func (*MockState_BlockVRF_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_BlockVRF_Call) RunAndReturn(run func(blockHeader *proto.BlockHeader, blockHeight proto.Height) ([]byte, error)) *MockState_BlockVRF_Call

type MockState_Block_Call added in v0.11.0 

type MockState_Block_Call struct {
	*mock.Call
}

MockState_Block_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Block'

func (*MockState_Block_Call) Return added in v0.11.0 

func (_c *MockState_Block_Call) Return(block *proto.Block, err error) *MockState_Block_Call

func (*MockState_Block_Call) Run added in v0.11.0 

func (_c *MockState_Block_Call) Run(run func(blockID proto.BlockID)) *MockState_Block_Call

func (*MockState_Block_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_Block_Call) RunAndReturn(run func(blockID proto.BlockID) (*proto.Block, error)) *MockState_Block_Call

type MockState_BlockchainSettings_Call added in v0.11.0 

type MockState_BlockchainSettings_Call struct {
	*mock.Call
}

MockState_BlockchainSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockchainSettings'

func (*MockState_BlockchainSettings_Call) Return added in v0.11.0 

func (_c *MockState_BlockchainSettings_Call) Return(blockchainSettings *settings.BlockchainSettings, err error) *MockState_BlockchainSettings_Call

func (*MockState_BlockchainSettings_Call) Run added in v0.11.0 

func (_c *MockState_BlockchainSettings_Call) Run(run func()) *MockState_BlockchainSettings_Call

func (*MockState_BlockchainSettings_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_BlockchainSettings_Call) RunAndReturn(run func() (*settings.BlockchainSettings, error)) *MockState_BlockchainSettings_Call

type MockState_CalculateVotingFinalization_Call added in v0.11.0 

type MockState_CalculateVotingFinalization_Call struct {
	*mock.Call
}

MockState_CalculateVotingFinalization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CalculateVotingFinalization'

func (*MockState_CalculateVotingFinalization_Call) Return added in v0.11.0 

func (_c *MockState_CalculateVotingFinalization_Call) Return(b bool, err error) *MockState_CalculateVotingFinalization_Call

func (*MockState_CalculateVotingFinalization_Call) Run added in v0.11.0 

func (_c *MockState_CalculateVotingFinalization_Call) Run(run func(endorsers []proto.WavesAddress, blockGeneratorAddress proto.WavesAddress, height proto.Height, allGenerators []proto.WavesAddress)) *MockState_CalculateVotingFinalization_Call

func (*MockState_CalculateVotingFinalization_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_CalculateVotingFinalization_Call) RunAndReturn(run func(endorsers []proto.WavesAddress, blockGeneratorAddress proto.WavesAddress, height proto.Height, allGenerators []proto.WavesAddress) (bool, error)) *MockState_CalculateVotingFinalization_Call

type MockState_CheckRollbackHeightAuto_Call added in v0.11.0 

type MockState_CheckRollbackHeightAuto_Call struct {
	*mock.Call
}

MockState_CheckRollbackHeightAuto_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckRollbackHeightAuto'

func (*MockState_CheckRollbackHeightAuto_Call) Return added in v0.11.0 

func (_c *MockState_CheckRollbackHeightAuto_Call) Return(err error) *MockState_CheckRollbackHeightAuto_Call

func (*MockState_CheckRollbackHeightAuto_Call) Run added in v0.11.0 

func (_c *MockState_CheckRollbackHeightAuto_Call) Run(run func(height proto.Height)) *MockState_CheckRollbackHeightAuto_Call

func (*MockState_CheckRollbackHeightAuto_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_CheckRollbackHeightAuto_Call) RunAndReturn(run func(height proto.Height) error) *MockState_CheckRollbackHeightAuto_Call

type MockState_Close_Call added in v0.11.0 

type MockState_Close_Call struct {
	*mock.Call
}

MockState_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'

func (*MockState_Close_Call) Return added in v0.11.0 

func (_c *MockState_Close_Call) Return(err error) *MockState_Close_Call

func (*MockState_Close_Call) Run added in v0.11.0 

func (_c *MockState_Close_Call) Run(run func()) *MockState_Close_Call

func (*MockState_Close_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_Close_Call) RunAndReturn(run func() error) *MockState_Close_Call

type MockState_CommittedGenerators_Call added in v0.11.0 

type MockState_CommittedGenerators_Call struct {
	*mock.Call
}

MockState_CommittedGenerators_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommittedGenerators'

func (*MockState_CommittedGenerators_Call) Return added in v0.11.0 

func (_c *MockState_CommittedGenerators_Call) Return(wavesAddresss []proto.WavesAddress, err error) *MockState_CommittedGenerators_Call

func (*MockState_CommittedGenerators_Call) Run added in v0.11.0 

func (_c *MockState_CommittedGenerators_Call) Run(run func(periodStart uint32)) *MockState_CommittedGenerators_Call

func (*MockState_CommittedGenerators_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_CommittedGenerators_Call) RunAndReturn(run func(periodStart uint32) ([]proto.WavesAddress, error)) *MockState_CommittedGenerators_Call

type MockState_CreateNextSnapshotHash_Call added in v0.11.0 

type MockState_CreateNextSnapshotHash_Call struct {
	*mock.Call
}

MockState_CreateNextSnapshotHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNextSnapshotHash'

func (*MockState_CreateNextSnapshotHash_Call) Return added in v0.11.0 

func (_c *MockState_CreateNextSnapshotHash_Call) Return(digest crypto.Digest, err error) *MockState_CreateNextSnapshotHash_Call

func (*MockState_CreateNextSnapshotHash_Call) Run added in v0.11.0 

func (_c *MockState_CreateNextSnapshotHash_Call) Run(run func(block *proto.Block)) *MockState_CreateNextSnapshotHash_Call

func (*MockState_CreateNextSnapshotHash_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_CreateNextSnapshotHash_Call) RunAndReturn(run func(block *proto.Block) (crypto.Digest, error)) *MockState_CreateNextSnapshotHash_Call

type MockState_CurrentScore_Call added in v0.11.0 

type MockState_CurrentScore_Call struct {
	*mock.Call
}

MockState_CurrentScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentScore'

func (*MockState_CurrentScore_Call) Return added in v0.11.0 

func (_c *MockState_CurrentScore_Call) Return(intParam *big.Int, err error) *MockState_CurrentScore_Call

func (*MockState_CurrentScore_Call) Run added in v0.11.0 

func (_c *MockState_CurrentScore_Call) Run(run func()) *MockState_CurrentScore_Call

func (*MockState_CurrentScore_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_CurrentScore_Call) RunAndReturn(run func() (*big.Int, error)) *MockState_CurrentScore_Call

type MockState_EnrichedFullAssetInfo_Call added in v0.11.0 

type MockState_EnrichedFullAssetInfo_Call struct {
	*mock.Call
}

MockState_EnrichedFullAssetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnrichedFullAssetInfo'

func (*MockState_EnrichedFullAssetInfo_Call) Return added in v0.11.0 

func (_c *MockState_EnrichedFullAssetInfo_Call) Return(enrichedFullAssetInfo *proto.EnrichedFullAssetInfo, err error) *MockState_EnrichedFullAssetInfo_Call

func (*MockState_EnrichedFullAssetInfo_Call) Run added in v0.11.0 

func (_c *MockState_EnrichedFullAssetInfo_Call) Run(run func(assetID proto.AssetID)) *MockState_EnrichedFullAssetInfo_Call

func (*MockState_EnrichedFullAssetInfo_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_EnrichedFullAssetInfo_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.EnrichedFullAssetInfo, error)) *MockState_EnrichedFullAssetInfo_Call

type MockState_EstimatorVersion_Call added in v0.11.0 

type MockState_EstimatorVersion_Call struct {
	*mock.Call
}

MockState_EstimatorVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatorVersion'

func (*MockState_EstimatorVersion_Call) Return added in v0.11.0 

func (_c *MockState_EstimatorVersion_Call) Return(n int, err error) *MockState_EstimatorVersion_Call

func (*MockState_EstimatorVersion_Call) Run added in v0.11.0 

func (_c *MockState_EstimatorVersion_Call) Run(run func()) *MockState_EstimatorVersion_Call

func (*MockState_EstimatorVersion_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_EstimatorVersion_Call) RunAndReturn(run func() (int, error)) *MockState_EstimatorVersion_Call

type MockState_Expecter added in v0.11.0 

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

func (*MockState_Expecter) ActivationHeight added in v0.11.0 

func (_e *MockState_Expecter) ActivationHeight(featureID interface{}) *MockState_ActivationHeight_Call

ActivationHeight is a helper method to define mock.On call

  • featureID int16

func (*MockState_Expecter) AddBlock added in v0.11.0 

func (_e *MockState_Expecter) AddBlock(block interface{}) *MockState_AddBlock_Call

AddBlock is a helper method to define mock.On call

  • block []byte

func (*MockState_Expecter) AddBlocks added in v0.11.0 

func (_e *MockState_Expecter) AddBlocks(blocks interface{}) *MockState_AddBlocks_Call

AddBlocks is a helper method to define mock.On call

  • blocks [][]byte

func (*MockState_Expecter) AddBlocksWithSnapshots added in v0.11.0 

func (_e *MockState_Expecter) AddBlocksWithSnapshots(blocks interface{}, snapshots interface{}) *MockState_AddBlocksWithSnapshots_Call

AddBlocksWithSnapshots is a helper method to define mock.On call

  • blocks [][]byte
  • snapshots []*proto.BlockSnapshot

func (*MockState_Expecter) AddDeserializedBlock added in v0.11.0 

func (_e *MockState_Expecter) AddDeserializedBlock(block interface{}) *MockState_AddDeserializedBlock_Call

AddDeserializedBlock is a helper method to define mock.On call

  • block *proto.Block

func (*MockState_Expecter) AddDeserializedBlocks added in v0.11.0 

func (_e *MockState_Expecter) AddDeserializedBlocks(blocks interface{}) *MockState_AddDeserializedBlocks_Call

AddDeserializedBlocks is a helper method to define mock.On call

  • blocks []*proto.Block

func (*MockState_Expecter) AddDeserializedBlocksWithSnapshots added in v0.11.0 

func (_e *MockState_Expecter) AddDeserializedBlocksWithSnapshots(blocks interface{}, snapshots interface{}) *MockState_AddDeserializedBlocksWithSnapshots_Call

AddDeserializedBlocksWithSnapshots is a helper method to define mock.On call

  • blocks []*proto.Block
  • snapshots []*proto.BlockSnapshot

func (*MockState_Expecter) AddrByAlias added in v0.11.0 

func (_e *MockState_Expecter) AddrByAlias(alias interface{}) *MockState_AddrByAlias_Call

AddrByAlias is a helper method to define mock.On call

  • alias proto.Alias

func (*MockState_Expecter) AliasesByAddr added in v0.11.0 

func (_e *MockState_Expecter) AliasesByAddr(addr interface{}) *MockState_AliasesByAddr_Call

AliasesByAddr is a helper method to define mock.On call

  • addr proto.WavesAddress

func (*MockState_Expecter) AllFeatures added in v0.11.0 

func (_e *MockState_Expecter) AllFeatures() *MockState_AllFeatures_Call

AllFeatures is a helper method to define mock.On call

func (*MockState_Expecter) ApprovalHeight added in v0.11.0 

func (_e *MockState_Expecter) ApprovalHeight(featureID interface{}) *MockState_ApprovalHeight_Call

ApprovalHeight is a helper method to define mock.On call

  • featureID int16

func (*MockState_Expecter) AssetBalance added in v0.11.0 

func (_e *MockState_Expecter) AssetBalance(account interface{}, assetID interface{}) *MockState_AssetBalance_Call

AssetBalance is a helper method to define mock.On call

  • account proto.Recipient
  • assetID proto.AssetID

func (*MockState_Expecter) AssetInfo added in v0.11.0 

func (_e *MockState_Expecter) AssetInfo(assetID interface{}) *MockState_AssetInfo_Call

AssetInfo is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) AssetIsSponsored added in v0.11.0 

func (_e *MockState_Expecter) AssetIsSponsored(assetID interface{}) *MockState_AssetIsSponsored_Call

AssetIsSponsored is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) Block added in v0.11.0 

func (_e *MockState_Expecter) Block(blockID interface{}) *MockState_Block_Call

Block is a helper method to define mock.On call

  • blockID proto.BlockID

func (*MockState_Expecter) BlockByHeight added in v0.11.0 

func (_e *MockState_Expecter) BlockByHeight(height interface{}) *MockState_BlockByHeight_Call

BlockByHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) BlockIDToHeight added in v0.11.0 

func (_e *MockState_Expecter) BlockIDToHeight(blockID interface{}) *MockState_BlockIDToHeight_Call

BlockIDToHeight is a helper method to define mock.On call

  • blockID proto.BlockID

func (*MockState_Expecter) BlockRewards added in v0.11.0 

func (_e *MockState_Expecter) BlockRewards(generator interface{}, height interface{}) *MockState_BlockRewards_Call

BlockRewards is a helper method to define mock.On call

  • generator proto.WavesAddress
  • height proto.Height

func (*MockState_Expecter) BlockVRF added in v0.11.0 

func (_e *MockState_Expecter) BlockVRF(blockHeader interface{}, blockHeight interface{}) *MockState_BlockVRF_Call

BlockVRF is a helper method to define mock.On call

  • blockHeader *proto.BlockHeader
  • blockHeight proto.Height

func (*MockState_Expecter) BlockchainSettings added in v0.11.0 

func (_e *MockState_Expecter) BlockchainSettings() *MockState_BlockchainSettings_Call

BlockchainSettings is a helper method to define mock.On call

func (*MockState_Expecter) CalculateVotingFinalization added in v0.11.0 

func (_e *MockState_Expecter) CalculateVotingFinalization(endorsers interface{}, blockGeneratorAddress interface{}, height interface{}, allGenerators interface{}) *MockState_CalculateVotingFinalization_Call

CalculateVotingFinalization is a helper method to define mock.On call

  • endorsers []proto.WavesAddress
  • blockGeneratorAddress proto.WavesAddress
  • height proto.Height
  • allGenerators []proto.WavesAddress

func (*MockState_Expecter) CheckRollbackHeightAuto added in v0.11.0 

func (_e *MockState_Expecter) CheckRollbackHeightAuto(height interface{}) *MockState_CheckRollbackHeightAuto_Call

CheckRollbackHeightAuto is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) Close added in v0.11.0 

func (_e *MockState_Expecter) Close() *MockState_Close_Call

Close is a helper method to define mock.On call

func (*MockState_Expecter) CommittedGenerators added in v0.11.0 

func (_e *MockState_Expecter) CommittedGenerators(periodStart interface{}) *MockState_CommittedGenerators_Call

CommittedGenerators is a helper method to define mock.On call

  • periodStart uint32

func (*MockState_Expecter) CreateNextSnapshotHash added in v0.11.0 

func (_e *MockState_Expecter) CreateNextSnapshotHash(block interface{}) *MockState_CreateNextSnapshotHash_Call

CreateNextSnapshotHash is a helper method to define mock.On call

  • block *proto.Block

func (*MockState_Expecter) CurrentScore added in v0.11.0 

func (_e *MockState_Expecter) CurrentScore() *MockState_CurrentScore_Call

CurrentScore is a helper method to define mock.On call

func (*MockState_Expecter) EnrichedFullAssetInfo added in v0.11.0 

func (_e *MockState_Expecter) EnrichedFullAssetInfo(assetID interface{}) *MockState_EnrichedFullAssetInfo_Call

EnrichedFullAssetInfo is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) EstimatorVersion added in v0.11.0 

func (_e *MockState_Expecter) EstimatorVersion() *MockState_EstimatorVersion_Call

EstimatorVersion is a helper method to define mock.On call

func (*MockState_Expecter) FindEndorserPKByIndex added in v0.11.0 

func (_e *MockState_Expecter) FindEndorserPKByIndex(periodStart interface{}, index interface{}) *MockState_FindEndorserPKByIndex_Call

FindEndorserPKByIndex is a helper method to define mock.On call

  • periodStart uint32
  • index int

func (*MockState_Expecter) FindGeneratorPKByEndorserPK added in v0.11.0 

func (_e *MockState_Expecter) FindGeneratorPKByEndorserPK(periodStart interface{}, endorserPK interface{}) *MockState_FindGeneratorPKByEndorserPK_Call

FindGeneratorPKByEndorserPK is a helper method to define mock.On call

  • periodStart uint32
  • endorserPK bls.PublicKey

func (*MockState_Expecter) FullAssetInfo added in v0.11.0 

func (_e *MockState_Expecter) FullAssetInfo(assetID interface{}) *MockState_FullAssetInfo_Call

FullAssetInfo is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) FullWavesBalance added in v0.11.0 

func (_e *MockState_Expecter) FullWavesBalance(account interface{}) *MockState_FullWavesBalance_Call

FullWavesBalance is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) GeneratingBalance added in v0.11.0 

func (_e *MockState_Expecter) GeneratingBalance(account interface{}, height interface{}) *MockState_GeneratingBalance_Call

GeneratingBalance is a helper method to define mock.On call

  • account proto.Recipient
  • height proto.Height

func (*MockState_Expecter) Header added in v0.11.0 

func (_e *MockState_Expecter) Header(blockID interface{}) *MockState_Header_Call

Header is a helper method to define mock.On call

  • blockID proto.BlockID

func (*MockState_Expecter) HeaderByHeight added in v0.11.0 

func (_e *MockState_Expecter) HeaderByHeight(height interface{}) *MockState_HeaderByHeight_Call

HeaderByHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) Height added in v0.11.0 

func (_e *MockState_Expecter) Height() *MockState_Height_Call

Height is a helper method to define mock.On call

func (*MockState_Expecter) HeightToBlockID added in v0.11.0 

func (_e *MockState_Expecter) HeightToBlockID(height interface{}) *MockState_HeightToBlockID_Call

HeightToBlockID is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) HitSourceAtHeight added in v0.11.0 

func (_e *MockState_Expecter) HitSourceAtHeight(height interface{}) *MockState_HitSourceAtHeight_Call

HitSourceAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) IndexByEndorserPK added in v0.11.0 

func (_e *MockState_Expecter) IndexByEndorserPK(periodStart interface{}, pk interface{}) *MockState_IndexByEndorserPK_Call

IndexByEndorserPK is a helper method to define mock.On call

  • periodStart uint32
  • pk bls.PublicKey

func (*MockState_Expecter) InvokeResultByID added in v0.11.0 

func (_e *MockState_Expecter) InvokeResultByID(invokeID interface{}) *MockState_InvokeResultByID_Call

InvokeResultByID is a helper method to define mock.On call

  • invokeID crypto.Digest

func (*MockState_Expecter) IsActivated added in v0.11.0 

func (_e *MockState_Expecter) IsActivated(featureID interface{}) *MockState_IsActivated_Call

IsActivated is a helper method to define mock.On call

  • featureID int16

func (*MockState_Expecter) IsActiveAtHeight added in v0.11.0 

func (_e *MockState_Expecter) IsActiveAtHeight(featureID interface{}, height interface{}) *MockState_IsActiveAtHeight_Call

IsActiveAtHeight is a helper method to define mock.On call

  • featureID int16
  • height proto.Height

func (*MockState_Expecter) IsActiveLeasing added in v0.11.0 

func (_e *MockState_Expecter) IsActiveLeasing(leaseID interface{}) *MockState_IsActiveLeasing_Call

IsActiveLeasing is a helper method to define mock.On call

  • leaseID crypto.Digest

func (*MockState_Expecter) IsActiveLightNodeNewBlocksFields added in v0.11.0 

func (_e *MockState_Expecter) IsActiveLightNodeNewBlocksFields(blockHeight interface{}) *MockState_IsActiveLightNodeNewBlocksFields_Call

IsActiveLightNodeNewBlocksFields is a helper method to define mock.On call

  • blockHeight proto.Height

func (*MockState_Expecter) IsApproved added in v0.11.0 

func (_e *MockState_Expecter) IsApproved(featureID interface{}) *MockState_IsApproved_Call

IsApproved is a helper method to define mock.On call

  • featureID int16

func (*MockState_Expecter) IsApprovedAtHeight added in v0.11.0 

func (_e *MockState_Expecter) IsApprovedAtHeight(featureID interface{}, height interface{}) *MockState_IsApprovedAtHeight_Call

IsApprovedAtHeight is a helper method to define mock.On call

  • featureID int16
  • height proto.Height

func (*MockState_Expecter) IsAssetExist added in v0.11.0 

func (_e *MockState_Expecter) IsAssetExist(assetID interface{}) *MockState_IsAssetExist_Call

IsAssetExist is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) LastFinalizedBlock added in v0.11.0 

func (_e *MockState_Expecter) LastFinalizedBlock() *MockState_LastFinalizedBlock_Call

LastFinalizedBlock is a helper method to define mock.On call

func (*MockState_Expecter) LastFinalizedHeight added in v0.11.0 

func (_e *MockState_Expecter) LastFinalizedHeight() *MockState_LastFinalizedHeight_Call

LastFinalizedHeight is a helper method to define mock.On call

func (*MockState_Expecter) LegacyStateHashAtHeight added in v0.11.0 

func (_e *MockState_Expecter) LegacyStateHashAtHeight(height interface{}) *MockState_LegacyStateHashAtHeight_Call

LegacyStateHashAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) Map added in v0.11.0 

func (_e *MockState_Expecter) Map(fn interface{}) *MockState_Map_Call

Map is a helper method to define mock.On call

  • fn func(state NonThreadSafeState) error

func (*MockState_Expecter) MapR added in v0.11.0 

func (_e *MockState_Expecter) MapR(fn interface{}) *MockState_MapR_Call

MapR is a helper method to define mock.On call

  • fn func(StateInfo) (any, error)

func (*MockState_Expecter) MapUnsafe added in v0.11.0 

func (_e *MockState_Expecter) MapUnsafe(fn interface{}) *MockState_MapUnsafe_Call

MapUnsafe is a helper method to define mock.On call

  • fn func(state NonThreadSafeState) error

func (*MockState_Expecter) NFTList added in v0.11.0 

func (_e *MockState_Expecter) NFTList(account interface{}, limit interface{}, afterAssetID interface{}) *MockState_NFTList_Call

NFTList is a helper method to define mock.On call

  • account proto.Recipient
  • limit uint64
  • afterAssetID *proto.AssetID

func (*MockState_Expecter) NewAddrTransactionsIterator added in v0.11.0 

func (_e *MockState_Expecter) NewAddrTransactionsIterator(addr interface{}) *MockState_NewAddrTransactionsIterator_Call

NewAddrTransactionsIterator is a helper method to define mock.On call

  • addr proto.Address

func (*MockState_Expecter) NewestBlockInfoByHeight added in v0.11.0 

func (_e *MockState_Expecter) NewestBlockInfoByHeight(height interface{}) *MockState_NewestBlockInfoByHeight_Call

NewestBlockInfoByHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) NewestCommitedEndorsers added in v0.11.0 

func (_e *MockState_Expecter) NewestCommitedEndorsers(periodStart interface{}) *MockState_NewestCommitedEndorsers_Call

NewestCommitedEndorsers is a helper method to define mock.On call

  • periodStart uint32

func (*MockState_Expecter) NewestCommitmentExistsByEndorserPK added in v0.11.0 

func (_e *MockState_Expecter) NewestCommitmentExistsByEndorserPK(periodStart interface{}, endorserPK interface{}) *MockState_NewestCommitmentExistsByEndorserPK_Call

NewestCommitmentExistsByEndorserPK is a helper method to define mock.On call

  • periodStart uint32
  • endorserPK bls.PublicKey

func (*MockState_Expecter) NewestHeaderByHeight added in v0.11.0 

func (_e *MockState_Expecter) NewestHeaderByHeight(height interface{}) *MockState_NewestHeaderByHeight_Call

NewestHeaderByHeight is a helper method to define mock.On call

  • height uint64

func (*MockState_Expecter) NewestScriptByAccount added in v0.11.0 

func (_e *MockState_Expecter) NewestScriptByAccount(account interface{}) *MockState_NewestScriptByAccount_Call

NewestScriptByAccount is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) NewestScriptBytesByAccount added in v0.11.0 

func (_e *MockState_Expecter) NewestScriptBytesByAccount(account interface{}) *MockState_NewestScriptBytesByAccount_Call

NewestScriptBytesByAccount is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) PersistAddressTransactions added in v0.11.0 

func (_e *MockState_Expecter) PersistAddressTransactions() *MockState_PersistAddressTransactions_Call

PersistAddressTransactions is a helper method to define mock.On call

func (*MockState_Expecter) ProvidesExtendedApi added in v0.11.0 

func (_e *MockState_Expecter) ProvidesExtendedApi() *MockState_ProvidesExtendedApi_Call

ProvidesExtendedApi is a helper method to define mock.On call

func (*MockState_Expecter) ProvidesStateHashes added in v0.11.0 

func (_e *MockState_Expecter) ProvidesStateHashes() *MockState_ProvidesStateHashes_Call

ProvidesStateHashes is a helper method to define mock.On call

func (*MockState_Expecter) ResetValidationList added in v0.11.0 

func (_e *MockState_Expecter) ResetValidationList() *MockState_ResetValidationList_Call

ResetValidationList is a helper method to define mock.On call

func (*MockState_Expecter) RetrieveBinaryEntry added in v0.11.0 

func (_e *MockState_Expecter) RetrieveBinaryEntry(account interface{}, key interface{}) *MockState_RetrieveBinaryEntry_Call

RetrieveBinaryEntry is a helper method to define mock.On call

  • account proto.Recipient
  • key string

func (*MockState_Expecter) RetrieveBooleanEntry added in v0.11.0 

func (_e *MockState_Expecter) RetrieveBooleanEntry(account interface{}, key interface{}) *MockState_RetrieveBooleanEntry_Call

RetrieveBooleanEntry is a helper method to define mock.On call

  • account proto.Recipient
  • key string

func (*MockState_Expecter) RetrieveEntries added in v0.11.0 

func (_e *MockState_Expecter) RetrieveEntries(account interface{}) *MockState_RetrieveEntries_Call

RetrieveEntries is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) RetrieveEntry added in v0.11.0 

func (_e *MockState_Expecter) RetrieveEntry(account interface{}, key interface{}) *MockState_RetrieveEntry_Call

RetrieveEntry is a helper method to define mock.On call

  • account proto.Recipient
  • key string

func (*MockState_Expecter) RetrieveIntegerEntry added in v0.11.0 

func (_e *MockState_Expecter) RetrieveIntegerEntry(account interface{}, key interface{}) *MockState_RetrieveIntegerEntry_Call

RetrieveIntegerEntry is a helper method to define mock.On call

  • account proto.Recipient
  • key string

func (*MockState_Expecter) RetrieveStringEntry added in v0.11.0 

func (_e *MockState_Expecter) RetrieveStringEntry(account interface{}, key interface{}) *MockState_RetrieveStringEntry_Call

RetrieveStringEntry is a helper method to define mock.On call

  • account proto.Recipient
  • key string

func (*MockState_Expecter) RewardAtHeight added in v0.11.0 

func (_e *MockState_Expecter) RewardAtHeight(height interface{}) *MockState_RewardAtHeight_Call

RewardAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) RewardVotes added in v0.11.0 

func (_e *MockState_Expecter) RewardVotes(height interface{}) *MockState_RewardVotes_Call

RewardVotes is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) RollbackTo added in v0.11.0 

func (_e *MockState_Expecter) RollbackTo(removalEdge interface{}, isAutoRollback interface{}) *MockState_RollbackTo_Call

RollbackTo is a helper method to define mock.On call

  • removalEdge proto.BlockID
  • isAutoRollback bool

func (*MockState_Expecter) RollbackToHeight added in v0.11.0 

func (_e *MockState_Expecter) RollbackToHeight(height interface{}, isAutoRollback interface{}) *MockState_RollbackToHeight_Call

RollbackToHeight is a helper method to define mock.On call

  • height proto.Height
  • isAutoRollback bool

func (*MockState_Expecter) ScoreAtHeight added in v0.11.0 

func (_e *MockState_Expecter) ScoreAtHeight(height interface{}) *MockState_ScoreAtHeight_Call

ScoreAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) ScriptBasicInfoByAccount added in v0.11.0 

func (_e *MockState_Expecter) ScriptBasicInfoByAccount(account interface{}) *MockState_ScriptBasicInfoByAccount_Call

ScriptBasicInfoByAccount is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) ScriptInfoByAccount added in v0.11.0 

func (_e *MockState_Expecter) ScriptInfoByAccount(account interface{}) *MockState_ScriptInfoByAccount_Call

ScriptInfoByAccount is a helper method to define mock.On call

  • account proto.Recipient

func (*MockState_Expecter) ScriptInfoByAsset added in v0.11.0 

func (_e *MockState_Expecter) ScriptInfoByAsset(assetID interface{}) *MockState_ScriptInfoByAsset_Call

ScriptInfoByAsset is a helper method to define mock.On call

  • assetID proto.AssetID

func (*MockState_Expecter) ShouldPersistAddressTransactions added in v0.11.0 

func (_e *MockState_Expecter) ShouldPersistAddressTransactions() *MockState_ShouldPersistAddressTransactions_Call

ShouldPersistAddressTransactions is a helper method to define mock.On call

func (*MockState_Expecter) SnapshotStateHashAtHeight added in v0.11.0 

func (_e *MockState_Expecter) SnapshotStateHashAtHeight(height interface{}) *MockState_SnapshotStateHashAtHeight_Call

SnapshotStateHashAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) SnapshotsAtHeight added in v0.11.0 

func (_e *MockState_Expecter) SnapshotsAtHeight(height interface{}) *MockState_SnapshotsAtHeight_Call

SnapshotsAtHeight is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) StartProvidingExtendedApi added in v0.11.0 

func (_e *MockState_Expecter) StartProvidingExtendedApi() *MockState_StartProvidingExtendedApi_Call

StartProvidingExtendedApi is a helper method to define mock.On call

func (*MockState_Expecter) TopBlock added in v0.11.0 

func (_e *MockState_Expecter) TopBlock() *MockState_TopBlock_Call

TopBlock is a helper method to define mock.On call

func (*MockState_Expecter) TotalWavesAmount added in v0.11.0 

func (_e *MockState_Expecter) TotalWavesAmount(height interface{}) *MockState_TotalWavesAmount_Call

TotalWavesAmount is a helper method to define mock.On call

  • height proto.Height

func (*MockState_Expecter) TransactionByID added in v0.11.0 

func (_e *MockState_Expecter) TransactionByID(id interface{}) *MockState_TransactionByID_Call

TransactionByID is a helper method to define mock.On call

  • id []byte

func (*MockState_Expecter) TransactionByIDWithStatus added in v0.11.0 

func (_e *MockState_Expecter) TransactionByIDWithStatus(id interface{}) *MockState_TransactionByIDWithStatus_Call

TransactionByIDWithStatus is a helper method to define mock.On call

  • id []byte

func (*MockState_Expecter) TransactionHeightByID added in v0.11.0 

func (_e *MockState_Expecter) TransactionHeightByID(id interface{}) *MockState_TransactionHeightByID_Call

TransactionHeightByID is a helper method to define mock.On call

  • id []byte

func (*MockState_Expecter) TxValidation added in v0.11.0 

func (_e *MockState_Expecter) TxValidation(fn interface{}) *MockState_TxValidation_Call

TxValidation is a helper method to define mock.On call

  • fn func(validation TxValidation) error

func (*MockState_Expecter) ValidateNextTx added in v0.11.0 

func (_e *MockState_Expecter) ValidateNextTx(tx interface{}, currentTimestamp interface{}, parentTimestamp interface{}, blockVersion interface{}, acceptFailed interface{}) *MockState_ValidateNextTx_Call

ValidateNextTx is a helper method to define mock.On call

  • tx proto.Transaction
  • currentTimestamp uint64
  • parentTimestamp uint64
  • blockVersion proto.BlockVersion
  • acceptFailed bool

func (*MockState_Expecter) VotesNum added in v0.11.0 

func (_e *MockState_Expecter) VotesNum(featureID interface{}) *MockState_VotesNum_Call

VotesNum is a helper method to define mock.On call

  • featureID int16

func (*MockState_Expecter) VotesNumAtHeight added in v0.11.0 

func (_e *MockState_Expecter) VotesNumAtHeight(featureID interface{}, height interface{}) *MockState_VotesNumAtHeight_Call

VotesNumAtHeight is a helper method to define mock.On call

  • featureID int16
  • height proto.Height

func (*MockState_Expecter) WavesAddressesNumber added in v0.11.0 

func (_e *MockState_Expecter) WavesAddressesNumber() *MockState_WavesAddressesNumber_Call

WavesAddressesNumber is a helper method to define mock.On call

func (*MockState_Expecter) WavesBalance added in v0.11.0 

func (_e *MockState_Expecter) WavesBalance(account interface{}) *MockState_WavesBalance_Call

WavesBalance is a helper method to define mock.On call

  • account proto.Recipient

type MockState_FindEndorserPKByIndex_Call added in v0.11.0 

type MockState_FindEndorserPKByIndex_Call struct {
	*mock.Call
}

MockState_FindEndorserPKByIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindEndorserPKByIndex'

func (*MockState_FindEndorserPKByIndex_Call) Return added in v0.11.0 

func (_c *MockState_FindEndorserPKByIndex_Call) Return(publicKey bls.PublicKey, err error) *MockState_FindEndorserPKByIndex_Call

func (*MockState_FindEndorserPKByIndex_Call) Run added in v0.11.0 

func (_c *MockState_FindEndorserPKByIndex_Call) Run(run func(periodStart uint32, index int)) *MockState_FindEndorserPKByIndex_Call

func (*MockState_FindEndorserPKByIndex_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_FindEndorserPKByIndex_Call) RunAndReturn(run func(periodStart uint32, index int) (bls.PublicKey, error)) *MockState_FindEndorserPKByIndex_Call

type MockState_FindGeneratorPKByEndorserPK_Call added in v0.11.0 

type MockState_FindGeneratorPKByEndorserPK_Call struct {
	*mock.Call
}

MockState_FindGeneratorPKByEndorserPK_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindGeneratorPKByEndorserPK'

func (*MockState_FindGeneratorPKByEndorserPK_Call) Return added in v0.11.0 

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

func (*MockState_FindGeneratorPKByEndorserPK_Call) Run added in v0.11.0 

func (_c *MockState_FindGeneratorPKByEndorserPK_Call) Run(run func(periodStart uint32, endorserPK bls.PublicKey)) *MockState_FindGeneratorPKByEndorserPK_Call

func (*MockState_FindGeneratorPKByEndorserPK_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_FindGeneratorPKByEndorserPK_Call) RunAndReturn(run func(periodStart uint32, endorserPK bls.PublicKey) (crypto.PublicKey, error)) *MockState_FindGeneratorPKByEndorserPK_Call

type MockState_FullAssetInfo_Call added in v0.11.0 

type MockState_FullAssetInfo_Call struct {
	*mock.Call
}

MockState_FullAssetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FullAssetInfo'

func (*MockState_FullAssetInfo_Call) Return added in v0.11.0 

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

func (*MockState_FullAssetInfo_Call) Run added in v0.11.0 

func (_c *MockState_FullAssetInfo_Call) Run(run func(assetID proto.AssetID)) *MockState_FullAssetInfo_Call

func (*MockState_FullAssetInfo_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_FullAssetInfo_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.FullAssetInfo, error)) *MockState_FullAssetInfo_Call

type MockState_FullWavesBalance_Call added in v0.11.0 

type MockState_FullWavesBalance_Call struct {
	*mock.Call
}

MockState_FullWavesBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FullWavesBalance'

func (*MockState_FullWavesBalance_Call) Return added in v0.11.0 

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

func (*MockState_FullWavesBalance_Call) Run added in v0.11.0 

func (_c *MockState_FullWavesBalance_Call) Run(run func(account proto.Recipient)) *MockState_FullWavesBalance_Call

func (*MockState_FullWavesBalance_Call) RunAndReturn added in v0.11.0 

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

type MockState_GeneratingBalance_Call added in v0.11.0 

type MockState_GeneratingBalance_Call struct {
	*mock.Call
}

MockState_GeneratingBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GeneratingBalance'

func (*MockState_GeneratingBalance_Call) Return added in v0.11.0 

func (_c *MockState_GeneratingBalance_Call) Return(v uint64, err error) *MockState_GeneratingBalance_Call

func (*MockState_GeneratingBalance_Call) Run added in v0.11.0 

func (_c *MockState_GeneratingBalance_Call) Run(run func(account proto.Recipient, height proto.Height)) *MockState_GeneratingBalance_Call

func (*MockState_GeneratingBalance_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_GeneratingBalance_Call) RunAndReturn(run func(account proto.Recipient, height proto.Height) (uint64, error)) *MockState_GeneratingBalance_Call

type MockState_HeaderByHeight_Call added in v0.11.0 

type MockState_HeaderByHeight_Call struct {
	*mock.Call
}

MockState_HeaderByHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByHeight'

func (*MockState_HeaderByHeight_Call) Return added in v0.11.0 

func (_c *MockState_HeaderByHeight_Call) Return(blockHeader *proto.BlockHeader, err error) *MockState_HeaderByHeight_Call

func (*MockState_HeaderByHeight_Call) Run added in v0.11.0 

func (_c *MockState_HeaderByHeight_Call) Run(run func(height proto.Height)) *MockState_HeaderByHeight_Call

func (*MockState_HeaderByHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_HeaderByHeight_Call) RunAndReturn(run func(height proto.Height) (*proto.BlockHeader, error)) *MockState_HeaderByHeight_Call

type MockState_Header_Call added in v0.11.0 

type MockState_Header_Call struct {
	*mock.Call
}

MockState_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'

func (*MockState_Header_Call) Return added in v0.11.0 

func (_c *MockState_Header_Call) Return(blockHeader *proto.BlockHeader, err error) *MockState_Header_Call

func (*MockState_Header_Call) Run added in v0.11.0 

func (_c *MockState_Header_Call) Run(run func(blockID proto.BlockID)) *MockState_Header_Call

func (*MockState_Header_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_Header_Call) RunAndReturn(run func(blockID proto.BlockID) (*proto.BlockHeader, error)) *MockState_Header_Call

type MockState_HeightToBlockID_Call added in v0.11.0 

type MockState_HeightToBlockID_Call struct {
	*mock.Call
}

MockState_HeightToBlockID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeightToBlockID'

func (*MockState_HeightToBlockID_Call) Return added in v0.11.0 

func (_c *MockState_HeightToBlockID_Call) Return(blockID proto.BlockID, err error) *MockState_HeightToBlockID_Call

func (*MockState_HeightToBlockID_Call) Run added in v0.11.0 

func (_c *MockState_HeightToBlockID_Call) Run(run func(height proto.Height)) *MockState_HeightToBlockID_Call

func (*MockState_HeightToBlockID_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_HeightToBlockID_Call) RunAndReturn(run func(height proto.Height) (proto.BlockID, error)) *MockState_HeightToBlockID_Call

type MockState_Height_Call added in v0.11.0 

type MockState_Height_Call struct {
	*mock.Call
}

MockState_Height_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Height'

func (*MockState_Height_Call) Return added in v0.11.0 

func (_c *MockState_Height_Call) Return(v proto.Height, err error) *MockState_Height_Call

func (*MockState_Height_Call) Run added in v0.11.0 

func (_c *MockState_Height_Call) Run(run func()) *MockState_Height_Call

func (*MockState_Height_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_Height_Call) RunAndReturn(run func() (proto.Height, error)) *MockState_Height_Call

type MockState_HitSourceAtHeight_Call added in v0.11.0 

type MockState_HitSourceAtHeight_Call struct {
	*mock.Call
}

MockState_HitSourceAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HitSourceAtHeight'

func (*MockState_HitSourceAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_HitSourceAtHeight_Call) Return(bytes []byte, err error) *MockState_HitSourceAtHeight_Call

func (*MockState_HitSourceAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_HitSourceAtHeight_Call) Run(run func(height proto.Height)) *MockState_HitSourceAtHeight_Call

func (*MockState_HitSourceAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_HitSourceAtHeight_Call) RunAndReturn(run func(height proto.Height) ([]byte, error)) *MockState_HitSourceAtHeight_Call

type MockState_IndexByEndorserPK_Call added in v0.11.0 

type MockState_IndexByEndorserPK_Call struct {
	*mock.Call
}

MockState_IndexByEndorserPK_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexByEndorserPK'

func (*MockState_IndexByEndorserPK_Call) Return added in v0.11.0 

func (_c *MockState_IndexByEndorserPK_Call) Return(v uint32, err error) *MockState_IndexByEndorserPK_Call

func (*MockState_IndexByEndorserPK_Call) Run added in v0.11.0 

func (_c *MockState_IndexByEndorserPK_Call) Run(run func(periodStart uint32, pk bls.PublicKey)) *MockState_IndexByEndorserPK_Call

func (*MockState_IndexByEndorserPK_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IndexByEndorserPK_Call) RunAndReturn(run func(periodStart uint32, pk bls.PublicKey) (uint32, error)) *MockState_IndexByEndorserPK_Call

type MockState_InvokeResultByID_Call added in v0.11.0 

type MockState_InvokeResultByID_Call struct {
	*mock.Call
}

MockState_InvokeResultByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeResultByID'

func (*MockState_InvokeResultByID_Call) Return added in v0.11.0 

func (_c *MockState_InvokeResultByID_Call) Return(scriptResult *proto.ScriptResult, err error) *MockState_InvokeResultByID_Call

func (*MockState_InvokeResultByID_Call) Run added in v0.11.0 

func (_c *MockState_InvokeResultByID_Call) Run(run func(invokeID crypto.Digest)) *MockState_InvokeResultByID_Call

func (*MockState_InvokeResultByID_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_InvokeResultByID_Call) RunAndReturn(run func(invokeID crypto.Digest) (*proto.ScriptResult, error)) *MockState_InvokeResultByID_Call

type MockState_IsActivated_Call added in v0.11.0 

type MockState_IsActivated_Call struct {
	*mock.Call
}

MockState_IsActivated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsActivated'

func (*MockState_IsActivated_Call) Return added in v0.11.0 

func (_c *MockState_IsActivated_Call) Return(b bool, err error) *MockState_IsActivated_Call

func (*MockState_IsActivated_Call) Run added in v0.11.0 

func (_c *MockState_IsActivated_Call) Run(run func(featureID int16)) *MockState_IsActivated_Call

func (*MockState_IsActivated_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsActivated_Call) RunAndReturn(run func(featureID int16) (bool, error)) *MockState_IsActivated_Call

type MockState_IsActiveAtHeight_Call added in v0.11.0 

type MockState_IsActiveAtHeight_Call struct {
	*mock.Call
}

MockState_IsActiveAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsActiveAtHeight'

func (*MockState_IsActiveAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_IsActiveAtHeight_Call) Return(b bool, err error) *MockState_IsActiveAtHeight_Call

func (*MockState_IsActiveAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_IsActiveAtHeight_Call) Run(run func(featureID int16, height proto.Height)) *MockState_IsActiveAtHeight_Call

func (*MockState_IsActiveAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsActiveAtHeight_Call) RunAndReturn(run func(featureID int16, height proto.Height) (bool, error)) *MockState_IsActiveAtHeight_Call

type MockState_IsActiveLeasing_Call added in v0.11.0 

type MockState_IsActiveLeasing_Call struct {
	*mock.Call
}

MockState_IsActiveLeasing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsActiveLeasing'

func (*MockState_IsActiveLeasing_Call) Return added in v0.11.0 

func (_c *MockState_IsActiveLeasing_Call) Return(b bool, err error) *MockState_IsActiveLeasing_Call

func (*MockState_IsActiveLeasing_Call) Run added in v0.11.0 

func (_c *MockState_IsActiveLeasing_Call) Run(run func(leaseID crypto.Digest)) *MockState_IsActiveLeasing_Call

func (*MockState_IsActiveLeasing_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsActiveLeasing_Call) RunAndReturn(run func(leaseID crypto.Digest) (bool, error)) *MockState_IsActiveLeasing_Call

type MockState_IsActiveLightNodeNewBlocksFields_Call added in v0.11.0 

type MockState_IsActiveLightNodeNewBlocksFields_Call struct {
	*mock.Call
}

MockState_IsActiveLightNodeNewBlocksFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsActiveLightNodeNewBlocksFields'

func (*MockState_IsActiveLightNodeNewBlocksFields_Call) Return added in v0.11.0 

func (_c *MockState_IsActiveLightNodeNewBlocksFields_Call) Return(b bool, err error) *MockState_IsActiveLightNodeNewBlocksFields_Call

func (*MockState_IsActiveLightNodeNewBlocksFields_Call) Run added in v0.11.0 

func (_c *MockState_IsActiveLightNodeNewBlocksFields_Call) Run(run func(blockHeight proto.Height)) *MockState_IsActiveLightNodeNewBlocksFields_Call

func (*MockState_IsActiveLightNodeNewBlocksFields_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsActiveLightNodeNewBlocksFields_Call) RunAndReturn(run func(blockHeight proto.Height) (bool, error)) *MockState_IsActiveLightNodeNewBlocksFields_Call

type MockState_IsApprovedAtHeight_Call added in v0.11.0 

type MockState_IsApprovedAtHeight_Call struct {
	*mock.Call
}

MockState_IsApprovedAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsApprovedAtHeight'

func (*MockState_IsApprovedAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_IsApprovedAtHeight_Call) Return(b bool, err error) *MockState_IsApprovedAtHeight_Call

func (*MockState_IsApprovedAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_IsApprovedAtHeight_Call) Run(run func(featureID int16, height proto.Height)) *MockState_IsApprovedAtHeight_Call

func (*MockState_IsApprovedAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsApprovedAtHeight_Call) RunAndReturn(run func(featureID int16, height proto.Height) (bool, error)) *MockState_IsApprovedAtHeight_Call

type MockState_IsApproved_Call added in v0.11.0 

type MockState_IsApproved_Call struct {
	*mock.Call
}

MockState_IsApproved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsApproved'

func (*MockState_IsApproved_Call) Return added in v0.11.0 

func (_c *MockState_IsApproved_Call) Return(b bool, err error) *MockState_IsApproved_Call

func (*MockState_IsApproved_Call) Run added in v0.11.0 

func (_c *MockState_IsApproved_Call) Run(run func(featureID int16)) *MockState_IsApproved_Call

func (*MockState_IsApproved_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsApproved_Call) RunAndReturn(run func(featureID int16) (bool, error)) *MockState_IsApproved_Call

type MockState_IsAssetExist_Call added in v0.11.0 

type MockState_IsAssetExist_Call struct {
	*mock.Call
}

MockState_IsAssetExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAssetExist'

func (*MockState_IsAssetExist_Call) Return added in v0.11.0 

func (_c *MockState_IsAssetExist_Call) Return(b bool, err error) *MockState_IsAssetExist_Call

func (*MockState_IsAssetExist_Call) Run added in v0.11.0 

func (_c *MockState_IsAssetExist_Call) Run(run func(assetID proto.AssetID)) *MockState_IsAssetExist_Call

func (*MockState_IsAssetExist_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_IsAssetExist_Call) RunAndReturn(run func(assetID proto.AssetID) (bool, error)) *MockState_IsAssetExist_Call

type MockState_LastFinalizedBlock_Call added in v0.11.0 

type MockState_LastFinalizedBlock_Call struct {
	*mock.Call
}

MockState_LastFinalizedBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastFinalizedBlock'

func (*MockState_LastFinalizedBlock_Call) Return added in v0.11.0 

func (_c *MockState_LastFinalizedBlock_Call) Return(blockHeader *proto.BlockHeader, err error) *MockState_LastFinalizedBlock_Call

func (*MockState_LastFinalizedBlock_Call) Run added in v0.11.0 

func (_c *MockState_LastFinalizedBlock_Call) Run(run func()) *MockState_LastFinalizedBlock_Call

func (*MockState_LastFinalizedBlock_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_LastFinalizedBlock_Call) RunAndReturn(run func() (*proto.BlockHeader, error)) *MockState_LastFinalizedBlock_Call

type MockState_LastFinalizedHeight_Call added in v0.11.0 

type MockState_LastFinalizedHeight_Call struct {
	*mock.Call
}

MockState_LastFinalizedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastFinalizedHeight'

func (*MockState_LastFinalizedHeight_Call) Return added in v0.11.0 

func (_c *MockState_LastFinalizedHeight_Call) Return(v proto.Height, err error) *MockState_LastFinalizedHeight_Call

func (*MockState_LastFinalizedHeight_Call) Run added in v0.11.0 

func (_c *MockState_LastFinalizedHeight_Call) Run(run func()) *MockState_LastFinalizedHeight_Call

func (*MockState_LastFinalizedHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_LastFinalizedHeight_Call) RunAndReturn(run func() (proto.Height, error)) *MockState_LastFinalizedHeight_Call

type MockState_LegacyStateHashAtHeight_Call added in v0.11.0 

type MockState_LegacyStateHashAtHeight_Call struct {
	*mock.Call
}

MockState_LegacyStateHashAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LegacyStateHashAtHeight'

func (*MockState_LegacyStateHashAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_LegacyStateHashAtHeight_Call) Return(stateHash proto.StateHash, err error) *MockState_LegacyStateHashAtHeight_Call

func (*MockState_LegacyStateHashAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_LegacyStateHashAtHeight_Call) Run(run func(height proto.Height)) *MockState_LegacyStateHashAtHeight_Call

func (*MockState_LegacyStateHashAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_LegacyStateHashAtHeight_Call) RunAndReturn(run func(height proto.Height) (proto.StateHash, error)) *MockState_LegacyStateHashAtHeight_Call

type MockState_MapR_Call added in v0.11.0 

type MockState_MapR_Call struct {
	*mock.Call
}

MockState_MapR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MapR'

func (*MockState_MapR_Call) Return added in v0.11.0 

func (_c *MockState_MapR_Call) Return(v any, err error) *MockState_MapR_Call

func (*MockState_MapR_Call) Run added in v0.11.0 

func (_c *MockState_MapR_Call) Run(run func(fn func(StateInfo) (any, error))) *MockState_MapR_Call

func (*MockState_MapR_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_MapR_Call) RunAndReturn(run func(fn func(StateInfo) (any, error)) (any, error)) *MockState_MapR_Call

type MockState_MapUnsafe_Call added in v0.11.0 

type MockState_MapUnsafe_Call struct {
	*mock.Call
}

MockState_MapUnsafe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MapUnsafe'

func (*MockState_MapUnsafe_Call) Return added in v0.11.0 

func (_c *MockState_MapUnsafe_Call) Return(err error) *MockState_MapUnsafe_Call

func (*MockState_MapUnsafe_Call) Run added in v0.11.0 

func (_c *MockState_MapUnsafe_Call) Run(run func(fn func(state NonThreadSafeState) error)) *MockState_MapUnsafe_Call

func (*MockState_MapUnsafe_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_MapUnsafe_Call) RunAndReturn(run func(fn func(state NonThreadSafeState) error) error) *MockState_MapUnsafe_Call

type MockState_Map_Call added in v0.11.0 

type MockState_Map_Call struct {
	*mock.Call
}

MockState_Map_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Map'

func (*MockState_Map_Call) Return added in v0.11.0 

func (_c *MockState_Map_Call) Return(err error) *MockState_Map_Call

func (*MockState_Map_Call) Run added in v0.11.0 

func (_c *MockState_Map_Call) Run(run func(fn func(state NonThreadSafeState) error)) *MockState_Map_Call

func (*MockState_Map_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_Map_Call) RunAndReturn(run func(fn func(state NonThreadSafeState) error) error) *MockState_Map_Call

type MockState_NFTList_Call added in v0.11.0 

type MockState_NFTList_Call struct {
	*mock.Call
}

MockState_NFTList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NFTList'

func (*MockState_NFTList_Call) Return added in v0.11.0 

func (_c *MockState_NFTList_Call) Return(fullAssetInfos []*proto.FullAssetInfo, err error) *MockState_NFTList_Call

func (*MockState_NFTList_Call) Run added in v0.11.0 

func (_c *MockState_NFTList_Call) Run(run func(account proto.Recipient, limit uint64, afterAssetID *proto.AssetID)) *MockState_NFTList_Call

func (*MockState_NFTList_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_NFTList_Call) RunAndReturn(run func(account proto.Recipient, limit uint64, afterAssetID *proto.AssetID) ([]*proto.FullAssetInfo, error)) *MockState_NFTList_Call

type MockState_NewAddrTransactionsIterator_Call added in v0.11.0 

type MockState_NewAddrTransactionsIterator_Call struct {
	*mock.Call
}

MockState_NewAddrTransactionsIterator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewAddrTransactionsIterator'

func (*MockState_NewAddrTransactionsIterator_Call) Return added in v0.11.0 

func (_c *MockState_NewAddrTransactionsIterator_Call) Return(transactionIterator TransactionIterator, err error) *MockState_NewAddrTransactionsIterator_Call

func (*MockState_NewAddrTransactionsIterator_Call) Run added in v0.11.0 

func (_c *MockState_NewAddrTransactionsIterator_Call) Run(run func(addr proto.Address)) *MockState_NewAddrTransactionsIterator_Call

func (*MockState_NewAddrTransactionsIterator_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_NewAddrTransactionsIterator_Call) RunAndReturn(run func(addr proto.Address) (TransactionIterator, error)) *MockState_NewAddrTransactionsIterator_Call

type MockState_NewestBlockInfoByHeight_Call added in v0.11.0 

type MockState_NewestBlockInfoByHeight_Call struct {
	*mock.Call
}

MockState_NewestBlockInfoByHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestBlockInfoByHeight'

func (*MockState_NewestBlockInfoByHeight_Call) Return added in v0.11.0 

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

func (*MockState_NewestBlockInfoByHeight_Call) Run added in v0.11.0 

func (_c *MockState_NewestBlockInfoByHeight_Call) Run(run func(height proto.Height)) *MockState_NewestBlockInfoByHeight_Call

func (*MockState_NewestBlockInfoByHeight_Call) RunAndReturn added in v0.11.0 

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

type MockState_NewestCommitedEndorsers_Call added in v0.11.0 

type MockState_NewestCommitedEndorsers_Call struct {
	*mock.Call
}

MockState_NewestCommitedEndorsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestCommitedEndorsers'

func (*MockState_NewestCommitedEndorsers_Call) Return added in v0.11.0 

func (_c *MockState_NewestCommitedEndorsers_Call) Return(publicKeys []bls.PublicKey, err error) *MockState_NewestCommitedEndorsers_Call

func (*MockState_NewestCommitedEndorsers_Call) Run added in v0.11.0 

func (_c *MockState_NewestCommitedEndorsers_Call) Run(run func(periodStart uint32)) *MockState_NewestCommitedEndorsers_Call

func (*MockState_NewestCommitedEndorsers_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_NewestCommitedEndorsers_Call) RunAndReturn(run func(periodStart uint32) ([]bls.PublicKey, error)) *MockState_NewestCommitedEndorsers_Call

type MockState_NewestCommitmentExistsByEndorserPK_Call added in v0.11.0 

type MockState_NewestCommitmentExistsByEndorserPK_Call struct {
	*mock.Call
}

MockState_NewestCommitmentExistsByEndorserPK_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestCommitmentExistsByEndorserPK'

func (*MockState_NewestCommitmentExistsByEndorserPK_Call) Return added in v0.11.0 

func (_c *MockState_NewestCommitmentExistsByEndorserPK_Call) Return(b bool, err error) *MockState_NewestCommitmentExistsByEndorserPK_Call

func (*MockState_NewestCommitmentExistsByEndorserPK_Call) Run added in v0.11.0 

func (_c *MockState_NewestCommitmentExistsByEndorserPK_Call) Run(run func(periodStart uint32, endorserPK bls.PublicKey)) *MockState_NewestCommitmentExistsByEndorserPK_Call

func (*MockState_NewestCommitmentExistsByEndorserPK_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_NewestCommitmentExistsByEndorserPK_Call) RunAndReturn(run func(periodStart uint32, endorserPK bls.PublicKey) (bool, error)) *MockState_NewestCommitmentExistsByEndorserPK_Call

type MockState_NewestHeaderByHeight_Call added in v0.11.0 

type MockState_NewestHeaderByHeight_Call struct {
	*mock.Call
}

MockState_NewestHeaderByHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestHeaderByHeight'

func (*MockState_NewestHeaderByHeight_Call) Return added in v0.11.0 

func (_c *MockState_NewestHeaderByHeight_Call) Return(blockHeader *proto.BlockHeader, err error) *MockState_NewestHeaderByHeight_Call

func (*MockState_NewestHeaderByHeight_Call) Run added in v0.11.0 

func (_c *MockState_NewestHeaderByHeight_Call) Run(run func(height uint64)) *MockState_NewestHeaderByHeight_Call

func (*MockState_NewestHeaderByHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_NewestHeaderByHeight_Call) RunAndReturn(run func(height uint64) (*proto.BlockHeader, error)) *MockState_NewestHeaderByHeight_Call

type MockState_NewestScriptByAccount_Call added in v0.11.0 

type MockState_NewestScriptByAccount_Call struct {
	*mock.Call
}

MockState_NewestScriptByAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestScriptByAccount'

func (*MockState_NewestScriptByAccount_Call) Return added in v0.11.0 

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

func (*MockState_NewestScriptByAccount_Call) Run added in v0.11.0 

func (_c *MockState_NewestScriptByAccount_Call) Run(run func(account proto.Recipient)) *MockState_NewestScriptByAccount_Call

func (*MockState_NewestScriptByAccount_Call) RunAndReturn added in v0.11.0 

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

type MockState_NewestScriptBytesByAccount_Call added in v0.11.0 

type MockState_NewestScriptBytesByAccount_Call struct {
	*mock.Call
}

MockState_NewestScriptBytesByAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewestScriptBytesByAccount'

func (*MockState_NewestScriptBytesByAccount_Call) Return added in v0.11.0 

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

func (*MockState_NewestScriptBytesByAccount_Call) Run added in v0.11.0 

func (_c *MockState_NewestScriptBytesByAccount_Call) Run(run func(account proto.Recipient)) *MockState_NewestScriptBytesByAccount_Call

func (*MockState_NewestScriptBytesByAccount_Call) RunAndReturn added in v0.11.0 

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

type MockState_PersistAddressTransactions_Call added in v0.11.0 

type MockState_PersistAddressTransactions_Call struct {
	*mock.Call
}

MockState_PersistAddressTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PersistAddressTransactions'

func (*MockState_PersistAddressTransactions_Call) Return added in v0.11.0 

func (_c *MockState_PersistAddressTransactions_Call) Return(err error) *MockState_PersistAddressTransactions_Call

func (*MockState_PersistAddressTransactions_Call) Run added in v0.11.0 

func (_c *MockState_PersistAddressTransactions_Call) Run(run func()) *MockState_PersistAddressTransactions_Call

func (*MockState_PersistAddressTransactions_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_PersistAddressTransactions_Call) RunAndReturn(run func() error) *MockState_PersistAddressTransactions_Call

type MockState_ProvidesExtendedApi_Call added in v0.11.0 

type MockState_ProvidesExtendedApi_Call struct {
	*mock.Call
}

MockState_ProvidesExtendedApi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvidesExtendedApi'

func (*MockState_ProvidesExtendedApi_Call) Return added in v0.11.0 

func (_c *MockState_ProvidesExtendedApi_Call) Return(b bool, err error) *MockState_ProvidesExtendedApi_Call

func (*MockState_ProvidesExtendedApi_Call) Run added in v0.11.0 

func (_c *MockState_ProvidesExtendedApi_Call) Run(run func()) *MockState_ProvidesExtendedApi_Call

func (*MockState_ProvidesExtendedApi_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ProvidesExtendedApi_Call) RunAndReturn(run func() (bool, error)) *MockState_ProvidesExtendedApi_Call

type MockState_ProvidesStateHashes_Call added in v0.11.0 

type MockState_ProvidesStateHashes_Call struct {
	*mock.Call
}

MockState_ProvidesStateHashes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvidesStateHashes'

func (*MockState_ProvidesStateHashes_Call) Return added in v0.11.0 

func (_c *MockState_ProvidesStateHashes_Call) Return(b bool, err error) *MockState_ProvidesStateHashes_Call

func (*MockState_ProvidesStateHashes_Call) Run added in v0.11.0 

func (_c *MockState_ProvidesStateHashes_Call) Run(run func()) *MockState_ProvidesStateHashes_Call

func (*MockState_ProvidesStateHashes_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ProvidesStateHashes_Call) RunAndReturn(run func() (bool, error)) *MockState_ProvidesStateHashes_Call

type MockState_ResetValidationList_Call added in v0.11.0 

type MockState_ResetValidationList_Call struct {
	*mock.Call
}

MockState_ResetValidationList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetValidationList'

func (*MockState_ResetValidationList_Call) Return added in v0.11.0 

func (_c *MockState_ResetValidationList_Call) Return() *MockState_ResetValidationList_Call

func (*MockState_ResetValidationList_Call) Run added in v0.11.0 

func (_c *MockState_ResetValidationList_Call) Run(run func()) *MockState_ResetValidationList_Call

func (*MockState_ResetValidationList_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ResetValidationList_Call) RunAndReturn(run func()) *MockState_ResetValidationList_Call

type MockState_RetrieveBinaryEntry_Call added in v0.11.0 

type MockState_RetrieveBinaryEntry_Call struct {
	*mock.Call
}

MockState_RetrieveBinaryEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveBinaryEntry'

func (*MockState_RetrieveBinaryEntry_Call) Return added in v0.11.0 

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

func (*MockState_RetrieveBinaryEntry_Call) Run added in v0.11.0 

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

func (*MockState_RetrieveBinaryEntry_Call) RunAndReturn added in v0.11.0 

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

type MockState_RetrieveBooleanEntry_Call added in v0.11.0 

type MockState_RetrieveBooleanEntry_Call struct {
	*mock.Call
}

MockState_RetrieveBooleanEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveBooleanEntry'

func (*MockState_RetrieveBooleanEntry_Call) Return added in v0.11.0 

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

func (*MockState_RetrieveBooleanEntry_Call) Run added in v0.11.0 

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

func (*MockState_RetrieveBooleanEntry_Call) RunAndReturn added in v0.11.0 

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

type MockState_RetrieveEntries_Call added in v0.11.0 

type MockState_RetrieveEntries_Call struct {
	*mock.Call
}

MockState_RetrieveEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntries'

func (*MockState_RetrieveEntries_Call) Return added in v0.11.0 

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

func (*MockState_RetrieveEntries_Call) Run added in v0.11.0 

func (_c *MockState_RetrieveEntries_Call) Run(run func(account proto.Recipient)) *MockState_RetrieveEntries_Call

func (*MockState_RetrieveEntries_Call) RunAndReturn added in v0.11.0 

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

type MockState_RetrieveEntry_Call added in v0.11.0 

type MockState_RetrieveEntry_Call struct {
	*mock.Call
}

MockState_RetrieveEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntry'

func (*MockState_RetrieveEntry_Call) Return added in v0.11.0 

func (_c *MockState_RetrieveEntry_Call) Return(dataEntry proto.DataEntry, err error) *MockState_RetrieveEntry_Call

func (*MockState_RetrieveEntry_Call) Run added in v0.11.0 

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

func (*MockState_RetrieveEntry_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_RetrieveEntry_Call) RunAndReturn(run func(account proto.Recipient, key string) (proto.DataEntry, error)) *MockState_RetrieveEntry_Call

type MockState_RetrieveIntegerEntry_Call added in v0.11.0 

type MockState_RetrieveIntegerEntry_Call struct {
	*mock.Call
}

MockState_RetrieveIntegerEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveIntegerEntry'

func (*MockState_RetrieveIntegerEntry_Call) Return added in v0.11.0 

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

func (*MockState_RetrieveIntegerEntry_Call) Run added in v0.11.0 

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

func (*MockState_RetrieveIntegerEntry_Call) RunAndReturn added in v0.11.0 

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

type MockState_RetrieveStringEntry_Call added in v0.11.0 

type MockState_RetrieveStringEntry_Call struct {
	*mock.Call
}

MockState_RetrieveStringEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveStringEntry'

func (*MockState_RetrieveStringEntry_Call) Return added in v0.11.0 

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

func (*MockState_RetrieveStringEntry_Call) Run added in v0.11.0 

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

func (*MockState_RetrieveStringEntry_Call) RunAndReturn added in v0.11.0 

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

type MockState_RewardAtHeight_Call added in v0.11.0 

type MockState_RewardAtHeight_Call struct {
	*mock.Call
}

MockState_RewardAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RewardAtHeight'

func (*MockState_RewardAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_RewardAtHeight_Call) Return(v uint64, err error) *MockState_RewardAtHeight_Call

func (*MockState_RewardAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_RewardAtHeight_Call) Run(run func(height proto.Height)) *MockState_RewardAtHeight_Call

func (*MockState_RewardAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_RewardAtHeight_Call) RunAndReturn(run func(height proto.Height) (uint64, error)) *MockState_RewardAtHeight_Call

type MockState_RewardVotes_Call added in v0.11.0 

type MockState_RewardVotes_Call struct {
	*mock.Call
}

MockState_RewardVotes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RewardVotes'

func (*MockState_RewardVotes_Call) Return added in v0.11.0 

func (_c *MockState_RewardVotes_Call) Return(rewardVotes proto.RewardVotes, err error) *MockState_RewardVotes_Call

func (*MockState_RewardVotes_Call) Run added in v0.11.0 

func (_c *MockState_RewardVotes_Call) Run(run func(height proto.Height)) *MockState_RewardVotes_Call

func (*MockState_RewardVotes_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_RewardVotes_Call) RunAndReturn(run func(height proto.Height) (proto.RewardVotes, error)) *MockState_RewardVotes_Call

type MockState_RollbackToHeight_Call added in v0.11.0 

type MockState_RollbackToHeight_Call struct {
	*mock.Call
}

MockState_RollbackToHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RollbackToHeight'

func (*MockState_RollbackToHeight_Call) Return added in v0.11.0 

func (_c *MockState_RollbackToHeight_Call) Return(err error) *MockState_RollbackToHeight_Call

func (*MockState_RollbackToHeight_Call) Run added in v0.11.0 

func (_c *MockState_RollbackToHeight_Call) Run(run func(height proto.Height, isAutoRollback bool)) *MockState_RollbackToHeight_Call

func (*MockState_RollbackToHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_RollbackToHeight_Call) RunAndReturn(run func(height proto.Height, isAutoRollback bool) error) *MockState_RollbackToHeight_Call

type MockState_RollbackTo_Call added in v0.11.0 

type MockState_RollbackTo_Call struct {
	*mock.Call
}

MockState_RollbackTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RollbackTo'

func (*MockState_RollbackTo_Call) Return added in v0.11.0 

func (_c *MockState_RollbackTo_Call) Return(err error) *MockState_RollbackTo_Call

func (*MockState_RollbackTo_Call) Run added in v0.11.0 

func (_c *MockState_RollbackTo_Call) Run(run func(removalEdge proto.BlockID, isAutoRollback bool)) *MockState_RollbackTo_Call

func (*MockState_RollbackTo_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_RollbackTo_Call) RunAndReturn(run func(removalEdge proto.BlockID, isAutoRollback bool) error) *MockState_RollbackTo_Call

type MockState_ScoreAtHeight_Call added in v0.11.0 

type MockState_ScoreAtHeight_Call struct {
	*mock.Call
}

MockState_ScoreAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScoreAtHeight'

func (*MockState_ScoreAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_ScoreAtHeight_Call) Return(intParam *big.Int, err error) *MockState_ScoreAtHeight_Call

func (*MockState_ScoreAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_ScoreAtHeight_Call) Run(run func(height proto.Height)) *MockState_ScoreAtHeight_Call

func (*MockState_ScoreAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ScoreAtHeight_Call) RunAndReturn(run func(height proto.Height) (*big.Int, error)) *MockState_ScoreAtHeight_Call

type MockState_ScriptBasicInfoByAccount_Call added in v0.11.0 

type MockState_ScriptBasicInfoByAccount_Call struct {
	*mock.Call
}

MockState_ScriptBasicInfoByAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptBasicInfoByAccount'

func (*MockState_ScriptBasicInfoByAccount_Call) Return added in v0.11.0 

func (_c *MockState_ScriptBasicInfoByAccount_Call) Return(scriptBasicInfo *proto.ScriptBasicInfo, err error) *MockState_ScriptBasicInfoByAccount_Call

func (*MockState_ScriptBasicInfoByAccount_Call) Run added in v0.11.0 

func (_c *MockState_ScriptBasicInfoByAccount_Call) Run(run func(account proto.Recipient)) *MockState_ScriptBasicInfoByAccount_Call

func (*MockState_ScriptBasicInfoByAccount_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ScriptBasicInfoByAccount_Call) RunAndReturn(run func(account proto.Recipient) (*proto.ScriptBasicInfo, error)) *MockState_ScriptBasicInfoByAccount_Call

type MockState_ScriptInfoByAccount_Call added in v0.11.0 

type MockState_ScriptInfoByAccount_Call struct {
	*mock.Call
}

MockState_ScriptInfoByAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptInfoByAccount'

func (*MockState_ScriptInfoByAccount_Call) Return added in v0.11.0 

func (_c *MockState_ScriptInfoByAccount_Call) Return(scriptInfo *proto.ScriptInfo, err error) *MockState_ScriptInfoByAccount_Call

func (*MockState_ScriptInfoByAccount_Call) Run added in v0.11.0 

func (_c *MockState_ScriptInfoByAccount_Call) Run(run func(account proto.Recipient)) *MockState_ScriptInfoByAccount_Call

func (*MockState_ScriptInfoByAccount_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ScriptInfoByAccount_Call) RunAndReturn(run func(account proto.Recipient) (*proto.ScriptInfo, error)) *MockState_ScriptInfoByAccount_Call

type MockState_ScriptInfoByAsset_Call added in v0.11.0 

type MockState_ScriptInfoByAsset_Call struct {
	*mock.Call
}

MockState_ScriptInfoByAsset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScriptInfoByAsset'

func (*MockState_ScriptInfoByAsset_Call) Return added in v0.11.0 

func (_c *MockState_ScriptInfoByAsset_Call) Return(scriptInfo *proto.ScriptInfo, err error) *MockState_ScriptInfoByAsset_Call

func (*MockState_ScriptInfoByAsset_Call) Run added in v0.11.0 

func (_c *MockState_ScriptInfoByAsset_Call) Run(run func(assetID proto.AssetID)) *MockState_ScriptInfoByAsset_Call

func (*MockState_ScriptInfoByAsset_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ScriptInfoByAsset_Call) RunAndReturn(run func(assetID proto.AssetID) (*proto.ScriptInfo, error)) *MockState_ScriptInfoByAsset_Call

type MockState_ShouldPersistAddressTransactions_Call added in v0.11.0 

type MockState_ShouldPersistAddressTransactions_Call struct {
	*mock.Call
}

MockState_ShouldPersistAddressTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShouldPersistAddressTransactions'

func (*MockState_ShouldPersistAddressTransactions_Call) Return added in v0.11.0 

func (_c *MockState_ShouldPersistAddressTransactions_Call) Return(b bool, err error) *MockState_ShouldPersistAddressTransactions_Call

func (*MockState_ShouldPersistAddressTransactions_Call) Run added in v0.11.0 

func (_c *MockState_ShouldPersistAddressTransactions_Call) Run(run func()) *MockState_ShouldPersistAddressTransactions_Call

func (*MockState_ShouldPersistAddressTransactions_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ShouldPersistAddressTransactions_Call) RunAndReturn(run func() (bool, error)) *MockState_ShouldPersistAddressTransactions_Call

type MockState_SnapshotStateHashAtHeight_Call added in v0.11.0 

type MockState_SnapshotStateHashAtHeight_Call struct {
	*mock.Call
}

MockState_SnapshotStateHashAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SnapshotStateHashAtHeight'

func (*MockState_SnapshotStateHashAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_SnapshotStateHashAtHeight_Call) Return(digest crypto.Digest, err error) *MockState_SnapshotStateHashAtHeight_Call

func (*MockState_SnapshotStateHashAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_SnapshotStateHashAtHeight_Call) Run(run func(height proto.Height)) *MockState_SnapshotStateHashAtHeight_Call

func (*MockState_SnapshotStateHashAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_SnapshotStateHashAtHeight_Call) RunAndReturn(run func(height proto.Height) (crypto.Digest, error)) *MockState_SnapshotStateHashAtHeight_Call

type MockState_SnapshotsAtHeight_Call added in v0.11.0 

type MockState_SnapshotsAtHeight_Call struct {
	*mock.Call
}

MockState_SnapshotsAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SnapshotsAtHeight'

func (*MockState_SnapshotsAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_SnapshotsAtHeight_Call) Return(blockSnapshot proto.BlockSnapshot, err error) *MockState_SnapshotsAtHeight_Call

func (*MockState_SnapshotsAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_SnapshotsAtHeight_Call) Run(run func(height proto.Height)) *MockState_SnapshotsAtHeight_Call

func (*MockState_SnapshotsAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_SnapshotsAtHeight_Call) RunAndReturn(run func(height proto.Height) (proto.BlockSnapshot, error)) *MockState_SnapshotsAtHeight_Call

type MockState_StartProvidingExtendedApi_Call added in v0.11.0 

type MockState_StartProvidingExtendedApi_Call struct {
	*mock.Call
}

MockState_StartProvidingExtendedApi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartProvidingExtendedApi'

func (*MockState_StartProvidingExtendedApi_Call) Return added in v0.11.0 

func (_c *MockState_StartProvidingExtendedApi_Call) Return(err error) *MockState_StartProvidingExtendedApi_Call

func (*MockState_StartProvidingExtendedApi_Call) Run added in v0.11.0 

func (_c *MockState_StartProvidingExtendedApi_Call) Run(run func()) *MockState_StartProvidingExtendedApi_Call

func (*MockState_StartProvidingExtendedApi_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_StartProvidingExtendedApi_Call) RunAndReturn(run func() error) *MockState_StartProvidingExtendedApi_Call

type MockState_TopBlock_Call added in v0.11.0 

type MockState_TopBlock_Call struct {
	*mock.Call
}

MockState_TopBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TopBlock'

func (*MockState_TopBlock_Call) Return added in v0.11.0 

func (_c *MockState_TopBlock_Call) Return(block *proto.Block) *MockState_TopBlock_Call

func (*MockState_TopBlock_Call) Run added in v0.11.0 

func (_c *MockState_TopBlock_Call) Run(run func()) *MockState_TopBlock_Call

func (*MockState_TopBlock_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TopBlock_Call) RunAndReturn(run func() *proto.Block) *MockState_TopBlock_Call

type MockState_TotalWavesAmount_Call added in v0.11.0 

type MockState_TotalWavesAmount_Call struct {
	*mock.Call
}

MockState_TotalWavesAmount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TotalWavesAmount'

func (*MockState_TotalWavesAmount_Call) Return added in v0.11.0 

func (_c *MockState_TotalWavesAmount_Call) Return(v uint64, err error) *MockState_TotalWavesAmount_Call

func (*MockState_TotalWavesAmount_Call) Run added in v0.11.0 

func (_c *MockState_TotalWavesAmount_Call) Run(run func(height proto.Height)) *MockState_TotalWavesAmount_Call

func (*MockState_TotalWavesAmount_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TotalWavesAmount_Call) RunAndReturn(run func(height proto.Height) (uint64, error)) *MockState_TotalWavesAmount_Call

type MockState_TransactionByIDWithStatus_Call added in v0.11.0 

type MockState_TransactionByIDWithStatus_Call struct {
	*mock.Call
}

MockState_TransactionByIDWithStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionByIDWithStatus'

func (*MockState_TransactionByIDWithStatus_Call) Return added in v0.11.0 

func (_c *MockState_TransactionByIDWithStatus_Call) Return(transaction proto.Transaction, transactionStatus proto.TransactionStatus, err error) *MockState_TransactionByIDWithStatus_Call

func (*MockState_TransactionByIDWithStatus_Call) Run added in v0.11.0 

func (_c *MockState_TransactionByIDWithStatus_Call) Run(run func(id []byte)) *MockState_TransactionByIDWithStatus_Call

func (*MockState_TransactionByIDWithStatus_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TransactionByIDWithStatus_Call) RunAndReturn(run func(id []byte) (proto.Transaction, proto.TransactionStatus, error)) *MockState_TransactionByIDWithStatus_Call

type MockState_TransactionByID_Call added in v0.11.0 

type MockState_TransactionByID_Call struct {
	*mock.Call
}

MockState_TransactionByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionByID'

func (*MockState_TransactionByID_Call) Return added in v0.11.0 

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

func (*MockState_TransactionByID_Call) Run added in v0.11.0 

func (_c *MockState_TransactionByID_Call) Run(run func(id []byte)) *MockState_TransactionByID_Call

func (*MockState_TransactionByID_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TransactionByID_Call) RunAndReturn(run func(id []byte) (proto.Transaction, error)) *MockState_TransactionByID_Call

type MockState_TransactionHeightByID_Call added in v0.11.0 

type MockState_TransactionHeightByID_Call struct {
	*mock.Call
}

MockState_TransactionHeightByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionHeightByID'

func (*MockState_TransactionHeightByID_Call) Return added in v0.11.0 

func (_c *MockState_TransactionHeightByID_Call) Return(v uint64, err error) *MockState_TransactionHeightByID_Call

func (*MockState_TransactionHeightByID_Call) Run added in v0.11.0 

func (_c *MockState_TransactionHeightByID_Call) Run(run func(id []byte)) *MockState_TransactionHeightByID_Call

func (*MockState_TransactionHeightByID_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TransactionHeightByID_Call) RunAndReturn(run func(id []byte) (uint64, error)) *MockState_TransactionHeightByID_Call

type MockState_TxValidation_Call added in v0.11.0 

type MockState_TxValidation_Call struct {
	*mock.Call
}

MockState_TxValidation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxValidation'

func (*MockState_TxValidation_Call) Return added in v0.11.0 

func (_c *MockState_TxValidation_Call) Return(err error) *MockState_TxValidation_Call

func (*MockState_TxValidation_Call) Run added in v0.11.0 

func (_c *MockState_TxValidation_Call) Run(run func(fn func(validation TxValidation) error)) *MockState_TxValidation_Call

func (*MockState_TxValidation_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_TxValidation_Call) RunAndReturn(run func(fn func(validation TxValidation) error) error) *MockState_TxValidation_Call

type MockState_ValidateNextTx_Call added in v0.11.0 

type MockState_ValidateNextTx_Call struct {
	*mock.Call
}

MockState_ValidateNextTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateNextTx'

func (*MockState_ValidateNextTx_Call) Return added in v0.11.0 

func (_c *MockState_ValidateNextTx_Call) Return(atomicSnapshots []proto.AtomicSnapshot, err error) *MockState_ValidateNextTx_Call

func (*MockState_ValidateNextTx_Call) Run added in v0.11.0 

func (_c *MockState_ValidateNextTx_Call) Run(run func(tx proto.Transaction, currentTimestamp uint64, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool)) *MockState_ValidateNextTx_Call

func (*MockState_ValidateNextTx_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_ValidateNextTx_Call) RunAndReturn(run func(tx proto.Transaction, currentTimestamp uint64, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) ([]proto.AtomicSnapshot, error)) *MockState_ValidateNextTx_Call

type MockState_VotesNumAtHeight_Call added in v0.11.0 

type MockState_VotesNumAtHeight_Call struct {
	*mock.Call
}

MockState_VotesNumAtHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VotesNumAtHeight'

func (*MockState_VotesNumAtHeight_Call) Return added in v0.11.0 

func (_c *MockState_VotesNumAtHeight_Call) Return(v uint64, err error) *MockState_VotesNumAtHeight_Call

func (*MockState_VotesNumAtHeight_Call) Run added in v0.11.0 

func (_c *MockState_VotesNumAtHeight_Call) Run(run func(featureID int16, height proto.Height)) *MockState_VotesNumAtHeight_Call

func (*MockState_VotesNumAtHeight_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_VotesNumAtHeight_Call) RunAndReturn(run func(featureID int16, height proto.Height) (uint64, error)) *MockState_VotesNumAtHeight_Call

type MockState_VotesNum_Call added in v0.11.0 

type MockState_VotesNum_Call struct {
	*mock.Call
}

MockState_VotesNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VotesNum'

func (*MockState_VotesNum_Call) Return added in v0.11.0 

func (_c *MockState_VotesNum_Call) Return(v uint64, err error) *MockState_VotesNum_Call

func (*MockState_VotesNum_Call) Run added in v0.11.0 

func (_c *MockState_VotesNum_Call) Run(run func(featureID int16)) *MockState_VotesNum_Call

func (*MockState_VotesNum_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_VotesNum_Call) RunAndReturn(run func(featureID int16) (uint64, error)) *MockState_VotesNum_Call

type MockState_WavesAddressesNumber_Call added in v0.11.0 

type MockState_WavesAddressesNumber_Call struct {
	*mock.Call
}

MockState_WavesAddressesNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WavesAddressesNumber'

func (*MockState_WavesAddressesNumber_Call) Return added in v0.11.0 

func (_c *MockState_WavesAddressesNumber_Call) Return(v uint64, err error) *MockState_WavesAddressesNumber_Call

func (*MockState_WavesAddressesNumber_Call) Run added in v0.11.0 

func (_c *MockState_WavesAddressesNumber_Call) Run(run func()) *MockState_WavesAddressesNumber_Call

func (*MockState_WavesAddressesNumber_Call) RunAndReturn added in v0.11.0 

func (_c *MockState_WavesAddressesNumber_Call) RunAndReturn(run func() (uint64, error)) *MockState_WavesAddressesNumber_Call

type MockState_WavesBalance_Call added in v0.11.0 

type MockState_WavesBalance_Call struct {
	*mock.Call
}

MockState_WavesBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WavesBalance'

func (*MockState_WavesBalance_Call) Return added in v0.11.0 

func (_c *MockState_WavesBalance_Call) Return(v uint64, err error) *MockState_WavesBalance_Call

func (*MockState_WavesBalance_Call) Run added in v0.11.0 

func (_c *MockState_WavesBalance_Call) Run(run func(account proto.Recipient)) *MockState_WavesBalance_Call

func (*MockState_WavesBalance_Call) RunAndReturn added in v0.11.0 

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

type NonThreadSafeState added in v0.6.0 

type NonThreadSafeState = State

type State 

type State interface {
	StateInfo
	StateModifier
}

func NewState added in v0.3.0 

func NewState(
	ctx context.Context,
	dataDir string,
	amend bool,
	params StateParams,
	settings *settings.BlockchainSettings,
	enableLightNode bool,
	bUpdatesPluginInfo *proto.BlockchainUpdatesPluginInfo,
) (State, error)

NewState() creates State. dataDir is path to directory to store all data, it's also possible to provide folder with existing data, and state will try to sync and use it in this case. params are state parameters (see below). settings are blockchain settings (settings.MainNetSettings, settings.TestNetSettings or custom settings).

type StateInfo added in v0.5.0 

type StateInfo interface {
	// Block getters.
	TopBlock() *proto.Block
	Block(blockID proto.BlockID) (*proto.Block, error)
	BlockByHeight(height proto.Height) (*proto.Block, error)
	NewestBlockInfoByHeight(height proto.Height) (*proto.BlockInfo, error)
	// Header getters.
	Header(blockID proto.BlockID) (*proto.BlockHeader, error)
	HeaderByHeight(height proto.Height) (*proto.BlockHeader, error)
	NewestHeaderByHeight(height uint64) (*proto.BlockHeader, error)
	// Height returns current blockchain height.
	Height() (proto.Height, error)
	// Height <---> blockID converters.
	BlockIDToHeight(blockID proto.BlockID) (proto.Height, error)
	HeightToBlockID(height proto.Height) (proto.BlockID, error)
	WavesBalance(account proto.Recipient) (uint64, error)
	// FullWavesBalance returns complete Waves balance record.
	FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error)
	GeneratingBalance(account proto.Recipient, height proto.Height) (uint64, error)
	// AssetBalance retrieves balance of account in specific currency, asset is asset's ID.
	AssetBalance(account proto.Recipient, assetID proto.AssetID) (uint64, error)
	// WavesAddressesNumber returns total number of Waves addresses in state.
	// It is extremely slow, so it is recommended to only use for testing purposes.
	WavesAddressesNumber() (uint64, error)

	// Get cumulative blocks score at given height.
	ScoreAtHeight(height proto.Height) (*big.Int, error)
	// Get current blockchain score (at top height).
	CurrentScore() (*big.Int, error)

	// Retrieve current blockchain settings.
	BlockchainSettings() (*settings.BlockchainSettings, error)

	// Features.
	VotesNum(featureID int16) (uint64, error)
	VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error)
	IsActivated(featureID int16) (bool, error)
	IsActiveAtHeight(featureID int16, height proto.Height) (bool, error)
	ActivationHeight(featureID int16) (proto.Height, error)
	IsApproved(featureID int16) (bool, error)
	IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error)
	ApprovalHeight(featureID int16) (proto.Height, error)
	AllFeatures() ([]int16, error)
	EstimatorVersion() (int, error)
	IsActiveLightNodeNewBlocksFields(blockHeight proto.Height) (bool, error)

	// Aliases.
	AddrByAlias(alias proto.Alias) (proto.WavesAddress, error)
	AliasesByAddr(addr proto.WavesAddress) ([]string, error)

	// Accounts data storage.
	RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error)
	RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error)
	RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)
	RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)
	RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error)
	RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

	// Transactions.
	TransactionByID(id []byte) (proto.Transaction, error)
	TransactionByIDWithStatus(id []byte) (proto.Transaction, proto.TransactionStatus, error)
	TransactionHeightByID(id []byte) (uint64, error)
	// NewAddrTransactionsIterator() returns iterator to iterate all transactions that affected
	// given address.
	// Iterator will move in range from most recent to oldest transactions.
	NewAddrTransactionsIterator(addr proto.Address) (TransactionIterator, error)

	// Asset fee sponsorship.
	AssetIsSponsored(assetID proto.AssetID) (bool, error)
	IsAssetExist(assetID proto.AssetID) (bool, error)
	AssetInfo(assetID proto.AssetID) (*proto.AssetInfo, error)
	FullAssetInfo(assetID proto.AssetID) (*proto.FullAssetInfo, error)
	EnrichedFullAssetInfo(assetID proto.AssetID) (*proto.EnrichedFullAssetInfo, error)
	NFTList(account proto.Recipient, limit uint64, afterAssetID *proto.AssetID) ([]*proto.FullAssetInfo, error)
	// Script information.
	ScriptBasicInfoByAccount(account proto.Recipient) (*proto.ScriptBasicInfo, error)
	ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error)
	ScriptInfoByAsset(assetID proto.AssetID) (*proto.ScriptInfo, error)
	NewestScriptByAccount(account proto.Recipient) (*ast.Tree, error)
	NewestScriptBytesByAccount(account proto.Recipient) (proto.Script, error)

	// Leases.
	IsActiveLeasing(leaseID crypto.Digest) (bool, error)

	// Invoke results.
	InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error)
	// True if state stores additional information in order to provide extended API.
	ProvidesExtendedApi() (bool, error)
	// True if state stores and calculates state hashes for each block height.
	ProvidesStateHashes() (bool, error)

	// State hashes.
	LegacyStateHashAtHeight(height proto.Height) (proto.StateHash, error)
	SnapshotStateHashAtHeight(height proto.Height) (crypto.Digest, error)

	// Map on readable state. Way to apply multiple operations under same lock.
	MapR(func(StateInfo) (any, error)) (any, error)

	// HitSourceAtHeight reads hit source stored in state.
	HitSourceAtHeight(height proto.Height) ([]byte, error)
	// BlockVRF calculates VRF value for the block at given height.
	BlockVRF(blockHeader *proto.BlockHeader, blockHeight proto.Height) ([]byte, error)

	// ShouldPersistAddressTransactions checks the size of temporary transaction storage file and returns true if we
	// should move transactions into the main storage.
	ShouldPersistAddressTransactions() (bool, error)

	// RewardAtHeight returns reward for the block at the given height.
	// Return zero without error if the feature #14 "BlockReward" is not activated.
	// It takes into account the reward multiplier introduced with the feature #23 "BoostBlockReward".
	RewardAtHeight(height proto.Height) (uint64, error)

	RewardVotes(height proto.Height) (proto.RewardVotes, error)

	// TotalWavesAmount returns total amount of Waves in the system at the given height.
	// It returns the initial Waves amount of 100 000 000 before activation of feature #14 "BlockReward".
	// It takes into account the reward multiplier introduced with the feature #23 "BoostBlockReward".
	TotalWavesAmount(height proto.Height) (uint64, error)
	// BlockRewards calculates block rewards for the block at given height with given generator address.
	BlockRewards(generator proto.WavesAddress, height proto.Height) (proto.Rewards, error)

	// SnapshotsAtHeight returns block snapshots at the given height.
	SnapshotsAtHeight(height proto.Height) (proto.BlockSnapshot, error)

	// CalculateVotingFinalization calculates whether the generating balance of endorsers at the block with the
	// Given height exceeds the total generating balance of all committed generators for that block.
	CalculateVotingFinalization(endorsers []proto.WavesAddress,
		blockGeneratorAddress proto.WavesAddress, height proto.Height,
		allGenerators []proto.WavesAddress) (bool, error)

	FindEndorserPKByIndex(periodStart uint32, index int) (bls.PublicKey, error)
	FindGeneratorPKByEndorserPK(periodStart uint32, endorserPK bls.PublicKey) (crypto.PublicKey, error)
	IndexByEndorserPK(periodStart uint32, pk bls.PublicKey) (uint32, error)
	NewestCommitmentExistsByEndorserPK(periodStart uint32, endorserPK bls.PublicKey) (bool, error)
	NewestCommitedEndorsers(periodStart uint32) ([]bls.PublicKey, error)
	CommittedGenerators(periodStart uint32) ([]proto.WavesAddress, error)
	LastFinalizedHeight() (proto.Height, error)
	LastFinalizedBlock() (*proto.BlockHeader, error)
	CheckRollbackHeightAuto(height proto.Height) error
}

StateInfo returns information that corresponds to latest fully applied block. This should be used for APIs and other modules where stable, fully verified state is needed. Methods of this interface are thread-safe.

func NewThreadSafeReadWrapper added in v0.6.0 

func NewThreadSafeReadWrapper(mu *sync.RWMutex, s StateInfo) StateInfo

type StateModifier added in v0.3.0 

type StateModifier interface {
	// AddBlock adds single block to state.
	// It's not recommended using this function when you are able to accumulate big blocks batch,
	// since it's much more efficient to add many blocks at once.
	AddBlock(block []byte) (*proto.Block, error)
	AddDeserializedBlock(block *proto.Block) (*proto.Block, error)
	// AddBlocks adds batch of new blocks to state.
	AddBlocks(blocks [][]byte) error
	AddBlocksWithSnapshots(blocks [][]byte, snapshots []*proto.BlockSnapshot) error
	// AddDeserializedBlocks marshals blocks to binary and calls AddBlocks.
	AddDeserializedBlocks(blocks []*proto.Block) (*proto.Block, error)
	AddDeserializedBlocksWithSnapshots(blocks []*proto.Block, snapshots []*proto.BlockSnapshot) (*proto.Block, error)
	// Rollback functionality.
	RollbackToHeight(height proto.Height, isAutoRollback bool) error
	RollbackTo(removalEdge proto.BlockID, isAutoRollback bool) error

	// CreateNextSnapshotHash creates snapshot hash for next block in the context of current state.
	// It also temporary modifies internal state.
	CreateNextSnapshotHash(block *proto.Block) (crypto.Digest, error)

	// -------------------------
	// Validation functionality (for UTX).
	// -------------------------
	// ValidateNextTx() validates transaction against state, taking into account all the previous changes from transactions
	// that were added using ValidateNextTx() until you call ResetValidationList().
	// Returns TxCommitmentError or other state error or nil.
	// When TxCommitmentError is returned, state MUST BE cleared using ResetValidationList().
	ValidateNextTx(
		tx proto.Transaction,
		currentTimestamp, parentTimestamp uint64,
		blockVersion proto.BlockVersion,
		acceptFailed bool,
	) ([]proto.AtomicSnapshot, error)
	// ResetValidationList() resets the validation list, so you can ValidateNextTx() from scratch after calling it.
	ResetValidationList()

	// Func internally calls ResetValidationList.
	TxValidation(func(validation TxValidation) error) error

	// Way to call multiple operations under same lock.
	Map(func(state NonThreadSafeState) error) error

	MapUnsafe(func(state NonThreadSafeState) error) error

	// State will provide extended API data after returning.
	StartProvidingExtendedApi() error

	// PersistAddressTransactions sorts and saves transactions to storage.
	PersistAddressTransactions() error

	Close() error
}

StateModifier contains all the methods needed to modify node's state. Methods of this interface are not thread-safe.

func NewThreadSafeWriteWrapper added in v0.6.0 

func NewThreadSafeWriteWrapper(i *int32, mu *sync.RWMutex, s State) StateModifier

type StateParams added in v0.3.0 

type StateParams struct {
	StorageParams
	ValidationParams
	// When StoreExtendedApiData is true, state builds additional data required for API.
	StoreExtendedApiData bool
	// ProvideExtendedApi specifies whether state must provide data for extended API.
	ProvideExtendedApi bool
	// BuildStateHashes enables building and storing state hashes by height.
	BuildStateHashes bool
}

func DefaultStateParams added in v0.3.0 

func DefaultStateParams() StateParams

func DefaultTestingStateParams added in v0.3.0 

func DefaultTestingStateParams() StateParams

type StorageParams added in v0.3.0 

type StorageParams struct {
	OffsetLen       int
	HeaderOffsetLen int
	DbParams        keyvalue.KeyValParams
}

func DefaultStorageParams added in v0.3.0 

func DefaultStorageParams() StorageParams

func DefaultTestingStorageParams added in v0.3.0 

func DefaultTestingStorageParams() StorageParams

type ThreadSafeReadWrapper added in v0.6.0 

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

func (*ThreadSafeReadWrapper) ActivationHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) ActivationHeight(featureID int16) (proto.Height, error)

func (*ThreadSafeReadWrapper) AddrByAlias added in v0.6.0 

func (a *ThreadSafeReadWrapper) AddrByAlias(alias proto.Alias) (proto.WavesAddress, error)

func (*ThreadSafeReadWrapper) AliasesByAddr added in v0.10.5 

func (a *ThreadSafeReadWrapper) AliasesByAddr(addr proto.WavesAddress) ([]string, error)

func (*ThreadSafeReadWrapper) AllFeatures added in v0.6.0 

func (a *ThreadSafeReadWrapper) AllFeatures() ([]int16, error)

func (*ThreadSafeReadWrapper) ApprovalHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) ApprovalHeight(featureID int16) (proto.Height, error)

func (*ThreadSafeReadWrapper) AssetBalance added in v0.10.0 

func (a *ThreadSafeReadWrapper) AssetBalance(account proto.Recipient, asset proto.AssetID) (uint64, error)

func (*ThreadSafeReadWrapper) AssetInfo added in v0.6.0 

func (a *ThreadSafeReadWrapper) AssetInfo(assetID proto.AssetID) (*proto.AssetInfo, error)

func (*ThreadSafeReadWrapper) AssetIsSponsored added in v0.6.0 

func (a *ThreadSafeReadWrapper) AssetIsSponsored(assetID proto.AssetID) (bool, error)

func (*ThreadSafeReadWrapper) Block added in v0.6.0 

func (a *ThreadSafeReadWrapper) Block(blockID proto.BlockID) (*proto.Block, error)

func (*ThreadSafeReadWrapper) BlockByHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) BlockByHeight(height proto.Height) (*proto.Block, error)

func (*ThreadSafeReadWrapper) BlockIDToHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error)

func (*ThreadSafeReadWrapper) BlockRewards added in v0.11.0 

func (a *ThreadSafeReadWrapper) BlockRewards(generator proto.WavesAddress, height proto.Height) (proto.Rewards, error)

func (*ThreadSafeReadWrapper) BlockVRF added in v0.6.0 

func (a *ThreadSafeReadWrapper) BlockVRF(blockHeader *proto.BlockHeader, blockHeight proto.Height) ([]byte, error)

func (*ThreadSafeReadWrapper) BlockchainSettings added in v0.6.0 

func (a *ThreadSafeReadWrapper) BlockchainSettings() (*settings.BlockchainSettings, error)

func (*ThreadSafeReadWrapper) CalculateVotingFinalization added in v0.11.0 

func (a *ThreadSafeReadWrapper) CalculateVotingFinalization(endorsers []proto.WavesAddress,
	blockGeneratorEndorser proto.WavesAddress, height proto.Height,
	allGenerators []proto.WavesAddress) (bool, error)

func (*ThreadSafeReadWrapper) CheckRollbackHeightAuto added in v0.11.0 

func (a *ThreadSafeReadWrapper) CheckRollbackHeightAuto(height proto.Height) error

CheckRollbackHeightAuto validates automatic rollback height constraints.

func (*ThreadSafeReadWrapper) CommittedGenerators added in v0.11.0 

func (a *ThreadSafeReadWrapper) CommittedGenerators(periodStart uint32) ([]proto.WavesAddress, error)

func (*ThreadSafeReadWrapper) CurrentScore added in v0.6.0 

func (a *ThreadSafeReadWrapper) CurrentScore() (*big.Int, error)

func (*ThreadSafeReadWrapper) EnrichedFullAssetInfo added in v0.10.5 

func (a *ThreadSafeReadWrapper) EnrichedFullAssetInfo(assetID proto.AssetID) (*proto.EnrichedFullAssetInfo, error)

func (*ThreadSafeReadWrapper) EstimatorVersion added in v0.8.0 

func (a *ThreadSafeReadWrapper) EstimatorVersion() (int, error)

func (*ThreadSafeReadWrapper) FindEndorserPKByIndex added in v0.11.0 

func (a *ThreadSafeReadWrapper) FindEndorserPKByIndex(periodStart uint32, index int) (bls.PublicKey, error)

func (*ThreadSafeReadWrapper) FindGeneratorPKByEndorserPK added in v0.11.0 

func (a *ThreadSafeReadWrapper) FindGeneratorPKByEndorserPK(periodStart uint32,
	endorserPK bls.PublicKey) (crypto.PublicKey, error)

func (*ThreadSafeReadWrapper) FullAssetInfo added in v0.6.0 

func (a *ThreadSafeReadWrapper) FullAssetInfo(assetID proto.AssetID) (*proto.FullAssetInfo, error)

func (*ThreadSafeReadWrapper) FullWavesBalance added in v0.6.0 

func (a *ThreadSafeReadWrapper) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error)

func (*ThreadSafeReadWrapper) GeneratingBalance added in v0.11.0 

func (a *ThreadSafeReadWrapper) GeneratingBalance(account proto.Recipient, height proto.Height) (uint64, error)

func (*ThreadSafeReadWrapper) Header added in v0.6.0 

func (a *ThreadSafeReadWrapper) Header(blockID proto.BlockID) (*proto.BlockHeader, error)

func (*ThreadSafeReadWrapper) HeaderByHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error)

func (*ThreadSafeReadWrapper) Height added in v0.6.0 

func (a *ThreadSafeReadWrapper) Height() (proto.Height, error)

func (*ThreadSafeReadWrapper) HeightToBlockID added in v0.6.0 

func (a *ThreadSafeReadWrapper) HeightToBlockID(height proto.Height) (proto.BlockID, error)

func (*ThreadSafeReadWrapper) HitSourceAtHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) HitSourceAtHeight(height proto.Height) ([]byte, error)

func (*ThreadSafeReadWrapper) IndexByEndorserPK added in v0.11.0 

func (a *ThreadSafeReadWrapper) IndexByEndorserPK(periodStart uint32, pk bls.PublicKey) (uint32, error)

func (*ThreadSafeReadWrapper) InvokeResultByID added in v0.6.0 

func (a *ThreadSafeReadWrapper) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error)

func (*ThreadSafeReadWrapper) IsActivated added in v0.6.0 

func (a *ThreadSafeReadWrapper) IsActivated(featureID int16) (bool, error)

func (*ThreadSafeReadWrapper) IsActiveAtHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error)

func (*ThreadSafeReadWrapper) IsActiveLeasing added in v0.6.0 

func (a *ThreadSafeReadWrapper) IsActiveLeasing(leaseID crypto.Digest) (bool, error)

func (*ThreadSafeReadWrapper) IsActiveLightNodeNewBlocksFields added in v0.11.0 

func (a *ThreadSafeReadWrapper) IsActiveLightNodeNewBlocksFields(blockHeight proto.Height) (bool, error)

func (*ThreadSafeReadWrapper) IsApproved added in v0.6.0 

func (a *ThreadSafeReadWrapper) IsApproved(featureID int16) (bool, error)

func (*ThreadSafeReadWrapper) IsApprovedAtHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error)

func (*ThreadSafeReadWrapper) IsAssetExist added in v0.10.5 

func (a *ThreadSafeReadWrapper) IsAssetExist(assetID proto.AssetID) (bool, error)

func (*ThreadSafeReadWrapper) LastFinalizedBlock added in v0.11.0 

func (a *ThreadSafeReadWrapper) LastFinalizedBlock() (*proto.BlockHeader, error)

func (*ThreadSafeReadWrapper) LastFinalizedHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) LastFinalizedHeight() (proto.Height, error)

func (*ThreadSafeReadWrapper) LegacyStateHashAtHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) LegacyStateHashAtHeight(height uint64) (proto.StateHash, error)

func (*ThreadSafeReadWrapper) MapR added in v0.6.0 

func (a *ThreadSafeReadWrapper) MapR(f func(StateInfo) (any, error)) (any, error)

func (*ThreadSafeReadWrapper) NFTList added in v0.8.0 

func (a *ThreadSafeReadWrapper) NFTList(account proto.Recipient, limit uint64, afterAssetID *proto.AssetID) ([]*proto.FullAssetInfo, error)

func (*ThreadSafeReadWrapper) NewAddrTransactionsIterator added in v0.6.0 

func (a *ThreadSafeReadWrapper) NewAddrTransactionsIterator(addr proto.Address) (TransactionIterator, error)

func (*ThreadSafeReadWrapper) NewestBlockInfoByHeight added in v0.11.0 

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

func (*ThreadSafeReadWrapper) NewestCommitedEndorsers added in v0.11.0 

func (a *ThreadSafeReadWrapper) NewestCommitedEndorsers(periodStart uint32) ([]bls.PublicKey, error)

func (*ThreadSafeReadWrapper) NewestCommitmentExistsByEndorserPK added in v0.11.0 

func (a *ThreadSafeReadWrapper) NewestCommitmentExistsByEndorserPK(periodStart uint32,
	endorserPK bls.PublicKey) (bool, error)

func (*ThreadSafeReadWrapper) NewestHeaderByHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) NewestHeaderByHeight(height uint64) (*proto.BlockHeader, error)

func (*ThreadSafeReadWrapper) NewestScriptByAccount added in v0.10.0 

func (a *ThreadSafeReadWrapper) NewestScriptByAccount(recipient proto.Recipient) (*ast.Tree, error)

func (*ThreadSafeReadWrapper) NewestScriptBytesByAccount added in v0.10.0 

func (a *ThreadSafeReadWrapper) NewestScriptBytesByAccount(recipient proto.Recipient) (proto.Script, error)

func (*ThreadSafeReadWrapper) ProvidesExtendedApi added in v0.6.0 

func (a *ThreadSafeReadWrapper) ProvidesExtendedApi() (bool, error)

func (*ThreadSafeReadWrapper) ProvidesStateHashes added in v0.6.0 

func (a *ThreadSafeReadWrapper) ProvidesStateHashes() (bool, error)

func (*ThreadSafeReadWrapper) RetrieveBinaryEntry added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error)

func (*ThreadSafeReadWrapper) RetrieveBooleanEntry added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error)

func (*ThreadSafeReadWrapper) RetrieveEntries added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error)

func (*ThreadSafeReadWrapper) RetrieveEntry added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error)

func (*ThreadSafeReadWrapper) RetrieveIntegerEntry added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error)

func (*ThreadSafeReadWrapper) RetrieveStringEntry added in v0.6.0 

func (a *ThreadSafeReadWrapper) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error)

func (*ThreadSafeReadWrapper) RewardAtHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) RewardAtHeight(height proto.Height) (uint64, error)

func (*ThreadSafeReadWrapper) RewardVotes added in v0.11.0 

func (a *ThreadSafeReadWrapper) RewardVotes(height proto.Height) (proto.RewardVotes, error)

func (*ThreadSafeReadWrapper) ScoreAtHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) ScoreAtHeight(height proto.Height) (*big.Int, error)

func (*ThreadSafeReadWrapper) ScriptBasicInfoByAccount added in v0.10.2 

func (a *ThreadSafeReadWrapper) ScriptBasicInfoByAccount(account proto.Recipient) (*proto.ScriptBasicInfo, error)

func (*ThreadSafeReadWrapper) ScriptInfoByAccount added in v0.6.0 

func (a *ThreadSafeReadWrapper) ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error)

func (*ThreadSafeReadWrapper) ScriptInfoByAsset added in v0.6.0 

func (a *ThreadSafeReadWrapper) ScriptInfoByAsset(assetID proto.AssetID) (*proto.ScriptInfo, error)

func (*ThreadSafeReadWrapper) ShouldPersistAddressTransactions added in v0.7.0 

func (a *ThreadSafeReadWrapper) ShouldPersistAddressTransactions() (bool, error)

func (*ThreadSafeReadWrapper) SnapshotStateHashAtHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) SnapshotStateHashAtHeight(height proto.Height) (crypto.Digest, error)

func (*ThreadSafeReadWrapper) SnapshotsAtHeight added in v0.11.0 

func (a *ThreadSafeReadWrapper) SnapshotsAtHeight(height proto.Height) (proto.BlockSnapshot, error)

func (*ThreadSafeReadWrapper) TopBlock added in v0.6.0 

func (a *ThreadSafeReadWrapper) TopBlock() *proto.Block

func (*ThreadSafeReadWrapper) TotalWavesAmount added in v0.11.0 

func (a *ThreadSafeReadWrapper) TotalWavesAmount(height proto.Height) (uint64, error)

func (*ThreadSafeReadWrapper) TransactionByID added in v0.6.0 

func (a *ThreadSafeReadWrapper) TransactionByID(id []byte) (proto.Transaction, error)

func (*ThreadSafeReadWrapper) TransactionByIDWithStatus added in v0.7.0 

func (a *ThreadSafeReadWrapper) TransactionByIDWithStatus(
	id []byte,
) (proto.Transaction, proto.TransactionStatus, error)

func (*ThreadSafeReadWrapper) TransactionHeightByID added in v0.6.0 

func (a *ThreadSafeReadWrapper) TransactionHeightByID(id []byte) (uint64, error)

func (*ThreadSafeReadWrapper) VotesNum added in v0.6.0 

func (a *ThreadSafeReadWrapper) VotesNum(featureID int16) (uint64, error)

func (*ThreadSafeReadWrapper) VotesNumAtHeight added in v0.6.0 

func (a *ThreadSafeReadWrapper) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error)

func (*ThreadSafeReadWrapper) WavesAddressesNumber added in v0.6.0 

func (a *ThreadSafeReadWrapper) WavesAddressesNumber() (uint64, error)

func (*ThreadSafeReadWrapper) WavesBalance added in v0.10.0 

func (a *ThreadSafeReadWrapper) WavesBalance(account proto.Recipient) (uint64, error)

type ThreadSafeState added in v0.6.0 

type ThreadSafeState struct {
	StateInfo
	StateModifier
}

func NewThreadSafeState added in v0.6.0 

func NewThreadSafeState(s State) *ThreadSafeState

type ThreadSafeWriteWrapper added in v0.6.0 

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

func (*ThreadSafeWriteWrapper) AddBlock added in v0.6.0 

func (a *ThreadSafeWriteWrapper) AddBlock(block []byte) (*proto.Block, error)

func (*ThreadSafeWriteWrapper) AddBlocks added in v0.10.0 

func (a *ThreadSafeWriteWrapper) AddBlocks(blocks [][]byte) error

func (*ThreadSafeWriteWrapper) AddBlocksWithSnapshots added in v0.11.0 

func (a *ThreadSafeWriteWrapper) AddBlocksWithSnapshots(blocks [][]byte, snapshots []*proto.BlockSnapshot) error

func (*ThreadSafeWriteWrapper) AddDeserializedBlock added in v0.6.0 

func (a *ThreadSafeWriteWrapper) AddDeserializedBlock(
	block *proto.Block,
) (*proto.Block, error)

func (*ThreadSafeWriteWrapper) AddDeserializedBlocks added in v0.10.0 

func (a *ThreadSafeWriteWrapper) AddDeserializedBlocks(
	blocks []*proto.Block,
) (*proto.Block, error)

func (*ThreadSafeWriteWrapper) AddDeserializedBlocksWithSnapshots added in v0.11.0 

func (a *ThreadSafeWriteWrapper) AddDeserializedBlocksWithSnapshots(
	blocks []*proto.Block,
	snapshots []*proto.BlockSnapshot,
) (*proto.Block, error)

func (*ThreadSafeWriteWrapper) Close added in v0.6.0 

func (a *ThreadSafeWriteWrapper) Close() error

func (*ThreadSafeWriteWrapper) CreateNextSnapshotHash added in v0.11.0 

func (a *ThreadSafeWriteWrapper) CreateNextSnapshotHash(block *proto.Block) (crypto.Digest, error)

func (*ThreadSafeWriteWrapper) Map added in v0.6.0 

func (a *ThreadSafeWriteWrapper) Map(f func(state NonThreadSafeState) error) error

func (*ThreadSafeWriteWrapper) MapUnsafe added in v0.11.0 

func (a *ThreadSafeWriteWrapper) MapUnsafe(f func(state NonThreadSafeState) error) error

func (*ThreadSafeWriteWrapper) PersistAddressTransactions added in v0.7.0 

func (a *ThreadSafeWriteWrapper) PersistAddressTransactions() error

func (*ThreadSafeWriteWrapper) ResetValidationList added in v0.6.0 

func (a *ThreadSafeWriteWrapper) ResetValidationList()

func (*ThreadSafeWriteWrapper) RollbackTo added in v0.6.0 

func (a *ThreadSafeWriteWrapper) RollbackTo(removalEdge proto.BlockID, isAutoRollback bool) error

func (*ThreadSafeWriteWrapper) RollbackToHeight added in v0.6.0 

func (a *ThreadSafeWriteWrapper) RollbackToHeight(height proto.Height, isAutoRollback bool) error

func (*ThreadSafeWriteWrapper) StartProvidingExtendedApi added in v0.6.0 

func (a *ThreadSafeWriteWrapper) StartProvidingExtendedApi() error

func (*ThreadSafeWriteWrapper) TxValidation added in v0.6.0 

func (a *ThreadSafeWriteWrapper) TxValidation(f func(validation TxValidation) error) error

func (*ThreadSafeWriteWrapper) ValidateNextTx added in v0.6.0 

func (a *ThreadSafeWriteWrapper) ValidateNextTx(
	_ proto.Transaction,
	_, _ uint64,
	_ proto.BlockVersion,
	_ bool,
) ([]proto.AtomicSnapshot, error)

type TransactionIterator added in v0.5.0 

type TransactionIterator interface {
	Transaction() (proto.Transaction, proto.TransactionStatus, error)
	Next() bool
	Release()
	Error() error
}

TransactionIterator can be used to iterate through transactions of given address. One instance is only valid for iterating once. Transaction() returns current transaction. Next() moves iterator to next position, it must be called first time at the beginning. Release() must be called after using iterator. Error() should return nil if iterating was successful.

type TxValidation added in v0.6.0 

type TxValidation = interface {
	ValidateNextTx(
		tx proto.Transaction,
		currentTimestamp, parentTimestamp uint64,
		blockVersion proto.BlockVersion,
		acceptFailed bool,
	) ([]proto.AtomicSnapshot, error)
}

type ValidationParams added in v0.3.0 

type ValidationParams struct {
	VerificationGoroutinesNum int
	Time                      types.Time
}

ValidationParams are validation parameters. VerificationGoroutinesNum specifies how many goroutines will be run for verification of transactions and blocks signatures.

Source Files

View all Source files

Directories

Path Synopsis

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.