mock

package

Go to main page

Versions in this module

v1

v1.10.16

Dec 17, 2024

v1.10.15

Dec 17, 2024

v1.10.14

Dec 16, 2024

v1.10.13

Dec 16, 2024

v1.10.12

Dec 14, 2024

v1.10.11

Dec 13, 2024

v1.10.10

Dec 12, 2024

v1.10.9

Nov 20, 2024

v1.10.8

Nov 15, 2024

Changes in this version

type MockIRollup

+ func (m *MockIRollup) RollupStatsGrouping(ctx context.Context, fltrs storage.RollupGroupStatsFilters) ([]storage.RollupGroupedStats, error)

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) RollupStatsGrouping(ctx, fltrs any) *MockIRollupRollupStatsGroupingCall

+ type MockIRollupRollupStatsGroupingCall struct

+ func (c *MockIRollupRollupStatsGroupingCall) Do(...) *MockIRollupRollupStatsGroupingCall

+ func (c *MockIRollupRollupStatsGroupingCall) DoAndReturn(...) *MockIRollupRollupStatsGroupingCall

+ func (c *MockIRollupRollupStatsGroupingCall) Return(arg0 []storage.RollupGroupedStats, arg1 error) *MockIRollupRollupStatsGroupingCall

v1.10.7

Nov 4, 2024

v1.10.6

Nov 4, 2024

Changes in this version

type MockITx

+ func (m *MockITx) IdAndTimeByHash(ctx context.Context, hash []byte) (uint64, time.Time, error)

+ type MockITxIdAndTimeByHashCall struct

+ func (c *MockITxIdAndTimeByHashCall) Do(f func(context.Context, []byte) (uint64, time.Time, error)) *MockITxIdAndTimeByHashCall

+ func (c *MockITxIdAndTimeByHashCall) DoAndReturn(f func(context.Context, []byte) (uint64, time.Time, error)) *MockITxIdAndTimeByHashCall

+ func (c *MockITxIdAndTimeByHashCall) Return(arg0 uint64, arg1 time.Time, arg2 error) *MockITxIdAndTimeByHashCall

type MockITxMockRecorder

+ func (mr *MockITxMockRecorder) IdAndTimeByHash(ctx, hash any) *MockITxIdAndTimeByHashCall

v1.10.5

Oct 25, 2024

v1.10.4

Oct 16, 2024

v1.10.3

Sep 24, 2024

v1.10.2

Sep 12, 2024

v1.10.1

Sep 9, 2024

Changes in this version

type MockIAddress

+ func (m *MockIAddress) IdByAddress(ctx context.Context, address string, ids ...uint64) (uint64, error)

+ type MockIAddressIdByAddressCall struct

+ func (c *MockIAddressIdByAddressCall) Do(f func(context.Context, string, ...uint64) (uint64, error)) *MockIAddressIdByAddressCall

+ func (c *MockIAddressIdByAddressCall) DoAndReturn(f func(context.Context, string, ...uint64) (uint64, error)) *MockIAddressIdByAddressCall

+ func (c *MockIAddressIdByAddressCall) Return(arg0 uint64, arg1 error) *MockIAddressIdByAddressCall

type MockIAddressMockRecorder

+ func (mr *MockIAddressMockRecorder) IdByAddress(ctx, address any, ids ...any) *MockIAddressIdByAddressCall

v1.10.0

Sep 8, 2024

Changes in this version

type MockIBlobLog

+ func (m *MockIBlobLog) ListBlobs(ctx context.Context, fltrs storage.ListBlobLogFilters) ([]storage.BlobLog, error)

+ type MockIBlobLogListBlobsCall struct

+ func (c *MockIBlobLogListBlobsCall) Do(f func(context.Context, storage.ListBlobLogFilters) ([]storage.BlobLog, error)) *MockIBlobLogListBlobsCall

+ func (c *MockIBlobLogListBlobsCall) DoAndReturn(f func(context.Context, storage.ListBlobLogFilters) ([]storage.BlobLog, error)) *MockIBlobLogListBlobsCall

+ func (c *MockIBlobLogListBlobsCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogListBlobsCall

type MockIBlobLogMockRecorder

+ func (mr *MockIBlobLogMockRecorder) ListBlobs(ctx, fltrs any) *MockIBlobLogListBlobsCall

v1.9.10

Aug 23, 2024

Changes in this version

type MockIRollup

+ func (m *MockIRollup) AllSeries(ctx context.Context) ([]storage.RollupHistogramItem, error)

+ func (m *MockIRollup) LeaderboardDay(ctx context.Context, sortField string, sort storage0.SortOrder, ...) ([]storage.RollupWithDayStats, error)

+ type MockIRollupAllSeriesCall struct

+ func (c *MockIRollupAllSeriesCall) Do(f func(context.Context) ([]storage.RollupHistogramItem, error)) *MockIRollupAllSeriesCall

+ func (c *MockIRollupAllSeriesCall) DoAndReturn(f func(context.Context) ([]storage.RollupHistogramItem, error)) *MockIRollupAllSeriesCall

+ func (c *MockIRollupAllSeriesCall) Return(arg0 []storage.RollupHistogramItem, arg1 error) *MockIRollupAllSeriesCall

+ type MockIRollupLeaderboardDayCall struct

+ func (c *MockIRollupLeaderboardDayCall) Do(...) *MockIRollupLeaderboardDayCall

+ func (c *MockIRollupLeaderboardDayCall) DoAndReturn(...) *MockIRollupLeaderboardDayCall

+ func (c *MockIRollupLeaderboardDayCall) Return(arg0 []storage.RollupWithDayStats, arg1 error) *MockIRollupLeaderboardDayCall

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) AllSeries(ctx any) *MockIRollupAllSeriesCall

+ func (mr *MockIRollupMockRecorder) LeaderboardDay(ctx, sortField, sort, limit, offset any) *MockIRollupLeaderboardDayCall

v1.9.9

Aug 13, 2024

Changes in this version

type MockExport

+ func (m *MockExport) ISGOMOCK() struct{}

+ type MockExportCloseCall struct

+ func (c *MockExportCloseCall) Do(f func() error) *MockExportCloseCall

+ func (c *MockExportCloseCall) DoAndReturn(f func() error) *MockExportCloseCall

+ func (c *MockExportCloseCall) Return(arg0 error) *MockExportCloseCall

+ type MockExportToCsvCall struct

+ func (c *MockExportToCsvCall) Do(f func(context.Context, io.Writer, string) error) *MockExportToCsvCall

+ func (c *MockExportToCsvCall) DoAndReturn(f func(context.Context, io.Writer, string) error) *MockExportToCsvCall

+ func (c *MockExportToCsvCall) Return(arg0 error) *MockExportToCsvCall

type MockIAddress

+ func (m *MockIAddress) ISGOMOCK() struct{}

+ type MockIAddressByHashCall struct

+ func (c *MockIAddressByHashCall) Do(f func(context.Context, []byte) (storage.Address, error)) *MockIAddressByHashCall

+ func (c *MockIAddressByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Address, error)) *MockIAddressByHashCall

+ func (c *MockIAddressByHashCall) Return(arg0 storage.Address, arg1 error) *MockIAddressByHashCall

+ type MockIAddressCursorListCall struct

+ func (c *MockIAddressCursorListCall) Do(...) *MockIAddressCursorListCall

+ func (c *MockIAddressCursorListCall) DoAndReturn(...) *MockIAddressCursorListCall

+ func (c *MockIAddressCursorListCall) Return(arg0 []*storage.Address, arg1 error) *MockIAddressCursorListCall

+ type MockIAddressGetByIDCall struct

+ func (c *MockIAddressGetByIDCall) Do(f func(context.Context, uint64) (*storage.Address, error)) *MockIAddressGetByIDCall

+ func (c *MockIAddressGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Address, error)) *MockIAddressGetByIDCall

+ func (c *MockIAddressGetByIDCall) Return(arg0 *storage.Address, arg1 error) *MockIAddressGetByIDCall

+ type MockIAddressIdByHashCall struct

+ func (c *MockIAddressIdByHashCall) Do(f func(context.Context, []byte) (uint64, error)) *MockIAddressIdByHashCall

+ func (c *MockIAddressIdByHashCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *MockIAddressIdByHashCall

+ func (c *MockIAddressIdByHashCall) Return(arg0 uint64, arg1 error) *MockIAddressIdByHashCall

+ type MockIAddressIsNoRowsCall struct

+ func (c *MockIAddressIsNoRowsCall) Do(f func(error) bool) *MockIAddressIsNoRowsCall

+ func (c *MockIAddressIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIAddressIsNoRowsCall

+ func (c *MockIAddressIsNoRowsCall) Return(arg0 bool) *MockIAddressIsNoRowsCall

+ type MockIAddressLastIDCall struct

+ func (c *MockIAddressLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIAddressLastIDCall

+ func (c *MockIAddressLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIAddressLastIDCall

+ func (c *MockIAddressLastIDCall) Return(arg0 uint64, arg1 error) *MockIAddressLastIDCall

+ type MockIAddressListCall struct

+ func (c *MockIAddressListCall) Do(...) *MockIAddressListCall

+ func (c *MockIAddressListCall) DoAndReturn(...) *MockIAddressListCall

+ func (c *MockIAddressListCall) Return(arg0 []*storage.Address, arg1 error) *MockIAddressListCall

+ type MockIAddressListWithBalanceCall struct

+ func (c *MockIAddressListWithBalanceCall) Do(f func(context.Context, storage.AddressListFilter) ([]storage.Address, error)) *MockIAddressListWithBalanceCall

+ func (c *MockIAddressListWithBalanceCall) DoAndReturn(f func(context.Context, storage.AddressListFilter) ([]storage.Address, error)) *MockIAddressListWithBalanceCall

+ func (c *MockIAddressListWithBalanceCall) Return(arg0 []storage.Address, arg1 error) *MockIAddressListWithBalanceCall

+ type MockIAddressSaveCall struct

+ func (c *MockIAddressSaveCall) Do(f func(context.Context, *storage.Address) error) *MockIAddressSaveCall

+ func (c *MockIAddressSaveCall) DoAndReturn(f func(context.Context, *storage.Address) error) *MockIAddressSaveCall

+ func (c *MockIAddressSaveCall) Return(arg0 error) *MockIAddressSaveCall

+ type MockIAddressSeriesCall struct

+ func (c *MockIAddressSeriesCall) Do(...) *MockIAddressSeriesCall

+ func (c *MockIAddressSeriesCall) DoAndReturn(...) *MockIAddressSeriesCall

+ func (c *MockIAddressSeriesCall) Return(items []storage.HistogramItem, err error) *MockIAddressSeriesCall

+ type MockIAddressUpdateCall struct

+ func (c *MockIAddressUpdateCall) Do(f func(context.Context, *storage.Address) error) *MockIAddressUpdateCall

+ func (c *MockIAddressUpdateCall) DoAndReturn(f func(context.Context, *storage.Address) error) *MockIAddressUpdateCall

+ func (c *MockIAddressUpdateCall) Return(arg0 error) *MockIAddressUpdateCall

type MockIBalance

+ func (m *MockIBalance) ISGOMOCK() struct{}

+ type MockIBalanceCursorListCall struct

+ func (c *MockIBalanceCursorListCall) Do(...) *MockIBalanceCursorListCall

+ func (c *MockIBalanceCursorListCall) DoAndReturn(...) *MockIBalanceCursorListCall

+ func (c *MockIBalanceCursorListCall) Return(arg0 []*storage.Balance, arg1 error) *MockIBalanceCursorListCall

+ type MockIBalanceGetByIDCall struct

+ func (c *MockIBalanceGetByIDCall) Do(f func(context.Context, uint64) (*storage.Balance, error)) *MockIBalanceGetByIDCall

+ func (c *MockIBalanceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Balance, error)) *MockIBalanceGetByIDCall

+ func (c *MockIBalanceGetByIDCall) Return(arg0 *storage.Balance, arg1 error) *MockIBalanceGetByIDCall

+ type MockIBalanceIsNoRowsCall struct

+ func (c *MockIBalanceIsNoRowsCall) Do(f func(error) bool) *MockIBalanceIsNoRowsCall

+ func (c *MockIBalanceIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIBalanceIsNoRowsCall

+ func (c *MockIBalanceIsNoRowsCall) Return(arg0 bool) *MockIBalanceIsNoRowsCall

+ type MockIBalanceLastIDCall struct

+ func (c *MockIBalanceLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIBalanceLastIDCall

+ func (c *MockIBalanceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIBalanceLastIDCall

+ func (c *MockIBalanceLastIDCall) Return(arg0 uint64, arg1 error) *MockIBalanceLastIDCall

+ type MockIBalanceListCall struct

+ func (c *MockIBalanceListCall) Do(...) *MockIBalanceListCall

+ func (c *MockIBalanceListCall) DoAndReturn(...) *MockIBalanceListCall

+ func (c *MockIBalanceListCall) Return(arg0 []*storage.Balance, arg1 error) *MockIBalanceListCall

+ type MockIBalanceSaveCall struct

+ func (c *MockIBalanceSaveCall) Do(f func(context.Context, *storage.Balance) error) *MockIBalanceSaveCall

+ func (c *MockIBalanceSaveCall) DoAndReturn(f func(context.Context, *storage.Balance) error) *MockIBalanceSaveCall

+ func (c *MockIBalanceSaveCall) Return(arg0 error) *MockIBalanceSaveCall

+ type MockIBalanceUpdateCall struct

+ func (c *MockIBalanceUpdateCall) Do(f func(context.Context, *storage.Balance) error) *MockIBalanceUpdateCall

+ func (c *MockIBalanceUpdateCall) DoAndReturn(f func(context.Context, *storage.Balance) error) *MockIBalanceUpdateCall

+ func (c *MockIBalanceUpdateCall) Return(arg0 error) *MockIBalanceUpdateCall

type MockIBlobLog

+ func (m *MockIBlobLog) ISGOMOCK() struct{}

+ type MockIBlobLogBlobCall struct

+ func (c *MockIBlobLogBlobCall) Do(f func(context.Context, types.Level, uint64, string) (storage.BlobLog, error)) *MockIBlobLogBlobCall

+ func (c *MockIBlobLogBlobCall) DoAndReturn(f func(context.Context, types.Level, uint64, string) (storage.BlobLog, error)) *MockIBlobLogBlobCall

+ func (c *MockIBlobLogBlobCall) Return(arg0 storage.BlobLog, arg1 error) *MockIBlobLogBlobCall

+ type MockIBlobLogByHeightCall struct

+ func (c *MockIBlobLogByHeightCall) Do(...) *MockIBlobLogByHeightCall

+ func (c *MockIBlobLogByHeightCall) DoAndReturn(...) *MockIBlobLogByHeightCall

+ func (c *MockIBlobLogByHeightCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogByHeightCall

+ type MockIBlobLogByNamespaceCall struct

+ func (c *MockIBlobLogByNamespaceCall) Do(...) *MockIBlobLogByNamespaceCall

+ func (c *MockIBlobLogByNamespaceCall) DoAndReturn(...) *MockIBlobLogByNamespaceCall

+ func (c *MockIBlobLogByNamespaceCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogByNamespaceCall

+ type MockIBlobLogByProvidersCall struct

+ func (c *MockIBlobLogByProvidersCall) Do(...) *MockIBlobLogByProvidersCall

+ func (c *MockIBlobLogByProvidersCall) DoAndReturn(...) *MockIBlobLogByProvidersCall

+ func (c *MockIBlobLogByProvidersCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogByProvidersCall

+ type MockIBlobLogBySignerCall struct

+ func (c *MockIBlobLogBySignerCall) Do(...) *MockIBlobLogBySignerCall

+ func (c *MockIBlobLogBySignerCall) DoAndReturn(...) *MockIBlobLogBySignerCall

+ func (c *MockIBlobLogBySignerCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogBySignerCall

+ type MockIBlobLogByTxIdCall struct

+ func (c *MockIBlobLogByTxIdCall) Do(...) *MockIBlobLogByTxIdCall

+ func (c *MockIBlobLogByTxIdCall) DoAndReturn(...) *MockIBlobLogByTxIdCall

+ func (c *MockIBlobLogByTxIdCall) Return(arg0 []storage.BlobLog, arg1 error) *MockIBlobLogByTxIdCall

+ type MockIBlobLogCountByHeightCall struct

+ func (c *MockIBlobLogCountByHeightCall) Do(f func(context.Context, types.Level) (int, error)) *MockIBlobLogCountByHeightCall

+ func (c *MockIBlobLogCountByHeightCall) DoAndReturn(f func(context.Context, types.Level) (int, error)) *MockIBlobLogCountByHeightCall

+ func (c *MockIBlobLogCountByHeightCall) Return(arg0 int, arg1 error) *MockIBlobLogCountByHeightCall

+ type MockIBlobLogCountByTxIdCall struct

+ func (c *MockIBlobLogCountByTxIdCall) Do(f func(context.Context, uint64) (int, error)) *MockIBlobLogCountByTxIdCall

+ func (c *MockIBlobLogCountByTxIdCall) DoAndReturn(f func(context.Context, uint64) (int, error)) *MockIBlobLogCountByTxIdCall

+ func (c *MockIBlobLogCountByTxIdCall) Return(arg0 int, arg1 error) *MockIBlobLogCountByTxIdCall

+ type MockIBlobLogCursorListCall struct

+ func (c *MockIBlobLogCursorListCall) Do(...) *MockIBlobLogCursorListCall

+ func (c *MockIBlobLogCursorListCall) DoAndReturn(...) *MockIBlobLogCursorListCall

+ func (c *MockIBlobLogCursorListCall) Return(arg0 []*storage.BlobLog, arg1 error) *MockIBlobLogCursorListCall

+ type MockIBlobLogExportByProvidersCall struct

+ func (c *MockIBlobLogExportByProvidersCall) Do(...) *MockIBlobLogExportByProvidersCall

+ func (c *MockIBlobLogExportByProvidersCall) DoAndReturn(...) *MockIBlobLogExportByProvidersCall

+ func (c *MockIBlobLogExportByProvidersCall) Return(err error) *MockIBlobLogExportByProvidersCall

+ type MockIBlobLogGetByIDCall struct

+ func (c *MockIBlobLogGetByIDCall) Do(f func(context.Context, uint64) (*storage.BlobLog, error)) *MockIBlobLogGetByIDCall

+ func (c *MockIBlobLogGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.BlobLog, error)) *MockIBlobLogGetByIDCall

+ func (c *MockIBlobLogGetByIDCall) Return(arg0 *storage.BlobLog, arg1 error) *MockIBlobLogGetByIDCall

+ type MockIBlobLogIsNoRowsCall struct

+ func (c *MockIBlobLogIsNoRowsCall) Do(f func(error) bool) *MockIBlobLogIsNoRowsCall

+ func (c *MockIBlobLogIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIBlobLogIsNoRowsCall

+ func (c *MockIBlobLogIsNoRowsCall) Return(arg0 bool) *MockIBlobLogIsNoRowsCall

+ type MockIBlobLogLastIDCall struct

+ func (c *MockIBlobLogLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIBlobLogLastIDCall

+ func (c *MockIBlobLogLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIBlobLogLastIDCall

+ func (c *MockIBlobLogLastIDCall) Return(arg0 uint64, arg1 error) *MockIBlobLogLastIDCall

+ type MockIBlobLogListCall struct

+ func (c *MockIBlobLogListCall) Do(...) *MockIBlobLogListCall

+ func (c *MockIBlobLogListCall) DoAndReturn(...) *MockIBlobLogListCall

+ func (c *MockIBlobLogListCall) Return(arg0 []*storage.BlobLog, arg1 error) *MockIBlobLogListCall

+ type MockIBlobLogSaveCall struct

+ func (c *MockIBlobLogSaveCall) Do(f func(context.Context, *storage.BlobLog) error) *MockIBlobLogSaveCall

+ func (c *MockIBlobLogSaveCall) DoAndReturn(f func(context.Context, *storage.BlobLog) error) *MockIBlobLogSaveCall

+ func (c *MockIBlobLogSaveCall) Return(arg0 error) *MockIBlobLogSaveCall

+ type MockIBlobLogUpdateCall struct

+ func (c *MockIBlobLogUpdateCall) Do(f func(context.Context, *storage.BlobLog) error) *MockIBlobLogUpdateCall

+ func (c *MockIBlobLogUpdateCall) DoAndReturn(f func(context.Context, *storage.BlobLog) error) *MockIBlobLogUpdateCall

+ func (c *MockIBlobLogUpdateCall) Return(arg0 error) *MockIBlobLogUpdateCall

type MockIBlock

+ func (m *MockIBlock) ISGOMOCK() struct{}

+ type MockIBlockByHashCall struct

+ func (c *MockIBlockByHashCall) Do(f func(context.Context, []byte) (storage.Block, error)) *MockIBlockByHashCall

+ func (c *MockIBlockByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Block, error)) *MockIBlockByHashCall

+ func (c *MockIBlockByHashCall) Return(arg0 storage.Block, arg1 error) *MockIBlockByHashCall

+ type MockIBlockByHeightCall struct

+ func (c *MockIBlockByHeightCall) Do(f func(context.Context, types.Level) (storage.Block, error)) *MockIBlockByHeightCall

+ func (c *MockIBlockByHeightCall) DoAndReturn(f func(context.Context, types.Level) (storage.Block, error)) *MockIBlockByHeightCall

+ func (c *MockIBlockByHeightCall) Return(arg0 storage.Block, arg1 error) *MockIBlockByHeightCall

+ type MockIBlockByHeightWithStatsCall struct

+ func (c *MockIBlockByHeightWithStatsCall) Do(f func(context.Context, types.Level) (storage.Block, error)) *MockIBlockByHeightWithStatsCall

+ func (c *MockIBlockByHeightWithStatsCall) DoAndReturn(f func(context.Context, types.Level) (storage.Block, error)) *MockIBlockByHeightWithStatsCall

+ func (c *MockIBlockByHeightWithStatsCall) Return(arg0 storage.Block, arg1 error) *MockIBlockByHeightWithStatsCall

+ type MockIBlockByIdWithRelationsCall struct

+ func (c *MockIBlockByIdWithRelationsCall) Do(f func(context.Context, uint64) (storage.Block, error)) *MockIBlockByIdWithRelationsCall

+ func (c *MockIBlockByIdWithRelationsCall) DoAndReturn(f func(context.Context, uint64) (storage.Block, error)) *MockIBlockByIdWithRelationsCall

+ func (c *MockIBlockByIdWithRelationsCall) Return(arg0 storage.Block, arg1 error) *MockIBlockByIdWithRelationsCall

+ type MockIBlockByProposerCall struct

+ func (c *MockIBlockByProposerCall) Do(f func(context.Context, uint64, int, int) ([]storage.Block, error)) *MockIBlockByProposerCall

+ func (c *MockIBlockByProposerCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Block, error)) *MockIBlockByProposerCall

+ func (c *MockIBlockByProposerCall) Return(arg0 []storage.Block, arg1 error) *MockIBlockByProposerCall

+ type MockIBlockCursorListCall struct

+ func (c *MockIBlockCursorListCall) Do(...) *MockIBlockCursorListCall

+ func (c *MockIBlockCursorListCall) DoAndReturn(...) *MockIBlockCursorListCall

+ func (c *MockIBlockCursorListCall) Return(arg0 []*storage.Block, arg1 error) *MockIBlockCursorListCall

+ type MockIBlockGetByIDCall struct

+ func (c *MockIBlockGetByIDCall) Do(f func(context.Context, uint64) (*storage.Block, error)) *MockIBlockGetByIDCall

+ func (c *MockIBlockGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Block, error)) *MockIBlockGetByIDCall

+ func (c *MockIBlockGetByIDCall) Return(arg0 *storage.Block, arg1 error) *MockIBlockGetByIDCall

+ type MockIBlockIsNoRowsCall struct

+ func (c *MockIBlockIsNoRowsCall) Do(f func(error) bool) *MockIBlockIsNoRowsCall

+ func (c *MockIBlockIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIBlockIsNoRowsCall

+ func (c *MockIBlockIsNoRowsCall) Return(arg0 bool) *MockIBlockIsNoRowsCall

+ type MockIBlockLastCall struct

+ func (c *MockIBlockLastCall) Do(f func(context.Context) (storage.Block, error)) *MockIBlockLastCall

+ func (c *MockIBlockLastCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *MockIBlockLastCall

+ func (c *MockIBlockLastCall) Return(arg0 storage.Block, arg1 error) *MockIBlockLastCall

+ type MockIBlockLastIDCall struct

+ func (c *MockIBlockLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIBlockLastIDCall

+ func (c *MockIBlockLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIBlockLastIDCall

+ func (c *MockIBlockLastIDCall) Return(arg0 uint64, arg1 error) *MockIBlockLastIDCall

+ type MockIBlockListCall struct

+ func (c *MockIBlockListCall) Do(...) *MockIBlockListCall

+ func (c *MockIBlockListCall) DoAndReturn(...) *MockIBlockListCall

+ func (c *MockIBlockListCall) Return(arg0 []*storage.Block, arg1 error) *MockIBlockListCall

+ type MockIBlockListWithStatsCall struct

+ func (c *MockIBlockListWithStatsCall) Do(...) *MockIBlockListWithStatsCall

+ func (c *MockIBlockListWithStatsCall) DoAndReturn(...) *MockIBlockListWithStatsCall

+ func (c *MockIBlockListWithStatsCall) Return(arg0 []*storage.Block, arg1 error) *MockIBlockListWithStatsCall

+ type MockIBlockSaveCall struct

+ func (c *MockIBlockSaveCall) Do(f func(context.Context, *storage.Block) error) *MockIBlockSaveCall

+ func (c *MockIBlockSaveCall) DoAndReturn(f func(context.Context, *storage.Block) error) *MockIBlockSaveCall

+ func (c *MockIBlockSaveCall) Return(arg0 error) *MockIBlockSaveCall

type MockIBlockSignature

+ func (m *MockIBlockSignature) ISGOMOCK() struct{}

+ type MockIBlockSignatureCursorListCall struct

+ func (c *MockIBlockSignatureCursorListCall) Do(...) *MockIBlockSignatureCursorListCall

+ func (c *MockIBlockSignatureCursorListCall) DoAndReturn(...) *MockIBlockSignatureCursorListCall

+ func (c *MockIBlockSignatureCursorListCall) Return(arg0 []*storage.BlockSignature, arg1 error) *MockIBlockSignatureCursorListCall

+ type MockIBlockSignatureGetByIDCall struct

+ func (c *MockIBlockSignatureGetByIDCall) Do(f func(context.Context, uint64) (*storage.BlockSignature, error)) *MockIBlockSignatureGetByIDCall

+ func (c *MockIBlockSignatureGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.BlockSignature, error)) *MockIBlockSignatureGetByIDCall

+ func (c *MockIBlockSignatureGetByIDCall) Return(arg0 *storage.BlockSignature, arg1 error) *MockIBlockSignatureGetByIDCall

+ type MockIBlockSignatureIsNoRowsCall struct

+ func (c *MockIBlockSignatureIsNoRowsCall) Do(f func(error) bool) *MockIBlockSignatureIsNoRowsCall

+ func (c *MockIBlockSignatureIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIBlockSignatureIsNoRowsCall

+ func (c *MockIBlockSignatureIsNoRowsCall) Return(arg0 bool) *MockIBlockSignatureIsNoRowsCall

+ type MockIBlockSignatureLastIDCall struct

+ func (c *MockIBlockSignatureLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIBlockSignatureLastIDCall

+ func (c *MockIBlockSignatureLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIBlockSignatureLastIDCall

+ func (c *MockIBlockSignatureLastIDCall) Return(arg0 uint64, arg1 error) *MockIBlockSignatureLastIDCall

+ type MockIBlockSignatureLevelsByValidatorCall struct

+ func (c *MockIBlockSignatureLevelsByValidatorCall) Do(f func(context.Context, uint64, types.Level) ([]types.Level, error)) *MockIBlockSignatureLevelsByValidatorCall

+ func (c *MockIBlockSignatureLevelsByValidatorCall) DoAndReturn(f func(context.Context, uint64, types.Level) ([]types.Level, error)) *MockIBlockSignatureLevelsByValidatorCall

+ func (c *MockIBlockSignatureLevelsByValidatorCall) Return(arg0 []types.Level, arg1 error) *MockIBlockSignatureLevelsByValidatorCall

+ type MockIBlockSignatureListCall struct

+ func (c *MockIBlockSignatureListCall) Do(...) *MockIBlockSignatureListCall

+ func (c *MockIBlockSignatureListCall) DoAndReturn(...) *MockIBlockSignatureListCall

+ func (c *MockIBlockSignatureListCall) Return(arg0 []*storage.BlockSignature, arg1 error) *MockIBlockSignatureListCall

+ type MockIBlockSignatureSaveCall struct

+ func (c *MockIBlockSignatureSaveCall) Do(f func(context.Context, *storage.BlockSignature) error) *MockIBlockSignatureSaveCall

+ func (c *MockIBlockSignatureSaveCall) DoAndReturn(f func(context.Context, *storage.BlockSignature) error) *MockIBlockSignatureSaveCall

+ func (c *MockIBlockSignatureSaveCall) Return(arg0 error) *MockIBlockSignatureSaveCall

+ type MockIBlockSignatureUpdateCall struct

+ func (c *MockIBlockSignatureUpdateCall) Do(f func(context.Context, *storage.BlockSignature) error) *MockIBlockSignatureUpdateCall

+ func (c *MockIBlockSignatureUpdateCall) DoAndReturn(f func(context.Context, *storage.BlockSignature) error) *MockIBlockSignatureUpdateCall

+ func (c *MockIBlockSignatureUpdateCall) Return(arg0 error) *MockIBlockSignatureUpdateCall

type MockIBlockStats

+ func (m *MockIBlockStats) ISGOMOCK() struct{}

+ type MockIBlockStatsByHeightCall struct

+ func (c *MockIBlockStatsByHeightCall) Do(f func(context.Context, types.Level) (storage.BlockStats, error)) *MockIBlockStatsByHeightCall

+ func (c *MockIBlockStatsByHeightCall) DoAndReturn(f func(context.Context, types.Level) (storage.BlockStats, error)) *MockIBlockStatsByHeightCall

+ func (c *MockIBlockStatsByHeightCall) Return(arg0 storage.BlockStats, arg1 error) *MockIBlockStatsByHeightCall

+ type MockIBlockStatsLastFromCall struct

+ func (c *MockIBlockStatsLastFromCall) Do(f func(context.Context, types.Level, int) ([]storage.BlockStats, error)) *MockIBlockStatsLastFromCall

+ func (c *MockIBlockStatsLastFromCall) DoAndReturn(f func(context.Context, types.Level, int) ([]storage.BlockStats, error)) *MockIBlockStatsLastFromCall

+ func (c *MockIBlockStatsLastFromCall) Return(arg0 []storage.BlockStats, arg1 error) *MockIBlockStatsLastFromCall

+ type MockIBlockTimeCall struct

+ func (c *MockIBlockTimeCall) Do(f func(context.Context, types.Level) (time.Time, error)) *MockIBlockTimeCall

+ func (c *MockIBlockTimeCall) DoAndReturn(f func(context.Context, types.Level) (time.Time, error)) *MockIBlockTimeCall

+ func (c *MockIBlockTimeCall) Return(arg0 time.Time, arg1 error) *MockIBlockTimeCall

+ type MockIBlockUpdateCall struct

+ func (c *MockIBlockUpdateCall) Do(f func(context.Context, *storage.Block) error) *MockIBlockUpdateCall

+ func (c *MockIBlockUpdateCall) DoAndReturn(f func(context.Context, *storage.Block) error) *MockIBlockUpdateCall

+ func (c *MockIBlockUpdateCall) Return(arg0 error) *MockIBlockUpdateCall

type MockIConstant

+ func (m *MockIConstant) ISGOMOCK() struct{}

+ type MockIConstantAllCall struct

+ func (c *MockIConstantAllCall) Do(f func(context.Context) ([]storage.Constant, error)) *MockIConstantAllCall

+ func (c *MockIConstantAllCall) DoAndReturn(f func(context.Context) ([]storage.Constant, error)) *MockIConstantAllCall

+ func (c *MockIConstantAllCall) Return(arg0 []storage.Constant, arg1 error) *MockIConstantAllCall

+ type MockIConstantByModuleCall struct

+ func (c *MockIConstantByModuleCall) Do(f func(context.Context, types.ModuleName) ([]storage.Constant, error)) *MockIConstantByModuleCall

+ func (c *MockIConstantByModuleCall) DoAndReturn(f func(context.Context, types.ModuleName) ([]storage.Constant, error)) *MockIConstantByModuleCall

+ func (c *MockIConstantByModuleCall) Return(arg0 []storage.Constant, arg1 error) *MockIConstantByModuleCall

+ type MockIConstantGetCall struct

+ func (c *MockIConstantGetCall) Do(f func(context.Context, types.ModuleName, string) (storage.Constant, error)) *MockIConstantGetCall

+ func (c *MockIConstantGetCall) DoAndReturn(f func(context.Context, types.ModuleName, string) (storage.Constant, error)) *MockIConstantGetCall

+ func (c *MockIConstantGetCall) Return(arg0 storage.Constant, arg1 error) *MockIConstantGetCall

type MockIDelegation

+ func (m *MockIDelegation) ISGOMOCK() struct{}

+ type MockIDelegationByAddressCall struct

+ func (c *MockIDelegationByAddressCall) Do(f func(context.Context, uint64, int, int, bool) ([]storage.Delegation, error)) *MockIDelegationByAddressCall

+ func (c *MockIDelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int, bool) ([]storage.Delegation, error)) *MockIDelegationByAddressCall

+ func (c *MockIDelegationByAddressCall) Return(arg0 []storage.Delegation, arg1 error) *MockIDelegationByAddressCall

+ type MockIDelegationByValidatorCall struct

+ func (c *MockIDelegationByValidatorCall) Do(f func(context.Context, uint64, int, int, bool) ([]storage.Delegation, error)) *MockIDelegationByValidatorCall

+ func (c *MockIDelegationByValidatorCall) DoAndReturn(f func(context.Context, uint64, int, int, bool) ([]storage.Delegation, error)) *MockIDelegationByValidatorCall

+ func (c *MockIDelegationByValidatorCall) Return(arg0 []storage.Delegation, arg1 error) *MockIDelegationByValidatorCall

+ type MockIDelegationCursorListCall struct

+ func (c *MockIDelegationCursorListCall) Do(...) *MockIDelegationCursorListCall

+ func (c *MockIDelegationCursorListCall) DoAndReturn(...) *MockIDelegationCursorListCall

+ func (c *MockIDelegationCursorListCall) Return(arg0 []*storage.Delegation, arg1 error) *MockIDelegationCursorListCall

+ type MockIDelegationGetByIDCall struct

+ func (c *MockIDelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Delegation, error)) *MockIDelegationGetByIDCall

+ func (c *MockIDelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Delegation, error)) *MockIDelegationGetByIDCall

+ func (c *MockIDelegationGetByIDCall) Return(arg0 *storage.Delegation, arg1 error) *MockIDelegationGetByIDCall

+ type MockIDelegationIsNoRowsCall struct

+ func (c *MockIDelegationIsNoRowsCall) Do(f func(error) bool) *MockIDelegationIsNoRowsCall

+ func (c *MockIDelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIDelegationIsNoRowsCall

+ func (c *MockIDelegationIsNoRowsCall) Return(arg0 bool) *MockIDelegationIsNoRowsCall

+ type MockIDelegationLastIDCall struct

+ func (c *MockIDelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIDelegationLastIDCall

+ func (c *MockIDelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIDelegationLastIDCall

+ func (c *MockIDelegationLastIDCall) Return(arg0 uint64, arg1 error) *MockIDelegationLastIDCall

+ type MockIDelegationListCall struct

+ func (c *MockIDelegationListCall) Do(...) *MockIDelegationListCall

+ func (c *MockIDelegationListCall) DoAndReturn(...) *MockIDelegationListCall

+ func (c *MockIDelegationListCall) Return(arg0 []*storage.Delegation, arg1 error) *MockIDelegationListCall

+ type MockIDelegationSaveCall struct

+ func (c *MockIDelegationSaveCall) Do(f func(context.Context, *storage.Delegation) error) *MockIDelegationSaveCall

+ func (c *MockIDelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Delegation) error) *MockIDelegationSaveCall

+ func (c *MockIDelegationSaveCall) Return(arg0 error) *MockIDelegationSaveCall

+ type MockIDelegationUpdateCall struct

+ func (c *MockIDelegationUpdateCall) Do(f func(context.Context, *storage.Delegation) error) *MockIDelegationUpdateCall

+ func (c *MockIDelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Delegation) error) *MockIDelegationUpdateCall

+ func (c *MockIDelegationUpdateCall) Return(arg0 error) *MockIDelegationUpdateCall

type MockIDenomMetadata

+ func (m *MockIDenomMetadata) ISGOMOCK() struct{}

+ type MockIDenomMetadataAllCall struct

+ func (c *MockIDenomMetadataAllCall) Do(f func(context.Context) ([]storage.DenomMetadata, error)) *MockIDenomMetadataAllCall

+ func (c *MockIDenomMetadataAllCall) DoAndReturn(f func(context.Context) ([]storage.DenomMetadata, error)) *MockIDenomMetadataAllCall

+ func (c *MockIDenomMetadataAllCall) Return(arg0 []storage.DenomMetadata, arg1 error) *MockIDenomMetadataAllCall

type MockIEvent

+ func (m *MockIEvent) ISGOMOCK() struct{}

+ type MockIEventByBlockCall struct

+ func (c *MockIEventByBlockCall) Do(...) *MockIEventByBlockCall

+ func (c *MockIEventByBlockCall) DoAndReturn(...) *MockIEventByBlockCall

+ func (c *MockIEventByBlockCall) Return(arg0 []storage.Event, arg1 error) *MockIEventByBlockCall

+ type MockIEventByTxIdCall struct

+ func (c *MockIEventByTxIdCall) Do(f func(context.Context, uint64, storage.EventFilter) ([]storage.Event, error)) *MockIEventByTxIdCall

+ func (c *MockIEventByTxIdCall) DoAndReturn(f func(context.Context, uint64, storage.EventFilter) ([]storage.Event, error)) *MockIEventByTxIdCall

+ func (c *MockIEventByTxIdCall) Return(arg0 []storage.Event, arg1 error) *MockIEventByTxIdCall

+ type MockIEventCursorListCall struct

+ func (c *MockIEventCursorListCall) Do(...) *MockIEventCursorListCall

+ func (c *MockIEventCursorListCall) DoAndReturn(...) *MockIEventCursorListCall

+ func (c *MockIEventCursorListCall) Return(arg0 []*storage.Event, arg1 error) *MockIEventCursorListCall

+ type MockIEventGetByIDCall struct

+ func (c *MockIEventGetByIDCall) Do(f func(context.Context, uint64) (*storage.Event, error)) *MockIEventGetByIDCall

+ func (c *MockIEventGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Event, error)) *MockIEventGetByIDCall

+ func (c *MockIEventGetByIDCall) Return(arg0 *storage.Event, arg1 error) *MockIEventGetByIDCall

+ type MockIEventIsNoRowsCall struct

+ func (c *MockIEventIsNoRowsCall) Do(f func(error) bool) *MockIEventIsNoRowsCall

+ func (c *MockIEventIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIEventIsNoRowsCall

+ func (c *MockIEventIsNoRowsCall) Return(arg0 bool) *MockIEventIsNoRowsCall

+ type MockIEventLastIDCall struct

+ func (c *MockIEventLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIEventLastIDCall

+ func (c *MockIEventLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIEventLastIDCall

+ func (c *MockIEventLastIDCall) Return(arg0 uint64, arg1 error) *MockIEventLastIDCall

+ type MockIEventListCall struct

+ func (c *MockIEventListCall) Do(...) *MockIEventListCall

+ func (c *MockIEventListCall) DoAndReturn(...) *MockIEventListCall

+ func (c *MockIEventListCall) Return(arg0 []*storage.Event, arg1 error) *MockIEventListCall

+ type MockIEventSaveCall struct

+ func (c *MockIEventSaveCall) Do(f func(context.Context, *storage.Event) error) *MockIEventSaveCall

+ func (c *MockIEventSaveCall) DoAndReturn(f func(context.Context, *storage.Event) error) *MockIEventSaveCall

+ func (c *MockIEventSaveCall) Return(arg0 error) *MockIEventSaveCall

+ type MockIEventUpdateCall struct

+ func (c *MockIEventUpdateCall) Do(f func(context.Context, *storage.Event) error) *MockIEventUpdateCall

+ func (c *MockIEventUpdateCall) DoAndReturn(f func(context.Context, *storage.Event) error) *MockIEventUpdateCall

+ func (c *MockIEventUpdateCall) Return(arg0 error) *MockIEventUpdateCall

type MockIGrant

+ func (m *MockIGrant) ISGOMOCK() struct{}

+ type MockIGrantByGranteeCall struct

+ func (c *MockIGrantByGranteeCall) Do(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *MockIGrantByGranteeCall

+ func (c *MockIGrantByGranteeCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *MockIGrantByGranteeCall

+ func (c *MockIGrantByGranteeCall) Return(arg0 []storage.Grant, arg1 error) *MockIGrantByGranteeCall

+ type MockIGrantByGranterCall struct

+ func (c *MockIGrantByGranterCall) Do(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *MockIGrantByGranterCall

+ func (c *MockIGrantByGranterCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *MockIGrantByGranterCall

+ func (c *MockIGrantByGranterCall) Return(arg0 []storage.Grant, arg1 error) *MockIGrantByGranterCall

+ type MockIGrantCursorListCall struct

+ func (c *MockIGrantCursorListCall) Do(...) *MockIGrantCursorListCall

+ func (c *MockIGrantCursorListCall) DoAndReturn(...) *MockIGrantCursorListCall

+ func (c *MockIGrantCursorListCall) Return(arg0 []*storage.Grant, arg1 error) *MockIGrantCursorListCall

+ type MockIGrantGetByIDCall struct

+ func (c *MockIGrantGetByIDCall) Do(f func(context.Context, uint64) (*storage.Grant, error)) *MockIGrantGetByIDCall

+ func (c *MockIGrantGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Grant, error)) *MockIGrantGetByIDCall

+ func (c *MockIGrantGetByIDCall) Return(arg0 *storage.Grant, arg1 error) *MockIGrantGetByIDCall

+ type MockIGrantIsNoRowsCall struct

+ func (c *MockIGrantIsNoRowsCall) Do(f func(error) bool) *MockIGrantIsNoRowsCall

+ func (c *MockIGrantIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIGrantIsNoRowsCall

+ func (c *MockIGrantIsNoRowsCall) Return(arg0 bool) *MockIGrantIsNoRowsCall

+ type MockIGrantLastIDCall struct

+ func (c *MockIGrantLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIGrantLastIDCall

+ func (c *MockIGrantLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIGrantLastIDCall

+ func (c *MockIGrantLastIDCall) Return(arg0 uint64, arg1 error) *MockIGrantLastIDCall

+ type MockIGrantListCall struct

+ func (c *MockIGrantListCall) Do(...) *MockIGrantListCall

+ func (c *MockIGrantListCall) DoAndReturn(...) *MockIGrantListCall

+ func (c *MockIGrantListCall) Return(arg0 []*storage.Grant, arg1 error) *MockIGrantListCall

+ type MockIGrantSaveCall struct

+ func (c *MockIGrantSaveCall) Do(f func(context.Context, *storage.Grant) error) *MockIGrantSaveCall

+ func (c *MockIGrantSaveCall) DoAndReturn(f func(context.Context, *storage.Grant) error) *MockIGrantSaveCall

+ func (c *MockIGrantSaveCall) Return(arg0 error) *MockIGrantSaveCall

+ type MockIGrantUpdateCall struct

+ func (c *MockIGrantUpdateCall) Do(f func(context.Context, *storage.Grant) error) *MockIGrantUpdateCall

+ func (c *MockIGrantUpdateCall) DoAndReturn(f func(context.Context, *storage.Grant) error) *MockIGrantUpdateCall

+ func (c *MockIGrantUpdateCall) Return(arg0 error) *MockIGrantUpdateCall

type MockIJail

+ func (m *MockIJail) ISGOMOCK() struct{}

+ type MockIJailByValidatorCall struct

+ func (c *MockIJailByValidatorCall) Do(f func(context.Context, uint64, int, int) ([]storage.Jail, error)) *MockIJailByValidatorCall

+ func (c *MockIJailByValidatorCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Jail, error)) *MockIJailByValidatorCall

+ func (c *MockIJailByValidatorCall) Return(arg0 []storage.Jail, arg1 error) *MockIJailByValidatorCall

+ type MockIJailCursorListCall struct

+ func (c *MockIJailCursorListCall) Do(...) *MockIJailCursorListCall

+ func (c *MockIJailCursorListCall) DoAndReturn(...) *MockIJailCursorListCall

+ func (c *MockIJailCursorListCall) Return(arg0 []*storage.Jail, arg1 error) *MockIJailCursorListCall

+ type MockIJailGetByIDCall struct

+ func (c *MockIJailGetByIDCall) Do(f func(context.Context, uint64) (*storage.Jail, error)) *MockIJailGetByIDCall

+ func (c *MockIJailGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Jail, error)) *MockIJailGetByIDCall

+ func (c *MockIJailGetByIDCall) Return(arg0 *storage.Jail, arg1 error) *MockIJailGetByIDCall

+ type MockIJailIsNoRowsCall struct

+ func (c *MockIJailIsNoRowsCall) Do(f func(error) bool) *MockIJailIsNoRowsCall

+ func (c *MockIJailIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIJailIsNoRowsCall

+ func (c *MockIJailIsNoRowsCall) Return(arg0 bool) *MockIJailIsNoRowsCall

+ type MockIJailLastIDCall struct

+ func (c *MockIJailLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIJailLastIDCall

+ func (c *MockIJailLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIJailLastIDCall

+ func (c *MockIJailLastIDCall) Return(arg0 uint64, arg1 error) *MockIJailLastIDCall

+ type MockIJailListCall struct

+ func (c *MockIJailListCall) Do(...) *MockIJailListCall

+ func (c *MockIJailListCall) DoAndReturn(...) *MockIJailListCall

+ func (c *MockIJailListCall) Return(arg0 []*storage.Jail, arg1 error) *MockIJailListCall

+ type MockIJailSaveCall struct

+ func (c *MockIJailSaveCall) Do(f func(context.Context, *storage.Jail) error) *MockIJailSaveCall

+ func (c *MockIJailSaveCall) DoAndReturn(f func(context.Context, *storage.Jail) error) *MockIJailSaveCall

+ func (c *MockIJailSaveCall) Return(arg0 error) *MockIJailSaveCall

+ type MockIJailUpdateCall struct

+ func (c *MockIJailUpdateCall) Do(f func(context.Context, *storage.Jail) error) *MockIJailUpdateCall

+ func (c *MockIJailUpdateCall) DoAndReturn(f func(context.Context, *storage.Jail) error) *MockIJailUpdateCall

+ func (c *MockIJailUpdateCall) Return(arg0 error) *MockIJailUpdateCall

type MockIMessage

+ func (m *MockIMessage) ISGOMOCK() struct{}

+ type MockIMessageByAddressCall struct

+ func (c *MockIMessageByAddressCall) Do(...) *MockIMessageByAddressCall

+ func (c *MockIMessageByAddressCall) DoAndReturn(...) *MockIMessageByAddressCall

+ func (c *MockIMessageByAddressCall) Return(arg0 []storage.AddressMessageWithTx, arg1 error) *MockIMessageByAddressCall

+ type MockIMessageByTxIdCall struct

+ func (c *MockIMessageByTxIdCall) Do(f func(context.Context, uint64, int, int) ([]storage.Message, error)) *MockIMessageByTxIdCall

+ func (c *MockIMessageByTxIdCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Message, error)) *MockIMessageByTxIdCall

+ func (c *MockIMessageByTxIdCall) Return(arg0 []storage.Message, arg1 error) *MockIMessageByTxIdCall

+ type MockIMessageCursorListCall struct

+ func (c *MockIMessageCursorListCall) Do(...) *MockIMessageCursorListCall

+ func (c *MockIMessageCursorListCall) DoAndReturn(...) *MockIMessageCursorListCall

+ func (c *MockIMessageCursorListCall) Return(arg0 []*storage.Message, arg1 error) *MockIMessageCursorListCall

+ type MockIMessageGetByIDCall struct

+ func (c *MockIMessageGetByIDCall) Do(f func(context.Context, uint64) (*storage.Message, error)) *MockIMessageGetByIDCall

+ func (c *MockIMessageGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Message, error)) *MockIMessageGetByIDCall

+ func (c *MockIMessageGetByIDCall) Return(arg0 *storage.Message, arg1 error) *MockIMessageGetByIDCall

+ type MockIMessageIsNoRowsCall struct

+ func (c *MockIMessageIsNoRowsCall) Do(f func(error) bool) *MockIMessageIsNoRowsCall

+ func (c *MockIMessageIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIMessageIsNoRowsCall

+ func (c *MockIMessageIsNoRowsCall) Return(arg0 bool) *MockIMessageIsNoRowsCall

+ type MockIMessageLastIDCall struct

+ func (c *MockIMessageLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIMessageLastIDCall

+ func (c *MockIMessageLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIMessageLastIDCall

+ func (c *MockIMessageLastIDCall) Return(arg0 uint64, arg1 error) *MockIMessageLastIDCall

+ type MockIMessageListCall struct

+ func (c *MockIMessageListCall) Do(...) *MockIMessageListCall

+ func (c *MockIMessageListCall) DoAndReturn(...) *MockIMessageListCall

+ func (c *MockIMessageListCall) Return(arg0 []*storage.Message, arg1 error) *MockIMessageListCall

+ type MockIMessageListWithTxCall struct

+ func (c *MockIMessageListWithTxCall) Do(...) *MockIMessageListWithTxCall

+ func (c *MockIMessageListWithTxCall) DoAndReturn(...) *MockIMessageListWithTxCall

+ func (c *MockIMessageListWithTxCall) Return(arg0 []storage.MessageWithTx, arg1 error) *MockIMessageListWithTxCall

+ type MockIMessageSaveCall struct

+ func (c *MockIMessageSaveCall) Do(f func(context.Context, *storage.Message) error) *MockIMessageSaveCall

+ func (c *MockIMessageSaveCall) DoAndReturn(f func(context.Context, *storage.Message) error) *MockIMessageSaveCall

+ func (c *MockIMessageSaveCall) Return(arg0 error) *MockIMessageSaveCall

+ type MockIMessageUpdateCall struct

+ func (c *MockIMessageUpdateCall) Do(f func(context.Context, *storage.Message) error) *MockIMessageUpdateCall

+ func (c *MockIMessageUpdateCall) DoAndReturn(f func(context.Context, *storage.Message) error) *MockIMessageUpdateCall

+ func (c *MockIMessageUpdateCall) Return(arg0 error) *MockIMessageUpdateCall

type MockINamespace

+ func (m *MockINamespace) ISGOMOCK() struct{}

+ type MockINamespaceByNamespaceIdAndVersionCall struct

+ func (c *MockINamespaceByNamespaceIdAndVersionCall) Do(f func(context.Context, []byte, byte) (storage.Namespace, error)) *MockINamespaceByNamespaceIdAndVersionCall

+ func (c *MockINamespaceByNamespaceIdAndVersionCall) DoAndReturn(f func(context.Context, []byte, byte) (storage.Namespace, error)) *MockINamespaceByNamespaceIdAndVersionCall

+ func (c *MockINamespaceByNamespaceIdAndVersionCall) Return(arg0 storage.Namespace, arg1 error) *MockINamespaceByNamespaceIdAndVersionCall

+ type MockINamespaceByNamespaceIdCall struct

+ func (c *MockINamespaceByNamespaceIdCall) Do(f func(context.Context, []byte) ([]storage.Namespace, error)) *MockINamespaceByNamespaceIdCall

+ func (c *MockINamespaceByNamespaceIdCall) DoAndReturn(f func(context.Context, []byte) ([]storage.Namespace, error)) *MockINamespaceByNamespaceIdCall

+ func (c *MockINamespaceByNamespaceIdCall) Return(arg0 []storage.Namespace, arg1 error) *MockINamespaceByNamespaceIdCall

+ type MockINamespaceCursorListCall struct

+ func (c *MockINamespaceCursorListCall) Do(...) *MockINamespaceCursorListCall

+ func (c *MockINamespaceCursorListCall) DoAndReturn(...) *MockINamespaceCursorListCall

+ func (c *MockINamespaceCursorListCall) Return(arg0 []*storage.Namespace, arg1 error) *MockINamespaceCursorListCall

+ type MockINamespaceGetByIDCall struct

+ func (c *MockINamespaceGetByIDCall) Do(f func(context.Context, uint64) (*storage.Namespace, error)) *MockINamespaceGetByIDCall

+ func (c *MockINamespaceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Namespace, error)) *MockINamespaceGetByIDCall

+ func (c *MockINamespaceGetByIDCall) Return(arg0 *storage.Namespace, arg1 error) *MockINamespaceGetByIDCall

+ type MockINamespaceGetByIdsCall struct

+ func (c *MockINamespaceGetByIdsCall) Do(f func(context.Context, ...uint64) ([]storage.Namespace, error)) *MockINamespaceGetByIdsCall

+ func (c *MockINamespaceGetByIdsCall) DoAndReturn(f func(context.Context, ...uint64) ([]storage.Namespace, error)) *MockINamespaceGetByIdsCall

+ func (c *MockINamespaceGetByIdsCall) Return(ns []storage.Namespace, err error) *MockINamespaceGetByIdsCall

+ type MockINamespaceIsNoRowsCall struct

+ func (c *MockINamespaceIsNoRowsCall) Do(f func(error) bool) *MockINamespaceIsNoRowsCall

+ func (c *MockINamespaceIsNoRowsCall) DoAndReturn(f func(error) bool) *MockINamespaceIsNoRowsCall

+ func (c *MockINamespaceIsNoRowsCall) Return(arg0 bool) *MockINamespaceIsNoRowsCall

+ type MockINamespaceLastIDCall struct

+ func (c *MockINamespaceLastIDCall) Do(f func(context.Context) (uint64, error)) *MockINamespaceLastIDCall

+ func (c *MockINamespaceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockINamespaceLastIDCall

+ func (c *MockINamespaceLastIDCall) Return(arg0 uint64, arg1 error) *MockINamespaceLastIDCall

+ type MockINamespaceListCall struct

+ func (c *MockINamespaceListCall) Do(...) *MockINamespaceListCall

+ func (c *MockINamespaceListCall) DoAndReturn(...) *MockINamespaceListCall

+ func (c *MockINamespaceListCall) Return(arg0 []*storage.Namespace, arg1 error) *MockINamespaceListCall

+ type MockINamespaceListWithSortCall struct

+ func (c *MockINamespaceListWithSortCall) Do(...) *MockINamespaceListWithSortCall

+ func (c *MockINamespaceListWithSortCall) DoAndReturn(...) *MockINamespaceListWithSortCall

+ func (c *MockINamespaceListWithSortCall) Return(ns []storage.Namespace, err error) *MockINamespaceListWithSortCall

+ type MockINamespaceMessagesCall struct

+ func (c *MockINamespaceMessagesCall) Do(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *MockINamespaceMessagesCall

+ func (c *MockINamespaceMessagesCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *MockINamespaceMessagesCall

+ func (c *MockINamespaceMessagesCall) Return(arg0 []storage.NamespaceMessage, arg1 error) *MockINamespaceMessagesCall

+ type MockINamespaceSaveCall struct

+ func (c *MockINamespaceSaveCall) Do(f func(context.Context, *storage.Namespace) error) *MockINamespaceSaveCall

+ func (c *MockINamespaceSaveCall) DoAndReturn(f func(context.Context, *storage.Namespace) error) *MockINamespaceSaveCall

+ func (c *MockINamespaceSaveCall) Return(arg0 error) *MockINamespaceSaveCall

+ type MockINamespaceUpdateCall struct

+ func (c *MockINamespaceUpdateCall) Do(f func(context.Context, *storage.Namespace) error) *MockINamespaceUpdateCall

+ func (c *MockINamespaceUpdateCall) DoAndReturn(f func(context.Context, *storage.Namespace) error) *MockINamespaceUpdateCall

+ func (c *MockINamespaceUpdateCall) Return(arg0 error) *MockINamespaceUpdateCall

type MockIPrice

+ func (m *MockIPrice) ISGOMOCK() struct{}

+ type MockIPriceGetCall struct

+ func (c *MockIPriceGetCall) Do(...) *MockIPriceGetCall

+ func (c *MockIPriceGetCall) DoAndReturn(...) *MockIPriceGetCall

+ func (c *MockIPriceGetCall) Return(arg0 []storage.Price, arg1 error) *MockIPriceGetCall

+ type MockIPriceLastCall struct

+ func (c *MockIPriceLastCall) Do(f func(context.Context) (storage.Price, error)) *MockIPriceLastCall

+ func (c *MockIPriceLastCall) DoAndReturn(f func(context.Context) (storage.Price, error)) *MockIPriceLastCall

+ func (c *MockIPriceLastCall) Return(arg0 storage.Price, arg1 error) *MockIPriceLastCall

+ type MockIPriceSaveCall struct

+ func (c *MockIPriceSaveCall) Do(f func(context.Context, *storage.Price) error) *MockIPriceSaveCall

+ func (c *MockIPriceSaveCall) DoAndReturn(f func(context.Context, *storage.Price) error) *MockIPriceSaveCall

+ func (c *MockIPriceSaveCall) Return(arg0 error) *MockIPriceSaveCall

type MockIRedelegation

+ func (m *MockIRedelegation) ISGOMOCK() struct{}

+ type MockIRedelegationByAddressCall struct

+ func (c *MockIRedelegationByAddressCall) Do(f func(context.Context, uint64, int, int) ([]storage.Redelegation, error)) *MockIRedelegationByAddressCall

+ func (c *MockIRedelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Redelegation, error)) *MockIRedelegationByAddressCall

+ func (c *MockIRedelegationByAddressCall) Return(arg0 []storage.Redelegation, arg1 error) *MockIRedelegationByAddressCall

+ type MockIRedelegationCursorListCall struct

+ func (c *MockIRedelegationCursorListCall) Do(...) *MockIRedelegationCursorListCall

+ func (c *MockIRedelegationCursorListCall) DoAndReturn(...) *MockIRedelegationCursorListCall

+ func (c *MockIRedelegationCursorListCall) Return(arg0 []*storage.Redelegation, arg1 error) *MockIRedelegationCursorListCall

+ type MockIRedelegationGetByIDCall struct

+ func (c *MockIRedelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Redelegation, error)) *MockIRedelegationGetByIDCall

+ func (c *MockIRedelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Redelegation, error)) *MockIRedelegationGetByIDCall

+ func (c *MockIRedelegationGetByIDCall) Return(arg0 *storage.Redelegation, arg1 error) *MockIRedelegationGetByIDCall

+ type MockIRedelegationIsNoRowsCall struct

+ func (c *MockIRedelegationIsNoRowsCall) Do(f func(error) bool) *MockIRedelegationIsNoRowsCall

+ func (c *MockIRedelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIRedelegationIsNoRowsCall

+ func (c *MockIRedelegationIsNoRowsCall) Return(arg0 bool) *MockIRedelegationIsNoRowsCall

+ type MockIRedelegationLastIDCall struct

+ func (c *MockIRedelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIRedelegationLastIDCall

+ func (c *MockIRedelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIRedelegationLastIDCall

+ func (c *MockIRedelegationLastIDCall) Return(arg0 uint64, arg1 error) *MockIRedelegationLastIDCall

+ type MockIRedelegationListCall struct

+ func (c *MockIRedelegationListCall) Do(...) *MockIRedelegationListCall

+ func (c *MockIRedelegationListCall) DoAndReturn(...) *MockIRedelegationListCall

+ func (c *MockIRedelegationListCall) Return(arg0 []*storage.Redelegation, arg1 error) *MockIRedelegationListCall

+ type MockIRedelegationSaveCall struct

+ func (c *MockIRedelegationSaveCall) Do(f func(context.Context, *storage.Redelegation) error) *MockIRedelegationSaveCall

+ func (c *MockIRedelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Redelegation) error) *MockIRedelegationSaveCall

+ func (c *MockIRedelegationSaveCall) Return(arg0 error) *MockIRedelegationSaveCall

+ type MockIRedelegationUpdateCall struct

+ func (c *MockIRedelegationUpdateCall) Do(f func(context.Context, *storage.Redelegation) error) *MockIRedelegationUpdateCall

+ func (c *MockIRedelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Redelegation) error) *MockIRedelegationUpdateCall

+ func (c *MockIRedelegationUpdateCall) Return(arg0 error) *MockIRedelegationUpdateCall

type MockIRollup

+ func (m *MockIRollup) ById(ctx context.Context, rollupId uint64) (storage.RollupWithStats, error)

+ func (m *MockIRollup) ISGOMOCK() struct{}

+ type MockIRollupByIdCall struct

+ func (c *MockIRollupByIdCall) Do(f func(context.Context, uint64) (storage.RollupWithStats, error)) *MockIRollupByIdCall

+ func (c *MockIRollupByIdCall) DoAndReturn(f func(context.Context, uint64) (storage.RollupWithStats, error)) *MockIRollupByIdCall

+ func (c *MockIRollupByIdCall) Return(arg0 storage.RollupWithStats, arg1 error) *MockIRollupByIdCall

+ type MockIRollupBySlugCall struct

+ func (c *MockIRollupBySlugCall) Do(f func(context.Context, string) (storage.RollupWithStats, error)) *MockIRollupBySlugCall

+ func (c *MockIRollupBySlugCall) DoAndReturn(f func(context.Context, string) (storage.RollupWithStats, error)) *MockIRollupBySlugCall

+ func (c *MockIRollupBySlugCall) Return(arg0 storage.RollupWithStats, arg1 error) *MockIRollupBySlugCall

+ type MockIRollupCountCall struct

+ func (c *MockIRollupCountCall) Do(f func(context.Context) (int64, error)) *MockIRollupCountCall

+ func (c *MockIRollupCountCall) DoAndReturn(f func(context.Context) (int64, error)) *MockIRollupCountCall

+ func (c *MockIRollupCountCall) Return(arg0 int64, arg1 error) *MockIRollupCountCall

+ type MockIRollupCursorListCall struct

+ func (c *MockIRollupCursorListCall) Do(...) *MockIRollupCursorListCall

+ func (c *MockIRollupCursorListCall) DoAndReturn(...) *MockIRollupCursorListCall

+ func (c *MockIRollupCursorListCall) Return(arg0 []*storage.Rollup, arg1 error) *MockIRollupCursorListCall

+ type MockIRollupDistributionCall struct

+ func (c *MockIRollupDistributionCall) Do(...) *MockIRollupDistributionCall

+ func (c *MockIRollupDistributionCall) DoAndReturn(...) *MockIRollupDistributionCall

+ func (c *MockIRollupDistributionCall) Return(items []storage.DistributionItem, err error) *MockIRollupDistributionCall

+ type MockIRollupGetByIDCall struct

+ func (c *MockIRollupGetByIDCall) Do(f func(context.Context, uint64) (*storage.Rollup, error)) *MockIRollupGetByIDCall

+ func (c *MockIRollupGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Rollup, error)) *MockIRollupGetByIDCall

+ func (c *MockIRollupGetByIDCall) Return(arg0 *storage.Rollup, arg1 error) *MockIRollupGetByIDCall

+ type MockIRollupIsNoRowsCall struct

+ func (c *MockIRollupIsNoRowsCall) Do(f func(error) bool) *MockIRollupIsNoRowsCall

+ func (c *MockIRollupIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIRollupIsNoRowsCall

+ func (c *MockIRollupIsNoRowsCall) Return(arg0 bool) *MockIRollupIsNoRowsCall

+ type MockIRollupLastIDCall struct

+ func (c *MockIRollupLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIRollupLastIDCall

+ func (c *MockIRollupLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIRollupLastIDCall

+ func (c *MockIRollupLastIDCall) Return(arg0 uint64, arg1 error) *MockIRollupLastIDCall

+ type MockIRollupLeaderboardCall struct

+ func (c *MockIRollupLeaderboardCall) Do(...) *MockIRollupLeaderboardCall

+ func (c *MockIRollupLeaderboardCall) DoAndReturn(...) *MockIRollupLeaderboardCall

+ func (c *MockIRollupLeaderboardCall) Return(arg0 []storage.RollupWithStats, arg1 error) *MockIRollupLeaderboardCall

+ type MockIRollupListCall struct

+ func (c *MockIRollupListCall) Do(...) *MockIRollupListCall

+ func (c *MockIRollupListCall) DoAndReturn(...) *MockIRollupListCall

+ func (c *MockIRollupListCall) Return(arg0 []*storage.Rollup, arg1 error) *MockIRollupListCall

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) ById(ctx, rollupId any) *MockIRollupByIdCall

+ type MockIRollupNamespacesCall struct

+ func (c *MockIRollupNamespacesCall) Do(f func(context.Context, uint64, int, int) ([]uint64, error)) *MockIRollupNamespacesCall

+ func (c *MockIRollupNamespacesCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]uint64, error)) *MockIRollupNamespacesCall

+ func (c *MockIRollupNamespacesCall) Return(namespaceIds []uint64, err error) *MockIRollupNamespacesCall

type MockIRollupProvider

+ func (m *MockIRollupProvider) ISGOMOCK() struct{}

+ type MockIRollupProviderCursorListCall struct

+ func (c *MockIRollupProviderCursorListCall) Do(...) *MockIRollupProviderCursorListCall

+ func (c *MockIRollupProviderCursorListCall) DoAndReturn(...) *MockIRollupProviderCursorListCall

+ func (c *MockIRollupProviderCursorListCall) Return(arg0 []*storage.RollupProvider, arg1 error) *MockIRollupProviderCursorListCall

+ type MockIRollupProviderGetByIDCall struct

+ func (c *MockIRollupProviderGetByIDCall) Do(f func(context.Context, uint64) (*storage.RollupProvider, error)) *MockIRollupProviderGetByIDCall

+ func (c *MockIRollupProviderGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.RollupProvider, error)) *MockIRollupProviderGetByIDCall

+ func (c *MockIRollupProviderGetByIDCall) Return(arg0 *storage.RollupProvider, arg1 error) *MockIRollupProviderGetByIDCall

+ type MockIRollupProviderIsNoRowsCall struct

+ func (c *MockIRollupProviderIsNoRowsCall) Do(f func(error) bool) *MockIRollupProviderIsNoRowsCall

+ func (c *MockIRollupProviderIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIRollupProviderIsNoRowsCall

+ func (c *MockIRollupProviderIsNoRowsCall) Return(arg0 bool) *MockIRollupProviderIsNoRowsCall

+ type MockIRollupProviderLastIDCall struct

+ func (c *MockIRollupProviderLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIRollupProviderLastIDCall

+ func (c *MockIRollupProviderLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIRollupProviderLastIDCall

+ func (c *MockIRollupProviderLastIDCall) Return(arg0 uint64, arg1 error) *MockIRollupProviderLastIDCall

+ type MockIRollupProviderListCall struct

+ func (c *MockIRollupProviderListCall) Do(...) *MockIRollupProviderListCall

+ func (c *MockIRollupProviderListCall) DoAndReturn(...) *MockIRollupProviderListCall

+ func (c *MockIRollupProviderListCall) Return(arg0 []*storage.RollupProvider, arg1 error) *MockIRollupProviderListCall

+ type MockIRollupProviderSaveCall struct

+ func (c *MockIRollupProviderSaveCall) Do(f func(context.Context, *storage.RollupProvider) error) *MockIRollupProviderSaveCall

+ func (c *MockIRollupProviderSaveCall) DoAndReturn(f func(context.Context, *storage.RollupProvider) error) *MockIRollupProviderSaveCall

+ func (c *MockIRollupProviderSaveCall) Return(arg0 error) *MockIRollupProviderSaveCall

+ type MockIRollupProviderUpdateCall struct

+ func (c *MockIRollupProviderUpdateCall) Do(f func(context.Context, *storage.RollupProvider) error) *MockIRollupProviderUpdateCall

+ func (c *MockIRollupProviderUpdateCall) DoAndReturn(f func(context.Context, *storage.RollupProvider) error) *MockIRollupProviderUpdateCall

+ func (c *MockIRollupProviderUpdateCall) Return(arg0 error) *MockIRollupProviderUpdateCall

+ type MockIRollupProvidersCall struct

+ func (c *MockIRollupProvidersCall) Do(f func(context.Context, uint64) ([]storage.RollupProvider, error)) *MockIRollupProvidersCall

+ func (c *MockIRollupProvidersCall) DoAndReturn(f func(context.Context, uint64) ([]storage.RollupProvider, error)) *MockIRollupProvidersCall

+ func (c *MockIRollupProvidersCall) Return(providers []storage.RollupProvider, err error) *MockIRollupProvidersCall

+ type MockIRollupRollupsByNamespaceCall struct

+ func (c *MockIRollupRollupsByNamespaceCall) Do(f func(context.Context, uint64, int, int) ([]storage.Rollup, error)) *MockIRollupRollupsByNamespaceCall

+ func (c *MockIRollupRollupsByNamespaceCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Rollup, error)) *MockIRollupRollupsByNamespaceCall

+ func (c *MockIRollupRollupsByNamespaceCall) Return(rollups []storage.Rollup, err error) *MockIRollupRollupsByNamespaceCall

+ type MockIRollupSaveCall struct

+ func (c *MockIRollupSaveCall) Do(f func(context.Context, *storage.Rollup) error) *MockIRollupSaveCall

+ func (c *MockIRollupSaveCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *MockIRollupSaveCall

+ func (c *MockIRollupSaveCall) Return(arg0 error) *MockIRollupSaveCall

+ type MockIRollupSeriesCall struct

+ func (c *MockIRollupSeriesCall) Do(...) *MockIRollupSeriesCall

+ func (c *MockIRollupSeriesCall) DoAndReturn(...) *MockIRollupSeriesCall

+ func (c *MockIRollupSeriesCall) Return(items []storage.HistogramItem, err error) *MockIRollupSeriesCall

+ type MockIRollupUpdateCall struct

+ func (c *MockIRollupUpdateCall) Do(f func(context.Context, *storage.Rollup) error) *MockIRollupUpdateCall

+ func (c *MockIRollupUpdateCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *MockIRollupUpdateCall

+ func (c *MockIRollupUpdateCall) Return(arg0 error) *MockIRollupUpdateCall

type MockISearch

+ func (m *MockISearch) ISGOMOCK() struct{}

+ type MockISearchSearchCall struct

+ func (c *MockISearchSearchCall) Do(f func(context.Context, []byte) ([]storage.SearchResult, error)) *MockISearchSearchCall

+ func (c *MockISearchSearchCall) DoAndReturn(f func(context.Context, []byte) ([]storage.SearchResult, error)) *MockISearchSearchCall

+ func (c *MockISearchSearchCall) Return(arg0 []storage.SearchResult, arg1 error) *MockISearchSearchCall

+ type MockISearchSearchTextCall struct

+ func (c *MockISearchSearchTextCall) Do(f func(context.Context, string) ([]storage.SearchResult, error)) *MockISearchSearchTextCall

+ func (c *MockISearchSearchTextCall) DoAndReturn(f func(context.Context, string) ([]storage.SearchResult, error)) *MockISearchSearchTextCall

+ func (c *MockISearchSearchTextCall) Return(arg0 []storage.SearchResult, arg1 error) *MockISearchSearchTextCall

type MockIStakingLog

+ func (m *MockIStakingLog) ISGOMOCK() struct{}

+ type MockIStakingLogCursorListCall struct

+ func (c *MockIStakingLogCursorListCall) Do(...) *MockIStakingLogCursorListCall

+ func (c *MockIStakingLogCursorListCall) DoAndReturn(...) *MockIStakingLogCursorListCall

+ func (c *MockIStakingLogCursorListCall) Return(arg0 []*storage.StakingLog, arg1 error) *MockIStakingLogCursorListCall

+ type MockIStakingLogGetByIDCall struct

+ func (c *MockIStakingLogGetByIDCall) Do(f func(context.Context, uint64) (*storage.StakingLog, error)) *MockIStakingLogGetByIDCall

+ func (c *MockIStakingLogGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.StakingLog, error)) *MockIStakingLogGetByIDCall

+ func (c *MockIStakingLogGetByIDCall) Return(arg0 *storage.StakingLog, arg1 error) *MockIStakingLogGetByIDCall

+ type MockIStakingLogIsNoRowsCall struct

+ func (c *MockIStakingLogIsNoRowsCall) Do(f func(error) bool) *MockIStakingLogIsNoRowsCall

+ func (c *MockIStakingLogIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIStakingLogIsNoRowsCall

+ func (c *MockIStakingLogIsNoRowsCall) Return(arg0 bool) *MockIStakingLogIsNoRowsCall

+ type MockIStakingLogLastIDCall struct

+ func (c *MockIStakingLogLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIStakingLogLastIDCall

+ func (c *MockIStakingLogLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIStakingLogLastIDCall

+ func (c *MockIStakingLogLastIDCall) Return(arg0 uint64, arg1 error) *MockIStakingLogLastIDCall

+ type MockIStakingLogListCall struct

+ func (c *MockIStakingLogListCall) Do(...) *MockIStakingLogListCall

+ func (c *MockIStakingLogListCall) DoAndReturn(...) *MockIStakingLogListCall

+ func (c *MockIStakingLogListCall) Return(arg0 []*storage.StakingLog, arg1 error) *MockIStakingLogListCall

+ type MockIStakingLogSaveCall struct

+ func (c *MockIStakingLogSaveCall) Do(f func(context.Context, *storage.StakingLog) error) *MockIStakingLogSaveCall

+ func (c *MockIStakingLogSaveCall) DoAndReturn(f func(context.Context, *storage.StakingLog) error) *MockIStakingLogSaveCall

+ func (c *MockIStakingLogSaveCall) Return(arg0 error) *MockIStakingLogSaveCall

+ type MockIStakingLogUpdateCall struct

+ func (c *MockIStakingLogUpdateCall) Do(f func(context.Context, *storage.StakingLog) error) *MockIStakingLogUpdateCall

+ func (c *MockIStakingLogUpdateCall) DoAndReturn(f func(context.Context, *storage.StakingLog) error) *MockIStakingLogUpdateCall

+ func (c *MockIStakingLogUpdateCall) Return(arg0 error) *MockIStakingLogUpdateCall

type MockIState

+ func (m *MockIState) ISGOMOCK() struct{}

+ type MockIStateByNameCall struct

+ func (c *MockIStateByNameCall) Do(f func(context.Context, string) (storage.State, error)) *MockIStateByNameCall

+ func (c *MockIStateByNameCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *MockIStateByNameCall

+ func (c *MockIStateByNameCall) Return(arg0 storage.State, arg1 error) *MockIStateByNameCall

+ type MockIStateCursorListCall struct

+ func (c *MockIStateCursorListCall) Do(...) *MockIStateCursorListCall

+ func (c *MockIStateCursorListCall) DoAndReturn(...) *MockIStateCursorListCall

+ func (c *MockIStateCursorListCall) Return(arg0 []*storage.State, arg1 error) *MockIStateCursorListCall

+ type MockIStateGetByIDCall struct

+ func (c *MockIStateGetByIDCall) Do(f func(context.Context, uint64) (*storage.State, error)) *MockIStateGetByIDCall

+ func (c *MockIStateGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.State, error)) *MockIStateGetByIDCall

+ func (c *MockIStateGetByIDCall) Return(arg0 *storage.State, arg1 error) *MockIStateGetByIDCall

+ type MockIStateIsNoRowsCall struct

+ func (c *MockIStateIsNoRowsCall) Do(f func(error) bool) *MockIStateIsNoRowsCall

+ func (c *MockIStateIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIStateIsNoRowsCall

+ func (c *MockIStateIsNoRowsCall) Return(arg0 bool) *MockIStateIsNoRowsCall

+ type MockIStateLastIDCall struct

+ func (c *MockIStateLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIStateLastIDCall

+ func (c *MockIStateLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIStateLastIDCall

+ func (c *MockIStateLastIDCall) Return(arg0 uint64, arg1 error) *MockIStateLastIDCall

+ type MockIStateListCall struct

+ func (c *MockIStateListCall) Do(...) *MockIStateListCall

+ func (c *MockIStateListCall) DoAndReturn(...) *MockIStateListCall

+ func (c *MockIStateListCall) Return(arg0 []*storage.State, arg1 error) *MockIStateListCall

+ type MockIStateSaveCall struct

+ func (c *MockIStateSaveCall) Do(f func(context.Context, *storage.State) error) *MockIStateSaveCall

+ func (c *MockIStateSaveCall) DoAndReturn(f func(context.Context, *storage.State) error) *MockIStateSaveCall

+ func (c *MockIStateSaveCall) Return(arg0 error) *MockIStateSaveCall

+ type MockIStateUpdateCall struct

+ func (c *MockIStateUpdateCall) Do(f func(context.Context, *storage.State) error) *MockIStateUpdateCall

+ func (c *MockIStateUpdateCall) DoAndReturn(f func(context.Context, *storage.State) error) *MockIStateUpdateCall

+ func (c *MockIStateUpdateCall) Return(arg0 error) *MockIStateUpdateCall

type MockIStats

+ func (m *MockIStats) ISGOMOCK() struct{}

+ type MockIStatsChange24hBlockStatsCall struct

+ func (c *MockIStatsChange24hBlockStatsCall) Do(f func(context.Context) (storage.Change24hBlockStats, error)) *MockIStatsChange24hBlockStatsCall

+ func (c *MockIStatsChange24hBlockStatsCall) DoAndReturn(f func(context.Context) (storage.Change24hBlockStats, error)) *MockIStatsChange24hBlockStatsCall

+ func (c *MockIStatsChange24hBlockStatsCall) Return(response storage.Change24hBlockStats, err error) *MockIStatsChange24hBlockStatsCall

+ type MockIStatsCountCall struct

+ func (c *MockIStatsCountCall) Do(f func(context.Context, storage.CountRequest) (string, error)) *MockIStatsCountCall

+ func (c *MockIStatsCountCall) DoAndReturn(f func(context.Context, storage.CountRequest) (string, error)) *MockIStatsCountCall

+ func (c *MockIStatsCountCall) Return(arg0 string, arg1 error) *MockIStatsCountCall

+ type MockIStatsCumulativeSeriesCall struct

+ func (c *MockIStatsCumulativeSeriesCall) Do(...) *MockIStatsCumulativeSeriesCall

+ func (c *MockIStatsCumulativeSeriesCall) DoAndReturn(...) *MockIStatsCumulativeSeriesCall

+ func (c *MockIStatsCumulativeSeriesCall) Return(arg0 []storage.SeriesItem, arg1 error) *MockIStatsCumulativeSeriesCall

+ type MockIStatsMessagesCount24hCall struct

+ func (c *MockIStatsMessagesCount24hCall) Do(f func(context.Context) ([]storage.CountItem, error)) *MockIStatsMessagesCount24hCall

+ func (c *MockIStatsMessagesCount24hCall) DoAndReturn(f func(context.Context) ([]storage.CountItem, error)) *MockIStatsMessagesCount24hCall

+ func (c *MockIStatsMessagesCount24hCall) Return(arg0 []storage.CountItem, arg1 error) *MockIStatsMessagesCount24hCall

+ type MockIStatsNamespaceSeriesCall struct

+ func (c *MockIStatsNamespaceSeriesCall) Do(...) *MockIStatsNamespaceSeriesCall

+ func (c *MockIStatsNamespaceSeriesCall) DoAndReturn(...) *MockIStatsNamespaceSeriesCall

+ func (c *MockIStatsNamespaceSeriesCall) Return(response []storage.SeriesItem, err error) *MockIStatsNamespaceSeriesCall

+ type MockIStatsRollupStats24hCall struct

+ func (c *MockIStatsRollupStats24hCall) Do(f func(context.Context) ([]storage.RollupStats24h, error)) *MockIStatsRollupStats24hCall

+ func (c *MockIStatsRollupStats24hCall) DoAndReturn(f func(context.Context) ([]storage.RollupStats24h, error)) *MockIStatsRollupStats24hCall

+ func (c *MockIStatsRollupStats24hCall) Return(arg0 []storage.RollupStats24h, arg1 error) *MockIStatsRollupStats24hCall

+ type MockIStatsSeriesCall struct

+ func (c *MockIStatsSeriesCall) Do(...) *MockIStatsSeriesCall

+ func (c *MockIStatsSeriesCall) DoAndReturn(...) *MockIStatsSeriesCall

+ func (c *MockIStatsSeriesCall) Return(arg0 []storage.SeriesItem, arg1 error) *MockIStatsSeriesCall

+ type MockIStatsSquareSizeCall struct

+ func (c *MockIStatsSquareSizeCall) Do(...) *MockIStatsSquareSizeCall

+ func (c *MockIStatsSquareSizeCall) DoAndReturn(...) *MockIStatsSquareSizeCall

+ func (c *MockIStatsSquareSizeCall) Return(arg0 map[int][]storage.SeriesItem, arg1 error) *MockIStatsSquareSizeCall

+ type MockIStatsStakingSeriesCall struct

+ func (c *MockIStatsStakingSeriesCall) Do(...) *MockIStatsStakingSeriesCall

+ func (c *MockIStatsStakingSeriesCall) DoAndReturn(...) *MockIStatsStakingSeriesCall

+ func (c *MockIStatsStakingSeriesCall) Return(response []storage.SeriesItem, err error) *MockIStatsStakingSeriesCall

+ type MockIStatsSummaryCall struct

+ func (c *MockIStatsSummaryCall) Do(f func(context.Context, storage.SummaryRequest) (string, error)) *MockIStatsSummaryCall

+ func (c *MockIStatsSummaryCall) DoAndReturn(f func(context.Context, storage.SummaryRequest) (string, error)) *MockIStatsSummaryCall

+ func (c *MockIStatsSummaryCall) Return(arg0 string, arg1 error) *MockIStatsSummaryCall

+ type MockIStatsTPSCall struct

+ func (c *MockIStatsTPSCall) Do(f func(context.Context) (storage.TPS, error)) *MockIStatsTPSCall

+ func (c *MockIStatsTPSCall) DoAndReturn(f func(context.Context) (storage.TPS, error)) *MockIStatsTPSCall

+ func (c *MockIStatsTPSCall) Return(arg0 storage.TPS, arg1 error) *MockIStatsTPSCall

type MockITx

+ func (m *MockITx) ISGOMOCK() struct{}

+ type MockITxByAddressCall struct

+ func (c *MockITxByAddressCall) Do(f func(context.Context, uint64, storage.TxFilter) ([]storage.Tx, error)) *MockITxByAddressCall

+ func (c *MockITxByAddressCall) DoAndReturn(f func(context.Context, uint64, storage.TxFilter) ([]storage.Tx, error)) *MockITxByAddressCall

+ func (c *MockITxByAddressCall) Return(arg0 []storage.Tx, arg1 error) *MockITxByAddressCall

+ type MockITxByHashCall struct

+ func (c *MockITxByHashCall) Do(f func(context.Context, []byte) (storage.Tx, error)) *MockITxByHashCall

+ func (c *MockITxByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Tx, error)) *MockITxByHashCall

+ func (c *MockITxByHashCall) Return(arg0 storage.Tx, arg1 error) *MockITxByHashCall

+ type MockITxByIdWithRelationsCall struct

+ func (c *MockITxByIdWithRelationsCall) Do(f func(context.Context, uint64) (storage.Tx, error)) *MockITxByIdWithRelationsCall

+ func (c *MockITxByIdWithRelationsCall) DoAndReturn(f func(context.Context, uint64) (storage.Tx, error)) *MockITxByIdWithRelationsCall

+ func (c *MockITxByIdWithRelationsCall) Return(arg0 storage.Tx, arg1 error) *MockITxByIdWithRelationsCall

+ type MockITxCursorListCall struct

+ func (c *MockITxCursorListCall) Do(...) *MockITxCursorListCall

+ func (c *MockITxCursorListCall) DoAndReturn(...) *MockITxCursorListCall

+ func (c *MockITxCursorListCall) Return(arg0 []*storage.Tx, arg1 error) *MockITxCursorListCall

+ type MockITxFilterCall struct

+ func (c *MockITxFilterCall) Do(f func(context.Context, storage.TxFilter) ([]storage.Tx, error)) *MockITxFilterCall

+ func (c *MockITxFilterCall) DoAndReturn(f func(context.Context, storage.TxFilter) ([]storage.Tx, error)) *MockITxFilterCall

+ func (c *MockITxFilterCall) Return(arg0 []storage.Tx, arg1 error) *MockITxFilterCall

+ type MockITxGasCall struct

+ func (c *MockITxGasCall) Do(f func(context.Context, types.Level, time.Time) ([]storage.Gas, error)) *MockITxGasCall

+ func (c *MockITxGasCall) DoAndReturn(f func(context.Context, types.Level, time.Time) ([]storage.Gas, error)) *MockITxGasCall

+ func (c *MockITxGasCall) Return(arg0 []storage.Gas, arg1 error) *MockITxGasCall

+ type MockITxGenesisCall struct

+ func (c *MockITxGenesisCall) Do(f func(context.Context, int, int, storage0.SortOrder) ([]storage.Tx, error)) *MockITxGenesisCall

+ func (c *MockITxGenesisCall) DoAndReturn(f func(context.Context, int, int, storage0.SortOrder) ([]storage.Tx, error)) *MockITxGenesisCall

+ func (c *MockITxGenesisCall) Return(arg0 []storage.Tx, arg1 error) *MockITxGenesisCall

+ type MockITxGetByIDCall struct

+ func (c *MockITxGetByIDCall) Do(f func(context.Context, uint64) (*storage.Tx, error)) *MockITxGetByIDCall

+ func (c *MockITxGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Tx, error)) *MockITxGetByIDCall

+ func (c *MockITxGetByIDCall) Return(arg0 *storage.Tx, arg1 error) *MockITxGetByIDCall

+ type MockITxIdByHashCall struct

+ func (c *MockITxIdByHashCall) Do(f func(context.Context, []byte) (uint64, error)) *MockITxIdByHashCall

+ func (c *MockITxIdByHashCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *MockITxIdByHashCall

+ func (c *MockITxIdByHashCall) Return(arg0 uint64, arg1 error) *MockITxIdByHashCall

+ type MockITxIsNoRowsCall struct

+ func (c *MockITxIsNoRowsCall) Do(f func(error) bool) *MockITxIsNoRowsCall

+ func (c *MockITxIsNoRowsCall) DoAndReturn(f func(error) bool) *MockITxIsNoRowsCall

+ func (c *MockITxIsNoRowsCall) Return(arg0 bool) *MockITxIsNoRowsCall

+ type MockITxLastIDCall struct

+ func (c *MockITxLastIDCall) Do(f func(context.Context) (uint64, error)) *MockITxLastIDCall

+ func (c *MockITxLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockITxLastIDCall

+ func (c *MockITxLastIDCall) Return(arg0 uint64, arg1 error) *MockITxLastIDCall

+ type MockITxListCall struct

+ func (c *MockITxListCall) Do(...) *MockITxListCall

+ func (c *MockITxListCall) DoAndReturn(...) *MockITxListCall

+ func (c *MockITxListCall) Return(arg0 []*storage.Tx, arg1 error) *MockITxListCall

+ type MockITxSaveCall struct

+ func (c *MockITxSaveCall) Do(f func(context.Context, *storage.Tx) error) *MockITxSaveCall

+ func (c *MockITxSaveCall) DoAndReturn(f func(context.Context, *storage.Tx) error) *MockITxSaveCall

+ func (c *MockITxSaveCall) Return(arg0 error) *MockITxSaveCall

+ type MockITxUpdateCall struct

+ func (c *MockITxUpdateCall) Do(f func(context.Context, *storage.Tx) error) *MockITxUpdateCall

+ func (c *MockITxUpdateCall) DoAndReturn(f func(context.Context, *storage.Tx) error) *MockITxUpdateCall

+ func (c *MockITxUpdateCall) Return(arg0 error) *MockITxUpdateCall

type MockIUndelegation

+ func (m *MockIUndelegation) ISGOMOCK() struct{}

+ type MockIUndelegationByAddressCall struct

+ func (c *MockIUndelegationByAddressCall) Do(f func(context.Context, uint64, int, int) ([]storage.Undelegation, error)) *MockIUndelegationByAddressCall

+ func (c *MockIUndelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Undelegation, error)) *MockIUndelegationByAddressCall

+ func (c *MockIUndelegationByAddressCall) Return(arg0 []storage.Undelegation, arg1 error) *MockIUndelegationByAddressCall

+ type MockIUndelegationCursorListCall struct

+ func (c *MockIUndelegationCursorListCall) Do(...) *MockIUndelegationCursorListCall

+ func (c *MockIUndelegationCursorListCall) DoAndReturn(...) *MockIUndelegationCursorListCall

+ func (c *MockIUndelegationCursorListCall) Return(arg0 []*storage.Undelegation, arg1 error) *MockIUndelegationCursorListCall

+ type MockIUndelegationGetByIDCall struct

+ func (c *MockIUndelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Undelegation, error)) *MockIUndelegationGetByIDCall

+ func (c *MockIUndelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Undelegation, error)) *MockIUndelegationGetByIDCall

+ func (c *MockIUndelegationGetByIDCall) Return(arg0 *storage.Undelegation, arg1 error) *MockIUndelegationGetByIDCall

+ type MockIUndelegationIsNoRowsCall struct

+ func (c *MockIUndelegationIsNoRowsCall) Do(f func(error) bool) *MockIUndelegationIsNoRowsCall

+ func (c *MockIUndelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIUndelegationIsNoRowsCall

+ func (c *MockIUndelegationIsNoRowsCall) Return(arg0 bool) *MockIUndelegationIsNoRowsCall

+ type MockIUndelegationLastIDCall struct

+ func (c *MockIUndelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIUndelegationLastIDCall

+ func (c *MockIUndelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIUndelegationLastIDCall

+ func (c *MockIUndelegationLastIDCall) Return(arg0 uint64, arg1 error) *MockIUndelegationLastIDCall

+ type MockIUndelegationListCall struct

+ func (c *MockIUndelegationListCall) Do(...) *MockIUndelegationListCall

+ func (c *MockIUndelegationListCall) DoAndReturn(...) *MockIUndelegationListCall

+ func (c *MockIUndelegationListCall) Return(arg0 []*storage.Undelegation, arg1 error) *MockIUndelegationListCall

+ type MockIUndelegationSaveCall struct

+ func (c *MockIUndelegationSaveCall) Do(f func(context.Context, *storage.Undelegation) error) *MockIUndelegationSaveCall

+ func (c *MockIUndelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Undelegation) error) *MockIUndelegationSaveCall

+ func (c *MockIUndelegationSaveCall) Return(arg0 error) *MockIUndelegationSaveCall

+ type MockIUndelegationUpdateCall struct

+ func (c *MockIUndelegationUpdateCall) Do(f func(context.Context, *storage.Undelegation) error) *MockIUndelegationUpdateCall

+ func (c *MockIUndelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Undelegation) error) *MockIUndelegationUpdateCall

+ func (c *MockIUndelegationUpdateCall) Return(arg0 error) *MockIUndelegationUpdateCall

type MockIValidator

+ func (m *MockIValidator) ISGOMOCK() struct{}

+ type MockIValidatorByAddressCall struct

+ func (c *MockIValidatorByAddressCall) Do(f func(context.Context, string) (storage.Validator, error)) *MockIValidatorByAddressCall

+ func (c *MockIValidatorByAddressCall) DoAndReturn(f func(context.Context, string) (storage.Validator, error)) *MockIValidatorByAddressCall

+ func (c *MockIValidatorByAddressCall) Return(arg0 storage.Validator, arg1 error) *MockIValidatorByAddressCall

+ type MockIValidatorCursorListCall struct

+ func (c *MockIValidatorCursorListCall) Do(...) *MockIValidatorCursorListCall

+ func (c *MockIValidatorCursorListCall) DoAndReturn(...) *MockIValidatorCursorListCall

+ func (c *MockIValidatorCursorListCall) Return(arg0 []*storage.Validator, arg1 error) *MockIValidatorCursorListCall

+ type MockIValidatorGetByIDCall struct

+ func (c *MockIValidatorGetByIDCall) Do(f func(context.Context, uint64) (*storage.Validator, error)) *MockIValidatorGetByIDCall

+ func (c *MockIValidatorGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Validator, error)) *MockIValidatorGetByIDCall

+ func (c *MockIValidatorGetByIDCall) Return(arg0 *storage.Validator, arg1 error) *MockIValidatorGetByIDCall

+ type MockIValidatorIsNoRowsCall struct

+ func (c *MockIValidatorIsNoRowsCall) Do(f func(error) bool) *MockIValidatorIsNoRowsCall

+ func (c *MockIValidatorIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIValidatorIsNoRowsCall

+ func (c *MockIValidatorIsNoRowsCall) Return(arg0 bool) *MockIValidatorIsNoRowsCall

+ type MockIValidatorJailedCountCall struct

+ func (c *MockIValidatorJailedCountCall) Do(f func(context.Context) (int, error)) *MockIValidatorJailedCountCall

+ func (c *MockIValidatorJailedCountCall) DoAndReturn(f func(context.Context) (int, error)) *MockIValidatorJailedCountCall

+ func (c *MockIValidatorJailedCountCall) Return(arg0 int, arg1 error) *MockIValidatorJailedCountCall

+ type MockIValidatorLastIDCall struct

+ func (c *MockIValidatorLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIValidatorLastIDCall

+ func (c *MockIValidatorLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIValidatorLastIDCall

+ func (c *MockIValidatorLastIDCall) Return(arg0 uint64, arg1 error) *MockIValidatorLastIDCall

+ type MockIValidatorListByPowerCall struct

+ func (c *MockIValidatorListByPowerCall) Do(f func(context.Context, storage.ValidatorFilters) ([]storage.Validator, error)) *MockIValidatorListByPowerCall

+ func (c *MockIValidatorListByPowerCall) DoAndReturn(f func(context.Context, storage.ValidatorFilters) ([]storage.Validator, error)) *MockIValidatorListByPowerCall

+ func (c *MockIValidatorListByPowerCall) Return(arg0 []storage.Validator, arg1 error) *MockIValidatorListByPowerCall

+ type MockIValidatorListCall struct

+ func (c *MockIValidatorListCall) Do(...) *MockIValidatorListCall

+ func (c *MockIValidatorListCall) DoAndReturn(...) *MockIValidatorListCall

+ func (c *MockIValidatorListCall) Return(arg0 []*storage.Validator, arg1 error) *MockIValidatorListCall

+ type MockIValidatorSaveCall struct

+ func (c *MockIValidatorSaveCall) Do(f func(context.Context, *storage.Validator) error) *MockIValidatorSaveCall

+ func (c *MockIValidatorSaveCall) DoAndReturn(f func(context.Context, *storage.Validator) error) *MockIValidatorSaveCall

+ func (c *MockIValidatorSaveCall) Return(arg0 error) *MockIValidatorSaveCall

+ type MockIValidatorTotalVotingPowerCall struct

+ func (c *MockIValidatorTotalVotingPowerCall) Do(f func(context.Context) (decimal.Decimal, error)) *MockIValidatorTotalVotingPowerCall

+ func (c *MockIValidatorTotalVotingPowerCall) DoAndReturn(f func(context.Context) (decimal.Decimal, error)) *MockIValidatorTotalVotingPowerCall

+ func (c *MockIValidatorTotalVotingPowerCall) Return(arg0 decimal.Decimal, arg1 error) *MockIValidatorTotalVotingPowerCall

+ type MockIValidatorUpdateCall struct

+ func (c *MockIValidatorUpdateCall) Do(f func(context.Context, *storage.Validator) error) *MockIValidatorUpdateCall

+ func (c *MockIValidatorUpdateCall) DoAndReturn(f func(context.Context, *storage.Validator) error) *MockIValidatorUpdateCall

+ func (c *MockIValidatorUpdateCall) Return(arg0 error) *MockIValidatorUpdateCall

type MockIVestingAccount

+ func (m *MockIVestingAccount) ISGOMOCK() struct{}

+ type MockIVestingAccountByAddressCall struct

+ func (c *MockIVestingAccountByAddressCall) Do(...) *MockIVestingAccountByAddressCall

+ func (c *MockIVestingAccountByAddressCall) DoAndReturn(...) *MockIVestingAccountByAddressCall

+ func (c *MockIVestingAccountByAddressCall) Return(arg0 []storage.VestingAccount, arg1 error) *MockIVestingAccountByAddressCall

+ type MockIVestingAccountCursorListCall struct

+ func (c *MockIVestingAccountCursorListCall) Do(...) *MockIVestingAccountCursorListCall

+ func (c *MockIVestingAccountCursorListCall) DoAndReturn(...) *MockIVestingAccountCursorListCall

+ func (c *MockIVestingAccountCursorListCall) Return(arg0 []*storage.VestingAccount, arg1 error) *MockIVestingAccountCursorListCall

+ type MockIVestingAccountGetByIDCall struct

+ func (c *MockIVestingAccountGetByIDCall) Do(f func(context.Context, uint64) (*storage.VestingAccount, error)) *MockIVestingAccountGetByIDCall

+ func (c *MockIVestingAccountGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.VestingAccount, error)) *MockIVestingAccountGetByIDCall

+ func (c *MockIVestingAccountGetByIDCall) Return(arg0 *storage.VestingAccount, arg1 error) *MockIVestingAccountGetByIDCall

+ type MockIVestingAccountIsNoRowsCall struct

+ func (c *MockIVestingAccountIsNoRowsCall) Do(f func(error) bool) *MockIVestingAccountIsNoRowsCall

+ func (c *MockIVestingAccountIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIVestingAccountIsNoRowsCall

+ func (c *MockIVestingAccountIsNoRowsCall) Return(arg0 bool) *MockIVestingAccountIsNoRowsCall

+ type MockIVestingAccountLastIDCall struct

+ func (c *MockIVestingAccountLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIVestingAccountLastIDCall

+ func (c *MockIVestingAccountLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIVestingAccountLastIDCall

+ func (c *MockIVestingAccountLastIDCall) Return(arg0 uint64, arg1 error) *MockIVestingAccountLastIDCall

+ type MockIVestingAccountListCall struct

+ func (c *MockIVestingAccountListCall) Do(...) *MockIVestingAccountListCall

+ func (c *MockIVestingAccountListCall) DoAndReturn(...) *MockIVestingAccountListCall

+ func (c *MockIVestingAccountListCall) Return(arg0 []*storage.VestingAccount, arg1 error) *MockIVestingAccountListCall

+ type MockIVestingAccountSaveCall struct

+ func (c *MockIVestingAccountSaveCall) Do(f func(context.Context, *storage.VestingAccount) error) *MockIVestingAccountSaveCall

+ func (c *MockIVestingAccountSaveCall) DoAndReturn(f func(context.Context, *storage.VestingAccount) error) *MockIVestingAccountSaveCall

+ func (c *MockIVestingAccountSaveCall) Return(arg0 error) *MockIVestingAccountSaveCall

+ type MockIVestingAccountUpdateCall struct

+ func (c *MockIVestingAccountUpdateCall) Do(f func(context.Context, *storage.VestingAccount) error) *MockIVestingAccountUpdateCall

+ func (c *MockIVestingAccountUpdateCall) DoAndReturn(f func(context.Context, *storage.VestingAccount) error) *MockIVestingAccountUpdateCall

+ func (c *MockIVestingAccountUpdateCall) Return(arg0 error) *MockIVestingAccountUpdateCall

type MockIVestingPeriod

+ func (m *MockIVestingPeriod) ISGOMOCK() struct{}

+ type MockIVestingPeriodByVestingCall struct

+ func (c *MockIVestingPeriodByVestingCall) Do(f func(context.Context, uint64, int, int) ([]storage.VestingPeriod, error)) *MockIVestingPeriodByVestingCall

+ func (c *MockIVestingPeriodByVestingCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.VestingPeriod, error)) *MockIVestingPeriodByVestingCall

+ func (c *MockIVestingPeriodByVestingCall) Return(arg0 []storage.VestingPeriod, arg1 error) *MockIVestingPeriodByVestingCall

+ type MockIVestingPeriodCursorListCall struct

+ func (c *MockIVestingPeriodCursorListCall) Do(...) *MockIVestingPeriodCursorListCall

+ func (c *MockIVestingPeriodCursorListCall) DoAndReturn(...) *MockIVestingPeriodCursorListCall

+ func (c *MockIVestingPeriodCursorListCall) Return(arg0 []*storage.VestingPeriod, arg1 error) *MockIVestingPeriodCursorListCall

+ type MockIVestingPeriodGetByIDCall struct

+ func (c *MockIVestingPeriodGetByIDCall) Do(f func(context.Context, uint64) (*storage.VestingPeriod, error)) *MockIVestingPeriodGetByIDCall

+ func (c *MockIVestingPeriodGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.VestingPeriod, error)) *MockIVestingPeriodGetByIDCall

+ func (c *MockIVestingPeriodGetByIDCall) Return(arg0 *storage.VestingPeriod, arg1 error) *MockIVestingPeriodGetByIDCall

+ type MockIVestingPeriodIsNoRowsCall struct

+ func (c *MockIVestingPeriodIsNoRowsCall) Do(f func(error) bool) *MockIVestingPeriodIsNoRowsCall

+ func (c *MockIVestingPeriodIsNoRowsCall) DoAndReturn(f func(error) bool) *MockIVestingPeriodIsNoRowsCall

+ func (c *MockIVestingPeriodIsNoRowsCall) Return(arg0 bool) *MockIVestingPeriodIsNoRowsCall

+ type MockIVestingPeriodLastIDCall struct

+ func (c *MockIVestingPeriodLastIDCall) Do(f func(context.Context) (uint64, error)) *MockIVestingPeriodLastIDCall

+ func (c *MockIVestingPeriodLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *MockIVestingPeriodLastIDCall

+ func (c *MockIVestingPeriodLastIDCall) Return(arg0 uint64, arg1 error) *MockIVestingPeriodLastIDCall

+ type MockIVestingPeriodListCall struct

+ func (c *MockIVestingPeriodListCall) Do(...) *MockIVestingPeriodListCall

+ func (c *MockIVestingPeriodListCall) DoAndReturn(...) *MockIVestingPeriodListCall

+ func (c *MockIVestingPeriodListCall) Return(arg0 []*storage.VestingPeriod, arg1 error) *MockIVestingPeriodListCall

+ type MockIVestingPeriodSaveCall struct

+ func (c *MockIVestingPeriodSaveCall) Do(f func(context.Context, *storage.VestingPeriod) error) *MockIVestingPeriodSaveCall

+ func (c *MockIVestingPeriodSaveCall) DoAndReturn(f func(context.Context, *storage.VestingPeriod) error) *MockIVestingPeriodSaveCall

+ func (c *MockIVestingPeriodSaveCall) Return(arg0 error) *MockIVestingPeriodSaveCall

+ type MockIVestingPeriodUpdateCall struct

+ func (c *MockIVestingPeriodUpdateCall) Do(f func(context.Context, *storage.VestingPeriod) error) *MockIVestingPeriodUpdateCall

+ func (c *MockIVestingPeriodUpdateCall) DoAndReturn(f func(context.Context, *storage.VestingPeriod) error) *MockIVestingPeriodUpdateCall

+ func (c *MockIVestingPeriodUpdateCall) Return(arg0 error) *MockIVestingPeriodUpdateCall

type MockListener

+ func (m *MockListener) ISGOMOCK() struct{}

+ type MockListenerCloseCall struct

+ func (c *MockListenerCloseCall) Do(f func() error) *MockListenerCloseCall

+ func (c *MockListenerCloseCall) DoAndReturn(f func() error) *MockListenerCloseCall

+ func (c *MockListenerCloseCall) Return(arg0 error) *MockListenerCloseCall

type MockListenerFactory

+ func (m *MockListenerFactory) ISGOMOCK() struct{}

+ type MockListenerFactoryCreateListenerCall struct

+ func (c *MockListenerFactoryCreateListenerCall) Do(f func() storage.Listener) *MockListenerFactoryCreateListenerCall

+ func (c *MockListenerFactoryCreateListenerCall) DoAndReturn(f func() storage.Listener) *MockListenerFactoryCreateListenerCall

+ func (c *MockListenerFactoryCreateListenerCall) Return(arg0 storage.Listener) *MockListenerFactoryCreateListenerCall

+ type MockListenerListenCall struct

+ func (c *MockListenerListenCall) Do(f func() chan *pq.Notification) *MockListenerListenCall

+ func (c *MockListenerListenCall) DoAndReturn(f func() chan *pq.Notification) *MockListenerListenCall

+ func (c *MockListenerListenCall) Return(arg0 chan *pq.Notification) *MockListenerListenCall

+ type MockListenerSubscribeCall struct

+ func (c *MockListenerSubscribeCall) Do(f func(context.Context, ...string) error) *MockListenerSubscribeCall

+ func (c *MockListenerSubscribeCall) DoAndReturn(f func(context.Context, ...string) error) *MockListenerSubscribeCall

+ func (c *MockListenerSubscribeCall) Return(arg0 error) *MockListenerSubscribeCall

type MockNotificator

+ func (m *MockNotificator) ISGOMOCK() struct{}

+ type MockNotificatorNotifyCall struct

+ func (c *MockNotificatorNotifyCall) Do(f func(context.Context, string, string) error) *MockNotificatorNotifyCall

+ func (c *MockNotificatorNotifyCall) DoAndReturn(f func(context.Context, string, string) error) *MockNotificatorNotifyCall

+ func (c *MockNotificatorNotifyCall) Return(arg0 error) *MockNotificatorNotifyCall

type MockTransaction

+ func (m *MockTransaction) ISGOMOCK() struct{}

+ type MockTransactionAddCall struct

+ func (c *MockTransactionAddCall) Do(f func(context.Context, any) error) *MockTransactionAddCall

+ func (c *MockTransactionAddCall) DoAndReturn(f func(context.Context, any) error) *MockTransactionAddCall

+ func (c *MockTransactionAddCall) Return(arg0 error) *MockTransactionAddCall

+ type MockTransactionBulkSaveCall struct

+ func (c *MockTransactionBulkSaveCall) Do(f func(context.Context, []any) error) *MockTransactionBulkSaveCall

+ func (c *MockTransactionBulkSaveCall) DoAndReturn(f func(context.Context, []any) error) *MockTransactionBulkSaveCall

+ func (c *MockTransactionBulkSaveCall) Return(arg0 error) *MockTransactionBulkSaveCall

+ type MockTransactionCancelUnbondingsCall struct

+ func (c *MockTransactionCancelUnbondingsCall) Do(f func(context.Context, ...storage.Undelegation) error) *MockTransactionCancelUnbondingsCall

+ func (c *MockTransactionCancelUnbondingsCall) DoAndReturn(f func(context.Context, ...storage.Undelegation) error) *MockTransactionCancelUnbondingsCall

+ func (c *MockTransactionCancelUnbondingsCall) Return(arg0 error) *MockTransactionCancelUnbondingsCall

+ type MockTransactionCloseCall struct

+ func (c *MockTransactionCloseCall) Do(f func(context.Context) error) *MockTransactionCloseCall

+ func (c *MockTransactionCloseCall) DoAndReturn(f func(context.Context) error) *MockTransactionCloseCall

+ func (c *MockTransactionCloseCall) Return(arg0 error) *MockTransactionCloseCall

+ type MockTransactionCopyFromCall struct

+ func (c *MockTransactionCopyFromCall) Do(f func(context.Context, string, []storage0.Copiable) error) *MockTransactionCopyFromCall

+ func (c *MockTransactionCopyFromCall) DoAndReturn(f func(context.Context, string, []storage0.Copiable) error) *MockTransactionCopyFromCall

+ func (c *MockTransactionCopyFromCall) Return(arg0 error) *MockTransactionCopyFromCall

+ type MockTransactionDelegationCall struct

+ func (c *MockTransactionDelegationCall) Do(f func(context.Context, uint64, uint64) (storage.Delegation, error)) *MockTransactionDelegationCall

+ func (c *MockTransactionDelegationCall) DoAndReturn(f func(context.Context, uint64, uint64) (storage.Delegation, error)) *MockTransactionDelegationCall

+ func (c *MockTransactionDelegationCall) Return(val storage.Delegation, err error) *MockTransactionDelegationCall

+ type MockTransactionDeleteBalancesCall struct

+ func (c *MockTransactionDeleteBalancesCall) Do(f func(context.Context, []uint64) error) *MockTransactionDeleteBalancesCall

+ func (c *MockTransactionDeleteBalancesCall) DoAndReturn(f func(context.Context, []uint64) error) *MockTransactionDeleteBalancesCall

+ func (c *MockTransactionDeleteBalancesCall) Return(arg0 error) *MockTransactionDeleteBalancesCall

+ type MockTransactionDeleteDelegationsByValidatorCall struct

+ func (c *MockTransactionDeleteDelegationsByValidatorCall) Do(f func(context.Context, ...uint64) error) *MockTransactionDeleteDelegationsByValidatorCall

+ func (c *MockTransactionDeleteDelegationsByValidatorCall) DoAndReturn(f func(context.Context, ...uint64) error) *MockTransactionDeleteDelegationsByValidatorCall

+ func (c *MockTransactionDeleteDelegationsByValidatorCall) Return(arg0 error) *MockTransactionDeleteDelegationsByValidatorCall

+ type MockTransactionDeleteProvidersCall struct

+ func (c *MockTransactionDeleteProvidersCall) Do(f func(context.Context, uint64) error) *MockTransactionDeleteProvidersCall

+ func (c *MockTransactionDeleteProvidersCall) DoAndReturn(f func(context.Context, uint64) error) *MockTransactionDeleteProvidersCall

+ func (c *MockTransactionDeleteProvidersCall) Return(arg0 error) *MockTransactionDeleteProvidersCall

+ type MockTransactionDeleteRollupCall struct

+ func (c *MockTransactionDeleteRollupCall) Do(f func(context.Context, uint64) error) *MockTransactionDeleteRollupCall

+ func (c *MockTransactionDeleteRollupCall) DoAndReturn(f func(context.Context, uint64) error) *MockTransactionDeleteRollupCall

+ func (c *MockTransactionDeleteRollupCall) Return(arg0 error) *MockTransactionDeleteRollupCall

+ type MockTransactionExecCall struct

+ func (c *MockTransactionExecCall) Do(f func(context.Context, string, ...any) (int64, error)) *MockTransactionExecCall

+ func (c *MockTransactionExecCall) DoAndReturn(f func(context.Context, string, ...any) (int64, error)) *MockTransactionExecCall

+ func (c *MockTransactionExecCall) Return(arg0 int64, arg1 error) *MockTransactionExecCall

+ type MockTransactionFlushCall struct

+ func (c *MockTransactionFlushCall) Do(f func(context.Context) error) *MockTransactionFlushCall

+ func (c *MockTransactionFlushCall) DoAndReturn(f func(context.Context) error) *MockTransactionFlushCall

+ func (c *MockTransactionFlushCall) Return(arg0 error) *MockTransactionFlushCall

+ type MockTransactionGetProposerIdCall struct

+ func (c *MockTransactionGetProposerIdCall) Do(f func(context.Context, string) (uint64, error)) *MockTransactionGetProposerIdCall

+ func (c *MockTransactionGetProposerIdCall) DoAndReturn(f func(context.Context, string) (uint64, error)) *MockTransactionGetProposerIdCall

+ func (c *MockTransactionGetProposerIdCall) Return(arg0 uint64, arg1 error) *MockTransactionGetProposerIdCall

+ type MockTransactionHandleErrorCall struct

+ func (c *MockTransactionHandleErrorCall) Do(f func(context.Context, error) error) *MockTransactionHandleErrorCall

+ func (c *MockTransactionHandleErrorCall) DoAndReturn(f func(context.Context, error) error) *MockTransactionHandleErrorCall

+ func (c *MockTransactionHandleErrorCall) Return(arg0 error) *MockTransactionHandleErrorCall

+ type MockTransactionJailCall struct

+ func (c *MockTransactionJailCall) Do(f func(context.Context, ...*storage.Validator) error) *MockTransactionJailCall

+ func (c *MockTransactionJailCall) DoAndReturn(f func(context.Context, ...*storage.Validator) error) *MockTransactionJailCall

+ func (c *MockTransactionJailCall) Return(arg0 error) *MockTransactionJailCall

+ type MockTransactionLastAddressActionCall struct

+ func (c *MockTransactionLastAddressActionCall) Do(f func(context.Context, []byte) (uint64, error)) *MockTransactionLastAddressActionCall

+ func (c *MockTransactionLastAddressActionCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *MockTransactionLastAddressActionCall

+ func (c *MockTransactionLastAddressActionCall) Return(arg0 uint64, arg1 error) *MockTransactionLastAddressActionCall

+ type MockTransactionLastBlockCall struct

+ func (c *MockTransactionLastBlockCall) Do(f func(context.Context) (storage.Block, error)) *MockTransactionLastBlockCall

+ func (c *MockTransactionLastBlockCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *MockTransactionLastBlockCall

+ func (c *MockTransactionLastBlockCall) Return(block storage.Block, err error) *MockTransactionLastBlockCall

+ type MockTransactionLastNamespaceMessageCall struct

+ func (c *MockTransactionLastNamespaceMessageCall) Do(f func(context.Context, uint64) (storage.NamespaceMessage, error)) *MockTransactionLastNamespaceMessageCall

+ func (c *MockTransactionLastNamespaceMessageCall) DoAndReturn(f func(context.Context, uint64) (storage.NamespaceMessage, error)) *MockTransactionLastNamespaceMessageCall

+ func (c *MockTransactionLastNamespaceMessageCall) Return(msg storage.NamespaceMessage, err error) *MockTransactionLastNamespaceMessageCall

+ type MockTransactionNamespaceCall struct

+ func (c *MockTransactionNamespaceCall) Do(f func(context.Context, uint64) (storage.Namespace, error)) *MockTransactionNamespaceCall

+ func (c *MockTransactionNamespaceCall) DoAndReturn(f func(context.Context, uint64) (storage.Namespace, error)) *MockTransactionNamespaceCall

+ func (c *MockTransactionNamespaceCall) Return(ns storage.Namespace, err error) *MockTransactionNamespaceCall

+ type MockTransactionRefreshLeaderboardCall struct

+ func (c *MockTransactionRefreshLeaderboardCall) Do(f func(context.Context) error) *MockTransactionRefreshLeaderboardCall

+ func (c *MockTransactionRefreshLeaderboardCall) DoAndReturn(f func(context.Context) error) *MockTransactionRefreshLeaderboardCall

+ func (c *MockTransactionRefreshLeaderboardCall) Return(arg0 error) *MockTransactionRefreshLeaderboardCall

+ type MockTransactionRetentionBlockSignaturesCall struct

+ func (c *MockTransactionRetentionBlockSignaturesCall) Do(f func(context.Context, types.Level) error) *MockTransactionRetentionBlockSignaturesCall

+ func (c *MockTransactionRetentionBlockSignaturesCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRetentionBlockSignaturesCall

+ func (c *MockTransactionRetentionBlockSignaturesCall) Return(arg0 error) *MockTransactionRetentionBlockSignaturesCall

+ type MockTransactionRetentionCompletedRedelegationsCall struct

+ func (c *MockTransactionRetentionCompletedRedelegationsCall) Do(f func(context.Context, time.Time) error) *MockTransactionRetentionCompletedRedelegationsCall

+ func (c *MockTransactionRetentionCompletedRedelegationsCall) DoAndReturn(f func(context.Context, time.Time) error) *MockTransactionRetentionCompletedRedelegationsCall

+ func (c *MockTransactionRetentionCompletedRedelegationsCall) Return(arg0 error) *MockTransactionRetentionCompletedRedelegationsCall

+ type MockTransactionRetentionCompletedUnbondingsCall struct

+ func (c *MockTransactionRetentionCompletedUnbondingsCall) Do(f func(context.Context, time.Time) error) *MockTransactionRetentionCompletedUnbondingsCall

+ func (c *MockTransactionRetentionCompletedUnbondingsCall) DoAndReturn(f func(context.Context, time.Time) error) *MockTransactionRetentionCompletedUnbondingsCall

+ func (c *MockTransactionRetentionCompletedUnbondingsCall) Return(arg0 error) *MockTransactionRetentionCompletedUnbondingsCall

+ type MockTransactionRollbackAddressesCall struct

+ func (c *MockTransactionRollbackAddressesCall) Do(f func(context.Context, types.Level) ([]storage.Address, error)) *MockTransactionRollbackAddressesCall

+ func (c *MockTransactionRollbackAddressesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Address, error)) *MockTransactionRollbackAddressesCall

+ func (c *MockTransactionRollbackAddressesCall) Return(address []storage.Address, err error) *MockTransactionRollbackAddressesCall

+ type MockTransactionRollbackBlobLogCall struct

+ func (c *MockTransactionRollbackBlobLogCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackBlobLogCall

+ func (c *MockTransactionRollbackBlobLogCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackBlobLogCall

+ func (c *MockTransactionRollbackBlobLogCall) Return(arg0 error) *MockTransactionRollbackBlobLogCall

+ type MockTransactionRollbackBlockCall struct

+ func (c *MockTransactionRollbackBlockCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackBlockCall

+ func (c *MockTransactionRollbackBlockCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackBlockCall

+ func (c *MockTransactionRollbackBlockCall) Return(arg0 error) *MockTransactionRollbackBlockCall

+ type MockTransactionRollbackBlockSignaturesCall struct

+ func (c *MockTransactionRollbackBlockSignaturesCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackBlockSignaturesCall

+ func (c *MockTransactionRollbackBlockSignaturesCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackBlockSignaturesCall

+ func (c *MockTransactionRollbackBlockSignaturesCall) Return(err error) *MockTransactionRollbackBlockSignaturesCall

+ type MockTransactionRollbackBlockStatsCall struct

+ func (c *MockTransactionRollbackBlockStatsCall) Do(f func(context.Context, types.Level) (storage.BlockStats, error)) *MockTransactionRollbackBlockStatsCall

+ func (c *MockTransactionRollbackBlockStatsCall) DoAndReturn(f func(context.Context, types.Level) (storage.BlockStats, error)) *MockTransactionRollbackBlockStatsCall

+ func (c *MockTransactionRollbackBlockStatsCall) Return(stats storage.BlockStats, err error) *MockTransactionRollbackBlockStatsCall

+ type MockTransactionRollbackCall struct

+ func (c *MockTransactionRollbackCall) Do(f func(context.Context) error) *MockTransactionRollbackCall

+ func (c *MockTransactionRollbackCall) DoAndReturn(f func(context.Context) error) *MockTransactionRollbackCall

+ func (c *MockTransactionRollbackCall) Return(arg0 error) *MockTransactionRollbackCall

+ type MockTransactionRollbackEventsCall struct

+ func (c *MockTransactionRollbackEventsCall) Do(f func(context.Context, types.Level) ([]storage.Event, error)) *MockTransactionRollbackEventsCall

+ func (c *MockTransactionRollbackEventsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Event, error)) *MockTransactionRollbackEventsCall

+ func (c *MockTransactionRollbackEventsCall) Return(events []storage.Event, err error) *MockTransactionRollbackEventsCall

+ type MockTransactionRollbackGrantsCall struct

+ func (c *MockTransactionRollbackGrantsCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackGrantsCall

+ func (c *MockTransactionRollbackGrantsCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackGrantsCall

+ func (c *MockTransactionRollbackGrantsCall) Return(arg0 error) *MockTransactionRollbackGrantsCall

+ type MockTransactionRollbackJailsCall struct

+ func (c *MockTransactionRollbackJailsCall) Do(f func(context.Context, types.Level) ([]storage.Jail, error)) *MockTransactionRollbackJailsCall

+ func (c *MockTransactionRollbackJailsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Jail, error)) *MockTransactionRollbackJailsCall

+ func (c *MockTransactionRollbackJailsCall) Return(arg0 []storage.Jail, arg1 error) *MockTransactionRollbackJailsCall

+ type MockTransactionRollbackMessageAddressesCall struct

+ func (c *MockTransactionRollbackMessageAddressesCall) Do(f func(context.Context, []uint64) error) *MockTransactionRollbackMessageAddressesCall

+ func (c *MockTransactionRollbackMessageAddressesCall) DoAndReturn(f func(context.Context, []uint64) error) *MockTransactionRollbackMessageAddressesCall

+ func (c *MockTransactionRollbackMessageAddressesCall) Return(err error) *MockTransactionRollbackMessageAddressesCall

+ type MockTransactionRollbackMessagesCall struct

+ func (c *MockTransactionRollbackMessagesCall) Do(f func(context.Context, types.Level) ([]storage.Message, error)) *MockTransactionRollbackMessagesCall

+ func (c *MockTransactionRollbackMessagesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Message, error)) *MockTransactionRollbackMessagesCall

+ func (c *MockTransactionRollbackMessagesCall) Return(msgs []storage.Message, err error) *MockTransactionRollbackMessagesCall

+ type MockTransactionRollbackNamespaceMessagesCall struct

+ func (c *MockTransactionRollbackNamespaceMessagesCall) Do(f func(context.Context, types.Level) ([]storage.NamespaceMessage, error)) *MockTransactionRollbackNamespaceMessagesCall

+ func (c *MockTransactionRollbackNamespaceMessagesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.NamespaceMessage, error)) *MockTransactionRollbackNamespaceMessagesCall

+ func (c *MockTransactionRollbackNamespaceMessagesCall) Return(msgs []storage.NamespaceMessage, err error) *MockTransactionRollbackNamespaceMessagesCall

+ type MockTransactionRollbackNamespacesCall struct

+ func (c *MockTransactionRollbackNamespacesCall) Do(f func(context.Context, types.Level) ([]storage.Namespace, error)) *MockTransactionRollbackNamespacesCall

+ func (c *MockTransactionRollbackNamespacesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Namespace, error)) *MockTransactionRollbackNamespacesCall

+ func (c *MockTransactionRollbackNamespacesCall) Return(ns []storage.Namespace, err error) *MockTransactionRollbackNamespacesCall

+ type MockTransactionRollbackRedelegationsCall struct

+ func (c *MockTransactionRollbackRedelegationsCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackRedelegationsCall

+ func (c *MockTransactionRollbackRedelegationsCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackRedelegationsCall

+ func (c *MockTransactionRollbackRedelegationsCall) Return(err error) *MockTransactionRollbackRedelegationsCall

+ type MockTransactionRollbackSignersCall struct

+ func (c *MockTransactionRollbackSignersCall) Do(f func(context.Context, []uint64) error) *MockTransactionRollbackSignersCall

+ func (c *MockTransactionRollbackSignersCall) DoAndReturn(f func(context.Context, []uint64) error) *MockTransactionRollbackSignersCall

+ func (c *MockTransactionRollbackSignersCall) Return(err error) *MockTransactionRollbackSignersCall

+ type MockTransactionRollbackStakingLogsCall struct

+ func (c *MockTransactionRollbackStakingLogsCall) Do(f func(context.Context, types.Level) ([]storage.StakingLog, error)) *MockTransactionRollbackStakingLogsCall

+ func (c *MockTransactionRollbackStakingLogsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.StakingLog, error)) *MockTransactionRollbackStakingLogsCall

+ func (c *MockTransactionRollbackStakingLogsCall) Return(arg0 []storage.StakingLog, arg1 error) *MockTransactionRollbackStakingLogsCall

+ type MockTransactionRollbackTxsCall struct

+ func (c *MockTransactionRollbackTxsCall) Do(f func(context.Context, types.Level) ([]storage.Tx, error)) *MockTransactionRollbackTxsCall

+ func (c *MockTransactionRollbackTxsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Tx, error)) *MockTransactionRollbackTxsCall

+ func (c *MockTransactionRollbackTxsCall) Return(txs []storage.Tx, err error) *MockTransactionRollbackTxsCall

+ type MockTransactionRollbackUndelegationsCall struct

+ func (c *MockTransactionRollbackUndelegationsCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackUndelegationsCall

+ func (c *MockTransactionRollbackUndelegationsCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackUndelegationsCall

+ func (c *MockTransactionRollbackUndelegationsCall) Return(err error) *MockTransactionRollbackUndelegationsCall

+ type MockTransactionRollbackValidatorsCall struct

+ func (c *MockTransactionRollbackValidatorsCall) Do(f func(context.Context, types.Level) ([]storage.Validator, error)) *MockTransactionRollbackValidatorsCall

+ func (c *MockTransactionRollbackValidatorsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Validator, error)) *MockTransactionRollbackValidatorsCall

+ func (c *MockTransactionRollbackValidatorsCall) Return(arg0 []storage.Validator, arg1 error) *MockTransactionRollbackValidatorsCall

+ type MockTransactionRollbackVestingAccountsCall struct

+ func (c *MockTransactionRollbackVestingAccountsCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackVestingAccountsCall

+ func (c *MockTransactionRollbackVestingAccountsCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackVestingAccountsCall

+ func (c *MockTransactionRollbackVestingAccountsCall) Return(arg0 error) *MockTransactionRollbackVestingAccountsCall

+ type MockTransactionRollbackVestingPeriodsCall struct

+ func (c *MockTransactionRollbackVestingPeriodsCall) Do(f func(context.Context, types.Level) error) *MockTransactionRollbackVestingPeriodsCall

+ func (c *MockTransactionRollbackVestingPeriodsCall) DoAndReturn(f func(context.Context, types.Level) error) *MockTransactionRollbackVestingPeriodsCall

+ func (c *MockTransactionRollbackVestingPeriodsCall) Return(arg0 error) *MockTransactionRollbackVestingPeriodsCall

+ type MockTransactionSaveAddressesCall struct

+ func (c *MockTransactionSaveAddressesCall) Do(f func(context.Context, ...*storage.Address) (int64, error)) *MockTransactionSaveAddressesCall

+ func (c *MockTransactionSaveAddressesCall) DoAndReturn(f func(context.Context, ...*storage.Address) (int64, error)) *MockTransactionSaveAddressesCall

+ func (c *MockTransactionSaveAddressesCall) Return(arg0 int64, arg1 error) *MockTransactionSaveAddressesCall

+ type MockTransactionSaveBalancesCall struct

+ func (c *MockTransactionSaveBalancesCall) Do(f func(context.Context, ...storage.Balance) error) *MockTransactionSaveBalancesCall

+ func (c *MockTransactionSaveBalancesCall) DoAndReturn(f func(context.Context, ...storage.Balance) error) *MockTransactionSaveBalancesCall

+ func (c *MockTransactionSaveBalancesCall) Return(arg0 error) *MockTransactionSaveBalancesCall

+ type MockTransactionSaveBlobLogsCall struct

+ func (c *MockTransactionSaveBlobLogsCall) Do(f func(context.Context, ...storage.BlobLog) error) *MockTransactionSaveBlobLogsCall

+ func (c *MockTransactionSaveBlobLogsCall) DoAndReturn(f func(context.Context, ...storage.BlobLog) error) *MockTransactionSaveBlobLogsCall

+ func (c *MockTransactionSaveBlobLogsCall) Return(arg0 error) *MockTransactionSaveBlobLogsCall

+ type MockTransactionSaveBlockSignaturesCall struct

+ func (c *MockTransactionSaveBlockSignaturesCall) Do(f func(context.Context, ...storage.BlockSignature) error) *MockTransactionSaveBlockSignaturesCall

+ func (c *MockTransactionSaveBlockSignaturesCall) DoAndReturn(f func(context.Context, ...storage.BlockSignature) error) *MockTransactionSaveBlockSignaturesCall

+ func (c *MockTransactionSaveBlockSignaturesCall) Return(arg0 error) *MockTransactionSaveBlockSignaturesCall

+ type MockTransactionSaveConstantsCall struct

+ func (c *MockTransactionSaveConstantsCall) Do(f func(context.Context, ...storage.Constant) error) *MockTransactionSaveConstantsCall

+ func (c *MockTransactionSaveConstantsCall) DoAndReturn(f func(context.Context, ...storage.Constant) error) *MockTransactionSaveConstantsCall

+ func (c *MockTransactionSaveConstantsCall) Return(arg0 error) *MockTransactionSaveConstantsCall

+ type MockTransactionSaveDelegationsCall struct

+ func (c *MockTransactionSaveDelegationsCall) Do(f func(context.Context, ...storage.Delegation) error) *MockTransactionSaveDelegationsCall

+ func (c *MockTransactionSaveDelegationsCall) DoAndReturn(f func(context.Context, ...storage.Delegation) error) *MockTransactionSaveDelegationsCall

+ func (c *MockTransactionSaveDelegationsCall) Return(arg0 error) *MockTransactionSaveDelegationsCall

+ type MockTransactionSaveEventsCall struct

+ func (c *MockTransactionSaveEventsCall) Do(f func(context.Context, ...storage.Event) error) *MockTransactionSaveEventsCall

+ func (c *MockTransactionSaveEventsCall) DoAndReturn(f func(context.Context, ...storage.Event) error) *MockTransactionSaveEventsCall

+ func (c *MockTransactionSaveEventsCall) Return(arg0 error) *MockTransactionSaveEventsCall

+ type MockTransactionSaveGrantsCall struct

+ func (c *MockTransactionSaveGrantsCall) Do(f func(context.Context, ...storage.Grant) error) *MockTransactionSaveGrantsCall

+ func (c *MockTransactionSaveGrantsCall) DoAndReturn(f func(context.Context, ...storage.Grant) error) *MockTransactionSaveGrantsCall

+ func (c *MockTransactionSaveGrantsCall) Return(arg0 error) *MockTransactionSaveGrantsCall

+ type MockTransactionSaveJailsCall struct

+ func (c *MockTransactionSaveJailsCall) Do(f func(context.Context, ...storage.Jail) error) *MockTransactionSaveJailsCall

+ func (c *MockTransactionSaveJailsCall) DoAndReturn(f func(context.Context, ...storage.Jail) error) *MockTransactionSaveJailsCall

+ func (c *MockTransactionSaveJailsCall) Return(arg0 error) *MockTransactionSaveJailsCall

+ type MockTransactionSaveMessagesCall struct

+ func (c *MockTransactionSaveMessagesCall) Do(f func(context.Context, ...*storage.Message) error) *MockTransactionSaveMessagesCall

+ func (c *MockTransactionSaveMessagesCall) DoAndReturn(f func(context.Context, ...*storage.Message) error) *MockTransactionSaveMessagesCall

+ func (c *MockTransactionSaveMessagesCall) Return(arg0 error) *MockTransactionSaveMessagesCall

+ type MockTransactionSaveMsgAddressesCall struct

+ func (c *MockTransactionSaveMsgAddressesCall) Do(f func(context.Context, ...storage.MsgAddress) error) *MockTransactionSaveMsgAddressesCall

+ func (c *MockTransactionSaveMsgAddressesCall) DoAndReturn(f func(context.Context, ...storage.MsgAddress) error) *MockTransactionSaveMsgAddressesCall

+ func (c *MockTransactionSaveMsgAddressesCall) Return(arg0 error) *MockTransactionSaveMsgAddressesCall

+ type MockTransactionSaveNamespaceMessageCall struct

+ func (c *MockTransactionSaveNamespaceMessageCall) Do(f func(context.Context, ...storage.NamespaceMessage) error) *MockTransactionSaveNamespaceMessageCall

+ func (c *MockTransactionSaveNamespaceMessageCall) DoAndReturn(f func(context.Context, ...storage.NamespaceMessage) error) *MockTransactionSaveNamespaceMessageCall

+ func (c *MockTransactionSaveNamespaceMessageCall) Return(arg0 error) *MockTransactionSaveNamespaceMessageCall

+ type MockTransactionSaveNamespacesCall struct

+ func (c *MockTransactionSaveNamespacesCall) Do(f func(context.Context, ...*storage.Namespace) (int64, error)) *MockTransactionSaveNamespacesCall

+ func (c *MockTransactionSaveNamespacesCall) DoAndReturn(f func(context.Context, ...*storage.Namespace) (int64, error)) *MockTransactionSaveNamespacesCall

+ func (c *MockTransactionSaveNamespacesCall) Return(arg0 int64, arg1 error) *MockTransactionSaveNamespacesCall

+ type MockTransactionSaveProvidersCall struct

+ func (c *MockTransactionSaveProvidersCall) Do(f func(context.Context, ...storage.RollupProvider) error) *MockTransactionSaveProvidersCall

+ func (c *MockTransactionSaveProvidersCall) DoAndReturn(f func(context.Context, ...storage.RollupProvider) error) *MockTransactionSaveProvidersCall

+ func (c *MockTransactionSaveProvidersCall) Return(arg0 error) *MockTransactionSaveProvidersCall

+ type MockTransactionSaveRedelegationsCall struct

+ func (c *MockTransactionSaveRedelegationsCall) Do(f func(context.Context, ...storage.Redelegation) error) *MockTransactionSaveRedelegationsCall

+ func (c *MockTransactionSaveRedelegationsCall) DoAndReturn(f func(context.Context, ...storage.Redelegation) error) *MockTransactionSaveRedelegationsCall

+ func (c *MockTransactionSaveRedelegationsCall) Return(arg0 error) *MockTransactionSaveRedelegationsCall

+ type MockTransactionSaveRollupCall struct

+ func (c *MockTransactionSaveRollupCall) Do(f func(context.Context, *storage.Rollup) error) *MockTransactionSaveRollupCall

+ func (c *MockTransactionSaveRollupCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *MockTransactionSaveRollupCall

+ func (c *MockTransactionSaveRollupCall) Return(arg0 error) *MockTransactionSaveRollupCall

+ type MockTransactionSaveSignersCall struct

+ func (c *MockTransactionSaveSignersCall) Do(f func(context.Context, ...storage.Signer) error) *MockTransactionSaveSignersCall

+ func (c *MockTransactionSaveSignersCall) DoAndReturn(f func(context.Context, ...storage.Signer) error) *MockTransactionSaveSignersCall

+ func (c *MockTransactionSaveSignersCall) Return(arg0 error) *MockTransactionSaveSignersCall

+ type MockTransactionSaveStakingLogsCall struct

+ func (c *MockTransactionSaveStakingLogsCall) Do(f func(context.Context, ...storage.StakingLog) error) *MockTransactionSaveStakingLogsCall

+ func (c *MockTransactionSaveStakingLogsCall) DoAndReturn(f func(context.Context, ...storage.StakingLog) error) *MockTransactionSaveStakingLogsCall

+ func (c *MockTransactionSaveStakingLogsCall) Return(arg0 error) *MockTransactionSaveStakingLogsCall

+ type MockTransactionSaveTransactionsCall struct

+ func (c *MockTransactionSaveTransactionsCall) Do(f func(context.Context, ...storage.Tx) error) *MockTransactionSaveTransactionsCall

+ func (c *MockTransactionSaveTransactionsCall) DoAndReturn(f func(context.Context, ...storage.Tx) error) *MockTransactionSaveTransactionsCall

+ func (c *MockTransactionSaveTransactionsCall) Return(arg0 error) *MockTransactionSaveTransactionsCall

+ type MockTransactionSaveUndelegationsCall struct

+ func (c *MockTransactionSaveUndelegationsCall) Do(f func(context.Context, ...storage.Undelegation) error) *MockTransactionSaveUndelegationsCall

+ func (c *MockTransactionSaveUndelegationsCall) DoAndReturn(f func(context.Context, ...storage.Undelegation) error) *MockTransactionSaveUndelegationsCall

+ func (c *MockTransactionSaveUndelegationsCall) Return(arg0 error) *MockTransactionSaveUndelegationsCall

+ type MockTransactionSaveValidatorsCall struct

+ func (c *MockTransactionSaveValidatorsCall) Do(f func(context.Context, ...*storage.Validator) (int, error)) *MockTransactionSaveValidatorsCall

+ func (c *MockTransactionSaveValidatorsCall) DoAndReturn(f func(context.Context, ...*storage.Validator) (int, error)) *MockTransactionSaveValidatorsCall

+ func (c *MockTransactionSaveValidatorsCall) Return(arg0 int, arg1 error) *MockTransactionSaveValidatorsCall

+ type MockTransactionSaveVestingAccountsCall struct

+ func (c *MockTransactionSaveVestingAccountsCall) Do(f func(context.Context, ...*storage.VestingAccount) error) *MockTransactionSaveVestingAccountsCall

+ func (c *MockTransactionSaveVestingAccountsCall) DoAndReturn(f func(context.Context, ...*storage.VestingAccount) error) *MockTransactionSaveVestingAccountsCall

+ func (c *MockTransactionSaveVestingAccountsCall) Return(arg0 error) *MockTransactionSaveVestingAccountsCall

+ type MockTransactionSaveVestingPeriodsCall struct

+ func (c *MockTransactionSaveVestingPeriodsCall) Do(f func(context.Context, ...storage.VestingPeriod) error) *MockTransactionSaveVestingPeriodsCall

+ func (c *MockTransactionSaveVestingPeriodsCall) DoAndReturn(f func(context.Context, ...storage.VestingPeriod) error) *MockTransactionSaveVestingPeriodsCall

+ func (c *MockTransactionSaveVestingPeriodsCall) Return(arg0 error) *MockTransactionSaveVestingPeriodsCall

+ type MockTransactionStateCall struct

+ func (c *MockTransactionStateCall) Do(f func(context.Context, string) (storage.State, error)) *MockTransactionStateCall

+ func (c *MockTransactionStateCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *MockTransactionStateCall

+ func (c *MockTransactionStateCall) Return(state storage.State, err error) *MockTransactionStateCall

+ type MockTransactionTxCall struct

+ func (c *MockTransactionTxCall) Do(f func() *bun.Tx) *MockTransactionTxCall

+ func (c *MockTransactionTxCall) DoAndReturn(f func() *bun.Tx) *MockTransactionTxCall

+ func (c *MockTransactionTxCall) Return(arg0 *bun.Tx) *MockTransactionTxCall

+ type MockTransactionUpdateCall struct

+ func (c *MockTransactionUpdateCall) Do(f func(context.Context, any) error) *MockTransactionUpdateCall

+ func (c *MockTransactionUpdateCall) DoAndReturn(f func(context.Context, any) error) *MockTransactionUpdateCall

+ func (c *MockTransactionUpdateCall) Return(arg0 error) *MockTransactionUpdateCall

+ type MockTransactionUpdateRollupCall struct

+ func (c *MockTransactionUpdateRollupCall) Do(f func(context.Context, *storage.Rollup) error) *MockTransactionUpdateRollupCall

+ func (c *MockTransactionUpdateRollupCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *MockTransactionUpdateRollupCall

+ func (c *MockTransactionUpdateRollupCall) Return(arg0 error) *MockTransactionUpdateRollupCall

+ type MockTransactionUpdateSlashedDelegationsCall struct

+ func (c *MockTransactionUpdateSlashedDelegationsCall) Do(f func(context.Context, uint64, decimal.Decimal) ([]storage.Balance, error)) *MockTransactionUpdateSlashedDelegationsCall

+ func (c *MockTransactionUpdateSlashedDelegationsCall) DoAndReturn(f func(context.Context, uint64, decimal.Decimal) ([]storage.Balance, error)) *MockTransactionUpdateSlashedDelegationsCall

+ func (c *MockTransactionUpdateSlashedDelegationsCall) Return(arg0 []storage.Balance, arg1 error) *MockTransactionUpdateSlashedDelegationsCall

+ type MockTransactionUpdateValidatorsCall struct

+ func (c *MockTransactionUpdateValidatorsCall) Do(f func(context.Context, ...*storage.Validator) error) *MockTransactionUpdateValidatorsCall

+ func (c *MockTransactionUpdateValidatorsCall) DoAndReturn(f func(context.Context, ...*storage.Validator) error) *MockTransactionUpdateValidatorsCall

+ func (c *MockTransactionUpdateValidatorsCall) Return(arg0 error) *MockTransactionUpdateValidatorsCall

+ type MockTransactionValidatorCall struct

+ func (c *MockTransactionValidatorCall) Do(f func(context.Context, uint64) (storage.Validator, error)) *MockTransactionValidatorCall

+ func (c *MockTransactionValidatorCall) DoAndReturn(f func(context.Context, uint64) (storage.Validator, error)) *MockTransactionValidatorCall

+ func (c *MockTransactionValidatorCall) Return(val storage.Validator, err error) *MockTransactionValidatorCall

v1.9.8

Jul 18, 2024

v1.9.7

Jul 14, 2024

Changes in this version

+ type IStatsChange24hBlockStatsCall struct

+ func (c *IStatsChange24hBlockStatsCall) Do(f func(context.Context) (storage.Change24hBlockStats, error)) *IStatsChange24hBlockStatsCall

+ func (c *IStatsChange24hBlockStatsCall) DoAndReturn(f func(context.Context) (storage.Change24hBlockStats, error)) *IStatsChange24hBlockStatsCall

+ func (c *IStatsChange24hBlockStatsCall) Return(response storage.Change24hBlockStats, err error) *IStatsChange24hBlockStatsCall

+ type IStatsMessagesCount24hCall struct

+ func (c *IStatsMessagesCount24hCall) Do(f func(context.Context) ([]storage.CountItem, error)) *IStatsMessagesCount24hCall

+ func (c *IStatsMessagesCount24hCall) DoAndReturn(f func(context.Context) ([]storage.CountItem, error)) *IStatsMessagesCount24hCall

+ func (c *IStatsMessagesCount24hCall) Return(arg0 []storage.CountItem, arg1 error) *IStatsMessagesCount24hCall

+ type IStatsRollupStats24hCall struct

+ func (c *IStatsRollupStats24hCall) Do(f func(context.Context) ([]storage.RollupStats24h, error)) *IStatsRollupStats24hCall

+ func (c *IStatsRollupStats24hCall) DoAndReturn(f func(context.Context) ([]storage.RollupStats24h, error)) *IStatsRollupStats24hCall

+ func (c *IStatsRollupStats24hCall) Return(arg0 []storage.RollupStats24h, arg1 error) *IStatsRollupStats24hCall

type MockIStats

+ func (m *MockIStats) Change24hBlockStats(ctx context.Context) (storage.Change24hBlockStats, error)

+ func (m *MockIStats) MessagesCount24h(ctx context.Context) ([]storage.CountItem, error)

+ func (m *MockIStats) RollupStats24h(ctx context.Context) ([]storage.RollupStats24h, error)

type MockIStatsMockRecorder

+ func (mr *MockIStatsMockRecorder) Change24hBlockStats(ctx any) *IStatsChange24hBlockStatsCall

+ func (mr *MockIStatsMockRecorder) MessagesCount24h(ctx any) *IStatsMessagesCount24hCall

+ func (mr *MockIStatsMockRecorder) RollupStats24h(ctx any) *IStatsRollupStats24hCall

v1.9.6

Jul 8, 2024

Changes in this version

+ type IStatsSquareSizeCall struct

+ func (c *IStatsSquareSizeCall) Do(...) *IStatsSquareSizeCall

+ func (c *IStatsSquareSizeCall) DoAndReturn(...) *IStatsSquareSizeCall

+ func (c *IStatsSquareSizeCall) Return(arg0 map[int][]storage.SeriesItem, arg1 error) *IStatsSquareSizeCall

type MockIStats

+ func (m *MockIStats) SquareSize(ctx context.Context, from, to *time.Time) (map[int][]storage.SeriesItem, error)

type MockIStatsMockRecorder

+ func (mr *MockIStatsMockRecorder) SquareSize(ctx, from, to any) *IStatsSquareSizeCall

v1.9.5

Jul 4, 2024

v1.9.4

Jul 4, 2024

v1.9.3

Jul 3, 2024

v1.9.2

Jul 3, 2024

Changes in this version

type MockTransaction

+ func (m *MockTransaction) RefreshLeaderboard(ctx context.Context) error

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) RefreshLeaderboard(ctx any) *TransactionRefreshLeaderboardCall

+ type TransactionRefreshLeaderboardCall struct

+ func (c *TransactionRefreshLeaderboardCall) Do(f func(context.Context) error) *TransactionRefreshLeaderboardCall

+ func (c *TransactionRefreshLeaderboardCall) DoAndReturn(f func(context.Context) error) *TransactionRefreshLeaderboardCall

+ func (c *TransactionRefreshLeaderboardCall) Return(arg0 error) *TransactionRefreshLeaderboardCall

v1.9.1

Jun 30, 2024

Changes in this version

+ type IStatsCumulativeSeriesCall struct

+ func (c *IStatsCumulativeSeriesCall) Do(...) *IStatsCumulativeSeriesCall

+ func (c *IStatsCumulativeSeriesCall) DoAndReturn(...) *IStatsCumulativeSeriesCall

+ func (c *IStatsCumulativeSeriesCall) Return(arg0 []storage.SeriesItem, arg1 error) *IStatsCumulativeSeriesCall

type MockIStats

+ func (m *MockIStats) CumulativeSeries(ctx context.Context, timeframe storage.Timeframe, name string, ...) ([]storage.SeriesItem, error)

type MockIStatsMockRecorder

+ func (mr *MockIStatsMockRecorder) CumulativeSeries(ctx, timeframe, name, req any) *IStatsCumulativeSeriesCall

v1.9.0

Jun 26, 2024

v1.8.4

Jun 17, 2024

v1.8.3

Jun 9, 2024

v1.8.2

Jun 9, 2024

v1.8.1

Jun 9, 2024

Changes in this version

+ type ITxIdByHashCall struct

+ func (c *ITxIdByHashCall) Do(f func(context.Context, []byte) (uint64, error)) *ITxIdByHashCall

+ func (c *ITxIdByHashCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *ITxIdByHashCall

+ func (c *ITxIdByHashCall) Return(arg0 uint64, arg1 error) *ITxIdByHashCall

type MockITx

+ func (m *MockITx) IdByHash(ctx context.Context, hash []byte) (uint64, error)

type MockITxMockRecorder

+ func (mr *MockITxMockRecorder) IdByHash(ctx, hash any) *ITxIdByHashCall

v1.8.0

Jun 3, 2024

v1.7.5

May 29, 2024

Changes in this version

+ type IBlobLogBlobCall struct

+ func (c *IBlobLogBlobCall) Do(f func(context.Context, types.Level, uint64, string) (storage.BlobLog, error)) *IBlobLogBlobCall

+ func (c *IBlobLogBlobCall) DoAndReturn(f func(context.Context, types.Level, uint64, string) (storage.BlobLog, error)) *IBlobLogBlobCall

+ func (c *IBlobLogBlobCall) Return(arg0 storage.BlobLog, arg1 error) *IBlobLogBlobCall

type MockIBlobLog

+ func (m *MockIBlobLog) Blob(ctx context.Context, height types.Level, nsId uint64, commitment string) (storage.BlobLog, error)

type MockIBlobLogMockRecorder

+ func (mr *MockIBlobLogMockRecorder) Blob(ctx, height, nsId, commitment any) *IBlobLogBlobCall

v1.7.4

May 28, 2024

Changes in this version

+ type IAddressIdByHashCall struct

+ func (c *IAddressIdByHashCall) Do(f func(context.Context, []byte) (uint64, error)) *IAddressIdByHashCall

+ func (c *IAddressIdByHashCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *IAddressIdByHashCall

+ func (c *IAddressIdByHashCall) Return(arg0 uint64, arg1 error) *IAddressIdByHashCall

+ type IAddressSeriesCall struct

+ func (c *IAddressSeriesCall) Do(...) *IAddressSeriesCall

+ func (c *IAddressSeriesCall) DoAndReturn(...) *IAddressSeriesCall

+ func (c *IAddressSeriesCall) Return(items []storage.HistogramItem, err error) *IAddressSeriesCall

type MockIAddress

+ func (m *MockIAddress) IdByHash(ctx context.Context, hash []byte) (uint64, error)

+ func (m *MockIAddress) Series(ctx context.Context, addressId uint64, timeframe storage.Timeframe, ...) ([]storage.HistogramItem, error)

type MockIAddressMockRecorder

+ func (mr *MockIAddressMockRecorder) IdByHash(ctx, hash any) *IAddressIdByHashCall

+ func (mr *MockIAddressMockRecorder) Series(ctx, addressId, timeframe, column, req any) *IAddressSeriesCall

v1.7.3

May 6, 2024

v1.7.2

May 6, 2024

v1.7.1

May 1, 2024

v1.7.0

Apr 1, 2024

Changes in this version

+ type IBlobLogExportByProvidersCall struct

+ func (c *IBlobLogExportByProvidersCall) Do(...) *IBlobLogExportByProvidersCall

+ func (c *IBlobLogExportByProvidersCall) DoAndReturn(...) *IBlobLogExportByProvidersCall

+ func (c *IBlobLogExportByProvidersCall) Return(err error) *IBlobLogExportByProvidersCall

+ type IGrantByGranteeCall struct

+ func (c *IGrantByGranteeCall) Do(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *IGrantByGranteeCall

+ func (c *IGrantByGranteeCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *IGrantByGranteeCall

+ func (c *IGrantByGranteeCall) Return(arg0 []storage.Grant, arg1 error) *IGrantByGranteeCall

+ type IGrantByGranterCall struct

+ func (c *IGrantByGranterCall) Do(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *IGrantByGranterCall

+ func (c *IGrantByGranterCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Grant, error)) *IGrantByGranterCall

+ func (c *IGrantByGranterCall) Return(arg0 []storage.Grant, arg1 error) *IGrantByGranterCall

+ type IGrantCursorListCall struct

+ func (c *IGrantCursorListCall) Do(...) *IGrantCursorListCall

+ func (c *IGrantCursorListCall) DoAndReturn(...) *IGrantCursorListCall

+ func (c *IGrantCursorListCall) Return(arg0 []*storage.Grant, arg1 error) *IGrantCursorListCall

+ type IGrantGetByIDCall struct

+ func (c *IGrantGetByIDCall) Do(f func(context.Context, uint64) (*storage.Grant, error)) *IGrantGetByIDCall

+ func (c *IGrantGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Grant, error)) *IGrantGetByIDCall

+ func (c *IGrantGetByIDCall) Return(arg0 *storage.Grant, arg1 error) *IGrantGetByIDCall

+ type IGrantIsNoRowsCall struct

+ func (c *IGrantIsNoRowsCall) Do(f func(error) bool) *IGrantIsNoRowsCall

+ func (c *IGrantIsNoRowsCall) DoAndReturn(f func(error) bool) *IGrantIsNoRowsCall

+ func (c *IGrantIsNoRowsCall) Return(arg0 bool) *IGrantIsNoRowsCall

+ type IGrantLastIDCall struct

+ func (c *IGrantLastIDCall) Do(f func(context.Context) (uint64, error)) *IGrantLastIDCall

+ func (c *IGrantLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IGrantLastIDCall

+ func (c *IGrantLastIDCall) Return(arg0 uint64, arg1 error) *IGrantLastIDCall

+ type IGrantListCall struct

+ func (c *IGrantListCall) Do(...) *IGrantListCall

+ func (c *IGrantListCall) DoAndReturn(...) *IGrantListCall

+ func (c *IGrantListCall) Return(arg0 []*storage.Grant, arg1 error) *IGrantListCall

+ type IGrantSaveCall struct

+ func (c *IGrantSaveCall) Do(f func(context.Context, *storage.Grant) error) *IGrantSaveCall

+ func (c *IGrantSaveCall) DoAndReturn(f func(context.Context, *storage.Grant) error) *IGrantSaveCall

+ func (c *IGrantSaveCall) Return(arg0 error) *IGrantSaveCall

+ type IGrantUpdateCall struct

+ func (c *IGrantUpdateCall) Do(f func(context.Context, *storage.Grant) error) *IGrantUpdateCall

+ func (c *IGrantUpdateCall) DoAndReturn(f func(context.Context, *storage.Grant) error) *IGrantUpdateCall

+ func (c *IGrantUpdateCall) Return(arg0 error) *IGrantUpdateCall

+ type IVestingAccountByAddressCall struct

+ func (c *IVestingAccountByAddressCall) Do(...) *IVestingAccountByAddressCall

+ func (c *IVestingAccountByAddressCall) DoAndReturn(...) *IVestingAccountByAddressCall

+ func (c *IVestingAccountByAddressCall) Return(arg0 []storage.VestingAccount, arg1 error) *IVestingAccountByAddressCall

+ type IVestingAccountCursorListCall struct

+ func (c *IVestingAccountCursorListCall) Do(...) *IVestingAccountCursorListCall

+ func (c *IVestingAccountCursorListCall) DoAndReturn(...) *IVestingAccountCursorListCall

+ func (c *IVestingAccountCursorListCall) Return(arg0 []*storage.VestingAccount, arg1 error) *IVestingAccountCursorListCall

+ type IVestingAccountGetByIDCall struct

+ func (c *IVestingAccountGetByIDCall) Do(f func(context.Context, uint64) (*storage.VestingAccount, error)) *IVestingAccountGetByIDCall

+ func (c *IVestingAccountGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.VestingAccount, error)) *IVestingAccountGetByIDCall

+ func (c *IVestingAccountGetByIDCall) Return(arg0 *storage.VestingAccount, arg1 error) *IVestingAccountGetByIDCall

+ type IVestingAccountIsNoRowsCall struct

+ func (c *IVestingAccountIsNoRowsCall) Do(f func(error) bool) *IVestingAccountIsNoRowsCall

+ func (c *IVestingAccountIsNoRowsCall) DoAndReturn(f func(error) bool) *IVestingAccountIsNoRowsCall

+ func (c *IVestingAccountIsNoRowsCall) Return(arg0 bool) *IVestingAccountIsNoRowsCall

+ type IVestingAccountLastIDCall struct

+ func (c *IVestingAccountLastIDCall) Do(f func(context.Context) (uint64, error)) *IVestingAccountLastIDCall

+ func (c *IVestingAccountLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IVestingAccountLastIDCall

+ func (c *IVestingAccountLastIDCall) Return(arg0 uint64, arg1 error) *IVestingAccountLastIDCall

+ type IVestingAccountListCall struct

+ func (c *IVestingAccountListCall) Do(...) *IVestingAccountListCall

+ func (c *IVestingAccountListCall) DoAndReturn(...) *IVestingAccountListCall

+ func (c *IVestingAccountListCall) Return(arg0 []*storage.VestingAccount, arg1 error) *IVestingAccountListCall

+ type IVestingAccountSaveCall struct

+ func (c *IVestingAccountSaveCall) Do(f func(context.Context, *storage.VestingAccount) error) *IVestingAccountSaveCall

+ func (c *IVestingAccountSaveCall) DoAndReturn(f func(context.Context, *storage.VestingAccount) error) *IVestingAccountSaveCall

+ func (c *IVestingAccountSaveCall) Return(arg0 error) *IVestingAccountSaveCall

+ type IVestingAccountUpdateCall struct

+ func (c *IVestingAccountUpdateCall) Do(f func(context.Context, *storage.VestingAccount) error) *IVestingAccountUpdateCall

+ func (c *IVestingAccountUpdateCall) DoAndReturn(f func(context.Context, *storage.VestingAccount) error) *IVestingAccountUpdateCall

+ func (c *IVestingAccountUpdateCall) Return(arg0 error) *IVestingAccountUpdateCall

+ type IVestingPeriodByVestingCall struct

+ func (c *IVestingPeriodByVestingCall) Do(f func(context.Context, uint64, int, int) ([]storage.VestingPeriod, error)) *IVestingPeriodByVestingCall

+ func (c *IVestingPeriodByVestingCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.VestingPeriod, error)) *IVestingPeriodByVestingCall

+ func (c *IVestingPeriodByVestingCall) Return(arg0 []storage.VestingPeriod, arg1 error) *IVestingPeriodByVestingCall

+ type IVestingPeriodCursorListCall struct

+ func (c *IVestingPeriodCursorListCall) Do(...) *IVestingPeriodCursorListCall

+ func (c *IVestingPeriodCursorListCall) DoAndReturn(...) *IVestingPeriodCursorListCall

+ func (c *IVestingPeriodCursorListCall) Return(arg0 []*storage.VestingPeriod, arg1 error) *IVestingPeriodCursorListCall

+ type IVestingPeriodGetByIDCall struct

+ func (c *IVestingPeriodGetByIDCall) Do(f func(context.Context, uint64) (*storage.VestingPeriod, error)) *IVestingPeriodGetByIDCall

+ func (c *IVestingPeriodGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.VestingPeriod, error)) *IVestingPeriodGetByIDCall

+ func (c *IVestingPeriodGetByIDCall) Return(arg0 *storage.VestingPeriod, arg1 error) *IVestingPeriodGetByIDCall

+ type IVestingPeriodIsNoRowsCall struct

+ func (c *IVestingPeriodIsNoRowsCall) Do(f func(error) bool) *IVestingPeriodIsNoRowsCall

+ func (c *IVestingPeriodIsNoRowsCall) DoAndReturn(f func(error) bool) *IVestingPeriodIsNoRowsCall

+ func (c *IVestingPeriodIsNoRowsCall) Return(arg0 bool) *IVestingPeriodIsNoRowsCall

+ type IVestingPeriodLastIDCall struct

+ func (c *IVestingPeriodLastIDCall) Do(f func(context.Context) (uint64, error)) *IVestingPeriodLastIDCall

+ func (c *IVestingPeriodLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IVestingPeriodLastIDCall

+ func (c *IVestingPeriodLastIDCall) Return(arg0 uint64, arg1 error) *IVestingPeriodLastIDCall

+ type IVestingPeriodListCall struct

+ func (c *IVestingPeriodListCall) Do(...) *IVestingPeriodListCall

+ func (c *IVestingPeriodListCall) DoAndReturn(...) *IVestingPeriodListCall

+ func (c *IVestingPeriodListCall) Return(arg0 []*storage.VestingPeriod, arg1 error) *IVestingPeriodListCall

+ type IVestingPeriodSaveCall struct

+ func (c *IVestingPeriodSaveCall) Do(f func(context.Context, *storage.VestingPeriod) error) *IVestingPeriodSaveCall

+ func (c *IVestingPeriodSaveCall) DoAndReturn(f func(context.Context, *storage.VestingPeriod) error) *IVestingPeriodSaveCall

+ func (c *IVestingPeriodSaveCall) Return(arg0 error) *IVestingPeriodSaveCall

+ type IVestingPeriodUpdateCall struct

+ func (c *IVestingPeriodUpdateCall) Do(f func(context.Context, *storage.VestingPeriod) error) *IVestingPeriodUpdateCall

+ func (c *IVestingPeriodUpdateCall) DoAndReturn(f func(context.Context, *storage.VestingPeriod) error) *IVestingPeriodUpdateCall

+ func (c *IVestingPeriodUpdateCall) Return(arg0 error) *IVestingPeriodUpdateCall

type MockIBlobLog

+ func (m *MockIBlobLog) ExportByProviders(ctx context.Context, providers []storage.RollupProvider, from, to time.Time, ...) error

type MockIBlobLogMockRecorder

+ func (mr *MockIBlobLogMockRecorder) ExportByProviders(ctx, providers, from, to, stream any) *IBlobLogExportByProvidersCall

+ type MockIGrant struct

+ func NewMockIGrant(ctrl *gomock.Controller) *MockIGrant

+ func (m *MockIGrant) ByGrantee(ctx context.Context, id uint64, limit, offset int) ([]storage.Grant, error)

+ func (m *MockIGrant) ByGranter(ctx context.Context, id uint64, limit, offset int) ([]storage.Grant, error)

+ func (m *MockIGrant) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Grant, error)

+ func (m *MockIGrant) EXPECT() *MockIGrantMockRecorder

+ func (m *MockIGrant) GetByID(ctx context.Context, id uint64) (*storage.Grant, error)

+ func (m *MockIGrant) IsNoRows(err error) bool

+ func (m *MockIGrant) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIGrant) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Grant, error)

+ func (m_2 *MockIGrant) Save(ctx context.Context, m *storage.Grant) error

+ func (m_2 *MockIGrant) Update(ctx context.Context, m *storage.Grant) error

+ type MockIGrantMockRecorder struct

+ func (mr *MockIGrantMockRecorder) ByGrantee(ctx, id, limit, offset any) *IGrantByGranteeCall

+ func (mr *MockIGrantMockRecorder) ByGranter(ctx, id, limit, offset any) *IGrantByGranterCall

+ func (mr *MockIGrantMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IGrantCursorListCall

+ func (mr *MockIGrantMockRecorder) GetByID(ctx, id any) *IGrantGetByIDCall

+ func (mr *MockIGrantMockRecorder) IsNoRows(err any) *IGrantIsNoRowsCall

+ func (mr *MockIGrantMockRecorder) LastID(ctx any) *IGrantLastIDCall

+ func (mr *MockIGrantMockRecorder) List(ctx, limit, offset, order any) *IGrantListCall

+ func (mr *MockIGrantMockRecorder) Save(ctx, m any) *IGrantSaveCall

+ func (mr *MockIGrantMockRecorder) Update(ctx, m any) *IGrantUpdateCall

+ type MockIVestingAccount struct

+ func NewMockIVestingAccount(ctrl *gomock.Controller) *MockIVestingAccount

+ func (m *MockIVestingAccount) ByAddress(ctx context.Context, addressId uint64, limit, offset int, showEnded bool) ([]storage.VestingAccount, error)

+ func (m *MockIVestingAccount) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.VestingAccount, error)

+ func (m *MockIVestingAccount) EXPECT() *MockIVestingAccountMockRecorder

+ func (m *MockIVestingAccount) GetByID(ctx context.Context, id uint64) (*storage.VestingAccount, error)

+ func (m *MockIVestingAccount) IsNoRows(err error) bool

+ func (m *MockIVestingAccount) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIVestingAccount) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.VestingAccount, error)

+ func (m_2 *MockIVestingAccount) Save(ctx context.Context, m *storage.VestingAccount) error

+ func (m_2 *MockIVestingAccount) Update(ctx context.Context, m *storage.VestingAccount) error

+ type MockIVestingAccountMockRecorder struct

+ func (mr *MockIVestingAccountMockRecorder) ByAddress(ctx, addressId, limit, offset, showEnded any) *IVestingAccountByAddressCall

+ func (mr *MockIVestingAccountMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IVestingAccountCursorListCall

+ func (mr *MockIVestingAccountMockRecorder) GetByID(ctx, id any) *IVestingAccountGetByIDCall

+ func (mr *MockIVestingAccountMockRecorder) IsNoRows(err any) *IVestingAccountIsNoRowsCall

+ func (mr *MockIVestingAccountMockRecorder) LastID(ctx any) *IVestingAccountLastIDCall

+ func (mr *MockIVestingAccountMockRecorder) List(ctx, limit, offset, order any) *IVestingAccountListCall

+ func (mr *MockIVestingAccountMockRecorder) Save(ctx, m any) *IVestingAccountSaveCall

+ func (mr *MockIVestingAccountMockRecorder) Update(ctx, m any) *IVestingAccountUpdateCall

+ type MockIVestingPeriod struct

+ func NewMockIVestingPeriod(ctrl *gomock.Controller) *MockIVestingPeriod

+ func (m *MockIVestingPeriod) ByVesting(ctx context.Context, id uint64, limit, offset int) ([]storage.VestingPeriod, error)

+ func (m *MockIVestingPeriod) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.VestingPeriod, error)

+ func (m *MockIVestingPeriod) EXPECT() *MockIVestingPeriodMockRecorder

+ func (m *MockIVestingPeriod) GetByID(ctx context.Context, id uint64) (*storage.VestingPeriod, error)

+ func (m *MockIVestingPeriod) IsNoRows(err error) bool

+ func (m *MockIVestingPeriod) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIVestingPeriod) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.VestingPeriod, error)

+ func (m_2 *MockIVestingPeriod) Save(ctx context.Context, m *storage.VestingPeriod) error

+ func (m_2 *MockIVestingPeriod) Update(ctx context.Context, m *storage.VestingPeriod) error

+ type MockIVestingPeriodMockRecorder struct

+ func (mr *MockIVestingPeriodMockRecorder) ByVesting(ctx, id, limit, offset any) *IVestingPeriodByVestingCall

+ func (mr *MockIVestingPeriodMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IVestingPeriodCursorListCall

+ func (mr *MockIVestingPeriodMockRecorder) GetByID(ctx, id any) *IVestingPeriodGetByIDCall

+ func (mr *MockIVestingPeriodMockRecorder) IsNoRows(err any) *IVestingPeriodIsNoRowsCall

+ func (mr *MockIVestingPeriodMockRecorder) LastID(ctx any) *IVestingPeriodLastIDCall

+ func (mr *MockIVestingPeriodMockRecorder) List(ctx, limit, offset, order any) *IVestingPeriodListCall

+ func (mr *MockIVestingPeriodMockRecorder) Save(ctx, m any) *IVestingPeriodSaveCall

+ func (mr *MockIVestingPeriodMockRecorder) Update(ctx, m any) *IVestingPeriodUpdateCall

type MockTransaction

+ func (m *MockTransaction) RollbackGrants(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) RollbackVestingAccounts(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) RollbackVestingPeriods(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) SaveGrants(ctx context.Context, grants ...storage.Grant) error

+ func (m *MockTransaction) SaveVestingAccounts(ctx context.Context, accounts ...*storage.VestingAccount) error

+ func (m *MockTransaction) SaveVestingPeriods(ctx context.Context, periods ...storage.VestingPeriod) error

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) RollbackGrants(ctx, height any) *TransactionRollbackGrantsCall

+ func (mr *MockTransactionMockRecorder) RollbackVestingAccounts(ctx, height any) *TransactionRollbackVestingAccountsCall

+ func (mr *MockTransactionMockRecorder) RollbackVestingPeriods(ctx, height any) *TransactionRollbackVestingPeriodsCall

+ func (mr *MockTransactionMockRecorder) SaveGrants(ctx any, grants ...any) *TransactionSaveGrantsCall

+ func (mr *MockTransactionMockRecorder) SaveVestingAccounts(ctx any, accounts ...any) *TransactionSaveVestingAccountsCall

+ func (mr *MockTransactionMockRecorder) SaveVestingPeriods(ctx any, periods ...any) *TransactionSaveVestingPeriodsCall

+ type TransactionRollbackGrantsCall struct

+ func (c *TransactionRollbackGrantsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackGrantsCall

+ func (c *TransactionRollbackGrantsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackGrantsCall

+ func (c *TransactionRollbackGrantsCall) Return(arg0 error) *TransactionRollbackGrantsCall

+ type TransactionRollbackVestingAccountsCall struct

+ func (c *TransactionRollbackVestingAccountsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackVestingAccountsCall

+ func (c *TransactionRollbackVestingAccountsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackVestingAccountsCall

+ func (c *TransactionRollbackVestingAccountsCall) Return(arg0 error) *TransactionRollbackVestingAccountsCall

+ type TransactionRollbackVestingPeriodsCall struct

+ func (c *TransactionRollbackVestingPeriodsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackVestingPeriodsCall

+ func (c *TransactionRollbackVestingPeriodsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackVestingPeriodsCall

+ func (c *TransactionRollbackVestingPeriodsCall) Return(arg0 error) *TransactionRollbackVestingPeriodsCall

+ type TransactionSaveGrantsCall struct

+ func (c *TransactionSaveGrantsCall) Do(f func(context.Context, ...storage.Grant) error) *TransactionSaveGrantsCall

+ func (c *TransactionSaveGrantsCall) DoAndReturn(f func(context.Context, ...storage.Grant) error) *TransactionSaveGrantsCall

+ func (c *TransactionSaveGrantsCall) Return(arg0 error) *TransactionSaveGrantsCall

+ type TransactionSaveVestingAccountsCall struct

+ func (c *TransactionSaveVestingAccountsCall) Do(f func(context.Context, ...*storage.VestingAccount) error) *TransactionSaveVestingAccountsCall

+ func (c *TransactionSaveVestingAccountsCall) DoAndReturn(f func(context.Context, ...*storage.VestingAccount) error) *TransactionSaveVestingAccountsCall

+ func (c *TransactionSaveVestingAccountsCall) Return(arg0 error) *TransactionSaveVestingAccountsCall

+ type TransactionSaveVestingPeriodsCall struct

+ func (c *TransactionSaveVestingPeriodsCall) Do(f func(context.Context, ...storage.VestingPeriod) error) *TransactionSaveVestingPeriodsCall

+ func (c *TransactionSaveVestingPeriodsCall) DoAndReturn(f func(context.Context, ...storage.VestingPeriod) error) *TransactionSaveVestingPeriodsCall

+ func (c *TransactionSaveVestingPeriodsCall) Return(arg0 error) *TransactionSaveVestingPeriodsCall

v1.6.4

Mar 12, 2024

v1.6.3

Mar 12, 2024

Changes in this version

type MockTransaction

+ func (m *MockTransaction) Delegation(ctx context.Context, validatorId, addressId uint64) (storage.Delegation, error)

+ func (m *MockTransaction) Validator(ctx context.Context, id uint64) (storage.Validator, error)

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) Delegation(ctx, validatorId, addressId any) *TransactionDelegationCall

+ func (mr *MockTransactionMockRecorder) Validator(ctx, id any) *TransactionValidatorCall

+ type TransactionDelegationCall struct

+ func (c *TransactionDelegationCall) Do(f func(context.Context, uint64, uint64) (storage.Delegation, error)) *TransactionDelegationCall

+ func (c *TransactionDelegationCall) DoAndReturn(f func(context.Context, uint64, uint64) (storage.Delegation, error)) *TransactionDelegationCall

+ func (c *TransactionDelegationCall) Return(val storage.Delegation, err error) *TransactionDelegationCall

+ type TransactionValidatorCall struct

+ func (c *TransactionValidatorCall) Do(f func(context.Context, uint64) (storage.Validator, error)) *TransactionValidatorCall

+ func (c *TransactionValidatorCall) DoAndReturn(f func(context.Context, uint64) (storage.Validator, error)) *TransactionValidatorCall

+ func (c *TransactionValidatorCall) Return(val storage.Validator, err error) *TransactionValidatorCall

v1.6.2

Mar 10, 2024

v1.6.1

Mar 10, 2024

Changes in this version

+ type IRollupDistributionCall struct

+ func (c *IRollupDistributionCall) Do(...) *IRollupDistributionCall

+ func (c *IRollupDistributionCall) DoAndReturn(...) *IRollupDistributionCall

+ func (c *IRollupDistributionCall) Return(items []storage.DistributionItem, err error) *IRollupDistributionCall

type MockIRollup

+ func (m *MockIRollup) Distribution(ctx context.Context, rollupId uint64, series, groupBy string) ([]storage.DistributionItem, error)

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) Distribution(ctx, rollupId, series, groupBy any) *IRollupDistributionCall

v1.6.0

Mar 3, 2024

Changes in this version

+ type IDelegationByAddressCall struct

+ func (c *IDelegationByAddressCall) Do(f func(context.Context, uint64, int, int) ([]storage.Delegation, error)) *IDelegationByAddressCall

+ func (c *IDelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Delegation, error)) *IDelegationByAddressCall

+ func (c *IDelegationByAddressCall) Return(arg0 []storage.Delegation, arg1 error) *IDelegationByAddressCall

+ type IDelegationByValidatorCall struct

+ func (c *IDelegationByValidatorCall) Do(f func(context.Context, uint64, int, int) ([]storage.Delegation, error)) *IDelegationByValidatorCall

+ func (c *IDelegationByValidatorCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Delegation, error)) *IDelegationByValidatorCall

+ func (c *IDelegationByValidatorCall) Return(arg0 []storage.Delegation, arg1 error) *IDelegationByValidatorCall

+ type IDelegationCursorListCall struct

+ func (c *IDelegationCursorListCall) Do(...) *IDelegationCursorListCall

+ func (c *IDelegationCursorListCall) DoAndReturn(...) *IDelegationCursorListCall

+ func (c *IDelegationCursorListCall) Return(arg0 []*storage.Delegation, arg1 error) *IDelegationCursorListCall

+ type IDelegationGetByIDCall struct

+ func (c *IDelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Delegation, error)) *IDelegationGetByIDCall

+ func (c *IDelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Delegation, error)) *IDelegationGetByIDCall

+ func (c *IDelegationGetByIDCall) Return(arg0 *storage.Delegation, arg1 error) *IDelegationGetByIDCall

+ type IDelegationIsNoRowsCall struct

+ func (c *IDelegationIsNoRowsCall) Do(f func(error) bool) *IDelegationIsNoRowsCall

+ func (c *IDelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *IDelegationIsNoRowsCall

+ func (c *IDelegationIsNoRowsCall) Return(arg0 bool) *IDelegationIsNoRowsCall

+ type IDelegationLastIDCall struct

+ func (c *IDelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *IDelegationLastIDCall

+ func (c *IDelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDelegationLastIDCall

+ func (c *IDelegationLastIDCall) Return(arg0 uint64, arg1 error) *IDelegationLastIDCall

+ type IDelegationListCall struct

+ func (c *IDelegationListCall) Do(...) *IDelegationListCall

+ func (c *IDelegationListCall) DoAndReturn(...) *IDelegationListCall

+ func (c *IDelegationListCall) Return(arg0 []*storage.Delegation, arg1 error) *IDelegationListCall

+ type IDelegationSaveCall struct

+ func (c *IDelegationSaveCall) Do(f func(context.Context, *storage.Delegation) error) *IDelegationSaveCall

+ func (c *IDelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Delegation) error) *IDelegationSaveCall

+ func (c *IDelegationSaveCall) Return(arg0 error) *IDelegationSaveCall

+ type IDelegationUpdateCall struct

+ func (c *IDelegationUpdateCall) Do(f func(context.Context, *storage.Delegation) error) *IDelegationUpdateCall

+ func (c *IDelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Delegation) error) *IDelegationUpdateCall

+ func (c *IDelegationUpdateCall) Return(arg0 error) *IDelegationUpdateCall

+ type IJailByValidatorCall struct

+ func (c *IJailByValidatorCall) Do(f func(context.Context, uint64, int, int) ([]storage.Jail, error)) *IJailByValidatorCall

+ func (c *IJailByValidatorCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Jail, error)) *IJailByValidatorCall

+ func (c *IJailByValidatorCall) Return(arg0 []storage.Jail, arg1 error) *IJailByValidatorCall

+ type IJailCursorListCall struct

+ func (c *IJailCursorListCall) Do(...) *IJailCursorListCall

+ func (c *IJailCursorListCall) DoAndReturn(...) *IJailCursorListCall

+ func (c *IJailCursorListCall) Return(arg0 []*storage.Jail, arg1 error) *IJailCursorListCall

+ type IJailGetByIDCall struct

+ func (c *IJailGetByIDCall) Do(f func(context.Context, uint64) (*storage.Jail, error)) *IJailGetByIDCall

+ func (c *IJailGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Jail, error)) *IJailGetByIDCall

+ func (c *IJailGetByIDCall) Return(arg0 *storage.Jail, arg1 error) *IJailGetByIDCall

+ type IJailIsNoRowsCall struct

+ func (c *IJailIsNoRowsCall) Do(f func(error) bool) *IJailIsNoRowsCall

+ func (c *IJailIsNoRowsCall) DoAndReturn(f func(error) bool) *IJailIsNoRowsCall

+ func (c *IJailIsNoRowsCall) Return(arg0 bool) *IJailIsNoRowsCall

+ type IJailLastIDCall struct

+ func (c *IJailLastIDCall) Do(f func(context.Context) (uint64, error)) *IJailLastIDCall

+ func (c *IJailLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IJailLastIDCall

+ func (c *IJailLastIDCall) Return(arg0 uint64, arg1 error) *IJailLastIDCall

+ type IJailListCall struct

+ func (c *IJailListCall) Do(...) *IJailListCall

+ func (c *IJailListCall) DoAndReturn(...) *IJailListCall

+ func (c *IJailListCall) Return(arg0 []*storage.Jail, arg1 error) *IJailListCall

+ type IJailSaveCall struct

+ func (c *IJailSaveCall) Do(f func(context.Context, *storage.Jail) error) *IJailSaveCall

+ func (c *IJailSaveCall) DoAndReturn(f func(context.Context, *storage.Jail) error) *IJailSaveCall

+ func (c *IJailSaveCall) Return(arg0 error) *IJailSaveCall

+ type IJailUpdateCall struct

+ func (c *IJailUpdateCall) Do(f func(context.Context, *storage.Jail) error) *IJailUpdateCall

+ func (c *IJailUpdateCall) DoAndReturn(f func(context.Context, *storage.Jail) error) *IJailUpdateCall

+ func (c *IJailUpdateCall) Return(arg0 error) *IJailUpdateCall

+ type IRedelegationByAddressCall struct

+ func (c *IRedelegationByAddressCall) Do(f func(context.Context, uint64, int, int) ([]storage.Redelegation, error)) *IRedelegationByAddressCall

+ func (c *IRedelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Redelegation, error)) *IRedelegationByAddressCall

+ func (c *IRedelegationByAddressCall) Return(arg0 []storage.Redelegation, arg1 error) *IRedelegationByAddressCall

+ type IRedelegationCursorListCall struct

+ func (c *IRedelegationCursorListCall) Do(...) *IRedelegationCursorListCall

+ func (c *IRedelegationCursorListCall) DoAndReturn(...) *IRedelegationCursorListCall

+ func (c *IRedelegationCursorListCall) Return(arg0 []*storage.Redelegation, arg1 error) *IRedelegationCursorListCall

+ type IRedelegationGetByIDCall struct

+ func (c *IRedelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Redelegation, error)) *IRedelegationGetByIDCall

+ func (c *IRedelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Redelegation, error)) *IRedelegationGetByIDCall

+ func (c *IRedelegationGetByIDCall) Return(arg0 *storage.Redelegation, arg1 error) *IRedelegationGetByIDCall

+ type IRedelegationIsNoRowsCall struct

+ func (c *IRedelegationIsNoRowsCall) Do(f func(error) bool) *IRedelegationIsNoRowsCall

+ func (c *IRedelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *IRedelegationIsNoRowsCall

+ func (c *IRedelegationIsNoRowsCall) Return(arg0 bool) *IRedelegationIsNoRowsCall

+ type IRedelegationLastIDCall struct

+ func (c *IRedelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *IRedelegationLastIDCall

+ func (c *IRedelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IRedelegationLastIDCall

+ func (c *IRedelegationLastIDCall) Return(arg0 uint64, arg1 error) *IRedelegationLastIDCall

+ type IRedelegationListCall struct

+ func (c *IRedelegationListCall) Do(...) *IRedelegationListCall

+ func (c *IRedelegationListCall) DoAndReturn(...) *IRedelegationListCall

+ func (c *IRedelegationListCall) Return(arg0 []*storage.Redelegation, arg1 error) *IRedelegationListCall

+ type IRedelegationSaveCall struct

+ func (c *IRedelegationSaveCall) Do(f func(context.Context, *storage.Redelegation) error) *IRedelegationSaveCall

+ func (c *IRedelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Redelegation) error) *IRedelegationSaveCall

+ func (c *IRedelegationSaveCall) Return(arg0 error) *IRedelegationSaveCall

+ type IRedelegationUpdateCall struct

+ func (c *IRedelegationUpdateCall) Do(f func(context.Context, *storage.Redelegation) error) *IRedelegationUpdateCall

+ func (c *IRedelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Redelegation) error) *IRedelegationUpdateCall

+ func (c *IRedelegationUpdateCall) Return(arg0 error) *IRedelegationUpdateCall

+ type IStakingLogByValidatorCall struct

+ func (c *IStakingLogByValidatorCall) Do(f func(context.Context, uint64, int, int) ([]storage.StakingLog, error)) *IStakingLogByValidatorCall

+ func (c *IStakingLogByValidatorCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.StakingLog, error)) *IStakingLogByValidatorCall

+ func (c *IStakingLogByValidatorCall) Return(arg0 []storage.StakingLog, arg1 error) *IStakingLogByValidatorCall

+ type IStakingLogCursorListCall struct

+ func (c *IStakingLogCursorListCall) Do(...) *IStakingLogCursorListCall

+ func (c *IStakingLogCursorListCall) DoAndReturn(...) *IStakingLogCursorListCall

+ func (c *IStakingLogCursorListCall) Return(arg0 []*storage.StakingLog, arg1 error) *IStakingLogCursorListCall

+ type IStakingLogGetByIDCall struct

+ func (c *IStakingLogGetByIDCall) Do(f func(context.Context, uint64) (*storage.StakingLog, error)) *IStakingLogGetByIDCall

+ func (c *IStakingLogGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.StakingLog, error)) *IStakingLogGetByIDCall

+ func (c *IStakingLogGetByIDCall) Return(arg0 *storage.StakingLog, arg1 error) *IStakingLogGetByIDCall

+ type IStakingLogIsNoRowsCall struct

+ func (c *IStakingLogIsNoRowsCall) Do(f func(error) bool) *IStakingLogIsNoRowsCall

+ func (c *IStakingLogIsNoRowsCall) DoAndReturn(f func(error) bool) *IStakingLogIsNoRowsCall

+ func (c *IStakingLogIsNoRowsCall) Return(arg0 bool) *IStakingLogIsNoRowsCall

+ type IStakingLogLastIDCall struct

+ func (c *IStakingLogLastIDCall) Do(f func(context.Context) (uint64, error)) *IStakingLogLastIDCall

+ func (c *IStakingLogLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStakingLogLastIDCall

+ func (c *IStakingLogLastIDCall) Return(arg0 uint64, arg1 error) *IStakingLogLastIDCall

+ type IStakingLogListCall struct

+ func (c *IStakingLogListCall) Do(...) *IStakingLogListCall

+ func (c *IStakingLogListCall) DoAndReturn(...) *IStakingLogListCall

+ func (c *IStakingLogListCall) Return(arg0 []*storage.StakingLog, arg1 error) *IStakingLogListCall

+ type IStakingLogSaveCall struct

+ func (c *IStakingLogSaveCall) Do(f func(context.Context, *storage.StakingLog) error) *IStakingLogSaveCall

+ func (c *IStakingLogSaveCall) DoAndReturn(f func(context.Context, *storage.StakingLog) error) *IStakingLogSaveCall

+ func (c *IStakingLogSaveCall) Return(arg0 error) *IStakingLogSaveCall

+ type IStakingLogUpdateCall struct

+ func (c *IStakingLogUpdateCall) Do(f func(context.Context, *storage.StakingLog) error) *IStakingLogUpdateCall

+ func (c *IStakingLogUpdateCall) DoAndReturn(f func(context.Context, *storage.StakingLog) error) *IStakingLogUpdateCall

+ func (c *IStakingLogUpdateCall) Return(arg0 error) *IStakingLogUpdateCall

+ type IStatsStakingSeriesCall struct

+ func (c *IStatsStakingSeriesCall) Do(...) *IStatsStakingSeriesCall

+ func (c *IStatsStakingSeriesCall) DoAndReturn(...) *IStatsStakingSeriesCall

+ func (c *IStatsStakingSeriesCall) Return(response []storage.SeriesItem, err error) *IStatsStakingSeriesCall

+ type IUndelegationByAddressCall struct

+ func (c *IUndelegationByAddressCall) Do(f func(context.Context, uint64, int, int) ([]storage.Undelegation, error)) *IUndelegationByAddressCall

+ func (c *IUndelegationByAddressCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Undelegation, error)) *IUndelegationByAddressCall

+ func (c *IUndelegationByAddressCall) Return(arg0 []storage.Undelegation, arg1 error) *IUndelegationByAddressCall

+ type IUndelegationCursorListCall struct

+ func (c *IUndelegationCursorListCall) Do(...) *IUndelegationCursorListCall

+ func (c *IUndelegationCursorListCall) DoAndReturn(...) *IUndelegationCursorListCall

+ func (c *IUndelegationCursorListCall) Return(arg0 []*storage.Undelegation, arg1 error) *IUndelegationCursorListCall

+ type IUndelegationGetByIDCall struct

+ func (c *IUndelegationGetByIDCall) Do(f func(context.Context, uint64) (*storage.Undelegation, error)) *IUndelegationGetByIDCall

+ func (c *IUndelegationGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Undelegation, error)) *IUndelegationGetByIDCall

+ func (c *IUndelegationGetByIDCall) Return(arg0 *storage.Undelegation, arg1 error) *IUndelegationGetByIDCall

+ type IUndelegationIsNoRowsCall struct

+ func (c *IUndelegationIsNoRowsCall) Do(f func(error) bool) *IUndelegationIsNoRowsCall

+ func (c *IUndelegationIsNoRowsCall) DoAndReturn(f func(error) bool) *IUndelegationIsNoRowsCall

+ func (c *IUndelegationIsNoRowsCall) Return(arg0 bool) *IUndelegationIsNoRowsCall

+ type IUndelegationLastIDCall struct

+ func (c *IUndelegationLastIDCall) Do(f func(context.Context) (uint64, error)) *IUndelegationLastIDCall

+ func (c *IUndelegationLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IUndelegationLastIDCall

+ func (c *IUndelegationLastIDCall) Return(arg0 uint64, arg1 error) *IUndelegationLastIDCall

+ type IUndelegationListCall struct

+ func (c *IUndelegationListCall) Do(...) *IUndelegationListCall

+ func (c *IUndelegationListCall) DoAndReturn(...) *IUndelegationListCall

+ func (c *IUndelegationListCall) Return(arg0 []*storage.Undelegation, arg1 error) *IUndelegationListCall

+ type IUndelegationSaveCall struct

+ func (c *IUndelegationSaveCall) Do(f func(context.Context, *storage.Undelegation) error) *IUndelegationSaveCall

+ func (c *IUndelegationSaveCall) DoAndReturn(f func(context.Context, *storage.Undelegation) error) *IUndelegationSaveCall

+ func (c *IUndelegationSaveCall) Return(arg0 error) *IUndelegationSaveCall

+ type IUndelegationUpdateCall struct

+ func (c *IUndelegationUpdateCall) Do(f func(context.Context, *storage.Undelegation) error) *IUndelegationUpdateCall

+ func (c *IUndelegationUpdateCall) DoAndReturn(f func(context.Context, *storage.Undelegation) error) *IUndelegationUpdateCall

+ func (c *IUndelegationUpdateCall) Return(arg0 error) *IUndelegationUpdateCall

+ type IValidatorJailedCountCall struct

+ func (c *IValidatorJailedCountCall) Do(f func(context.Context) (int, error)) *IValidatorJailedCountCall

+ func (c *IValidatorJailedCountCall) DoAndReturn(f func(context.Context) (int, error)) *IValidatorJailedCountCall

+ func (c *IValidatorJailedCountCall) Return(arg0 int, arg1 error) *IValidatorJailedCountCall

+ type IValidatorListByPowerCall struct

+ func (c *IValidatorListByPowerCall) Do(f func(context.Context, storage.ValidatorFilters) ([]storage.Validator, error)) *IValidatorListByPowerCall

+ func (c *IValidatorListByPowerCall) DoAndReturn(f func(context.Context, storage.ValidatorFilters) ([]storage.Validator, error)) *IValidatorListByPowerCall

+ func (c *IValidatorListByPowerCall) Return(arg0 []storage.Validator, arg1 error) *IValidatorListByPowerCall

+ type IValidatorTotalVotingPowerCall struct

+ func (c *IValidatorTotalVotingPowerCall) Do(f func(context.Context) (decimal.Decimal, error)) *IValidatorTotalVotingPowerCall

+ func (c *IValidatorTotalVotingPowerCall) DoAndReturn(f func(context.Context) (decimal.Decimal, error)) *IValidatorTotalVotingPowerCall

+ func (c *IValidatorTotalVotingPowerCall) Return(arg0 decimal.Decimal, arg1 error) *IValidatorTotalVotingPowerCall

+ type MockIDelegation struct

+ func NewMockIDelegation(ctrl *gomock.Controller) *MockIDelegation

+ func (m *MockIDelegation) ByAddress(ctx context.Context, addressId uint64, limit, offset int) ([]storage.Delegation, error)

+ func (m *MockIDelegation) ByValidator(ctx context.Context, validatorId uint64, limit, offset int) ([]storage.Delegation, error)

+ func (m *MockIDelegation) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Delegation, error)

+ func (m *MockIDelegation) EXPECT() *MockIDelegationMockRecorder

+ func (m *MockIDelegation) GetByID(ctx context.Context, id uint64) (*storage.Delegation, error)

+ func (m *MockIDelegation) IsNoRows(err error) bool

+ func (m *MockIDelegation) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIDelegation) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Delegation, error)

+ func (m_2 *MockIDelegation) Save(ctx context.Context, m *storage.Delegation) error

+ func (m_2 *MockIDelegation) Update(ctx context.Context, m *storage.Delegation) error

+ type MockIDelegationMockRecorder struct

+ func (mr *MockIDelegationMockRecorder) ByAddress(ctx, addressId, limit, offset any) *IDelegationByAddressCall

+ func (mr *MockIDelegationMockRecorder) ByValidator(ctx, validatorId, limit, offset any) *IDelegationByValidatorCall

+ func (mr *MockIDelegationMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDelegationCursorListCall

+ func (mr *MockIDelegationMockRecorder) GetByID(ctx, id any) *IDelegationGetByIDCall

+ func (mr *MockIDelegationMockRecorder) IsNoRows(err any) *IDelegationIsNoRowsCall

+ func (mr *MockIDelegationMockRecorder) LastID(ctx any) *IDelegationLastIDCall

+ func (mr *MockIDelegationMockRecorder) List(ctx, limit, offset, order any) *IDelegationListCall

+ func (mr *MockIDelegationMockRecorder) Save(ctx, m any) *IDelegationSaveCall

+ func (mr *MockIDelegationMockRecorder) Update(ctx, m any) *IDelegationUpdateCall

+ type MockIJail struct

+ func NewMockIJail(ctrl *gomock.Controller) *MockIJail

+ func (m *MockIJail) ByValidator(ctx context.Context, id uint64, limit, offset int) ([]storage.Jail, error)

+ func (m *MockIJail) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Jail, error)

+ func (m *MockIJail) EXPECT() *MockIJailMockRecorder

+ func (m *MockIJail) GetByID(ctx context.Context, id uint64) (*storage.Jail, error)

+ func (m *MockIJail) IsNoRows(err error) bool

+ func (m *MockIJail) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIJail) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Jail, error)

+ func (m_2 *MockIJail) Save(ctx context.Context, m *storage.Jail) error

+ func (m_2 *MockIJail) Update(ctx context.Context, m *storage.Jail) error

+ type MockIJailMockRecorder struct

+ func (mr *MockIJailMockRecorder) ByValidator(ctx, id, limit, offset any) *IJailByValidatorCall

+ func (mr *MockIJailMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IJailCursorListCall

+ func (mr *MockIJailMockRecorder) GetByID(ctx, id any) *IJailGetByIDCall

+ func (mr *MockIJailMockRecorder) IsNoRows(err any) *IJailIsNoRowsCall

+ func (mr *MockIJailMockRecorder) LastID(ctx any) *IJailLastIDCall

+ func (mr *MockIJailMockRecorder) List(ctx, limit, offset, order any) *IJailListCall

+ func (mr *MockIJailMockRecorder) Save(ctx, m any) *IJailSaveCall

+ func (mr *MockIJailMockRecorder) Update(ctx, m any) *IJailUpdateCall

+ type MockIRedelegation struct

+ func NewMockIRedelegation(ctrl *gomock.Controller) *MockIRedelegation

+ func (m *MockIRedelegation) ByAddress(ctx context.Context, addressId uint64, limit, offset int) ([]storage.Redelegation, error)

+ func (m *MockIRedelegation) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Redelegation, error)

+ func (m *MockIRedelegation) EXPECT() *MockIRedelegationMockRecorder

+ func (m *MockIRedelegation) GetByID(ctx context.Context, id uint64) (*storage.Redelegation, error)

+ func (m *MockIRedelegation) IsNoRows(err error) bool

+ func (m *MockIRedelegation) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIRedelegation) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Redelegation, error)

+ func (m_2 *MockIRedelegation) Save(ctx context.Context, m *storage.Redelegation) error

+ func (m_2 *MockIRedelegation) Update(ctx context.Context, m *storage.Redelegation) error

+ type MockIRedelegationMockRecorder struct

+ func (mr *MockIRedelegationMockRecorder) ByAddress(ctx, addressId, limit, offset any) *IRedelegationByAddressCall

+ func (mr *MockIRedelegationMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IRedelegationCursorListCall

+ func (mr *MockIRedelegationMockRecorder) GetByID(ctx, id any) *IRedelegationGetByIDCall

+ func (mr *MockIRedelegationMockRecorder) IsNoRows(err any) *IRedelegationIsNoRowsCall

+ func (mr *MockIRedelegationMockRecorder) LastID(ctx any) *IRedelegationLastIDCall

+ func (mr *MockIRedelegationMockRecorder) List(ctx, limit, offset, order any) *IRedelegationListCall

+ func (mr *MockIRedelegationMockRecorder) Save(ctx, m any) *IRedelegationSaveCall

+ func (mr *MockIRedelegationMockRecorder) Update(ctx, m any) *IRedelegationUpdateCall

+ type MockIStakingLog struct

+ func NewMockIStakingLog(ctrl *gomock.Controller) *MockIStakingLog

+ func (m *MockIStakingLog) ByValidator(ctx context.Context, validatorId uint64, limit, offset int) ([]storage.StakingLog, error)

+ func (m *MockIStakingLog) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.StakingLog, error)

+ func (m *MockIStakingLog) EXPECT() *MockIStakingLogMockRecorder

+ func (m *MockIStakingLog) GetByID(ctx context.Context, id uint64) (*storage.StakingLog, error)

+ func (m *MockIStakingLog) IsNoRows(err error) bool

+ func (m *MockIStakingLog) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIStakingLog) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.StakingLog, error)

+ func (m_2 *MockIStakingLog) Save(ctx context.Context, m *storage.StakingLog) error

+ func (m_2 *MockIStakingLog) Update(ctx context.Context, m *storage.StakingLog) error

+ type MockIStakingLogMockRecorder struct

+ func (mr *MockIStakingLogMockRecorder) ByValidator(ctx, validatorId, limit, offset any) *IStakingLogByValidatorCall

+ func (mr *MockIStakingLogMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStakingLogCursorListCall

+ func (mr *MockIStakingLogMockRecorder) GetByID(ctx, id any) *IStakingLogGetByIDCall

+ func (mr *MockIStakingLogMockRecorder) IsNoRows(err any) *IStakingLogIsNoRowsCall

+ func (mr *MockIStakingLogMockRecorder) LastID(ctx any) *IStakingLogLastIDCall

+ func (mr *MockIStakingLogMockRecorder) List(ctx, limit, offset, order any) *IStakingLogListCall

+ func (mr *MockIStakingLogMockRecorder) Save(ctx, m any) *IStakingLogSaveCall

+ func (mr *MockIStakingLogMockRecorder) Update(ctx, m any) *IStakingLogUpdateCall

type MockIStats

+ func (m *MockIStats) StakingSeries(ctx context.Context, timeframe storage.Timeframe, name string, ...) ([]storage.SeriesItem, error)

type MockIStatsMockRecorder

+ func (mr *MockIStatsMockRecorder) StakingSeries(ctx, timeframe, name, validatorId, req any) *IStatsStakingSeriesCall

+ type MockIUndelegation struct

+ func NewMockIUndelegation(ctrl *gomock.Controller) *MockIUndelegation

+ func (m *MockIUndelegation) ByAddress(ctx context.Context, addressId uint64, limit, offset int) ([]storage.Undelegation, error)

+ func (m *MockIUndelegation) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Undelegation, error)

+ func (m *MockIUndelegation) EXPECT() *MockIUndelegationMockRecorder

+ func (m *MockIUndelegation) GetByID(ctx context.Context, id uint64) (*storage.Undelegation, error)

+ func (m *MockIUndelegation) IsNoRows(err error) bool

+ func (m *MockIUndelegation) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIUndelegation) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Undelegation, error)

+ func (m_2 *MockIUndelegation) Save(ctx context.Context, m *storage.Undelegation) error

+ func (m_2 *MockIUndelegation) Update(ctx context.Context, m *storage.Undelegation) error

+ type MockIUndelegationMockRecorder struct

+ func (mr *MockIUndelegationMockRecorder) ByAddress(ctx, addressId, limit, offset any) *IUndelegationByAddressCall

+ func (mr *MockIUndelegationMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IUndelegationCursorListCall

+ func (mr *MockIUndelegationMockRecorder) GetByID(ctx, id any) *IUndelegationGetByIDCall

+ func (mr *MockIUndelegationMockRecorder) IsNoRows(err any) *IUndelegationIsNoRowsCall

+ func (mr *MockIUndelegationMockRecorder) LastID(ctx any) *IUndelegationLastIDCall

+ func (mr *MockIUndelegationMockRecorder) List(ctx, limit, offset, order any) *IUndelegationListCall

+ func (mr *MockIUndelegationMockRecorder) Save(ctx, m any) *IUndelegationSaveCall

+ func (mr *MockIUndelegationMockRecorder) Update(ctx, m any) *IUndelegationUpdateCall

type MockIValidator

+ func (m *MockIValidator) JailedCount(ctx context.Context) (int, error)

+ func (m *MockIValidator) ListByPower(ctx context.Context, fltrs storage.ValidatorFilters) ([]storage.Validator, error)

+ func (m *MockIValidator) TotalVotingPower(ctx context.Context) (decimal.Decimal, error)

type MockIValidatorMockRecorder

+ func (mr *MockIValidatorMockRecorder) JailedCount(ctx any) *IValidatorJailedCountCall

+ func (mr *MockIValidatorMockRecorder) ListByPower(ctx, fltrs any) *IValidatorListByPowerCall

+ func (mr *MockIValidatorMockRecorder) TotalVotingPower(ctx any) *IValidatorTotalVotingPowerCall

type MockTransaction

+ func (m *MockTransaction) CancelUnbondings(ctx context.Context, cancellations ...storage.Undelegation) error

+ func (m *MockTransaction) DeleteDelegationsByValidator(ctx context.Context, ids ...uint64) error

+ func (m *MockTransaction) Jail(ctx context.Context, validators ...*storage.Validator) error

+ func (m *MockTransaction) RetentionCompletedRedelegations(ctx context.Context, blockTime time.Time) error

+ func (m *MockTransaction) RetentionCompletedUnbondings(ctx context.Context, blockTime time.Time) error

+ func (m *MockTransaction) RollbackJails(ctx context.Context, height types.Level) ([]storage.Jail, error)

+ func (m *MockTransaction) RollbackRedelegations(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) RollbackStakingLogs(ctx context.Context, height types.Level) ([]storage.StakingLog, error)

+ func (m *MockTransaction) RollbackUndelegations(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) SaveDelegations(ctx context.Context, delegations ...storage.Delegation) error

+ func (m *MockTransaction) SaveJails(ctx context.Context, jails ...storage.Jail) error

+ func (m *MockTransaction) SaveRedelegations(ctx context.Context, redelegations ...storage.Redelegation) error

+ func (m *MockTransaction) SaveStakingLogs(ctx context.Context, logs ...storage.StakingLog) error

+ func (m *MockTransaction) SaveUndelegations(ctx context.Context, undelegations ...storage.Undelegation) error

+ func (m *MockTransaction) UpdateSlashedDelegations(ctx context.Context, validatorId uint64, fraction decimal.Decimal) ([]storage.Balance, error)

+ func (m *MockTransaction) UpdateValidators(ctx context.Context, validators ...*storage.Validator) error

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) CancelUnbondings(ctx any, cancellations ...any) *TransactionCancelUnbondingsCall

+ func (mr *MockTransactionMockRecorder) DeleteDelegationsByValidator(ctx any, ids ...any) *TransactionDeleteDelegationsByValidatorCall

+ func (mr *MockTransactionMockRecorder) Jail(ctx any, validators ...any) *TransactionJailCall

+ func (mr *MockTransactionMockRecorder) RetentionCompletedRedelegations(ctx, blockTime any) *TransactionRetentionCompletedRedelegationsCall

+ func (mr *MockTransactionMockRecorder) RetentionCompletedUnbondings(ctx, blockTime any) *TransactionRetentionCompletedUnbondingsCall

+ func (mr *MockTransactionMockRecorder) RollbackJails(ctx, height any) *TransactionRollbackJailsCall

+ func (mr *MockTransactionMockRecorder) RollbackRedelegations(ctx, height any) *TransactionRollbackRedelegationsCall

+ func (mr *MockTransactionMockRecorder) RollbackStakingLogs(ctx, height any) *TransactionRollbackStakingLogsCall

+ func (mr *MockTransactionMockRecorder) RollbackUndelegations(ctx, height any) *TransactionRollbackUndelegationsCall

+ func (mr *MockTransactionMockRecorder) SaveDelegations(ctx any, delegations ...any) *TransactionSaveDelegationsCall

+ func (mr *MockTransactionMockRecorder) SaveJails(ctx any, jails ...any) *TransactionSaveJailsCall

+ func (mr *MockTransactionMockRecorder) SaveRedelegations(ctx any, redelegations ...any) *TransactionSaveRedelegationsCall

+ func (mr *MockTransactionMockRecorder) SaveStakingLogs(ctx any, logs ...any) *TransactionSaveStakingLogsCall

+ func (mr *MockTransactionMockRecorder) SaveUndelegations(ctx any, undelegations ...any) *TransactionSaveUndelegationsCall

+ func (mr *MockTransactionMockRecorder) UpdateSlashedDelegations(ctx, validatorId, fraction any) *TransactionUpdateSlashedDelegationsCall

+ func (mr *MockTransactionMockRecorder) UpdateValidators(ctx any, validators ...any) *TransactionUpdateValidatorsCall

+ type TransactionCancelUnbondingsCall struct

+ func (c *TransactionCancelUnbondingsCall) Do(f func(context.Context, ...storage.Undelegation) error) *TransactionCancelUnbondingsCall

+ func (c *TransactionCancelUnbondingsCall) DoAndReturn(f func(context.Context, ...storage.Undelegation) error) *TransactionCancelUnbondingsCall

+ func (c *TransactionCancelUnbondingsCall) Return(arg0 error) *TransactionCancelUnbondingsCall

+ type TransactionDeleteDelegationsByValidatorCall struct

+ func (c *TransactionDeleteDelegationsByValidatorCall) Do(f func(context.Context, ...uint64) error) *TransactionDeleteDelegationsByValidatorCall

+ func (c *TransactionDeleteDelegationsByValidatorCall) DoAndReturn(f func(context.Context, ...uint64) error) *TransactionDeleteDelegationsByValidatorCall

+ func (c *TransactionDeleteDelegationsByValidatorCall) Return(arg0 error) *TransactionDeleteDelegationsByValidatorCall

+ type TransactionJailCall struct

+ func (c *TransactionJailCall) Do(f func(context.Context, ...*storage.Validator) error) *TransactionJailCall

+ func (c *TransactionJailCall) DoAndReturn(f func(context.Context, ...*storage.Validator) error) *TransactionJailCall

+ func (c *TransactionJailCall) Return(arg0 error) *TransactionJailCall

+ type TransactionRetentionCompletedRedelegationsCall struct

+ func (c *TransactionRetentionCompletedRedelegationsCall) Do(f func(context.Context, time.Time) error) *TransactionRetentionCompletedRedelegationsCall

+ func (c *TransactionRetentionCompletedRedelegationsCall) DoAndReturn(f func(context.Context, time.Time) error) *TransactionRetentionCompletedRedelegationsCall

+ func (c *TransactionRetentionCompletedRedelegationsCall) Return(arg0 error) *TransactionRetentionCompletedRedelegationsCall

+ type TransactionRetentionCompletedUnbondingsCall struct

+ func (c *TransactionRetentionCompletedUnbondingsCall) Do(f func(context.Context, time.Time) error) *TransactionRetentionCompletedUnbondingsCall

+ func (c *TransactionRetentionCompletedUnbondingsCall) DoAndReturn(f func(context.Context, time.Time) error) *TransactionRetentionCompletedUnbondingsCall

+ func (c *TransactionRetentionCompletedUnbondingsCall) Return(arg0 error) *TransactionRetentionCompletedUnbondingsCall

+ type TransactionRollbackJailsCall struct

+ func (c *TransactionRollbackJailsCall) Do(f func(context.Context, types.Level) ([]storage.Jail, error)) *TransactionRollbackJailsCall

+ func (c *TransactionRollbackJailsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Jail, error)) *TransactionRollbackJailsCall

+ func (c *TransactionRollbackJailsCall) Return(arg0 []storage.Jail, arg1 error) *TransactionRollbackJailsCall

+ type TransactionRollbackRedelegationsCall struct

+ func (c *TransactionRollbackRedelegationsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackRedelegationsCall

+ func (c *TransactionRollbackRedelegationsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackRedelegationsCall

+ func (c *TransactionRollbackRedelegationsCall) Return(err error) *TransactionRollbackRedelegationsCall

+ type TransactionRollbackStakingLogsCall struct

+ func (c *TransactionRollbackStakingLogsCall) Do(f func(context.Context, types.Level) ([]storage.StakingLog, error)) *TransactionRollbackStakingLogsCall

+ func (c *TransactionRollbackStakingLogsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.StakingLog, error)) *TransactionRollbackStakingLogsCall

+ func (c *TransactionRollbackStakingLogsCall) Return(arg0 []storage.StakingLog, arg1 error) *TransactionRollbackStakingLogsCall

+ type TransactionRollbackUndelegationsCall struct

+ func (c *TransactionRollbackUndelegationsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackUndelegationsCall

+ func (c *TransactionRollbackUndelegationsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackUndelegationsCall

+ func (c *TransactionRollbackUndelegationsCall) Return(err error) *TransactionRollbackUndelegationsCall

+ type TransactionSaveDelegationsCall struct

+ func (c *TransactionSaveDelegationsCall) Do(f func(context.Context, ...storage.Delegation) error) *TransactionSaveDelegationsCall

+ func (c *TransactionSaveDelegationsCall) DoAndReturn(f func(context.Context, ...storage.Delegation) error) *TransactionSaveDelegationsCall

+ func (c *TransactionSaveDelegationsCall) Return(arg0 error) *TransactionSaveDelegationsCall

+ type TransactionSaveJailsCall struct

+ func (c *TransactionSaveJailsCall) Do(f func(context.Context, ...storage.Jail) error) *TransactionSaveJailsCall

+ func (c *TransactionSaveJailsCall) DoAndReturn(f func(context.Context, ...storage.Jail) error) *TransactionSaveJailsCall

+ func (c *TransactionSaveJailsCall) Return(arg0 error) *TransactionSaveJailsCall

+ type TransactionSaveRedelegationsCall struct

+ func (c *TransactionSaveRedelegationsCall) Do(f func(context.Context, ...storage.Redelegation) error) *TransactionSaveRedelegationsCall

+ func (c *TransactionSaveRedelegationsCall) DoAndReturn(f func(context.Context, ...storage.Redelegation) error) *TransactionSaveRedelegationsCall

+ func (c *TransactionSaveRedelegationsCall) Return(arg0 error) *TransactionSaveRedelegationsCall

+ type TransactionSaveStakingLogsCall struct

+ func (c *TransactionSaveStakingLogsCall) Do(f func(context.Context, ...storage.StakingLog) error) *TransactionSaveStakingLogsCall

+ func (c *TransactionSaveStakingLogsCall) DoAndReturn(f func(context.Context, ...storage.StakingLog) error) *TransactionSaveStakingLogsCall

+ func (c *TransactionSaveStakingLogsCall) Return(arg0 error) *TransactionSaveStakingLogsCall

+ type TransactionSaveUndelegationsCall struct

+ func (c *TransactionSaveUndelegationsCall) Do(f func(context.Context, ...storage.Undelegation) error) *TransactionSaveUndelegationsCall

+ func (c *TransactionSaveUndelegationsCall) DoAndReturn(f func(context.Context, ...storage.Undelegation) error) *TransactionSaveUndelegationsCall

+ func (c *TransactionSaveUndelegationsCall) Return(arg0 error) *TransactionSaveUndelegationsCall

+ type TransactionUpdateSlashedDelegationsCall struct

+ func (c *TransactionUpdateSlashedDelegationsCall) Do(f func(context.Context, uint64, decimal.Decimal) ([]storage.Balance, error)) *TransactionUpdateSlashedDelegationsCall

+ func (c *TransactionUpdateSlashedDelegationsCall) DoAndReturn(f func(context.Context, uint64, decimal.Decimal) ([]storage.Balance, error)) *TransactionUpdateSlashedDelegationsCall

+ func (c *TransactionUpdateSlashedDelegationsCall) Return(arg0 []storage.Balance, arg1 error) *TransactionUpdateSlashedDelegationsCall

+ type TransactionUpdateValidatorsCall struct

+ func (c *TransactionUpdateValidatorsCall) Do(f func(context.Context, ...*storage.Validator) error) *TransactionUpdateValidatorsCall

+ func (c *TransactionUpdateValidatorsCall) DoAndReturn(f func(context.Context, ...*storage.Validator) error) *TransactionUpdateValidatorsCall

+ func (c *TransactionUpdateValidatorsCall) Return(arg0 error) *TransactionUpdateValidatorsCall

v1.5.2

Feb 23, 2024

v1.5.1

Feb 19, 2024

v1.5.0

Feb 16, 2024

Changes in this version

+ type ExportCloseCall struct

+ func (c *ExportCloseCall) Do(f func() error) *ExportCloseCall

+ func (c *ExportCloseCall) DoAndReturn(f func() error) *ExportCloseCall

+ func (c *ExportCloseCall) Return(arg0 error) *ExportCloseCall

+ type ExportToCsvCall struct

+ func (c *ExportToCsvCall) Do(f func(context.Context, io.Writer, string) error) *ExportToCsvCall

+ func (c *ExportToCsvCall) DoAndReturn(f func(context.Context, io.Writer, string) error) *ExportToCsvCall

+ func (c *ExportToCsvCall) Return(arg0 error) *ExportToCsvCall

+ type IBlockTimeCall struct

+ func (c *IBlockTimeCall) Do(f func(context.Context, types.Level) (time.Time, error)) *IBlockTimeCall

+ func (c *IBlockTimeCall) DoAndReturn(f func(context.Context, types.Level) (time.Time, error)) *IBlockTimeCall

+ func (c *IBlockTimeCall) Return(arg0 time.Time, arg1 error) *IBlockTimeCall

+ type IRollupRollupsByNamespaceCall struct

+ func (c *IRollupRollupsByNamespaceCall) Do(f func(context.Context, uint64, int, int) ([]storage.Rollup, error)) *IRollupRollupsByNamespaceCall

+ func (c *IRollupRollupsByNamespaceCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Rollup, error)) *IRollupRollupsByNamespaceCall

+ func (c *IRollupRollupsByNamespaceCall) Return(rollups []storage.Rollup, err error) *IRollupRollupsByNamespaceCall

+ type MockExport struct

+ func NewMockExport(ctrl *gomock.Controller) *MockExport

+ func (m *MockExport) Close() error

+ func (m *MockExport) EXPECT() *MockExportMockRecorder

+ func (m *MockExport) ToCsv(ctx context.Context, writer io.Writer, query string) error

+ type MockExportMockRecorder struct

+ func (mr *MockExportMockRecorder) Close() *ExportCloseCall

+ func (mr *MockExportMockRecorder) ToCsv(ctx, writer, query any) *ExportToCsvCall

type MockIBlock

+ func (m *MockIBlock) Time(ctx context.Context, height types.Level) (time.Time, error)

type MockIBlockMockRecorder

+ func (mr *MockIBlockMockRecorder) Time(ctx, height any) *IBlockTimeCall

type MockIRollup

+ func (m *MockIRollup) RollupsByNamespace(ctx context.Context, namespaceId uint64, limit, offset int) ([]storage.Rollup, error)

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) RollupsByNamespace(ctx, namespaceId, limit, offset any) *IRollupRollupsByNamespaceCall

v1.4.0

Feb 12, 2024

Changes in this version

+ type IBlockByProposerCall struct

+ func (c *IBlockByProposerCall) Do(f func(context.Context, uint64, int, int) ([]storage.Block, error)) *IBlockByProposerCall

+ func (c *IBlockByProposerCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.Block, error)) *IBlockByProposerCall

+ func (c *IBlockByProposerCall) Return(arg0 []storage.Block, arg1 error) *IBlockByProposerCall

+ type IBlockSignatureCursorListCall struct

+ func (c *IBlockSignatureCursorListCall) Do(...) *IBlockSignatureCursorListCall

+ func (c *IBlockSignatureCursorListCall) DoAndReturn(...) *IBlockSignatureCursorListCall

+ func (c *IBlockSignatureCursorListCall) Return(arg0 []*storage.BlockSignature, arg1 error) *IBlockSignatureCursorListCall

+ type IBlockSignatureGetByIDCall struct

+ func (c *IBlockSignatureGetByIDCall) Do(f func(context.Context, uint64) (*storage.BlockSignature, error)) *IBlockSignatureGetByIDCall

+ func (c *IBlockSignatureGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.BlockSignature, error)) *IBlockSignatureGetByIDCall

+ func (c *IBlockSignatureGetByIDCall) Return(arg0 *storage.BlockSignature, arg1 error) *IBlockSignatureGetByIDCall

+ type IBlockSignatureIsNoRowsCall struct

+ func (c *IBlockSignatureIsNoRowsCall) Do(f func(error) bool) *IBlockSignatureIsNoRowsCall

+ func (c *IBlockSignatureIsNoRowsCall) DoAndReturn(f func(error) bool) *IBlockSignatureIsNoRowsCall

+ func (c *IBlockSignatureIsNoRowsCall) Return(arg0 bool) *IBlockSignatureIsNoRowsCall

+ type IBlockSignatureLastIDCall struct

+ func (c *IBlockSignatureLastIDCall) Do(f func(context.Context) (uint64, error)) *IBlockSignatureLastIDCall

+ func (c *IBlockSignatureLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBlockSignatureLastIDCall

+ func (c *IBlockSignatureLastIDCall) Return(arg0 uint64, arg1 error) *IBlockSignatureLastIDCall

+ type IBlockSignatureLevelsByValidatorCall struct

+ func (c *IBlockSignatureLevelsByValidatorCall) Do(f func(context.Context, uint64, types.Level) ([]types.Level, error)) *IBlockSignatureLevelsByValidatorCall

+ func (c *IBlockSignatureLevelsByValidatorCall) DoAndReturn(f func(context.Context, uint64, types.Level) ([]types.Level, error)) *IBlockSignatureLevelsByValidatorCall

+ func (c *IBlockSignatureLevelsByValidatorCall) Return(arg0 []types.Level, arg1 error) *IBlockSignatureLevelsByValidatorCall

+ type IBlockSignatureListCall struct

+ func (c *IBlockSignatureListCall) Do(...) *IBlockSignatureListCall

+ func (c *IBlockSignatureListCall) DoAndReturn(...) *IBlockSignatureListCall

+ func (c *IBlockSignatureListCall) Return(arg0 []*storage.BlockSignature, arg1 error) *IBlockSignatureListCall

+ type IBlockSignatureSaveCall struct

+ func (c *IBlockSignatureSaveCall) Do(f func(context.Context, *storage.BlockSignature) error) *IBlockSignatureSaveCall

+ func (c *IBlockSignatureSaveCall) DoAndReturn(f func(context.Context, *storage.BlockSignature) error) *IBlockSignatureSaveCall

+ func (c *IBlockSignatureSaveCall) Return(arg0 error) *IBlockSignatureSaveCall

+ type IBlockSignatureUpdateCall struct

+ func (c *IBlockSignatureUpdateCall) Do(f func(context.Context, *storage.BlockSignature) error) *IBlockSignatureUpdateCall

+ func (c *IBlockSignatureUpdateCall) DoAndReturn(f func(context.Context, *storage.BlockSignature) error) *IBlockSignatureUpdateCall

+ func (c *IBlockSignatureUpdateCall) Return(arg0 error) *IBlockSignatureUpdateCall

+ type IRollupBySlugCall struct

+ func (c *IRollupBySlugCall) Do(f func(context.Context, string) (storage.Rollup, error)) *IRollupBySlugCall

+ func (c *IRollupBySlugCall) DoAndReturn(f func(context.Context, string) (storage.Rollup, error)) *IRollupBySlugCall

+ func (c *IRollupBySlugCall) Return(arg0 storage.Rollup, arg1 error) *IRollupBySlugCall

+ type ISearchSearchCall struct

+ func (c *ISearchSearchCall) Do(f func(context.Context, []byte) ([]storage.SearchResult, error)) *ISearchSearchCall

+ func (c *ISearchSearchCall) DoAndReturn(f func(context.Context, []byte) ([]storage.SearchResult, error)) *ISearchSearchCall

+ func (c *ISearchSearchCall) Return(arg0 []storage.SearchResult, arg1 error) *ISearchSearchCall

+ type ISearchSearchTextCall struct

+ func (c *ISearchSearchTextCall) Do(f func(context.Context, string) ([]storage.SearchResult, error)) *ISearchSearchTextCall

+ func (c *ISearchSearchTextCall) DoAndReturn(f func(context.Context, string) ([]storage.SearchResult, error)) *ISearchSearchTextCall

+ func (c *ISearchSearchTextCall) Return(arg0 []storage.SearchResult, arg1 error) *ISearchSearchTextCall

type MockIBlock

+ func (m *MockIBlock) ByProposer(ctx context.Context, proposerId uint64, limit, offset int) ([]storage.Block, error)

type MockIBlockMockRecorder

+ func (mr *MockIBlockMockRecorder) ByProposer(ctx, proposerId, limit, offset any) *IBlockByProposerCall

+ type MockIBlockSignature struct

+ func NewMockIBlockSignature(ctrl *gomock.Controller) *MockIBlockSignature

+ func (m *MockIBlockSignature) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.BlockSignature, error)

+ func (m *MockIBlockSignature) EXPECT() *MockIBlockSignatureMockRecorder

+ func (m *MockIBlockSignature) GetByID(ctx context.Context, id uint64) (*storage.BlockSignature, error)

+ func (m *MockIBlockSignature) IsNoRows(err error) bool

+ func (m *MockIBlockSignature) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIBlockSignature) LevelsByValidator(ctx context.Context, validatorId uint64, startHeight types.Level) ([]types.Level, error)

+ func (m *MockIBlockSignature) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.BlockSignature, error)

+ func (m_2 *MockIBlockSignature) Save(ctx context.Context, m *storage.BlockSignature) error

+ func (m_2 *MockIBlockSignature) Update(ctx context.Context, m *storage.BlockSignature) error

+ type MockIBlockSignatureMockRecorder struct

+ func (mr *MockIBlockSignatureMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBlockSignatureCursorListCall

+ func (mr *MockIBlockSignatureMockRecorder) GetByID(ctx, id any) *IBlockSignatureGetByIDCall

+ func (mr *MockIBlockSignatureMockRecorder) IsNoRows(err any) *IBlockSignatureIsNoRowsCall

+ func (mr *MockIBlockSignatureMockRecorder) LastID(ctx any) *IBlockSignatureLastIDCall

+ func (mr *MockIBlockSignatureMockRecorder) LevelsByValidator(ctx, validatorId, startHeight any) *IBlockSignatureLevelsByValidatorCall

+ func (mr *MockIBlockSignatureMockRecorder) List(ctx, limit, offset, order any) *IBlockSignatureListCall

+ func (mr *MockIBlockSignatureMockRecorder) Save(ctx, m any) *IBlockSignatureSaveCall

+ func (mr *MockIBlockSignatureMockRecorder) Update(ctx, m any) *IBlockSignatureUpdateCall

type MockIRollup

+ func (m *MockIRollup) BySlug(ctx context.Context, slug string) (storage.Rollup, error)

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) BySlug(ctx, slug any) *IRollupBySlugCall

+ type MockISearch struct

+ func NewMockISearch(ctrl *gomock.Controller) *MockISearch

+ func (m *MockISearch) EXPECT() *MockISearchMockRecorder

+ func (m *MockISearch) Search(ctx context.Context, query []byte) ([]storage.SearchResult, error)

+ func (m *MockISearch) SearchText(ctx context.Context, text string) ([]storage.SearchResult, error)

+ type MockISearchMockRecorder struct

+ func (mr *MockISearchMockRecorder) Search(ctx, query any) *ISearchSearchCall

+ func (mr *MockISearchMockRecorder) SearchText(ctx, text any) *ISearchSearchTextCall

type MockTransaction

+ func (m *MockTransaction) RetentionBlockSignatures(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) RollbackBlockSignatures(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) SaveBlockSignatures(ctx context.Context, signs ...storage.BlockSignature) error

+ func (m *MockTransaction) Validators(ctx context.Context) ([]storage.Validator, error)

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) RetentionBlockSignatures(ctx, height any) *TransactionRetentionBlockSignaturesCall

+ func (mr *MockTransactionMockRecorder) RollbackBlockSignatures(ctx, height any) *TransactionRollbackBlockSignaturesCall

+ func (mr *MockTransactionMockRecorder) SaveBlockSignatures(ctx any, signs ...any) *TransactionSaveBlockSignaturesCall

+ func (mr *MockTransactionMockRecorder) Validators(ctx any) *TransactionValidatorsCall

+ type TransactionRetentionBlockSignaturesCall struct

+ func (c *TransactionRetentionBlockSignaturesCall) Do(f func(context.Context, types.Level) error) *TransactionRetentionBlockSignaturesCall

+ func (c *TransactionRetentionBlockSignaturesCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRetentionBlockSignaturesCall

+ func (c *TransactionRetentionBlockSignaturesCall) Return(arg0 error) *TransactionRetentionBlockSignaturesCall

+ type TransactionRollbackBlockSignaturesCall struct

+ func (c *TransactionRollbackBlockSignaturesCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackBlockSignaturesCall

+ func (c *TransactionRollbackBlockSignaturesCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackBlockSignaturesCall

+ func (c *TransactionRollbackBlockSignaturesCall) Return(err error) *TransactionRollbackBlockSignaturesCall

+ type TransactionSaveBlockSignaturesCall struct

+ func (c *TransactionSaveBlockSignaturesCall) Do(f func(context.Context, ...storage.BlockSignature) error) *TransactionSaveBlockSignaturesCall

+ func (c *TransactionSaveBlockSignaturesCall) DoAndReturn(f func(context.Context, ...storage.BlockSignature) error) *TransactionSaveBlockSignaturesCall

+ func (c *TransactionSaveBlockSignaturesCall) Return(arg0 error) *TransactionSaveBlockSignaturesCall

+ type TransactionValidatorsCall struct

+ func (c *TransactionValidatorsCall) Do(f func(context.Context) ([]storage.Validator, error)) *TransactionValidatorsCall

+ func (c *TransactionValidatorsCall) DoAndReturn(f func(context.Context) ([]storage.Validator, error)) *TransactionValidatorsCall

+ func (c *TransactionValidatorsCall) Return(arg0 []storage.Validator, arg1 error) *TransactionValidatorsCall

v1.3.2

Jan 29, 2024

Changes in this version

+ type IBlobLogByHeightCall struct

+ func (c *IBlobLogByHeightCall) Do(...) *IBlobLogByHeightCall

+ func (c *IBlobLogByHeightCall) DoAndReturn(...) *IBlobLogByHeightCall

+ func (c *IBlobLogByHeightCall) Return(arg0 []storage.BlobLog, arg1 error) *IBlobLogByHeightCall

+ type IBlobLogByTxIdCall struct

+ func (c *IBlobLogByTxIdCall) Do(...) *IBlobLogByTxIdCall

+ func (c *IBlobLogByTxIdCall) DoAndReturn(...) *IBlobLogByTxIdCall

+ func (c *IBlobLogByTxIdCall) Return(arg0 []storage.BlobLog, arg1 error) *IBlobLogByTxIdCall

+ type IBlobLogCountByHeightCall struct

+ func (c *IBlobLogCountByHeightCall) Do(f func(context.Context, types.Level) (int, error)) *IBlobLogCountByHeightCall

+ func (c *IBlobLogCountByHeightCall) DoAndReturn(f func(context.Context, types.Level) (int, error)) *IBlobLogCountByHeightCall

+ func (c *IBlobLogCountByHeightCall) Return(arg0 int, arg1 error) *IBlobLogCountByHeightCall

+ type IBlobLogCountByTxIdCall struct

+ func (c *IBlobLogCountByTxIdCall) Do(f func(context.Context, uint64) (int, error)) *IBlobLogCountByTxIdCall

+ func (c *IBlobLogCountByTxIdCall) DoAndReturn(f func(context.Context, uint64) (int, error)) *IBlobLogCountByTxIdCall

+ func (c *IBlobLogCountByTxIdCall) Return(arg0 int, arg1 error) *IBlobLogCountByTxIdCall

+ type IRollupCountCall struct

+ func (c *IRollupCountCall) Do(f func(context.Context) (int64, error)) *IRollupCountCall

+ func (c *IRollupCountCall) DoAndReturn(f func(context.Context) (int64, error)) *IRollupCountCall

+ func (c *IRollupCountCall) Return(arg0 int64, arg1 error) *IRollupCountCall

+ type IRollupSeriesCall struct

+ func (c *IRollupSeriesCall) Do(...) *IRollupSeriesCall

+ func (c *IRollupSeriesCall) DoAndReturn(...) *IRollupSeriesCall

+ func (c *IRollupSeriesCall) Return(items []storage.HistogramItem, err error) *IRollupSeriesCall

type MockIBlobLog

+ func (m *MockIBlobLog) ByHeight(ctx context.Context, height types.Level, fltrs storage.BlobLogFilters) ([]storage.BlobLog, error)

+ func (m *MockIBlobLog) ByTxId(ctx context.Context, txId uint64, fltrs storage.BlobLogFilters) ([]storage.BlobLog, error)

+ func (m *MockIBlobLog) CountByHeight(ctx context.Context, height types.Level) (int, error)

+ func (m *MockIBlobLog) CountByTxId(ctx context.Context, txId uint64) (int, error)

type MockIBlobLogMockRecorder

+ func (mr *MockIBlobLogMockRecorder) ByHeight(ctx, height, fltrs any) *IBlobLogByHeightCall

+ func (mr *MockIBlobLogMockRecorder) ByTxId(ctx, txId, fltrs any) *IBlobLogByTxIdCall

+ func (mr *MockIBlobLogMockRecorder) CountByHeight(ctx, height any) *IBlobLogCountByHeightCall

+ func (mr *MockIBlobLogMockRecorder) CountByTxId(ctx, txId any) *IBlobLogCountByTxIdCall

type MockIRollup

+ func (m *MockIRollup) Count(ctx context.Context) (int64, error)

+ func (m *MockIRollup) Series(ctx context.Context, rollupId uint64, timeframe, column string, ...) ([]storage.HistogramItem, error)

type MockIRollupMockRecorder

+ func (mr *MockIRollupMockRecorder) Count(ctx any) *IRollupCountCall

+ func (mr *MockIRollupMockRecorder) Series(ctx, rollupId, timeframe, column, req any) *IRollupSeriesCall

v1.3.1

Jan 14, 2024

v1.3.0

Jan 13, 2024

v1.2.2

Jan 4, 2024

v1.2.1

Dec 31, 2023

v1.2.0

Dec 31, 2023

Changes in this version

+ type IBlobLogByNamespaceCall struct

+ func (c *IBlobLogByNamespaceCall) Do(...) *IBlobLogByNamespaceCall

+ func (c *IBlobLogByNamespaceCall) DoAndReturn(...) *IBlobLogByNamespaceCall

+ func (c *IBlobLogByNamespaceCall) Return(arg0 []storage.BlobLog, arg1 error) *IBlobLogByNamespaceCall

+ type IBlobLogByProvidersCall struct

+ func (c *IBlobLogByProvidersCall) Do(...) *IBlobLogByProvidersCall

+ func (c *IBlobLogByProvidersCall) DoAndReturn(...) *IBlobLogByProvidersCall

+ func (c *IBlobLogByProvidersCall) Return(arg0 []storage.BlobLog, arg1 error) *IBlobLogByProvidersCall

+ type IBlobLogBySignerCall struct

+ func (c *IBlobLogBySignerCall) Do(...) *IBlobLogBySignerCall

+ func (c *IBlobLogBySignerCall) DoAndReturn(...) *IBlobLogBySignerCall

+ func (c *IBlobLogBySignerCall) Return(arg0 []storage.BlobLog, arg1 error) *IBlobLogBySignerCall

+ type IBlobLogCursorListCall struct

+ func (c *IBlobLogCursorListCall) Do(...) *IBlobLogCursorListCall

+ func (c *IBlobLogCursorListCall) DoAndReturn(...) *IBlobLogCursorListCall

+ func (c *IBlobLogCursorListCall) Return(arg0 []*storage.BlobLog, arg1 error) *IBlobLogCursorListCall

+ type IBlobLogGetByIDCall struct

+ func (c *IBlobLogGetByIDCall) Do(f func(context.Context, uint64) (*storage.BlobLog, error)) *IBlobLogGetByIDCall

+ func (c *IBlobLogGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.BlobLog, error)) *IBlobLogGetByIDCall

+ func (c *IBlobLogGetByIDCall) Return(arg0 *storage.BlobLog, arg1 error) *IBlobLogGetByIDCall

+ type IBlobLogIsNoRowsCall struct

+ func (c *IBlobLogIsNoRowsCall) Do(f func(error) bool) *IBlobLogIsNoRowsCall

+ func (c *IBlobLogIsNoRowsCall) DoAndReturn(f func(error) bool) *IBlobLogIsNoRowsCall

+ func (c *IBlobLogIsNoRowsCall) Return(arg0 bool) *IBlobLogIsNoRowsCall

+ type IBlobLogLastIDCall struct

+ func (c *IBlobLogLastIDCall) Do(f func(context.Context) (uint64, error)) *IBlobLogLastIDCall

+ func (c *IBlobLogLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBlobLogLastIDCall

+ func (c *IBlobLogLastIDCall) Return(arg0 uint64, arg1 error) *IBlobLogLastIDCall

+ type IBlobLogListCall struct

+ func (c *IBlobLogListCall) Do(...) *IBlobLogListCall

+ func (c *IBlobLogListCall) DoAndReturn(...) *IBlobLogListCall

+ func (c *IBlobLogListCall) Return(arg0 []*storage.BlobLog, arg1 error) *IBlobLogListCall

+ type IBlobLogSaveCall struct

+ func (c *IBlobLogSaveCall) Do(f func(context.Context, *storage.BlobLog) error) *IBlobLogSaveCall

+ func (c *IBlobLogSaveCall) DoAndReturn(f func(context.Context, *storage.BlobLog) error) *IBlobLogSaveCall

+ func (c *IBlobLogSaveCall) Return(arg0 error) *IBlobLogSaveCall

+ type IBlobLogUpdateCall struct

+ func (c *IBlobLogUpdateCall) Do(f func(context.Context, *storage.BlobLog) error) *IBlobLogUpdateCall

+ func (c *IBlobLogUpdateCall) DoAndReturn(f func(context.Context, *storage.BlobLog) error) *IBlobLogUpdateCall

+ func (c *IBlobLogUpdateCall) Return(arg0 error) *IBlobLogUpdateCall

+ type IMessageByAddressCall struct

+ func (c *IMessageByAddressCall) Do(...) *IMessageByAddressCall

+ func (c *IMessageByAddressCall) DoAndReturn(...) *IMessageByAddressCall

+ func (c *IMessageByAddressCall) Return(arg0 []storage.AddressMessageWithTx, arg1 error) *IMessageByAddressCall

+ type INamespaceGetByIdsCall struct

+ func (c *INamespaceGetByIdsCall) Do(f func(context.Context, ...uint64) ([]storage.Namespace, error)) *INamespaceGetByIdsCall

+ func (c *INamespaceGetByIdsCall) DoAndReturn(f func(context.Context, ...uint64) ([]storage.Namespace, error)) *INamespaceGetByIdsCall

+ func (c *INamespaceGetByIdsCall) Return(ns []storage.Namespace, err error) *INamespaceGetByIdsCall

+ type IPriceGetCall struct

+ func (c *IPriceGetCall) Do(f func(context.Context, string, int64, int64, int) ([]storage.Price, error)) *IPriceGetCall

+ func (c *IPriceGetCall) DoAndReturn(f func(context.Context, string, int64, int64, int) ([]storage.Price, error)) *IPriceGetCall

+ func (c *IPriceGetCall) Return(arg0 []storage.Price, arg1 error) *IPriceGetCall

+ type IPriceLastCall struct

+ func (c *IPriceLastCall) Do(f func(context.Context) (storage.Price, error)) *IPriceLastCall

+ func (c *IPriceLastCall) DoAndReturn(f func(context.Context) (storage.Price, error)) *IPriceLastCall

+ func (c *IPriceLastCall) Return(arg0 storage.Price, arg1 error) *IPriceLastCall

+ type IPriceSaveCall struct

+ func (c *IPriceSaveCall) Do(f func(context.Context, *storage.Price) error) *IPriceSaveCall

+ func (c *IPriceSaveCall) DoAndReturn(f func(context.Context, *storage.Price) error) *IPriceSaveCall

+ func (c *IPriceSaveCall) Return(arg0 error) *IPriceSaveCall

+ type IRollupCursorListCall struct

+ func (c *IRollupCursorListCall) Do(...) *IRollupCursorListCall

+ func (c *IRollupCursorListCall) DoAndReturn(...) *IRollupCursorListCall

+ func (c *IRollupCursorListCall) Return(arg0 []*storage.Rollup, arg1 error) *IRollupCursorListCall

+ type IRollupGetByIDCall struct

+ func (c *IRollupGetByIDCall) Do(f func(context.Context, uint64) (*storage.Rollup, error)) *IRollupGetByIDCall

+ func (c *IRollupGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Rollup, error)) *IRollupGetByIDCall

+ func (c *IRollupGetByIDCall) Return(arg0 *storage.Rollup, arg1 error) *IRollupGetByIDCall

+ type IRollupIsNoRowsCall struct

+ func (c *IRollupIsNoRowsCall) Do(f func(error) bool) *IRollupIsNoRowsCall

+ func (c *IRollupIsNoRowsCall) DoAndReturn(f func(error) bool) *IRollupIsNoRowsCall

+ func (c *IRollupIsNoRowsCall) Return(arg0 bool) *IRollupIsNoRowsCall

+ type IRollupLastIDCall struct

+ func (c *IRollupLastIDCall) Do(f func(context.Context) (uint64, error)) *IRollupLastIDCall

+ func (c *IRollupLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IRollupLastIDCall

+ func (c *IRollupLastIDCall) Return(arg0 uint64, arg1 error) *IRollupLastIDCall

+ type IRollupLeaderboardCall struct

+ func (c *IRollupLeaderboardCall) Do(...) *IRollupLeaderboardCall

+ func (c *IRollupLeaderboardCall) DoAndReturn(...) *IRollupLeaderboardCall

+ func (c *IRollupLeaderboardCall) Return(arg0 []storage.RollupWithStats, arg1 error) *IRollupLeaderboardCall

+ type IRollupListCall struct

+ func (c *IRollupListCall) Do(...) *IRollupListCall

+ func (c *IRollupListCall) DoAndReturn(...) *IRollupListCall

+ func (c *IRollupListCall) Return(arg0 []*storage.Rollup, arg1 error) *IRollupListCall

+ type IRollupNamespacesCall struct

+ func (c *IRollupNamespacesCall) Do(f func(context.Context, uint64, int, int) ([]uint64, error)) *IRollupNamespacesCall

+ func (c *IRollupNamespacesCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]uint64, error)) *IRollupNamespacesCall

+ func (c *IRollupNamespacesCall) Return(namespaceIds []uint64, err error) *IRollupNamespacesCall

+ type IRollupProviderCursorListCall struct

+ func (c *IRollupProviderCursorListCall) Do(...) *IRollupProviderCursorListCall

+ func (c *IRollupProviderCursorListCall) DoAndReturn(...) *IRollupProviderCursorListCall

+ func (c *IRollupProviderCursorListCall) Return(arg0 []*storage.RollupProvider, arg1 error) *IRollupProviderCursorListCall

+ type IRollupProviderGetByIDCall struct

+ func (c *IRollupProviderGetByIDCall) Do(f func(context.Context, uint64) (*storage.RollupProvider, error)) *IRollupProviderGetByIDCall

+ func (c *IRollupProviderGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.RollupProvider, error)) *IRollupProviderGetByIDCall

+ func (c *IRollupProviderGetByIDCall) Return(arg0 *storage.RollupProvider, arg1 error) *IRollupProviderGetByIDCall

+ type IRollupProviderIsNoRowsCall struct

+ func (c *IRollupProviderIsNoRowsCall) Do(f func(error) bool) *IRollupProviderIsNoRowsCall

+ func (c *IRollupProviderIsNoRowsCall) DoAndReturn(f func(error) bool) *IRollupProviderIsNoRowsCall

+ func (c *IRollupProviderIsNoRowsCall) Return(arg0 bool) *IRollupProviderIsNoRowsCall

+ type IRollupProviderLastIDCall struct

+ func (c *IRollupProviderLastIDCall) Do(f func(context.Context) (uint64, error)) *IRollupProviderLastIDCall

+ func (c *IRollupProviderLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IRollupProviderLastIDCall

+ func (c *IRollupProviderLastIDCall) Return(arg0 uint64, arg1 error) *IRollupProviderLastIDCall

+ type IRollupProviderListCall struct

+ func (c *IRollupProviderListCall) Do(...) *IRollupProviderListCall

+ func (c *IRollupProviderListCall) DoAndReturn(...) *IRollupProviderListCall

+ func (c *IRollupProviderListCall) Return(arg0 []*storage.RollupProvider, arg1 error) *IRollupProviderListCall

+ type IRollupProviderSaveCall struct

+ func (c *IRollupProviderSaveCall) Do(f func(context.Context, *storage.RollupProvider) error) *IRollupProviderSaveCall

+ func (c *IRollupProviderSaveCall) DoAndReturn(f func(context.Context, *storage.RollupProvider) error) *IRollupProviderSaveCall

+ func (c *IRollupProviderSaveCall) Return(arg0 error) *IRollupProviderSaveCall

+ type IRollupProviderUpdateCall struct

+ func (c *IRollupProviderUpdateCall) Do(f func(context.Context, *storage.RollupProvider) error) *IRollupProviderUpdateCall

+ func (c *IRollupProviderUpdateCall) DoAndReturn(f func(context.Context, *storage.RollupProvider) error) *IRollupProviderUpdateCall

+ func (c *IRollupProviderUpdateCall) Return(arg0 error) *IRollupProviderUpdateCall

+ type IRollupProvidersCall struct

+ func (c *IRollupProvidersCall) Do(f func(context.Context, uint64) ([]storage.RollupProvider, error)) *IRollupProvidersCall

+ func (c *IRollupProvidersCall) DoAndReturn(f func(context.Context, uint64) ([]storage.RollupProvider, error)) *IRollupProvidersCall

+ func (c *IRollupProvidersCall) Return(providers []storage.RollupProvider, err error) *IRollupProvidersCall

+ type IRollupSaveCall struct

+ func (c *IRollupSaveCall) Do(f func(context.Context, *storage.Rollup) error) *IRollupSaveCall

+ func (c *IRollupSaveCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *IRollupSaveCall

+ func (c *IRollupSaveCall) Return(arg0 error) *IRollupSaveCall

+ type IRollupStatsCall struct

+ func (c *IRollupStatsCall) Do(...) *IRollupStatsCall

+ func (c *IRollupStatsCall) DoAndReturn(...) *IRollupStatsCall

+ func (c *IRollupStatsCall) Return(items []storage.HistogramItem, err error) *IRollupStatsCall

+ type IRollupUpdateCall struct

+ func (c *IRollupUpdateCall) Do(f func(context.Context, *storage.Rollup) error) *IRollupUpdateCall

+ func (c *IRollupUpdateCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *IRollupUpdateCall

+ func (c *IRollupUpdateCall) Return(arg0 error) *IRollupUpdateCall

+ type MockIBlobLog struct

+ func NewMockIBlobLog(ctrl *gomock.Controller) *MockIBlobLog

+ func (m *MockIBlobLog) ByNamespace(ctx context.Context, nsId uint64, fltrs storage.BlobLogFilters) ([]storage.BlobLog, error)

+ func (m *MockIBlobLog) ByProviders(ctx context.Context, providers []storage.RollupProvider, ...) ([]storage.BlobLog, error)

+ func (m *MockIBlobLog) BySigner(ctx context.Context, signerId uint64, fltrs storage.BlobLogFilters) ([]storage.BlobLog, error)

+ func (m *MockIBlobLog) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.BlobLog, error)

+ func (m *MockIBlobLog) EXPECT() *MockIBlobLogMockRecorder

+ func (m *MockIBlobLog) GetByID(ctx context.Context, id uint64) (*storage.BlobLog, error)

+ func (m *MockIBlobLog) IsNoRows(err error) bool

+ func (m *MockIBlobLog) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIBlobLog) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.BlobLog, error)

+ func (m_2 *MockIBlobLog) Save(ctx context.Context, m *storage.BlobLog) error

+ func (m_2 *MockIBlobLog) Update(ctx context.Context, m *storage.BlobLog) error

+ type MockIBlobLogMockRecorder struct

+ func (mr *MockIBlobLogMockRecorder) ByNamespace(ctx, nsId, fltrs any) *IBlobLogByNamespaceCall

+ func (mr *MockIBlobLogMockRecorder) ByProviders(ctx, providers, fltrs any) *IBlobLogByProvidersCall

+ func (mr *MockIBlobLogMockRecorder) BySigner(ctx, signerId, fltrs any) *IBlobLogBySignerCall

+ func (mr *MockIBlobLogMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBlobLogCursorListCall

+ func (mr *MockIBlobLogMockRecorder) GetByID(ctx, id any) *IBlobLogGetByIDCall

+ func (mr *MockIBlobLogMockRecorder) IsNoRows(err any) *IBlobLogIsNoRowsCall

+ func (mr *MockIBlobLogMockRecorder) LastID(ctx any) *IBlobLogLastIDCall

+ func (mr *MockIBlobLogMockRecorder) List(ctx, limit, offset, order any) *IBlobLogListCall

+ func (mr *MockIBlobLogMockRecorder) Save(ctx, m any) *IBlobLogSaveCall

+ func (mr *MockIBlobLogMockRecorder) Update(ctx, m any) *IBlobLogUpdateCall

type MockIMessage

+ func (m *MockIMessage) ByAddress(ctx context.Context, id uint64, filters storage.AddressMsgsFilter) ([]storage.AddressMessageWithTx, error)

type MockIMessageMockRecorder

+ func (mr *MockIMessageMockRecorder) ByAddress(ctx, id, filters any) *IMessageByAddressCall

type MockINamespace

+ func (m *MockINamespace) GetByIds(ctx context.Context, ids ...uint64) ([]storage.Namespace, error)

type MockINamespaceMockRecorder

+ func (mr *MockINamespaceMockRecorder) GetByIds(ctx any, ids ...any) *INamespaceGetByIdsCall

+ type MockIPrice struct

+ func NewMockIPrice(ctrl *gomock.Controller) *MockIPrice

+ func (m *MockIPrice) EXPECT() *MockIPriceMockRecorder

+ func (m *MockIPrice) Get(ctx context.Context, timeframe string, start, end int64, limit int) ([]storage.Price, error)

+ func (m *MockIPrice) Last(ctx context.Context) (storage.Price, error)

+ func (m *MockIPrice) Save(ctx context.Context, price *storage.Price) error

+ type MockIPriceMockRecorder struct

+ func (mr *MockIPriceMockRecorder) Get(ctx, timeframe, start, end, limit any) *IPriceGetCall

+ func (mr *MockIPriceMockRecorder) Last(ctx any) *IPriceLastCall

+ func (mr *MockIPriceMockRecorder) Save(ctx, price any) *IPriceSaveCall

+ type MockIRollup struct

+ func NewMockIRollup(ctrl *gomock.Controller) *MockIRollup

+ func (m *MockIRollup) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Rollup, error)

+ func (m *MockIRollup) EXPECT() *MockIRollupMockRecorder

+ func (m *MockIRollup) GetByID(ctx context.Context, id uint64) (*storage.Rollup, error)

+ func (m *MockIRollup) IsNoRows(err error) bool

+ func (m *MockIRollup) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIRollup) Leaderboard(ctx context.Context, sortField string, sort storage0.SortOrder, ...) ([]storage.RollupWithStats, error)

+ func (m *MockIRollup) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Rollup, error)

+ func (m *MockIRollup) Namespaces(ctx context.Context, rollupId uint64, limit, offset int) ([]uint64, error)

+ func (m *MockIRollup) Providers(ctx context.Context, rollupId uint64) ([]storage.RollupProvider, error)

+ func (m *MockIRollup) Stats(ctx context.Context, rollupId uint64, timeframe, column string, ...) ([]storage.HistogramItem, error)

+ func (m_2 *MockIRollup) Save(ctx context.Context, m *storage.Rollup) error

+ func (m_2 *MockIRollup) Update(ctx context.Context, m *storage.Rollup) error

+ type MockIRollupMockRecorder struct

+ func (mr *MockIRollupMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IRollupCursorListCall

+ func (mr *MockIRollupMockRecorder) GetByID(ctx, id any) *IRollupGetByIDCall

+ func (mr *MockIRollupMockRecorder) IsNoRows(err any) *IRollupIsNoRowsCall

+ func (mr *MockIRollupMockRecorder) LastID(ctx any) *IRollupLastIDCall

+ func (mr *MockIRollupMockRecorder) Leaderboard(ctx, sortField, sort, limit, offset any) *IRollupLeaderboardCall

+ func (mr *MockIRollupMockRecorder) List(ctx, limit, offset, order any) *IRollupListCall

+ func (mr *MockIRollupMockRecorder) Namespaces(ctx, rollupId, limit, offset any) *IRollupNamespacesCall

+ func (mr *MockIRollupMockRecorder) Providers(ctx, rollupId any) *IRollupProvidersCall

+ func (mr *MockIRollupMockRecorder) Save(ctx, m any) *IRollupSaveCall

+ func (mr *MockIRollupMockRecorder) Stats(ctx, rollupId, timeframe, column, req any) *IRollupStatsCall

+ func (mr *MockIRollupMockRecorder) Update(ctx, m any) *IRollupUpdateCall

+ type MockIRollupProvider struct

+ func NewMockIRollupProvider(ctrl *gomock.Controller) *MockIRollupProvider

+ func (m *MockIRollupProvider) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.RollupProvider, error)

+ func (m *MockIRollupProvider) EXPECT() *MockIRollupProviderMockRecorder

+ func (m *MockIRollupProvider) GetByID(ctx context.Context, id uint64) (*storage.RollupProvider, error)

+ func (m *MockIRollupProvider) IsNoRows(err error) bool

+ func (m *MockIRollupProvider) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIRollupProvider) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.RollupProvider, error)

+ func (m_2 *MockIRollupProvider) Save(ctx context.Context, m *storage.RollupProvider) error

+ func (m_2 *MockIRollupProvider) Update(ctx context.Context, m *storage.RollupProvider) error

+ type MockIRollupProviderMockRecorder struct

+ func (mr *MockIRollupProviderMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IRollupProviderCursorListCall

+ func (mr *MockIRollupProviderMockRecorder) GetByID(ctx, id any) *IRollupProviderGetByIDCall

+ func (mr *MockIRollupProviderMockRecorder) IsNoRows(err any) *IRollupProviderIsNoRowsCall

+ func (mr *MockIRollupProviderMockRecorder) LastID(ctx any) *IRollupProviderLastIDCall

+ func (mr *MockIRollupProviderMockRecorder) List(ctx, limit, offset, order any) *IRollupProviderListCall

+ func (mr *MockIRollupProviderMockRecorder) Save(ctx, m any) *IRollupProviderSaveCall

+ func (mr *MockIRollupProviderMockRecorder) Update(ctx, m any) *IRollupProviderUpdateCall

type MockTransaction

+ func (m *MockTransaction) DeleteProviders(ctx context.Context, rollupId uint64) error

+ func (m *MockTransaction) DeleteRollup(ctx context.Context, rollupId uint64) error

+ func (m *MockTransaction) RollbackBlobLog(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) SaveBlobLogs(ctx context.Context, logs ...storage.BlobLog) error

+ func (m *MockTransaction) SaveProviders(ctx context.Context, providers ...storage.RollupProvider) error

+ func (m *MockTransaction) SaveRollup(ctx context.Context, rollup *storage.Rollup) error

+ func (m *MockTransaction) UpdateRollup(ctx context.Context, rollup *storage.Rollup) error

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) DeleteProviders(ctx, rollupId any) *TransactionDeleteProvidersCall

+ func (mr *MockTransactionMockRecorder) DeleteRollup(ctx, rollupId any) *TransactionDeleteRollupCall

+ func (mr *MockTransactionMockRecorder) RollbackBlobLog(ctx, height any) *TransactionRollbackBlobLogCall

+ func (mr *MockTransactionMockRecorder) SaveBlobLogs(ctx any, logs ...any) *TransactionSaveBlobLogsCall

+ func (mr *MockTransactionMockRecorder) SaveProviders(ctx any, providers ...any) *TransactionSaveProvidersCall

+ func (mr *MockTransactionMockRecorder) SaveRollup(ctx, rollup any) *TransactionSaveRollupCall

+ func (mr *MockTransactionMockRecorder) UpdateRollup(ctx, rollup any) *TransactionUpdateRollupCall

+ type TransactionDeleteProvidersCall struct

+ func (c *TransactionDeleteProvidersCall) Do(f func(context.Context, uint64) error) *TransactionDeleteProvidersCall

+ func (c *TransactionDeleteProvidersCall) DoAndReturn(f func(context.Context, uint64) error) *TransactionDeleteProvidersCall

+ func (c *TransactionDeleteProvidersCall) Return(arg0 error) *TransactionDeleteProvidersCall

+ type TransactionDeleteRollupCall struct

+ func (c *TransactionDeleteRollupCall) Do(f func(context.Context, uint64) error) *TransactionDeleteRollupCall

+ func (c *TransactionDeleteRollupCall) DoAndReturn(f func(context.Context, uint64) error) *TransactionDeleteRollupCall

+ func (c *TransactionDeleteRollupCall) Return(arg0 error) *TransactionDeleteRollupCall

+ type TransactionRollbackBlobLogCall struct

+ func (c *TransactionRollbackBlobLogCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackBlobLogCall

+ func (c *TransactionRollbackBlobLogCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackBlobLogCall

+ func (c *TransactionRollbackBlobLogCall) Return(arg0 error) *TransactionRollbackBlobLogCall

+ type TransactionSaveBlobLogsCall struct

+ func (c *TransactionSaveBlobLogsCall) Do(f func(context.Context, ...storage.BlobLog) error) *TransactionSaveBlobLogsCall

+ func (c *TransactionSaveBlobLogsCall) DoAndReturn(f func(context.Context, ...storage.BlobLog) error) *TransactionSaveBlobLogsCall

+ func (c *TransactionSaveBlobLogsCall) Return(arg0 error) *TransactionSaveBlobLogsCall

+ type TransactionSaveProvidersCall struct

+ func (c *TransactionSaveProvidersCall) Do(f func(context.Context, ...storage.RollupProvider) error) *TransactionSaveProvidersCall

+ func (c *TransactionSaveProvidersCall) DoAndReturn(f func(context.Context, ...storage.RollupProvider) error) *TransactionSaveProvidersCall

+ func (c *TransactionSaveProvidersCall) Return(arg0 error) *TransactionSaveProvidersCall

+ type TransactionSaveRollupCall struct

+ func (c *TransactionSaveRollupCall) Do(f func(context.Context, *storage.Rollup) error) *TransactionSaveRollupCall

+ func (c *TransactionSaveRollupCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *TransactionSaveRollupCall

+ func (c *TransactionSaveRollupCall) Return(arg0 error) *TransactionSaveRollupCall

+ type TransactionUpdateRollupCall struct

+ func (c *TransactionUpdateRollupCall) Do(f func(context.Context, *storage.Rollup) error) *TransactionUpdateRollupCall

+ func (c *TransactionUpdateRollupCall) DoAndReturn(f func(context.Context, *storage.Rollup) error) *TransactionUpdateRollupCall

+ func (c *TransactionUpdateRollupCall) Return(arg0 error) *TransactionUpdateRollupCall

v1.1.7

Dec 19, 2023

v1.1.6

Dec 17, 2023

v1.1.5

Dec 17, 2023

Changes in this version

+ type INamespaceCountMessagesByTxIdCall struct

+ func (c *INamespaceCountMessagesByTxIdCall) Do(f func(context.Context, uint64) (int, error)) *INamespaceCountMessagesByTxIdCall

+ func (c *INamespaceCountMessagesByTxIdCall) DoAndReturn(f func(context.Context, uint64) (int, error)) *INamespaceCountMessagesByTxIdCall

+ func (c *INamespaceCountMessagesByTxIdCall) Return(arg0 int, arg1 error) *INamespaceCountMessagesByTxIdCall

+ type INamespaceMessagesByTxIdCall struct

+ func (c *INamespaceMessagesByTxIdCall) Do(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *INamespaceMessagesByTxIdCall

+ func (c *INamespaceMessagesByTxIdCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *INamespaceMessagesByTxIdCall

+ func (c *INamespaceMessagesByTxIdCall) Return(arg0 []storage.NamespaceMessage, arg1 error) *INamespaceMessagesByTxIdCall

type MockINamespace

+ func (m *MockINamespace) CountMessagesByTxId(ctx context.Context, txId uint64) (int, error)

+ func (m *MockINamespace) MessagesByTxId(ctx context.Context, txId uint64, limit, offset int) ([]storage.NamespaceMessage, error)

type MockINamespaceMockRecorder

+ func (mr *MockINamespaceMockRecorder) CountMessagesByTxId(ctx, txId any) *INamespaceCountMessagesByTxIdCall

+ func (mr *MockINamespaceMockRecorder) MessagesByTxId(ctx, txId, limit, offset any) *INamespaceMessagesByTxIdCall

v1.1.4

Dec 11, 2023

v1.1.3

Dec 9, 2023

v1.1.2

Dec 7, 2023

Changes in this version

+ type INamespaceListWithSortCall struct

+ func (c *INamespaceListWithSortCall) Do(...) *INamespaceListWithSortCall

+ func (c *INamespaceListWithSortCall) DoAndReturn(...) *INamespaceListWithSortCall

+ func (c *INamespaceListWithSortCall) Return(ns []storage.Namespace, err error) *INamespaceListWithSortCall

type MockINamespace

+ func (m *MockINamespace) ListWithSort(ctx context.Context, sortField string, sort storage0.SortOrder, ...) ([]storage.Namespace, error)

type MockINamespaceMockRecorder

+ func (mr *MockINamespaceMockRecorder) ListWithSort(ctx, sortField, sort, limit, offset any) *INamespaceListWithSortCall

v1.1.1

Nov 27, 2023

v1.1.0

Nov 25, 2023

Changes in this version

+ type IBlockStatsLastFromCall struct

+ func (c *IBlockStatsLastFromCall) Do(f func(context.Context, types.Level, int) ([]storage.BlockStats, error)) *IBlockStatsLastFromCall

+ func (c *IBlockStatsLastFromCall) DoAndReturn(f func(context.Context, types.Level, int) ([]storage.BlockStats, error)) *IBlockStatsLastFromCall

+ func (c *IBlockStatsLastFromCall) Return(arg0 []storage.BlockStats, arg1 error) *IBlockStatsLastFromCall

+ type IStatsNamespaceSeriesCall struct

+ func (c *IStatsNamespaceSeriesCall) Do(...) *IStatsNamespaceSeriesCall

+ func (c *IStatsNamespaceSeriesCall) DoAndReturn(...) *IStatsNamespaceSeriesCall

+ func (c *IStatsNamespaceSeriesCall) Return(response []storage.SeriesItem, err error) *IStatsNamespaceSeriesCall

+ type IStatsSeriesCall struct

+ func (c *IStatsSeriesCall) Do(...) *IStatsSeriesCall

+ func (c *IStatsSeriesCall) DoAndReturn(...) *IStatsSeriesCall

+ func (c *IStatsSeriesCall) Return(arg0 []storage.SeriesItem, arg1 error) *IStatsSeriesCall

+ type IStatsTPSCall struct

+ func (c *IStatsTPSCall) Do(f func(context.Context) (storage.TPS, error)) *IStatsTPSCall

+ func (c *IStatsTPSCall) DoAndReturn(f func(context.Context) (storage.TPS, error)) *IStatsTPSCall

+ func (c *IStatsTPSCall) Return(arg0 storage.TPS, arg1 error) *IStatsTPSCall

+ type IStatsTxCountForLast24hCall struct

+ func (c *IStatsTxCountForLast24hCall) Do(f func(context.Context) ([]storage.TxCountForLast24hItem, error)) *IStatsTxCountForLast24hCall

+ func (c *IStatsTxCountForLast24hCall) DoAndReturn(f func(context.Context) ([]storage.TxCountForLast24hItem, error)) *IStatsTxCountForLast24hCall

+ func (c *IStatsTxCountForLast24hCall) Return(arg0 []storage.TxCountForLast24hItem, arg1 error) *IStatsTxCountForLast24hCall

+ type ITxGasCall struct

+ func (c *ITxGasCall) Do(f func(context.Context, types.Level) ([]storage.Gas, error)) *ITxGasCall

+ func (c *ITxGasCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Gas, error)) *ITxGasCall

+ func (c *ITxGasCall) Return(arg0 []storage.Gas, arg1 error) *ITxGasCall

type MockIBlockStats

+ func (m *MockIBlockStats) LastFrom(ctx context.Context, head types.Level, limit int) ([]storage.BlockStats, error)

type MockIBlockStatsMockRecorder

+ func (mr *MockIBlockStatsMockRecorder) LastFrom(ctx, head, limit any) *IBlockStatsLastFromCall

type MockIStats

+ func (m *MockIStats) NamespaceSeries(ctx context.Context, timeframe storage.Timeframe, name string, nsId uint64, ...) ([]storage.SeriesItem, error)

+ func (m *MockIStats) Series(ctx context.Context, timeframe storage.Timeframe, name string, ...) ([]storage.SeriesItem, error)

+ func (m *MockIStats) TPS(ctx context.Context) (storage.TPS, error)

+ func (m *MockIStats) TxCountForLast24h(ctx context.Context) ([]storage.TxCountForLast24hItem, error)

type MockIStatsMockRecorder

+ func (mr *MockIStatsMockRecorder) NamespaceSeries(ctx, timeframe, name, nsId, req any) *IStatsNamespaceSeriesCall

+ func (mr *MockIStatsMockRecorder) Series(ctx, timeframe, name, req any) *IStatsSeriesCall

+ func (mr *MockIStatsMockRecorder) TPS(ctx any) *IStatsTPSCall

+ func (mr *MockIStatsMockRecorder) TxCountForLast24h(ctx any) *IStatsTxCountForLast24hCall

type MockITx

+ func (m *MockITx) Gas(ctx context.Context, height types.Level) ([]storage.Gas, error)

type MockITxMockRecorder

+ func (mr *MockITxMockRecorder) Gas(ctx, height any) *ITxGasCall

type MockTransaction

+ func (m *MockTransaction) GetProposerId(ctx context.Context, address string) (uint64, error)

+ func (m *MockTransaction) LastNamespaceMessage(ctx context.Context, nsId uint64) (storage.NamespaceMessage, error)

type MockTransactionMockRecorder

+ func (mr *MockTransactionMockRecorder) GetProposerId(ctx, address any) *TransactionGetProposerIdCall

+ func (mr *MockTransactionMockRecorder) LastNamespaceMessage(ctx, nsId any) *TransactionLastNamespaceMessageCall

+ type TransactionGetProposerIdCall struct

+ func (c *TransactionGetProposerIdCall) Do(f func(context.Context, string) (uint64, error)) *TransactionGetProposerIdCall

+ func (c *TransactionGetProposerIdCall) DoAndReturn(f func(context.Context, string) (uint64, error)) *TransactionGetProposerIdCall

+ func (c *TransactionGetProposerIdCall) Return(arg0 uint64, arg1 error) *TransactionGetProposerIdCall

+ type TransactionLastNamespaceMessageCall struct

+ func (c *TransactionLastNamespaceMessageCall) Do(f func(context.Context, uint64) (storage.NamespaceMessage, error)) *TransactionLastNamespaceMessageCall

+ func (c *TransactionLastNamespaceMessageCall) DoAndReturn(f func(context.Context, uint64) (storage.NamespaceMessage, error)) *TransactionLastNamespaceMessageCall

+ func (c *TransactionLastNamespaceMessageCall) Return(msg storage.NamespaceMessage, err error) *TransactionLastNamespaceMessageCall

v1.1.0-rc1

Nov 3, 2023

v1.0.5

Nov 6, 2023

v1.0.4

Nov 4, 2023

Changes in this version

+ type IMessageListWithTxCall struct

+ func (c *IMessageListWithTxCall) Do(...) *IMessageListWithTxCall

+ func (c *IMessageListWithTxCall) DoAndReturn(...) *IMessageListWithTxCall

+ func (c *IMessageListWithTxCall) Return(arg0 []storage.MessageWithTx, arg1 error) *IMessageListWithTxCall

type MockIMessage

+ func (m *MockIMessage) ListWithTx(ctx context.Context, filters storage.MessageListWithTxFilters) ([]storage.MessageWithTx, error)

type MockIMessageMockRecorder

+ func (mr *MockIMessageMockRecorder) ListWithTx(ctx, filters any) *IMessageListWithTxCall

v1.0.3

Nov 1, 2023

v1.0.2

Oct 31, 2023

v1.0.1

Oct 31, 2023

v1.0.0

Oct 31, 2023

Changes in this version

+ type IAddressByHashCall struct

+ func (c *IAddressByHashCall) Do(f func(context.Context, []byte) (storage.Address, error)) *IAddressByHashCall

+ func (c *IAddressByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Address, error)) *IAddressByHashCall

+ func (c *IAddressByHashCall) Return(arg0 storage.Address, arg1 error) *IAddressByHashCall

+ type IAddressCursorListCall struct

+ func (c *IAddressCursorListCall) Do(...) *IAddressCursorListCall

+ func (c *IAddressCursorListCall) DoAndReturn(...) *IAddressCursorListCall

+ func (c *IAddressCursorListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressCursorListCall

+ type IAddressGetByIDCall struct

+ func (c *IAddressGetByIDCall) Do(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall

+ func (c *IAddressGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall

+ func (c *IAddressGetByIDCall) Return(arg0 *storage.Address, arg1 error) *IAddressGetByIDCall

+ type IAddressIsNoRowsCall struct

+ func (c *IAddressIsNoRowsCall) Do(f func(error) bool) *IAddressIsNoRowsCall

+ func (c *IAddressIsNoRowsCall) DoAndReturn(f func(error) bool) *IAddressIsNoRowsCall

+ func (c *IAddressIsNoRowsCall) Return(arg0 bool) *IAddressIsNoRowsCall

+ type IAddressLastIDCall struct

+ func (c *IAddressLastIDCall) Do(f func(context.Context) (uint64, error)) *IAddressLastIDCall

+ func (c *IAddressLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IAddressLastIDCall

+ func (c *IAddressLastIDCall) Return(arg0 uint64, arg1 error) *IAddressLastIDCall

+ type IAddressListCall struct

+ func (c *IAddressListCall) Do(...) *IAddressListCall

+ func (c *IAddressListCall) DoAndReturn(...) *IAddressListCall

+ func (c *IAddressListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressListCall

+ type IAddressListWithBalanceCall struct

+ func (c *IAddressListWithBalanceCall) Do(f func(context.Context, storage.AddressListFilter) ([]storage.Address, error)) *IAddressListWithBalanceCall

+ func (c *IAddressListWithBalanceCall) DoAndReturn(f func(context.Context, storage.AddressListFilter) ([]storage.Address, error)) *IAddressListWithBalanceCall

+ func (c *IAddressListWithBalanceCall) Return(arg0 []storage.Address, arg1 error) *IAddressListWithBalanceCall

+ type IAddressMessagesCall struct

+ func (c *IAddressMessagesCall) Do(...) *IAddressMessagesCall

+ func (c *IAddressMessagesCall) DoAndReturn(...) *IAddressMessagesCall

+ func (c *IAddressMessagesCall) Return(arg0 []storage.MsgAddress, arg1 error) *IAddressMessagesCall

+ type IAddressSaveCall struct

+ func (c *IAddressSaveCall) Do(f func(context.Context, *storage.Address) error) *IAddressSaveCall

+ func (c *IAddressSaveCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressSaveCall

+ func (c *IAddressSaveCall) Return(arg0 error) *IAddressSaveCall

+ type IAddressUpdateCall struct

+ func (c *IAddressUpdateCall) Do(f func(context.Context, *storage.Address) error) *IAddressUpdateCall

+ func (c *IAddressUpdateCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressUpdateCall

+ func (c *IAddressUpdateCall) Return(arg0 error) *IAddressUpdateCall

+ type IBalanceCursorListCall struct

+ func (c *IBalanceCursorListCall) Do(...) *IBalanceCursorListCall

+ func (c *IBalanceCursorListCall) DoAndReturn(...) *IBalanceCursorListCall

+ func (c *IBalanceCursorListCall) Return(arg0 []*storage.Balance, arg1 error) *IBalanceCursorListCall

+ type IBalanceGetByIDCall struct

+ func (c *IBalanceGetByIDCall) Do(f func(context.Context, uint64) (*storage.Balance, error)) *IBalanceGetByIDCall

+ func (c *IBalanceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Balance, error)) *IBalanceGetByIDCall

+ func (c *IBalanceGetByIDCall) Return(arg0 *storage.Balance, arg1 error) *IBalanceGetByIDCall

+ type IBalanceIsNoRowsCall struct

+ func (c *IBalanceIsNoRowsCall) Do(f func(error) bool) *IBalanceIsNoRowsCall

+ func (c *IBalanceIsNoRowsCall) DoAndReturn(f func(error) bool) *IBalanceIsNoRowsCall

+ func (c *IBalanceIsNoRowsCall) Return(arg0 bool) *IBalanceIsNoRowsCall

+ type IBalanceLastIDCall struct

+ func (c *IBalanceLastIDCall) Do(f func(context.Context) (uint64, error)) *IBalanceLastIDCall

+ func (c *IBalanceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBalanceLastIDCall

+ func (c *IBalanceLastIDCall) Return(arg0 uint64, arg1 error) *IBalanceLastIDCall

+ type IBalanceListCall struct

+ func (c *IBalanceListCall) Do(...) *IBalanceListCall

+ func (c *IBalanceListCall) DoAndReturn(...) *IBalanceListCall

+ func (c *IBalanceListCall) Return(arg0 []*storage.Balance, arg1 error) *IBalanceListCall

+ type IBalanceSaveCall struct

+ func (c *IBalanceSaveCall) Do(f func(context.Context, *storage.Balance) error) *IBalanceSaveCall

+ func (c *IBalanceSaveCall) DoAndReturn(f func(context.Context, *storage.Balance) error) *IBalanceSaveCall

+ func (c *IBalanceSaveCall) Return(arg0 error) *IBalanceSaveCall

+ type IBalanceUpdateCall struct

+ func (c *IBalanceUpdateCall) Do(f func(context.Context, *storage.Balance) error) *IBalanceUpdateCall

+ func (c *IBalanceUpdateCall) DoAndReturn(f func(context.Context, *storage.Balance) error) *IBalanceUpdateCall

+ func (c *IBalanceUpdateCall) Return(arg0 error) *IBalanceUpdateCall

+ type IBlockByHashCall struct

+ func (c *IBlockByHashCall) Do(f func(context.Context, []byte) (storage.Block, error)) *IBlockByHashCall

+ func (c *IBlockByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Block, error)) *IBlockByHashCall

+ func (c *IBlockByHashCall) Return(arg0 storage.Block, arg1 error) *IBlockByHashCall

+ type IBlockByHeightCall struct

+ func (c *IBlockByHeightCall) Do(f func(context.Context, types.Level) (storage.Block, error)) *IBlockByHeightCall

+ func (c *IBlockByHeightCall) DoAndReturn(f func(context.Context, types.Level) (storage.Block, error)) *IBlockByHeightCall

+ func (c *IBlockByHeightCall) Return(arg0 storage.Block, arg1 error) *IBlockByHeightCall

+ type IBlockByHeightWithStatsCall struct

+ func (c *IBlockByHeightWithStatsCall) Do(f func(context.Context, types.Level) (storage.Block, error)) *IBlockByHeightWithStatsCall

+ func (c *IBlockByHeightWithStatsCall) DoAndReturn(f func(context.Context, types.Level) (storage.Block, error)) *IBlockByHeightWithStatsCall

+ func (c *IBlockByHeightWithStatsCall) Return(arg0 storage.Block, arg1 error) *IBlockByHeightWithStatsCall

+ type IBlockByIdWithRelationsCall struct

+ func (c *IBlockByIdWithRelationsCall) Do(f func(context.Context, uint64) (storage.Block, error)) *IBlockByIdWithRelationsCall

+ func (c *IBlockByIdWithRelationsCall) DoAndReturn(f func(context.Context, uint64) (storage.Block, error)) *IBlockByIdWithRelationsCall

+ func (c *IBlockByIdWithRelationsCall) Return(arg0 storage.Block, arg1 error) *IBlockByIdWithRelationsCall

+ type IBlockCursorListCall struct

+ func (c *IBlockCursorListCall) Do(...) *IBlockCursorListCall

+ func (c *IBlockCursorListCall) DoAndReturn(...) *IBlockCursorListCall

+ func (c *IBlockCursorListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockCursorListCall

+ type IBlockGetByIDCall struct

+ func (c *IBlockGetByIDCall) Do(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall

+ func (c *IBlockGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall

+ func (c *IBlockGetByIDCall) Return(arg0 *storage.Block, arg1 error) *IBlockGetByIDCall

+ type IBlockIsNoRowsCall struct

+ func (c *IBlockIsNoRowsCall) Do(f func(error) bool) *IBlockIsNoRowsCall

+ func (c *IBlockIsNoRowsCall) DoAndReturn(f func(error) bool) *IBlockIsNoRowsCall

+ func (c *IBlockIsNoRowsCall) Return(arg0 bool) *IBlockIsNoRowsCall

+ type IBlockLastCall struct

+ func (c *IBlockLastCall) Do(f func(context.Context) (storage.Block, error)) *IBlockLastCall

+ func (c *IBlockLastCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *IBlockLastCall

+ func (c *IBlockLastCall) Return(arg0 storage.Block, arg1 error) *IBlockLastCall

+ type IBlockLastIDCall struct

+ func (c *IBlockLastIDCall) Do(f func(context.Context) (uint64, error)) *IBlockLastIDCall

+ func (c *IBlockLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBlockLastIDCall

+ func (c *IBlockLastIDCall) Return(arg0 uint64, arg1 error) *IBlockLastIDCall

+ type IBlockListCall struct

+ func (c *IBlockListCall) Do(...) *IBlockListCall

+ func (c *IBlockListCall) DoAndReturn(...) *IBlockListCall

+ func (c *IBlockListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockListCall

+ type IBlockListWithStatsCall struct

+ func (c *IBlockListWithStatsCall) Do(...) *IBlockListWithStatsCall

+ func (c *IBlockListWithStatsCall) DoAndReturn(...) *IBlockListWithStatsCall

+ func (c *IBlockListWithStatsCall) Return(arg0 []*storage.Block, arg1 error) *IBlockListWithStatsCall

+ type IBlockSaveCall struct

+ func (c *IBlockSaveCall) Do(f func(context.Context, *storage.Block) error) *IBlockSaveCall

+ func (c *IBlockSaveCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockSaveCall

+ func (c *IBlockSaveCall) Return(arg0 error) *IBlockSaveCall

+ type IBlockStatsByHeightCall struct

+ func (c *IBlockStatsByHeightCall) Do(f func(context.Context, types.Level) (storage.BlockStats, error)) *IBlockStatsByHeightCall

+ func (c *IBlockStatsByHeightCall) DoAndReturn(f func(context.Context, types.Level) (storage.BlockStats, error)) *IBlockStatsByHeightCall

+ func (c *IBlockStatsByHeightCall) Return(arg0 storage.BlockStats, arg1 error) *IBlockStatsByHeightCall

+ type IBlockUpdateCall struct

+ func (c *IBlockUpdateCall) Do(f func(context.Context, *storage.Block) error) *IBlockUpdateCall

+ func (c *IBlockUpdateCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockUpdateCall

+ func (c *IBlockUpdateCall) Return(arg0 error) *IBlockUpdateCall

+ type IConstantAllCall struct

+ func (c *IConstantAllCall) Do(f func(context.Context) ([]storage.Constant, error)) *IConstantAllCall

+ func (c *IConstantAllCall) DoAndReturn(f func(context.Context) ([]storage.Constant, error)) *IConstantAllCall

+ func (c *IConstantAllCall) Return(arg0 []storage.Constant, arg1 error) *IConstantAllCall

+ type IConstantByModuleCall struct

+ func (c *IConstantByModuleCall) Do(f func(context.Context, types.ModuleName) ([]storage.Constant, error)) *IConstantByModuleCall

+ func (c *IConstantByModuleCall) DoAndReturn(f func(context.Context, types.ModuleName) ([]storage.Constant, error)) *IConstantByModuleCall

+ func (c *IConstantByModuleCall) Return(arg0 []storage.Constant, arg1 error) *IConstantByModuleCall

+ type IConstantGetCall struct

+ func (c *IConstantGetCall) Do(f func(context.Context, types.ModuleName, string) (storage.Constant, error)) *IConstantGetCall

+ func (c *IConstantGetCall) DoAndReturn(f func(context.Context, types.ModuleName, string) (storage.Constant, error)) *IConstantGetCall

+ func (c *IConstantGetCall) Return(arg0 storage.Constant, arg1 error) *IConstantGetCall

+ type IDenomMetadataAllCall struct

+ func (c *IDenomMetadataAllCall) Do(f func(context.Context) ([]storage.DenomMetadata, error)) *IDenomMetadataAllCall

+ func (c *IDenomMetadataAllCall) DoAndReturn(f func(context.Context) ([]storage.DenomMetadata, error)) *IDenomMetadataAllCall

+ func (c *IDenomMetadataAllCall) Return(arg0 []storage.DenomMetadata, arg1 error) *IDenomMetadataAllCall

+ type IEventByBlockCall struct

+ func (c *IEventByBlockCall) Do(f func(context.Context, types.Level) ([]storage.Event, error)) *IEventByBlockCall

+ func (c *IEventByBlockCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Event, error)) *IEventByBlockCall

+ func (c *IEventByBlockCall) Return(arg0 []storage.Event, arg1 error) *IEventByBlockCall

+ type IEventByTxIdCall struct

+ func (c *IEventByTxIdCall) Do(f func(context.Context, uint64) ([]storage.Event, error)) *IEventByTxIdCall

+ func (c *IEventByTxIdCall) DoAndReturn(f func(context.Context, uint64) ([]storage.Event, error)) *IEventByTxIdCall

+ func (c *IEventByTxIdCall) Return(arg0 []storage.Event, arg1 error) *IEventByTxIdCall

+ type IEventCursorListCall struct

+ func (c *IEventCursorListCall) Do(...) *IEventCursorListCall

+ func (c *IEventCursorListCall) DoAndReturn(...) *IEventCursorListCall

+ func (c *IEventCursorListCall) Return(arg0 []*storage.Event, arg1 error) *IEventCursorListCall

+ type IEventGetByIDCall struct

+ func (c *IEventGetByIDCall) Do(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall

+ func (c *IEventGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall

+ func (c *IEventGetByIDCall) Return(arg0 *storage.Event, arg1 error) *IEventGetByIDCall

+ type IEventIsNoRowsCall struct

+ func (c *IEventIsNoRowsCall) Do(f func(error) bool) *IEventIsNoRowsCall

+ func (c *IEventIsNoRowsCall) DoAndReturn(f func(error) bool) *IEventIsNoRowsCall

+ func (c *IEventIsNoRowsCall) Return(arg0 bool) *IEventIsNoRowsCall

+ type IEventLastIDCall struct

+ func (c *IEventLastIDCall) Do(f func(context.Context) (uint64, error)) *IEventLastIDCall

+ func (c *IEventLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IEventLastIDCall

+ func (c *IEventLastIDCall) Return(arg0 uint64, arg1 error) *IEventLastIDCall

+ type IEventListCall struct

+ func (c *IEventListCall) Do(...) *IEventListCall

+ func (c *IEventListCall) DoAndReturn(...) *IEventListCall

+ func (c *IEventListCall) Return(arg0 []*storage.Event, arg1 error) *IEventListCall

+ type IEventSaveCall struct

+ func (c *IEventSaveCall) Do(f func(context.Context, *storage.Event) error) *IEventSaveCall

+ func (c *IEventSaveCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventSaveCall

+ func (c *IEventSaveCall) Return(arg0 error) *IEventSaveCall

+ type IEventUpdateCall struct

+ func (c *IEventUpdateCall) Do(f func(context.Context, *storage.Event) error) *IEventUpdateCall

+ func (c *IEventUpdateCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventUpdateCall

+ func (c *IEventUpdateCall) Return(arg0 error) *IEventUpdateCall

+ type IMessageByTxIdCall struct

+ func (c *IMessageByTxIdCall) Do(f func(context.Context, uint64) ([]storage.Message, error)) *IMessageByTxIdCall

+ func (c *IMessageByTxIdCall) DoAndReturn(f func(context.Context, uint64) ([]storage.Message, error)) *IMessageByTxIdCall

+ func (c *IMessageByTxIdCall) Return(arg0 []storage.Message, arg1 error) *IMessageByTxIdCall

+ type IMessageCursorListCall struct

+ func (c *IMessageCursorListCall) Do(...) *IMessageCursorListCall

+ func (c *IMessageCursorListCall) DoAndReturn(...) *IMessageCursorListCall

+ func (c *IMessageCursorListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageCursorListCall

+ type IMessageGetByIDCall struct

+ func (c *IMessageGetByIDCall) Do(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall

+ func (c *IMessageGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall

+ func (c *IMessageGetByIDCall) Return(arg0 *storage.Message, arg1 error) *IMessageGetByIDCall

+ type IMessageIsNoRowsCall struct

+ func (c *IMessageIsNoRowsCall) Do(f func(error) bool) *IMessageIsNoRowsCall

+ func (c *IMessageIsNoRowsCall) DoAndReturn(f func(error) bool) *IMessageIsNoRowsCall

+ func (c *IMessageIsNoRowsCall) Return(arg0 bool) *IMessageIsNoRowsCall

+ type IMessageLastIDCall struct

+ func (c *IMessageLastIDCall) Do(f func(context.Context) (uint64, error)) *IMessageLastIDCall

+ func (c *IMessageLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IMessageLastIDCall

+ func (c *IMessageLastIDCall) Return(arg0 uint64, arg1 error) *IMessageLastIDCall

+ type IMessageListCall struct

+ func (c *IMessageListCall) Do(...) *IMessageListCall

+ func (c *IMessageListCall) DoAndReturn(...) *IMessageListCall

+ func (c *IMessageListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageListCall

+ type IMessageSaveCall struct

+ func (c *IMessageSaveCall) Do(f func(context.Context, *storage.Message) error) *IMessageSaveCall

+ func (c *IMessageSaveCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageSaveCall

+ func (c *IMessageSaveCall) Return(arg0 error) *IMessageSaveCall

+ type IMessageUpdateCall struct

+ func (c *IMessageUpdateCall) Do(f func(context.Context, *storage.Message) error) *IMessageUpdateCall

+ func (c *IMessageUpdateCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageUpdateCall

+ func (c *IMessageUpdateCall) Return(arg0 error) *IMessageUpdateCall

+ type INamespaceActiveCall struct

+ func (c *INamespaceActiveCall) Do(f func(context.Context, int) ([]storage.ActiveNamespace, error)) *INamespaceActiveCall

+ func (c *INamespaceActiveCall) DoAndReturn(f func(context.Context, int) ([]storage.ActiveNamespace, error)) *INamespaceActiveCall

+ func (c *INamespaceActiveCall) Return(arg0 []storage.ActiveNamespace, arg1 error) *INamespaceActiveCall

+ type INamespaceByNamespaceIdAndVersionCall struct

+ func (c *INamespaceByNamespaceIdAndVersionCall) Do(f func(context.Context, []byte, byte) (storage.Namespace, error)) *INamespaceByNamespaceIdAndVersionCall

+ func (c *INamespaceByNamespaceIdAndVersionCall) DoAndReturn(f func(context.Context, []byte, byte) (storage.Namespace, error)) *INamespaceByNamespaceIdAndVersionCall

+ func (c *INamespaceByNamespaceIdAndVersionCall) Return(arg0 storage.Namespace, arg1 error) *INamespaceByNamespaceIdAndVersionCall

+ type INamespaceByNamespaceIdCall struct

+ func (c *INamespaceByNamespaceIdCall) Do(f func(context.Context, []byte) ([]storage.Namespace, error)) *INamespaceByNamespaceIdCall

+ func (c *INamespaceByNamespaceIdCall) DoAndReturn(f func(context.Context, []byte) ([]storage.Namespace, error)) *INamespaceByNamespaceIdCall

+ func (c *INamespaceByNamespaceIdCall) Return(arg0 []storage.Namespace, arg1 error) *INamespaceByNamespaceIdCall

+ type INamespaceCountMessagesByHeightCall struct

+ func (c *INamespaceCountMessagesByHeightCall) Do(f func(context.Context, types.Level) (int, error)) *INamespaceCountMessagesByHeightCall

+ func (c *INamespaceCountMessagesByHeightCall) DoAndReturn(f func(context.Context, types.Level) (int, error)) *INamespaceCountMessagesByHeightCall

+ func (c *INamespaceCountMessagesByHeightCall) Return(arg0 int, arg1 error) *INamespaceCountMessagesByHeightCall

+ type INamespaceCursorListCall struct

+ func (c *INamespaceCursorListCall) Do(...) *INamespaceCursorListCall

+ func (c *INamespaceCursorListCall) DoAndReturn(...) *INamespaceCursorListCall

+ func (c *INamespaceCursorListCall) Return(arg0 []*storage.Namespace, arg1 error) *INamespaceCursorListCall

+ type INamespaceGetByIDCall struct

+ func (c *INamespaceGetByIDCall) Do(f func(context.Context, uint64) (*storage.Namespace, error)) *INamespaceGetByIDCall

+ func (c *INamespaceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Namespace, error)) *INamespaceGetByIDCall

+ func (c *INamespaceGetByIDCall) Return(arg0 *storage.Namespace, arg1 error) *INamespaceGetByIDCall

+ type INamespaceIsNoRowsCall struct

+ func (c *INamespaceIsNoRowsCall) Do(f func(error) bool) *INamespaceIsNoRowsCall

+ func (c *INamespaceIsNoRowsCall) DoAndReturn(f func(error) bool) *INamespaceIsNoRowsCall

+ func (c *INamespaceIsNoRowsCall) Return(arg0 bool) *INamespaceIsNoRowsCall

+ type INamespaceLastIDCall struct

+ func (c *INamespaceLastIDCall) Do(f func(context.Context) (uint64, error)) *INamespaceLastIDCall

+ func (c *INamespaceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *INamespaceLastIDCall

+ func (c *INamespaceLastIDCall) Return(arg0 uint64, arg1 error) *INamespaceLastIDCall

+ type INamespaceListCall struct

+ func (c *INamespaceListCall) Do(...) *INamespaceListCall

+ func (c *INamespaceListCall) DoAndReturn(...) *INamespaceListCall

+ func (c *INamespaceListCall) Return(arg0 []*storage.Namespace, arg1 error) *INamespaceListCall

+ type INamespaceMessagesByHeightCall struct

+ func (c *INamespaceMessagesByHeightCall) Do(...) *INamespaceMessagesByHeightCall

+ func (c *INamespaceMessagesByHeightCall) DoAndReturn(...) *INamespaceMessagesByHeightCall

+ func (c *INamespaceMessagesByHeightCall) Return(arg0 []storage.NamespaceMessage, arg1 error) *INamespaceMessagesByHeightCall

+ type INamespaceMessagesCall struct

+ func (c *INamespaceMessagesCall) Do(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *INamespaceMessagesCall

+ func (c *INamespaceMessagesCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.NamespaceMessage, error)) *INamespaceMessagesCall

+ func (c *INamespaceMessagesCall) Return(arg0 []storage.NamespaceMessage, arg1 error) *INamespaceMessagesCall

+ type INamespaceSaveCall struct

+ func (c *INamespaceSaveCall) Do(f func(context.Context, *storage.Namespace) error) *INamespaceSaveCall

+ func (c *INamespaceSaveCall) DoAndReturn(f func(context.Context, *storage.Namespace) error) *INamespaceSaveCall

+ func (c *INamespaceSaveCall) Return(arg0 error) *INamespaceSaveCall

+ type INamespaceUpdateCall struct

+ func (c *INamespaceUpdateCall) Do(f func(context.Context, *storage.Namespace) error) *INamespaceUpdateCall

+ func (c *INamespaceUpdateCall) DoAndReturn(f func(context.Context, *storage.Namespace) error) *INamespaceUpdateCall

+ func (c *INamespaceUpdateCall) Return(arg0 error) *INamespaceUpdateCall

+ type IStateByNameCall struct

+ func (c *IStateByNameCall) Do(f func(context.Context, string) (storage.State, error)) *IStateByNameCall

+ func (c *IStateByNameCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *IStateByNameCall

+ func (c *IStateByNameCall) Return(arg0 storage.State, arg1 error) *IStateByNameCall

+ type IStateCursorListCall struct

+ func (c *IStateCursorListCall) Do(...) *IStateCursorListCall

+ func (c *IStateCursorListCall) DoAndReturn(...) *IStateCursorListCall

+ func (c *IStateCursorListCall) Return(arg0 []*storage.State, arg1 error) *IStateCursorListCall

+ type IStateGetByIDCall struct

+ func (c *IStateGetByIDCall) Do(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall

+ func (c *IStateGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall

+ func (c *IStateGetByIDCall) Return(arg0 *storage.State, arg1 error) *IStateGetByIDCall

+ type IStateIsNoRowsCall struct

+ func (c *IStateIsNoRowsCall) Do(f func(error) bool) *IStateIsNoRowsCall

+ func (c *IStateIsNoRowsCall) DoAndReturn(f func(error) bool) *IStateIsNoRowsCall

+ func (c *IStateIsNoRowsCall) Return(arg0 bool) *IStateIsNoRowsCall

+ type IStateLastIDCall struct

+ func (c *IStateLastIDCall) Do(f func(context.Context) (uint64, error)) *IStateLastIDCall

+ func (c *IStateLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStateLastIDCall

+ func (c *IStateLastIDCall) Return(arg0 uint64, arg1 error) *IStateLastIDCall

+ type IStateListCall struct

+ func (c *IStateListCall) Do(...) *IStateListCall

+ func (c *IStateListCall) DoAndReturn(...) *IStateListCall

+ func (c *IStateListCall) Return(arg0 []*storage.State, arg1 error) *IStateListCall

+ type IStateSaveCall struct

+ func (c *IStateSaveCall) Do(f func(context.Context, *storage.State) error) *IStateSaveCall

+ func (c *IStateSaveCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateSaveCall

+ func (c *IStateSaveCall) Return(arg0 error) *IStateSaveCall

+ type IStateUpdateCall struct

+ func (c *IStateUpdateCall) Do(f func(context.Context, *storage.State) error) *IStateUpdateCall

+ func (c *IStateUpdateCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateUpdateCall

+ func (c *IStateUpdateCall) Return(arg0 error) *IStateUpdateCall

+ type IStatsCountCall struct

+ func (c *IStatsCountCall) Do(f func(context.Context, storage.CountRequest) (string, error)) *IStatsCountCall

+ func (c *IStatsCountCall) DoAndReturn(f func(context.Context, storage.CountRequest) (string, error)) *IStatsCountCall

+ func (c *IStatsCountCall) Return(arg0 string, arg1 error) *IStatsCountCall

+ type IStatsHistogramCall struct

+ func (c *IStatsHistogramCall) Do(...) *IStatsHistogramCall

+ func (c *IStatsHistogramCall) DoAndReturn(...) *IStatsHistogramCall

+ func (c *IStatsHistogramCall) Return(arg0 []storage.HistogramItem, arg1 error) *IStatsHistogramCall

+ type IStatsHistogramCountCall struct

+ func (c *IStatsHistogramCountCall) Do(...) *IStatsHistogramCountCall

+ func (c *IStatsHistogramCountCall) DoAndReturn(...) *IStatsHistogramCountCall

+ func (c *IStatsHistogramCountCall) Return(arg0 []storage.HistogramItem, arg1 error) *IStatsHistogramCountCall

+ type IStatsSummaryCall struct

+ func (c *IStatsSummaryCall) Do(f func(context.Context, storage.SummaryRequest) (string, error)) *IStatsSummaryCall

+ func (c *IStatsSummaryCall) DoAndReturn(f func(context.Context, storage.SummaryRequest) (string, error)) *IStatsSummaryCall

+ func (c *IStatsSummaryCall) Return(arg0 string, arg1 error) *IStatsSummaryCall

+ type ITxByAddressCall struct

+ func (c *ITxByAddressCall) Do(f func(context.Context, uint64, storage.TxFilter) ([]storage.Tx, error)) *ITxByAddressCall

+ func (c *ITxByAddressCall) DoAndReturn(f func(context.Context, uint64, storage.TxFilter) ([]storage.Tx, error)) *ITxByAddressCall

+ func (c *ITxByAddressCall) Return(arg0 []storage.Tx, arg1 error) *ITxByAddressCall

+ type ITxByHashCall struct

+ func (c *ITxByHashCall) Do(f func(context.Context, []byte) (storage.Tx, error)) *ITxByHashCall

+ func (c *ITxByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Tx, error)) *ITxByHashCall

+ func (c *ITxByHashCall) Return(arg0 storage.Tx, arg1 error) *ITxByHashCall

+ type ITxByIdWithRelationsCall struct

+ func (c *ITxByIdWithRelationsCall) Do(f func(context.Context, uint64) (storage.Tx, error)) *ITxByIdWithRelationsCall

+ func (c *ITxByIdWithRelationsCall) DoAndReturn(f func(context.Context, uint64) (storage.Tx, error)) *ITxByIdWithRelationsCall

+ func (c *ITxByIdWithRelationsCall) Return(arg0 storage.Tx, arg1 error) *ITxByIdWithRelationsCall

+ type ITxCursorListCall struct

+ func (c *ITxCursorListCall) Do(...) *ITxCursorListCall

+ func (c *ITxCursorListCall) DoAndReturn(...) *ITxCursorListCall

+ func (c *ITxCursorListCall) Return(arg0 []*storage.Tx, arg1 error) *ITxCursorListCall

+ type ITxFilterCall struct

+ func (c *ITxFilterCall) Do(f func(context.Context, storage.TxFilter) ([]storage.Tx, error)) *ITxFilterCall

+ func (c *ITxFilterCall) DoAndReturn(f func(context.Context, storage.TxFilter) ([]storage.Tx, error)) *ITxFilterCall

+ func (c *ITxFilterCall) Return(arg0 []storage.Tx, arg1 error) *ITxFilterCall

+ type ITxGenesisCall struct

+ func (c *ITxGenesisCall) Do(f func(context.Context, int, int, storage0.SortOrder) ([]storage.Tx, error)) *ITxGenesisCall

+ func (c *ITxGenesisCall) DoAndReturn(f func(context.Context, int, int, storage0.SortOrder) ([]storage.Tx, error)) *ITxGenesisCall

+ func (c *ITxGenesisCall) Return(arg0 []storage.Tx, arg1 error) *ITxGenesisCall

+ type ITxGetByIDCall struct

+ func (c *ITxGetByIDCall) Do(f func(context.Context, uint64) (*storage.Tx, error)) *ITxGetByIDCall

+ func (c *ITxGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Tx, error)) *ITxGetByIDCall

+ func (c *ITxGetByIDCall) Return(arg0 *storage.Tx, arg1 error) *ITxGetByIDCall

+ type ITxIsNoRowsCall struct

+ func (c *ITxIsNoRowsCall) Do(f func(error) bool) *ITxIsNoRowsCall

+ func (c *ITxIsNoRowsCall) DoAndReturn(f func(error) bool) *ITxIsNoRowsCall

+ func (c *ITxIsNoRowsCall) Return(arg0 bool) *ITxIsNoRowsCall

+ type ITxLastIDCall struct

+ func (c *ITxLastIDCall) Do(f func(context.Context) (uint64, error)) *ITxLastIDCall

+ func (c *ITxLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITxLastIDCall

+ func (c *ITxLastIDCall) Return(arg0 uint64, arg1 error) *ITxLastIDCall

+ type ITxListCall struct

+ func (c *ITxListCall) Do(...) *ITxListCall

+ func (c *ITxListCall) DoAndReturn(...) *ITxListCall

+ func (c *ITxListCall) Return(arg0 []*storage.Tx, arg1 error) *ITxListCall

+ type ITxSaveCall struct

+ func (c *ITxSaveCall) Do(f func(context.Context, *storage.Tx) error) *ITxSaveCall

+ func (c *ITxSaveCall) DoAndReturn(f func(context.Context, *storage.Tx) error) *ITxSaveCall

+ func (c *ITxSaveCall) Return(arg0 error) *ITxSaveCall

+ type ITxUpdateCall struct

+ func (c *ITxUpdateCall) Do(f func(context.Context, *storage.Tx) error) *ITxUpdateCall

+ func (c *ITxUpdateCall) DoAndReturn(f func(context.Context, *storage.Tx) error) *ITxUpdateCall

+ func (c *ITxUpdateCall) Return(arg0 error) *ITxUpdateCall

+ type IValidatorByAddressCall struct

+ func (c *IValidatorByAddressCall) Do(f func(context.Context, string) (storage.Validator, error)) *IValidatorByAddressCall

+ func (c *IValidatorByAddressCall) DoAndReturn(f func(context.Context, string) (storage.Validator, error)) *IValidatorByAddressCall

+ func (c *IValidatorByAddressCall) Return(arg0 storage.Validator, arg1 error) *IValidatorByAddressCall

+ type IValidatorCursorListCall struct

+ func (c *IValidatorCursorListCall) Do(...) *IValidatorCursorListCall

+ func (c *IValidatorCursorListCall) DoAndReturn(...) *IValidatorCursorListCall

+ func (c *IValidatorCursorListCall) Return(arg0 []*storage.Validator, arg1 error) *IValidatorCursorListCall

+ type IValidatorGetByIDCall struct

+ func (c *IValidatorGetByIDCall) Do(f func(context.Context, uint64) (*storage.Validator, error)) *IValidatorGetByIDCall

+ func (c *IValidatorGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Validator, error)) *IValidatorGetByIDCall

+ func (c *IValidatorGetByIDCall) Return(arg0 *storage.Validator, arg1 error) *IValidatorGetByIDCall

+ type IValidatorIsNoRowsCall struct

+ func (c *IValidatorIsNoRowsCall) Do(f func(error) bool) *IValidatorIsNoRowsCall

+ func (c *IValidatorIsNoRowsCall) DoAndReturn(f func(error) bool) *IValidatorIsNoRowsCall

+ func (c *IValidatorIsNoRowsCall) Return(arg0 bool) *IValidatorIsNoRowsCall

+ type IValidatorLastIDCall struct

+ func (c *IValidatorLastIDCall) Do(f func(context.Context) (uint64, error)) *IValidatorLastIDCall

+ func (c *IValidatorLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IValidatorLastIDCall

+ func (c *IValidatorLastIDCall) Return(arg0 uint64, arg1 error) *IValidatorLastIDCall

+ type IValidatorListCall struct

+ func (c *IValidatorListCall) Do(...) *IValidatorListCall

+ func (c *IValidatorListCall) DoAndReturn(...) *IValidatorListCall

+ func (c *IValidatorListCall) Return(arg0 []*storage.Validator, arg1 error) *IValidatorListCall

+ type IValidatorSaveCall struct

+ func (c *IValidatorSaveCall) Do(f func(context.Context, *storage.Validator) error) *IValidatorSaveCall

+ func (c *IValidatorSaveCall) DoAndReturn(f func(context.Context, *storage.Validator) error) *IValidatorSaveCall

+ func (c *IValidatorSaveCall) Return(arg0 error) *IValidatorSaveCall

+ type IValidatorUpdateCall struct

+ func (c *IValidatorUpdateCall) Do(f func(context.Context, *storage.Validator) error) *IValidatorUpdateCall

+ func (c *IValidatorUpdateCall) DoAndReturn(f func(context.Context, *storage.Validator) error) *IValidatorUpdateCall

+ func (c *IValidatorUpdateCall) Return(arg0 error) *IValidatorUpdateCall

+ type ListenerCloseCall struct

+ func (c *ListenerCloseCall) Do(f func() error) *ListenerCloseCall

+ func (c *ListenerCloseCall) DoAndReturn(f func() error) *ListenerCloseCall

+ func (c *ListenerCloseCall) Return(arg0 error) *ListenerCloseCall

+ type ListenerFactoryCreateListenerCall struct

+ func (c *ListenerFactoryCreateListenerCall) Do(f func() storage.Listener) *ListenerFactoryCreateListenerCall

+ func (c *ListenerFactoryCreateListenerCall) DoAndReturn(f func() storage.Listener) *ListenerFactoryCreateListenerCall

+ func (c *ListenerFactoryCreateListenerCall) Return(arg0 storage.Listener) *ListenerFactoryCreateListenerCall

+ type ListenerListenCall struct

+ func (c *ListenerListenCall) Do(f func() chan *pq.Notification) *ListenerListenCall

+ func (c *ListenerListenCall) DoAndReturn(f func() chan *pq.Notification) *ListenerListenCall

+ func (c *ListenerListenCall) Return(arg0 chan *pq.Notification) *ListenerListenCall

+ type ListenerSubscribeCall struct

+ func (c *ListenerSubscribeCall) Do(f func(context.Context, ...string) error) *ListenerSubscribeCall

+ func (c *ListenerSubscribeCall) DoAndReturn(f func(context.Context, ...string) error) *ListenerSubscribeCall

+ func (c *ListenerSubscribeCall) Return(arg0 error) *ListenerSubscribeCall

+ type MockIAddress struct

+ func NewMockIAddress(ctrl *gomock.Controller) *MockIAddress

+ func (m *MockIAddress) ByHash(ctx context.Context, hash []byte) (storage.Address, error)

+ func (m *MockIAddress) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Address, error)

+ func (m *MockIAddress) EXPECT() *MockIAddressMockRecorder

+ func (m *MockIAddress) GetByID(ctx context.Context, id uint64) (*storage.Address, error)

+ func (m *MockIAddress) IsNoRows(err error) bool

+ func (m *MockIAddress) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIAddress) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Address, error)

+ func (m *MockIAddress) ListWithBalance(ctx context.Context, filters storage.AddressListFilter) ([]storage.Address, error)

+ func (m *MockIAddress) Messages(ctx context.Context, id uint64, filters storage.AddressMsgsFilter) ([]storage.MsgAddress, error)

+ func (m_2 *MockIAddress) Save(ctx context.Context, m *storage.Address) error

+ func (m_2 *MockIAddress) Update(ctx context.Context, m *storage.Address) error

+ type MockIAddressMockRecorder struct

+ func (mr *MockIAddressMockRecorder) ByHash(ctx, hash any) *IAddressByHashCall

+ func (mr *MockIAddressMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IAddressCursorListCall

+ func (mr *MockIAddressMockRecorder) GetByID(ctx, id any) *IAddressGetByIDCall

+ func (mr *MockIAddressMockRecorder) IsNoRows(err any) *IAddressIsNoRowsCall

+ func (mr *MockIAddressMockRecorder) LastID(ctx any) *IAddressLastIDCall

+ func (mr *MockIAddressMockRecorder) List(ctx, limit, offset, order any) *IAddressListCall

+ func (mr *MockIAddressMockRecorder) ListWithBalance(ctx, filters any) *IAddressListWithBalanceCall

+ func (mr *MockIAddressMockRecorder) Messages(ctx, id, filters any) *IAddressMessagesCall

+ func (mr *MockIAddressMockRecorder) Save(ctx, m any) *IAddressSaveCall

+ func (mr *MockIAddressMockRecorder) Update(ctx, m any) *IAddressUpdateCall

+ type MockIBalance struct

+ func NewMockIBalance(ctrl *gomock.Controller) *MockIBalance

+ func (m *MockIBalance) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Balance, error)

+ func (m *MockIBalance) EXPECT() *MockIBalanceMockRecorder

+ func (m *MockIBalance) GetByID(ctx context.Context, id uint64) (*storage.Balance, error)

+ func (m *MockIBalance) IsNoRows(err error) bool

+ func (m *MockIBalance) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIBalance) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Balance, error)

+ func (m_2 *MockIBalance) Save(ctx context.Context, m *storage.Balance) error

+ func (m_2 *MockIBalance) Update(ctx context.Context, m *storage.Balance) error

+ type MockIBalanceMockRecorder struct

+ func (mr *MockIBalanceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBalanceCursorListCall

+ func (mr *MockIBalanceMockRecorder) GetByID(ctx, id any) *IBalanceGetByIDCall

+ func (mr *MockIBalanceMockRecorder) IsNoRows(err any) *IBalanceIsNoRowsCall

+ func (mr *MockIBalanceMockRecorder) LastID(ctx any) *IBalanceLastIDCall

+ func (mr *MockIBalanceMockRecorder) List(ctx, limit, offset, order any) *IBalanceListCall

+ func (mr *MockIBalanceMockRecorder) Save(ctx, m any) *IBalanceSaveCall

+ func (mr *MockIBalanceMockRecorder) Update(ctx, m any) *IBalanceUpdateCall

+ type MockIBlock struct

+ func NewMockIBlock(ctrl *gomock.Controller) *MockIBlock

+ func (m *MockIBlock) ByHash(ctx context.Context, hash []byte) (storage.Block, error)

+ func (m *MockIBlock) ByHeight(ctx context.Context, height types.Level) (storage.Block, error)

+ func (m *MockIBlock) ByHeightWithStats(ctx context.Context, height types.Level) (storage.Block, error)

+ func (m *MockIBlock) ByIdWithRelations(ctx context.Context, id uint64) (storage.Block, error)

+ func (m *MockIBlock) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Block, error)

+ func (m *MockIBlock) EXPECT() *MockIBlockMockRecorder

+ func (m *MockIBlock) GetByID(ctx context.Context, id uint64) (*storage.Block, error)

+ func (m *MockIBlock) IsNoRows(err error) bool

+ func (m *MockIBlock) Last(ctx context.Context) (storage.Block, error)

+ func (m *MockIBlock) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIBlock) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Block, error)

+ func (m *MockIBlock) ListWithStats(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Block, error)

+ func (m_2 *MockIBlock) Save(ctx context.Context, m *storage.Block) error

+ func (m_2 *MockIBlock) Update(ctx context.Context, m *storage.Block) error

+ type MockIBlockMockRecorder struct

+ func (mr *MockIBlockMockRecorder) ByHash(ctx, hash any) *IBlockByHashCall

+ func (mr *MockIBlockMockRecorder) ByHeight(ctx, height any) *IBlockByHeightCall

+ func (mr *MockIBlockMockRecorder) ByHeightWithStats(ctx, height any) *IBlockByHeightWithStatsCall

+ func (mr *MockIBlockMockRecorder) ByIdWithRelations(ctx, id any) *IBlockByIdWithRelationsCall

+ func (mr *MockIBlockMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBlockCursorListCall

+ func (mr *MockIBlockMockRecorder) GetByID(ctx, id any) *IBlockGetByIDCall

+ func (mr *MockIBlockMockRecorder) IsNoRows(err any) *IBlockIsNoRowsCall

+ func (mr *MockIBlockMockRecorder) Last(ctx any) *IBlockLastCall

+ func (mr *MockIBlockMockRecorder) LastID(ctx any) *IBlockLastIDCall

+ func (mr *MockIBlockMockRecorder) List(ctx, limit, offset, order any) *IBlockListCall

+ func (mr *MockIBlockMockRecorder) ListWithStats(ctx, limit, offset, order any) *IBlockListWithStatsCall

+ func (mr *MockIBlockMockRecorder) Save(ctx, m any) *IBlockSaveCall

+ func (mr *MockIBlockMockRecorder) Update(ctx, m any) *IBlockUpdateCall

+ type MockIBlockStats struct

+ func NewMockIBlockStats(ctrl *gomock.Controller) *MockIBlockStats

+ func (m *MockIBlockStats) ByHeight(ctx context.Context, height types.Level) (storage.BlockStats, error)

+ func (m *MockIBlockStats) EXPECT() *MockIBlockStatsMockRecorder

+ type MockIBlockStatsMockRecorder struct

+ func (mr *MockIBlockStatsMockRecorder) ByHeight(ctx, height any) *IBlockStatsByHeightCall

+ type MockIConstant struct

+ func NewMockIConstant(ctrl *gomock.Controller) *MockIConstant

+ func (m *MockIConstant) All(ctx context.Context) ([]storage.Constant, error)

+ func (m *MockIConstant) ByModule(ctx context.Context, module types.ModuleName) ([]storage.Constant, error)

+ func (m *MockIConstant) EXPECT() *MockIConstantMockRecorder

+ func (m *MockIConstant) Get(ctx context.Context, module types.ModuleName, name string) (storage.Constant, error)

+ type MockIConstantMockRecorder struct

+ func (mr *MockIConstantMockRecorder) All(ctx any) *IConstantAllCall

+ func (mr *MockIConstantMockRecorder) ByModule(ctx, module any) *IConstantByModuleCall

+ func (mr *MockIConstantMockRecorder) Get(ctx, module, name any) *IConstantGetCall

+ type MockIDenomMetadata struct

+ func NewMockIDenomMetadata(ctrl *gomock.Controller) *MockIDenomMetadata

+ func (m *MockIDenomMetadata) All(ctx context.Context) ([]storage.DenomMetadata, error)

+ func (m *MockIDenomMetadata) EXPECT() *MockIDenomMetadataMockRecorder

+ type MockIDenomMetadataMockRecorder struct

+ func (mr *MockIDenomMetadataMockRecorder) All(ctx any) *IDenomMetadataAllCall

+ type MockIEvent struct

+ func NewMockIEvent(ctrl *gomock.Controller) *MockIEvent

+ func (m *MockIEvent) ByBlock(ctx context.Context, height types.Level) ([]storage.Event, error)

+ func (m *MockIEvent) ByTxId(ctx context.Context, txId uint64) ([]storage.Event, error)

+ func (m *MockIEvent) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Event, error)

+ func (m *MockIEvent) EXPECT() *MockIEventMockRecorder

+ func (m *MockIEvent) GetByID(ctx context.Context, id uint64) (*storage.Event, error)

+ func (m *MockIEvent) IsNoRows(err error) bool

+ func (m *MockIEvent) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIEvent) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Event, error)

+ func (m_2 *MockIEvent) Save(ctx context.Context, m *storage.Event) error

+ func (m_2 *MockIEvent) Update(ctx context.Context, m *storage.Event) error

+ type MockIEventMockRecorder struct

+ func (mr *MockIEventMockRecorder) ByBlock(ctx, height any) *IEventByBlockCall

+ func (mr *MockIEventMockRecorder) ByTxId(ctx, txId any) *IEventByTxIdCall

+ func (mr *MockIEventMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IEventCursorListCall

+ func (mr *MockIEventMockRecorder) GetByID(ctx, id any) *IEventGetByIDCall

+ func (mr *MockIEventMockRecorder) IsNoRows(err any) *IEventIsNoRowsCall

+ func (mr *MockIEventMockRecorder) LastID(ctx any) *IEventLastIDCall

+ func (mr *MockIEventMockRecorder) List(ctx, limit, offset, order any) *IEventListCall

+ func (mr *MockIEventMockRecorder) Save(ctx, m any) *IEventSaveCall

+ func (mr *MockIEventMockRecorder) Update(ctx, m any) *IEventUpdateCall

+ type MockIMessage struct

+ func NewMockIMessage(ctrl *gomock.Controller) *MockIMessage

+ func (m *MockIMessage) ByTxId(ctx context.Context, txId uint64) ([]storage.Message, error)

+ func (m *MockIMessage) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Message, error)

+ func (m *MockIMessage) EXPECT() *MockIMessageMockRecorder

+ func (m *MockIMessage) GetByID(ctx context.Context, id uint64) (*storage.Message, error)

+ func (m *MockIMessage) IsNoRows(err error) bool

+ func (m *MockIMessage) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIMessage) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Message, error)

+ func (m_2 *MockIMessage) Save(ctx context.Context, m *storage.Message) error

+ func (m_2 *MockIMessage) Update(ctx context.Context, m *storage.Message) error

+ type MockIMessageMockRecorder struct

+ func (mr *MockIMessageMockRecorder) ByTxId(ctx, txId any) *IMessageByTxIdCall

+ func (mr *MockIMessageMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IMessageCursorListCall

+ func (mr *MockIMessageMockRecorder) GetByID(ctx, id any) *IMessageGetByIDCall

+ func (mr *MockIMessageMockRecorder) IsNoRows(err any) *IMessageIsNoRowsCall

+ func (mr *MockIMessageMockRecorder) LastID(ctx any) *IMessageLastIDCall

+ func (mr *MockIMessageMockRecorder) List(ctx, limit, offset, order any) *IMessageListCall

+ func (mr *MockIMessageMockRecorder) Save(ctx, m any) *IMessageSaveCall

+ func (mr *MockIMessageMockRecorder) Update(ctx, m any) *IMessageUpdateCall

+ type MockINamespace struct

+ func NewMockINamespace(ctrl *gomock.Controller) *MockINamespace

+ func (m *MockINamespace) Active(ctx context.Context, top int) ([]storage.ActiveNamespace, error)

+ func (m *MockINamespace) ByNamespaceId(ctx context.Context, namespaceId []byte) ([]storage.Namespace, error)

+ func (m *MockINamespace) ByNamespaceIdAndVersion(ctx context.Context, namespaceId []byte, version byte) (storage.Namespace, error)

+ func (m *MockINamespace) CountMessagesByHeight(ctx context.Context, height types.Level) (int, error)

+ func (m *MockINamespace) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Namespace, error)

+ func (m *MockINamespace) EXPECT() *MockINamespaceMockRecorder

+ func (m *MockINamespace) GetByID(ctx context.Context, id uint64) (*storage.Namespace, error)

+ func (m *MockINamespace) IsNoRows(err error) bool

+ func (m *MockINamespace) LastID(ctx context.Context) (uint64, error)

+ func (m *MockINamespace) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Namespace, error)

+ func (m *MockINamespace) Messages(ctx context.Context, id uint64, limit, offset int) ([]storage.NamespaceMessage, error)

+ func (m *MockINamespace) MessagesByHeight(ctx context.Context, height types.Level, limit, offset int) ([]storage.NamespaceMessage, error)

+ func (m_2 *MockINamespace) Save(ctx context.Context, m *storage.Namespace) error

+ func (m_2 *MockINamespace) Update(ctx context.Context, m *storage.Namespace) error

+ type MockINamespaceMockRecorder struct

+ func (mr *MockINamespaceMockRecorder) Active(ctx, top any) *INamespaceActiveCall

+ func (mr *MockINamespaceMockRecorder) ByNamespaceId(ctx, namespaceId any) *INamespaceByNamespaceIdCall

+ func (mr *MockINamespaceMockRecorder) ByNamespaceIdAndVersion(ctx, namespaceId, version any) *INamespaceByNamespaceIdAndVersionCall

+ func (mr *MockINamespaceMockRecorder) CountMessagesByHeight(ctx, height any) *INamespaceCountMessagesByHeightCall

+ func (mr *MockINamespaceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *INamespaceCursorListCall

+ func (mr *MockINamespaceMockRecorder) GetByID(ctx, id any) *INamespaceGetByIDCall

+ func (mr *MockINamespaceMockRecorder) IsNoRows(err any) *INamespaceIsNoRowsCall

+ func (mr *MockINamespaceMockRecorder) LastID(ctx any) *INamespaceLastIDCall

+ func (mr *MockINamespaceMockRecorder) List(ctx, limit, offset, order any) *INamespaceListCall

+ func (mr *MockINamespaceMockRecorder) Messages(ctx, id, limit, offset any) *INamespaceMessagesCall

+ func (mr *MockINamespaceMockRecorder) MessagesByHeight(ctx, height, limit, offset any) *INamespaceMessagesByHeightCall

+ func (mr *MockINamespaceMockRecorder) Save(ctx, m any) *INamespaceSaveCall

+ func (mr *MockINamespaceMockRecorder) Update(ctx, m any) *INamespaceUpdateCall

+ type MockIState struct

+ func NewMockIState(ctrl *gomock.Controller) *MockIState

+ func (m *MockIState) ByName(ctx context.Context, name string) (storage.State, error)

+ func (m *MockIState) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.State, error)

+ func (m *MockIState) EXPECT() *MockIStateMockRecorder

+ func (m *MockIState) GetByID(ctx context.Context, id uint64) (*storage.State, error)

+ func (m *MockIState) IsNoRows(err error) bool

+ func (m *MockIState) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIState) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.State, error)

+ func (m_2 *MockIState) Save(ctx context.Context, m *storage.State) error

+ func (m_2 *MockIState) Update(ctx context.Context, m *storage.State) error

+ type MockIStateMockRecorder struct

+ func (mr *MockIStateMockRecorder) ByName(ctx, name any) *IStateByNameCall

+ func (mr *MockIStateMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStateCursorListCall

+ func (mr *MockIStateMockRecorder) GetByID(ctx, id any) *IStateGetByIDCall

+ func (mr *MockIStateMockRecorder) IsNoRows(err any) *IStateIsNoRowsCall

+ func (mr *MockIStateMockRecorder) LastID(ctx any) *IStateLastIDCall

+ func (mr *MockIStateMockRecorder) List(ctx, limit, offset, order any) *IStateListCall

+ func (mr *MockIStateMockRecorder) Save(ctx, m any) *IStateSaveCall

+ func (mr *MockIStateMockRecorder) Update(ctx, m any) *IStateUpdateCall

+ type MockIStats struct

+ func NewMockIStats(ctrl *gomock.Controller) *MockIStats

+ func (m *MockIStats) Count(ctx context.Context, req storage.CountRequest) (string, error)

+ func (m *MockIStats) EXPECT() *MockIStatsMockRecorder

+ func (m *MockIStats) Histogram(ctx context.Context, req storage.HistogramRequest) ([]storage.HistogramItem, error)

+ func (m *MockIStats) HistogramCount(ctx context.Context, req storage.HistogramCountRequest) ([]storage.HistogramItem, error)

+ func (m *MockIStats) Summary(ctx context.Context, req storage.SummaryRequest) (string, error)

+ type MockIStatsMockRecorder struct

+ func (mr *MockIStatsMockRecorder) Count(ctx, req any) *IStatsCountCall

+ func (mr *MockIStatsMockRecorder) Histogram(ctx, req any) *IStatsHistogramCall

+ func (mr *MockIStatsMockRecorder) HistogramCount(ctx, req any) *IStatsHistogramCountCall

+ func (mr *MockIStatsMockRecorder) Summary(ctx, req any) *IStatsSummaryCall

+ type MockITx struct

+ func NewMockITx(ctrl *gomock.Controller) *MockITx

+ func (m *MockITx) ByAddress(ctx context.Context, addressId uint64, fltrs storage.TxFilter) ([]storage.Tx, error)

+ func (m *MockITx) ByHash(ctx context.Context, hash []byte) (storage.Tx, error)

+ func (m *MockITx) ByIdWithRelations(ctx context.Context, id uint64) (storage.Tx, error)

+ func (m *MockITx) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Tx, error)

+ func (m *MockITx) EXPECT() *MockITxMockRecorder

+ func (m *MockITx) Filter(ctx context.Context, fltrs storage.TxFilter) ([]storage.Tx, error)

+ func (m *MockITx) Genesis(ctx context.Context, limit, offset int, sortOrder storage0.SortOrder) ([]storage.Tx, error)

+ func (m *MockITx) GetByID(ctx context.Context, id uint64) (*storage.Tx, error)

+ func (m *MockITx) IsNoRows(err error) bool

+ func (m *MockITx) LastID(ctx context.Context) (uint64, error)

+ func (m *MockITx) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Tx, error)

+ func (m_2 *MockITx) Save(ctx context.Context, m *storage.Tx) error

+ func (m_2 *MockITx) Update(ctx context.Context, m *storage.Tx) error

+ type MockITxMockRecorder struct

+ func (mr *MockITxMockRecorder) ByAddress(ctx, addressId, fltrs any) *ITxByAddressCall

+ func (mr *MockITxMockRecorder) ByHash(ctx, hash any) *ITxByHashCall

+ func (mr *MockITxMockRecorder) ByIdWithRelations(ctx, id any) *ITxByIdWithRelationsCall

+ func (mr *MockITxMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITxCursorListCall

+ func (mr *MockITxMockRecorder) Filter(ctx, fltrs any) *ITxFilterCall

+ func (mr *MockITxMockRecorder) Genesis(ctx, limit, offset, sortOrder any) *ITxGenesisCall

+ func (mr *MockITxMockRecorder) GetByID(ctx, id any) *ITxGetByIDCall

+ func (mr *MockITxMockRecorder) IsNoRows(err any) *ITxIsNoRowsCall

+ func (mr *MockITxMockRecorder) LastID(ctx any) *ITxLastIDCall

+ func (mr *MockITxMockRecorder) List(ctx, limit, offset, order any) *ITxListCall

+ func (mr *MockITxMockRecorder) Save(ctx, m any) *ITxSaveCall

+ func (mr *MockITxMockRecorder) Update(ctx, m any) *ITxUpdateCall

+ type MockIValidator struct

+ func NewMockIValidator(ctrl *gomock.Controller) *MockIValidator

+ func (m *MockIValidator) ByAddress(ctx context.Context, address string) (storage.Validator, error)

+ func (m *MockIValidator) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Validator, error)

+ func (m *MockIValidator) EXPECT() *MockIValidatorMockRecorder

+ func (m *MockIValidator) GetByID(ctx context.Context, id uint64) (*storage.Validator, error)

+ func (m *MockIValidator) IsNoRows(err error) bool

+ func (m *MockIValidator) LastID(ctx context.Context) (uint64, error)

+ func (m *MockIValidator) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Validator, error)

+ func (m_2 *MockIValidator) Save(ctx context.Context, m *storage.Validator) error

+ func (m_2 *MockIValidator) Update(ctx context.Context, m *storage.Validator) error

+ type MockIValidatorMockRecorder struct

+ func (mr *MockIValidatorMockRecorder) ByAddress(ctx, address any) *IValidatorByAddressCall

+ func (mr *MockIValidatorMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IValidatorCursorListCall

+ func (mr *MockIValidatorMockRecorder) GetByID(ctx, id any) *IValidatorGetByIDCall

+ func (mr *MockIValidatorMockRecorder) IsNoRows(err any) *IValidatorIsNoRowsCall

+ func (mr *MockIValidatorMockRecorder) LastID(ctx any) *IValidatorLastIDCall

+ func (mr *MockIValidatorMockRecorder) List(ctx, limit, offset, order any) *IValidatorListCall

+ func (mr *MockIValidatorMockRecorder) Save(ctx, m any) *IValidatorSaveCall

+ func (mr *MockIValidatorMockRecorder) Update(ctx, m any) *IValidatorUpdateCall

+ type MockListener struct

+ func NewMockListener(ctrl *gomock.Controller) *MockListener

+ func (m *MockListener) Close() error

+ func (m *MockListener) EXPECT() *MockListenerMockRecorder

+ func (m *MockListener) Listen() chan *pq.Notification

+ func (m *MockListener) Subscribe(ctx context.Context, channels ...string) error

+ type MockListenerFactory struct

+ func NewMockListenerFactory(ctrl *gomock.Controller) *MockListenerFactory

+ func (m *MockListenerFactory) CreateListener() storage.Listener

+ func (m *MockListenerFactory) EXPECT() *MockListenerFactoryMockRecorder

+ type MockListenerFactoryMockRecorder struct

+ func (mr *MockListenerFactoryMockRecorder) CreateListener() *ListenerFactoryCreateListenerCall

+ type MockListenerMockRecorder struct

+ func (mr *MockListenerMockRecorder) Close() *ListenerCloseCall

+ func (mr *MockListenerMockRecorder) Listen() *ListenerListenCall

+ func (mr *MockListenerMockRecorder) Subscribe(ctx any, channels ...any) *ListenerSubscribeCall

+ type MockNotificator struct

+ func NewMockNotificator(ctrl *gomock.Controller) *MockNotificator

+ func (m *MockNotificator) EXPECT() *MockNotificatorMockRecorder

+ func (m *MockNotificator) Notify(ctx context.Context, channel, payload string) error

+ type MockNotificatorMockRecorder struct

+ func (mr *MockNotificatorMockRecorder) Notify(ctx, channel, payload any) *NotificatorNotifyCall

+ type MockTransaction struct

+ func NewMockTransaction(ctrl *gomock.Controller) *MockTransaction

+ func (m *MockTransaction) Add(ctx context.Context, model any) error

+ func (m *MockTransaction) BulkSave(ctx context.Context, models []any) error

+ func (m *MockTransaction) Close(ctx context.Context) error

+ func (m *MockTransaction) CopyFrom(ctx context.Context, tableName string, data []storage0.Copiable) error

+ func (m *MockTransaction) DeleteBalances(ctx context.Context, ids []uint64) error

+ func (m *MockTransaction) EXPECT() *MockTransactionMockRecorder

+ func (m *MockTransaction) Exec(ctx context.Context, query string, params ...any) (int64, error)

+ func (m *MockTransaction) Flush(ctx context.Context) error

+ func (m *MockTransaction) HandleError(ctx context.Context, err error) error

+ func (m *MockTransaction) LastAddressAction(ctx context.Context, address []byte) (uint64, error)

+ func (m *MockTransaction) LastBlock(ctx context.Context) (storage.Block, error)

+ func (m *MockTransaction) Namespace(ctx context.Context, id uint64) (storage.Namespace, error)

+ func (m *MockTransaction) Rollback(ctx context.Context) error

+ func (m *MockTransaction) RollbackAddresses(ctx context.Context, height types.Level) ([]storage.Address, error)

+ func (m *MockTransaction) RollbackBlock(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) RollbackBlockStats(ctx context.Context, height types.Level) (storage.BlockStats, error)

+ func (m *MockTransaction) RollbackEvents(ctx context.Context, height types.Level) ([]storage.Event, error)

+ func (m *MockTransaction) RollbackMessageAddresses(ctx context.Context, msgIds []uint64) error

+ func (m *MockTransaction) RollbackMessages(ctx context.Context, height types.Level) ([]storage.Message, error)

+ func (m *MockTransaction) RollbackNamespaceMessages(ctx context.Context, height types.Level) ([]storage.NamespaceMessage, error)

+ func (m *MockTransaction) RollbackNamespaces(ctx context.Context, height types.Level) ([]storage.Namespace, error)

+ func (m *MockTransaction) RollbackSigners(ctx context.Context, txIds []uint64) error

+ func (m *MockTransaction) RollbackTxs(ctx context.Context, height types.Level) ([]storage.Tx, error)

+ func (m *MockTransaction) RollbackValidators(ctx context.Context, height types.Level) error

+ func (m *MockTransaction) SaveAddresses(ctx context.Context, addresses ...*storage.Address) (int64, error)

+ func (m *MockTransaction) SaveBalances(ctx context.Context, balances ...storage.Balance) error

+ func (m *MockTransaction) SaveConstants(ctx context.Context, constants ...storage.Constant) error

+ func (m *MockTransaction) SaveEvents(ctx context.Context, events ...storage.Event) error

+ func (m *MockTransaction) SaveMessages(ctx context.Context, msgs ...*storage.Message) error

+ func (m *MockTransaction) SaveMsgAddresses(ctx context.Context, addresses ...storage.MsgAddress) error

+ func (m *MockTransaction) SaveNamespaceMessage(ctx context.Context, nsMsgs ...storage.NamespaceMessage) error

+ func (m *MockTransaction) SaveNamespaces(ctx context.Context, namespaces ...*storage.Namespace) (int64, error)

+ func (m *MockTransaction) SaveSigners(ctx context.Context, addresses ...storage.Signer) error

+ func (m *MockTransaction) SaveTransactions(ctx context.Context, txs ...storage.Tx) error

+ func (m *MockTransaction) SaveValidators(ctx context.Context, validators ...*storage.Validator) error

+ func (m *MockTransaction) State(ctx context.Context, name string) (storage.State, error)

+ func (m *MockTransaction) Tx() *bun.Tx

+ func (m *MockTransaction) Update(ctx context.Context, model any) error

+ type MockTransactionMockRecorder struct

+ func (mr *MockTransactionMockRecorder) Add(ctx, model any) *TransactionAddCall

+ func (mr *MockTransactionMockRecorder) BulkSave(ctx, models any) *TransactionBulkSaveCall

+ func (mr *MockTransactionMockRecorder) Close(ctx any) *TransactionCloseCall

+ func (mr *MockTransactionMockRecorder) CopyFrom(ctx, tableName, data any) *TransactionCopyFromCall

+ func (mr *MockTransactionMockRecorder) DeleteBalances(ctx, ids any) *TransactionDeleteBalancesCall

+ func (mr *MockTransactionMockRecorder) Exec(ctx, query any, params ...any) *TransactionExecCall

+ func (mr *MockTransactionMockRecorder) Flush(ctx any) *TransactionFlushCall

+ func (mr *MockTransactionMockRecorder) HandleError(ctx, err any) *TransactionHandleErrorCall

+ func (mr *MockTransactionMockRecorder) LastAddressAction(ctx, address any) *TransactionLastAddressActionCall

+ func (mr *MockTransactionMockRecorder) LastBlock(ctx any) *TransactionLastBlockCall

+ func (mr *MockTransactionMockRecorder) Namespace(ctx, id any) *TransactionNamespaceCall

+ func (mr *MockTransactionMockRecorder) Rollback(ctx any) *TransactionRollbackCall

+ func (mr *MockTransactionMockRecorder) RollbackAddresses(ctx, height any) *TransactionRollbackAddressesCall

+ func (mr *MockTransactionMockRecorder) RollbackBlock(ctx, height any) *TransactionRollbackBlockCall

+ func (mr *MockTransactionMockRecorder) RollbackBlockStats(ctx, height any) *TransactionRollbackBlockStatsCall

+ func (mr *MockTransactionMockRecorder) RollbackEvents(ctx, height any) *TransactionRollbackEventsCall

+ func (mr *MockTransactionMockRecorder) RollbackMessageAddresses(ctx, msgIds any) *TransactionRollbackMessageAddressesCall

+ func (mr *MockTransactionMockRecorder) RollbackMessages(ctx, height any) *TransactionRollbackMessagesCall

+ func (mr *MockTransactionMockRecorder) RollbackNamespaceMessages(ctx, height any) *TransactionRollbackNamespaceMessagesCall

+ func (mr *MockTransactionMockRecorder) RollbackNamespaces(ctx, height any) *TransactionRollbackNamespacesCall

+ func (mr *MockTransactionMockRecorder) RollbackSigners(ctx, txIds any) *TransactionRollbackSignersCall

+ func (mr *MockTransactionMockRecorder) RollbackTxs(ctx, height any) *TransactionRollbackTxsCall

+ func (mr *MockTransactionMockRecorder) RollbackValidators(ctx, height any) *TransactionRollbackValidatorsCall

+ func (mr *MockTransactionMockRecorder) SaveAddresses(ctx any, addresses ...any) *TransactionSaveAddressesCall

+ func (mr *MockTransactionMockRecorder) SaveBalances(ctx any, balances ...any) *TransactionSaveBalancesCall

+ func (mr *MockTransactionMockRecorder) SaveConstants(ctx any, constants ...any) *TransactionSaveConstantsCall

+ func (mr *MockTransactionMockRecorder) SaveEvents(ctx any, events ...any) *TransactionSaveEventsCall

+ func (mr *MockTransactionMockRecorder) SaveMessages(ctx any, msgs ...any) *TransactionSaveMessagesCall

+ func (mr *MockTransactionMockRecorder) SaveMsgAddresses(ctx any, addresses ...any) *TransactionSaveMsgAddressesCall

+ func (mr *MockTransactionMockRecorder) SaveNamespaceMessage(ctx any, nsMsgs ...any) *TransactionSaveNamespaceMessageCall

+ func (mr *MockTransactionMockRecorder) SaveNamespaces(ctx any, namespaces ...any) *TransactionSaveNamespacesCall

+ func (mr *MockTransactionMockRecorder) SaveSigners(ctx any, addresses ...any) *TransactionSaveSignersCall

+ func (mr *MockTransactionMockRecorder) SaveTransactions(ctx any, txs ...any) *TransactionSaveTransactionsCall

+ func (mr *MockTransactionMockRecorder) SaveValidators(ctx any, validators ...any) *TransactionSaveValidatorsCall

+ func (mr *MockTransactionMockRecorder) State(ctx, name any) *TransactionStateCall

+ func (mr *MockTransactionMockRecorder) Tx() *TransactionTxCall

+ func (mr *MockTransactionMockRecorder) Update(ctx, model any) *TransactionUpdateCall

+ type NotificatorNotifyCall struct

+ func (c *NotificatorNotifyCall) Do(f func(context.Context, string, string) error) *NotificatorNotifyCall

+ func (c *NotificatorNotifyCall) DoAndReturn(f func(context.Context, string, string) error) *NotificatorNotifyCall

+ func (c *NotificatorNotifyCall) Return(arg0 error) *NotificatorNotifyCall

+ type Storage struct

+ Address models.IAddress

+ Blocks models.IBlock

+ Event models.IEvent

+ Message models.IMessage

+ Namespace models.INamespace

+ State models.IState

+ Tx models.ITx

+ func Create(t gomock.TestReporter) Storage

+ func (s Storage) Close() error

+ func (s Storage) Ctrl() *gomock.Controller

+ type TransactionAddCall struct

+ func (c *TransactionAddCall) Do(f func(context.Context, any) error) *TransactionAddCall

+ func (c *TransactionAddCall) DoAndReturn(f func(context.Context, any) error) *TransactionAddCall

+ func (c *TransactionAddCall) Return(arg0 error) *TransactionAddCall

+ type TransactionBulkSaveCall struct

+ func (c *TransactionBulkSaveCall) Do(f func(context.Context, []any) error) *TransactionBulkSaveCall

+ func (c *TransactionBulkSaveCall) DoAndReturn(f func(context.Context, []any) error) *TransactionBulkSaveCall

+ func (c *TransactionBulkSaveCall) Return(arg0 error) *TransactionBulkSaveCall

+ type TransactionCloseCall struct

+ func (c *TransactionCloseCall) Do(f func(context.Context) error) *TransactionCloseCall

+ func (c *TransactionCloseCall) DoAndReturn(f func(context.Context) error) *TransactionCloseCall

+ func (c *TransactionCloseCall) Return(arg0 error) *TransactionCloseCall

+ type TransactionCopyFromCall struct

+ func (c *TransactionCopyFromCall) Do(f func(context.Context, string, []storage0.Copiable) error) *TransactionCopyFromCall

+ func (c *TransactionCopyFromCall) DoAndReturn(f func(context.Context, string, []storage0.Copiable) error) *TransactionCopyFromCall

+ func (c *TransactionCopyFromCall) Return(arg0 error) *TransactionCopyFromCall

+ type TransactionDeleteBalancesCall struct

+ func (c *TransactionDeleteBalancesCall) Do(f func(context.Context, []uint64) error) *TransactionDeleteBalancesCall

+ func (c *TransactionDeleteBalancesCall) DoAndReturn(f func(context.Context, []uint64) error) *TransactionDeleteBalancesCall

+ func (c *TransactionDeleteBalancesCall) Return(arg0 error) *TransactionDeleteBalancesCall

+ type TransactionExecCall struct

+ func (c *TransactionExecCall) Do(f func(context.Context, string, ...any) (int64, error)) *TransactionExecCall

+ func (c *TransactionExecCall) DoAndReturn(f func(context.Context, string, ...any) (int64, error)) *TransactionExecCall

+ func (c *TransactionExecCall) Return(arg0 int64, arg1 error) *TransactionExecCall

+ type TransactionFlushCall struct

+ func (c *TransactionFlushCall) Do(f func(context.Context) error) *TransactionFlushCall

+ func (c *TransactionFlushCall) DoAndReturn(f func(context.Context) error) *TransactionFlushCall

+ func (c *TransactionFlushCall) Return(arg0 error) *TransactionFlushCall

+ type TransactionHandleErrorCall struct

+ func (c *TransactionHandleErrorCall) Do(f func(context.Context, error) error) *TransactionHandleErrorCall

+ func (c *TransactionHandleErrorCall) DoAndReturn(f func(context.Context, error) error) *TransactionHandleErrorCall

+ func (c *TransactionHandleErrorCall) Return(arg0 error) *TransactionHandleErrorCall

+ type TransactionLastAddressActionCall struct

+ func (c *TransactionLastAddressActionCall) Do(f func(context.Context, []byte) (uint64, error)) *TransactionLastAddressActionCall

+ func (c *TransactionLastAddressActionCall) DoAndReturn(f func(context.Context, []byte) (uint64, error)) *TransactionLastAddressActionCall

+ func (c *TransactionLastAddressActionCall) Return(arg0 uint64, arg1 error) *TransactionLastAddressActionCall

+ type TransactionLastBlockCall struct

+ func (c *TransactionLastBlockCall) Do(f func(context.Context) (storage.Block, error)) *TransactionLastBlockCall

+ func (c *TransactionLastBlockCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *TransactionLastBlockCall

+ func (c *TransactionLastBlockCall) Return(block storage.Block, err error) *TransactionLastBlockCall

+ type TransactionNamespaceCall struct

+ func (c *TransactionNamespaceCall) Do(f func(context.Context, uint64) (storage.Namespace, error)) *TransactionNamespaceCall

+ func (c *TransactionNamespaceCall) DoAndReturn(f func(context.Context, uint64) (storage.Namespace, error)) *TransactionNamespaceCall

+ func (c *TransactionNamespaceCall) Return(ns storage.Namespace, err error) *TransactionNamespaceCall

+ type TransactionRollbackAddressesCall struct

+ func (c *TransactionRollbackAddressesCall) Do(f func(context.Context, types.Level) ([]storage.Address, error)) *TransactionRollbackAddressesCall

+ func (c *TransactionRollbackAddressesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Address, error)) *TransactionRollbackAddressesCall

+ func (c *TransactionRollbackAddressesCall) Return(address []storage.Address, err error) *TransactionRollbackAddressesCall

+ type TransactionRollbackBlockCall struct

+ func (c *TransactionRollbackBlockCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackBlockCall

+ func (c *TransactionRollbackBlockCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackBlockCall

+ func (c *TransactionRollbackBlockCall) Return(arg0 error) *TransactionRollbackBlockCall

+ type TransactionRollbackBlockStatsCall struct

+ func (c *TransactionRollbackBlockStatsCall) Do(f func(context.Context, types.Level) (storage.BlockStats, error)) *TransactionRollbackBlockStatsCall

+ func (c *TransactionRollbackBlockStatsCall) DoAndReturn(f func(context.Context, types.Level) (storage.BlockStats, error)) *TransactionRollbackBlockStatsCall

+ func (c *TransactionRollbackBlockStatsCall) Return(stats storage.BlockStats, err error) *TransactionRollbackBlockStatsCall

+ type TransactionRollbackCall struct

+ func (c *TransactionRollbackCall) Do(f func(context.Context) error) *TransactionRollbackCall

+ func (c *TransactionRollbackCall) DoAndReturn(f func(context.Context) error) *TransactionRollbackCall

+ func (c *TransactionRollbackCall) Return(arg0 error) *TransactionRollbackCall

+ type TransactionRollbackEventsCall struct

+ func (c *TransactionRollbackEventsCall) Do(f func(context.Context, types.Level) ([]storage.Event, error)) *TransactionRollbackEventsCall

+ func (c *TransactionRollbackEventsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Event, error)) *TransactionRollbackEventsCall

+ func (c *TransactionRollbackEventsCall) Return(events []storage.Event, err error) *TransactionRollbackEventsCall

+ type TransactionRollbackMessageAddressesCall struct

+ func (c *TransactionRollbackMessageAddressesCall) Do(f func(context.Context, []uint64) error) *TransactionRollbackMessageAddressesCall

+ func (c *TransactionRollbackMessageAddressesCall) DoAndReturn(f func(context.Context, []uint64) error) *TransactionRollbackMessageAddressesCall

+ func (c *TransactionRollbackMessageAddressesCall) Return(err error) *TransactionRollbackMessageAddressesCall

+ type TransactionRollbackMessagesCall struct

+ func (c *TransactionRollbackMessagesCall) Do(f func(context.Context, types.Level) ([]storage.Message, error)) *TransactionRollbackMessagesCall

+ func (c *TransactionRollbackMessagesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Message, error)) *TransactionRollbackMessagesCall

+ func (c *TransactionRollbackMessagesCall) Return(msgs []storage.Message, err error) *TransactionRollbackMessagesCall

+ type TransactionRollbackNamespaceMessagesCall struct

+ func (c *TransactionRollbackNamespaceMessagesCall) Do(f func(context.Context, types.Level) ([]storage.NamespaceMessage, error)) *TransactionRollbackNamespaceMessagesCall

+ func (c *TransactionRollbackNamespaceMessagesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.NamespaceMessage, error)) *TransactionRollbackNamespaceMessagesCall

+ func (c *TransactionRollbackNamespaceMessagesCall) Return(msgs []storage.NamespaceMessage, err error) *TransactionRollbackNamespaceMessagesCall

+ type TransactionRollbackNamespacesCall struct

+ func (c *TransactionRollbackNamespacesCall) Do(f func(context.Context, types.Level) ([]storage.Namespace, error)) *TransactionRollbackNamespacesCall

+ func (c *TransactionRollbackNamespacesCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Namespace, error)) *TransactionRollbackNamespacesCall

+ func (c *TransactionRollbackNamespacesCall) Return(ns []storage.Namespace, err error) *TransactionRollbackNamespacesCall

+ type TransactionRollbackSignersCall struct

+ func (c *TransactionRollbackSignersCall) Do(f func(context.Context, []uint64) error) *TransactionRollbackSignersCall

+ func (c *TransactionRollbackSignersCall) DoAndReturn(f func(context.Context, []uint64) error) *TransactionRollbackSignersCall

+ func (c *TransactionRollbackSignersCall) Return(err error) *TransactionRollbackSignersCall

+ type TransactionRollbackTxsCall struct

+ func (c *TransactionRollbackTxsCall) Do(f func(context.Context, types.Level) ([]storage.Tx, error)) *TransactionRollbackTxsCall

+ func (c *TransactionRollbackTxsCall) DoAndReturn(f func(context.Context, types.Level) ([]storage.Tx, error)) *TransactionRollbackTxsCall

+ func (c *TransactionRollbackTxsCall) Return(txs []storage.Tx, err error) *TransactionRollbackTxsCall

+ type TransactionRollbackValidatorsCall struct

+ func (c *TransactionRollbackValidatorsCall) Do(f func(context.Context, types.Level) error) *TransactionRollbackValidatorsCall

+ func (c *TransactionRollbackValidatorsCall) DoAndReturn(f func(context.Context, types.Level) error) *TransactionRollbackValidatorsCall

+ func (c *TransactionRollbackValidatorsCall) Return(err error) *TransactionRollbackValidatorsCall

+ type TransactionSaveAddressesCall struct

+ func (c *TransactionSaveAddressesCall) Do(f func(context.Context, ...*storage.Address) (int64, error)) *TransactionSaveAddressesCall

+ func (c *TransactionSaveAddressesCall) DoAndReturn(f func(context.Context, ...*storage.Address) (int64, error)) *TransactionSaveAddressesCall

+ func (c *TransactionSaveAddressesCall) Return(arg0 int64, arg1 error) *TransactionSaveAddressesCall

+ type TransactionSaveBalancesCall struct

+ func (c *TransactionSaveBalancesCall) Do(f func(context.Context, ...storage.Balance) error) *TransactionSaveBalancesCall

+ func (c *TransactionSaveBalancesCall) DoAndReturn(f func(context.Context, ...storage.Balance) error) *TransactionSaveBalancesCall

+ func (c *TransactionSaveBalancesCall) Return(arg0 error) *TransactionSaveBalancesCall

+ type TransactionSaveConstantsCall struct

+ func (c *TransactionSaveConstantsCall) Do(f func(context.Context, ...storage.Constant) error) *TransactionSaveConstantsCall

+ func (c *TransactionSaveConstantsCall) DoAndReturn(f func(context.Context, ...storage.Constant) error) *TransactionSaveConstantsCall

+ func (c *TransactionSaveConstantsCall) Return(arg0 error) *TransactionSaveConstantsCall

+ type TransactionSaveEventsCall struct

+ func (c *TransactionSaveEventsCall) Do(f func(context.Context, ...storage.Event) error) *TransactionSaveEventsCall

+ func (c *TransactionSaveEventsCall) DoAndReturn(f func(context.Context, ...storage.Event) error) *TransactionSaveEventsCall

+ func (c *TransactionSaveEventsCall) Return(arg0 error) *TransactionSaveEventsCall

+ type TransactionSaveMessagesCall struct

+ func (c *TransactionSaveMessagesCall) Do(f func(context.Context, ...*storage.Message) error) *TransactionSaveMessagesCall

+ func (c *TransactionSaveMessagesCall) DoAndReturn(f func(context.Context, ...*storage.Message) error) *TransactionSaveMessagesCall

+ func (c *TransactionSaveMessagesCall) Return(arg0 error) *TransactionSaveMessagesCall

+ type TransactionSaveMsgAddressesCall struct

+ func (c *TransactionSaveMsgAddressesCall) Do(f func(context.Context, ...storage.MsgAddress) error) *TransactionSaveMsgAddressesCall

+ func (c *TransactionSaveMsgAddressesCall) DoAndReturn(f func(context.Context, ...storage.MsgAddress) error) *TransactionSaveMsgAddressesCall

+ func (c *TransactionSaveMsgAddressesCall) Return(arg0 error) *TransactionSaveMsgAddressesCall

+ type TransactionSaveNamespaceMessageCall struct

+ func (c *TransactionSaveNamespaceMessageCall) Do(f func(context.Context, ...storage.NamespaceMessage) error) *TransactionSaveNamespaceMessageCall

+ func (c *TransactionSaveNamespaceMessageCall) DoAndReturn(f func(context.Context, ...storage.NamespaceMessage) error) *TransactionSaveNamespaceMessageCall

+ func (c *TransactionSaveNamespaceMessageCall) Return(arg0 error) *TransactionSaveNamespaceMessageCall

+ type TransactionSaveNamespacesCall struct

+ func (c *TransactionSaveNamespacesCall) Do(f func(context.Context, ...*storage.Namespace) (int64, error)) *TransactionSaveNamespacesCall

+ func (c *TransactionSaveNamespacesCall) DoAndReturn(f func(context.Context, ...*storage.Namespace) (int64, error)) *TransactionSaveNamespacesCall

+ func (c *TransactionSaveNamespacesCall) Return(arg0 int64, arg1 error) *TransactionSaveNamespacesCall

+ type TransactionSaveSignersCall struct

+ func (c *TransactionSaveSignersCall) Do(f func(context.Context, ...storage.Signer) error) *TransactionSaveSignersCall

+ func (c *TransactionSaveSignersCall) DoAndReturn(f func(context.Context, ...storage.Signer) error) *TransactionSaveSignersCall

+ func (c *TransactionSaveSignersCall) Return(arg0 error) *TransactionSaveSignersCall

+ type TransactionSaveTransactionsCall struct

+ func (c *TransactionSaveTransactionsCall) Do(f func(context.Context, ...storage.Tx) error) *TransactionSaveTransactionsCall

+ func (c *TransactionSaveTransactionsCall) DoAndReturn(f func(context.Context, ...storage.Tx) error) *TransactionSaveTransactionsCall

+ func (c *TransactionSaveTransactionsCall) Return(arg0 error) *TransactionSaveTransactionsCall

+ type TransactionSaveValidatorsCall struct

+ func (c *TransactionSaveValidatorsCall) Do(f func(context.Context, ...*storage.Validator) error) *TransactionSaveValidatorsCall

+ func (c *TransactionSaveValidatorsCall) DoAndReturn(f func(context.Context, ...*storage.Validator) error) *TransactionSaveValidatorsCall

+ func (c *TransactionSaveValidatorsCall) Return(arg0 error) *TransactionSaveValidatorsCall

+ type TransactionStateCall struct

+ func (c *TransactionStateCall) Do(f func(context.Context, string) (storage.State, error)) *TransactionStateCall

+ func (c *TransactionStateCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *TransactionStateCall

+ func (c *TransactionStateCall) Return(state storage.State, err error) *TransactionStateCall

+ type TransactionTxCall struct

+ func (c *TransactionTxCall) Do(f func() *bun.Tx) *TransactionTxCall

+ func (c *TransactionTxCall) DoAndReturn(f func() *bun.Tx) *TransactionTxCall

+ func (c *TransactionTxCall) Return(arg0 *bun.Tx) *TransactionTxCall

+ type TransactionUpdateCall struct

+ func (c *TransactionUpdateCall) Do(f func(context.Context, any) error) *TransactionUpdateCall

+ func (c *TransactionUpdateCall) DoAndReturn(f func(context.Context, any) error) *TransactionUpdateCall

+ func (c *TransactionUpdateCall) Return(arg0 error) *TransactionUpdateCall

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