diff --git a/go.mod b/go.mod index 57a0359..3721b47 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,7 @@ toolchain go1.22.4 require ( cosmossdk.io/api v0.7.5 + cosmossdk.io/math v1.3.0 github.com/avast/retry-go/v4 v4.5.1 github.com/cometbft/cometbft v0.38.7 github.com/cosmos/cosmos-sdk v0.50.7 @@ -16,6 +17,7 @@ require ( github.com/go-openapi/strfmt v0.21.3 github.com/go-openapi/swag v0.22.3 github.com/go-openapi/validate v0.21.0 + github.com/golang/mock v1.6.0 github.com/gorilla/mux v1.8.1 github.com/kelseyhightower/envconfig v1.4.0 github.com/neutron-org/neutron-logger v0.0.0-20221027125151-535167f2dd73 @@ -42,7 +44,6 @@ require ( cosmossdk.io/depinject v1.0.0-alpha.4 // indirect cosmossdk.io/errors v1.0.1 // indirect cosmossdk.io/log v1.3.1 // indirect - cosmossdk.io/math v1.3.0 // indirect cosmossdk.io/store v1.1.0 // indirect cosmossdk.io/x/feegrant v0.1.1 // indirect cosmossdk.io/x/tx v0.13.3 // indirect @@ -125,7 +126,6 @@ require ( github.com/gogo/protobuf v1.3.3 // indirect github.com/golang/glog v1.2.1 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect - github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect github.com/google/btree v1.1.2 // indirect @@ -256,7 +256,7 @@ replace ( github.com/99designs/keyring => github.com/cosmos/keyring v1.2.0 github.com/ChainSafe/go-schnorrkel => github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d github.com/CosmWasm/wasmd => github.com/neutron-org/wasmd v0.45.1-0.20240501180153-d9bebe629e05 - github.com/cosmos/admin-module => github.com/neutron-org/admin-module v1.0.2-0.20240402143659-7dcb4a8c2056 + github.com/cosmos/admin-module/v2 => github.com/neutron-org/admin-module/v2 v2.0.0 github.com/cosmos/cosmos-sdk => github.com/neutron-org/cosmos-sdk v0.50.7-neutron github.com/cosmos/gaia/v11 => github.com/cosmos/gaia/v11 v11.0.0-20230724152830-861ba391c3b4 github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 diff --git a/internal/submit/submit_test.go b/internal/submit/submit_test.go new file mode 100644 index 0000000..920dd50 --- /dev/null +++ b/internal/submit/submit_test.go @@ -0,0 +1,153 @@ +package submit + +import ( + "context" + "testing" + + cosmossdk_io_math "cosmossdk.io/math" + abci "github.com/cometbft/cometbft/abci/types" + coretypes "github.com/cometbft/cometbft/rpc/core/types" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/types" + authtxtypes "github.com/cosmos/cosmos-sdk/x/auth/tx" + "github.com/golang/mock/gomock" + submit_mock "github.com/neutron-org/neutron-query-relayer/testutil/mocks/submit" + feemarkettypes "github.com/skip-mev/feemarket/x/feemarket/types" + "github.com/stretchr/testify/require" + "go.uber.org/zap" +) + +func setupTest(t *testing.T, gasMultiplier float64, maxGas float64, gasPrices string, mockClient *submit_mock.MockClient) *TxSender { + logger, _ := zap.NewDevelopment() + txConfig := authtxtypes.NewTxConfig(codec.NewProtoCodec(nil), authtxtypes.DefaultSignModes) + return &TxSender{ + rpcClient: mockClient, + txConfig: txConfig, + logger: logger, + denom: "testdenom", + gasMultiplier: gasMultiplier, + maxGas: maxGas, + gasPrices: gasPrices, + } +} + +func TestQueryDynamicPrice(t *testing.T) { + tests := []struct { + name string + gasMultiplier float64 + maxGas float64 + gasPrices string + mockResponse *coretypes.ResultABCIQuery + expectedPrice string + expectError bool + }{ + { + name: "Basic", + gasMultiplier: 1.0, + maxGas: 100000000, + mockResponse: &coretypes.ResultABCIQuery{ + Response: abci.ResponseQuery{ + Code: 0, + Value: func() []byte { + gasPrice := feemarkettypes.GasPriceResponse{ + Price: types.DecCoin{ + Denom: "testdenom", + Amount: cosmossdk_io_math.LegacyNewDec(123), + }, + } + rawGasPrice, _ := gasPrice.Marshal() + return rawGasPrice + }(), + }, + }, + expectedPrice: "123testdenom", + expectError: false, + }, + { + name: "Multiply", + gasMultiplier: 1.1, + maxGas: 100000000, + mockResponse: &coretypes.ResultABCIQuery{ + Response: abci.ResponseQuery{ + Code: 0, + Value: func() []byte { + gasPrice := feemarkettypes.GasPriceResponse{ + Price: types.DecCoin{ + Denom: "testdenom", + Amount: cosmossdk_io_math.LegacyNewDec(123), + }, + } + rawGasPrice, _ := gasPrice.Marshal() + return rawGasPrice + }(), + }, + }, + expectedPrice: "135.3testdenom", + expectError: false, + }, + { + name: "DefaultGasPrice", + gasMultiplier: 1.0, + maxGas: 100.0, + gasPrices: "99.0testdenom", + mockResponse: &coretypes.ResultABCIQuery{ + Response: abci.ResponseQuery{ + Code: 1, + }, + }, + expectedPrice: "99.0testdenom", + expectError: false, + }, + { + name: "MaxGas", + gasMultiplier: 1.5, + maxGas: 111.1, + gasPrices: "99.0testdenom", + mockResponse: &coretypes.ResultABCIQuery{ + Response: abci.ResponseQuery{ + Code: 0, + Value: func() []byte { + gasPrice := feemarkettypes.GasPriceResponse{ + Price: types.DecCoin{ + Denom: "testdenom", + Amount: cosmossdk_io_math.LegacyNewDec(123), + }, + } + rawGasPrice, _ := gasPrice.Marshal() + return rawGasPrice + }(), + }, + }, + expectedPrice: "111.1testdenom", + expectError: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockClient := submit_mock.NewMockClient(ctrl) + txs := setupTest(t, tt.gasMultiplier, tt.maxGas, tt.gasPrices, mockClient) + + if tt.mockResponse != nil { + mockClient.EXPECT(). + ABCIQueryWithOptions(gomock.Any(), getPricesQueryPath, gomock.Any(), gomock.Any()). + Return(tt.mockResponse, nil) + } else { + mockClient.EXPECT(). + ABCIQueryWithOptions(gomock.Any(), getPricesQueryPath, gomock.Any(), gomock.Any()). + Return(nil, nil) + } + + price, err := txs.getGasPrice(context.Background()) + if tt.expectError { + require.Error(t, err) + } else { + require.NoError(t, err) + require.Equal(t, tt.expectedPrice, price) + } + }) + } +} diff --git a/internal/submit/tx_sender.go b/internal/submit/tx_sender.go index 0b5c03e..dcd15b9 100644 --- a/internal/submit/tx_sender.go +++ b/internal/submit/tx_sender.go @@ -8,6 +8,7 @@ import ( "strings" "sync" + cosmossdk_io_math "cosmossdk.io/math" tmtypes "github.com/cometbft/cometbft/types" "go.uber.org/zap" @@ -153,7 +154,7 @@ func (txs *TxSender) Send(ctx context.Context, msgs []sdk.Msg) (string, error) { txf = txf. WithGas(gasNeeded). - WithGasPrices(txs.gasPrices) + WithGasPrices(gasPrice) bz, err := txs.signAndBuildTxBz(ctx, txf, msgs) if err != nil { @@ -228,11 +229,11 @@ func (txs *TxSender) queryAccount(ctx context.Context, address string) (*authtyp return &account, nil } -func (txs *TxSender) queryDynamicPrice(ctx context.Context) (string, error) { +func (txs *TxSender) queryDynamicPrice(ctx context.Context) (cosmossdk_io_math.LegacyDec, error) { request := feemarkettypes.GasPriceRequest{Denom: txs.denom} req, err := request.Marshal() if err != nil { - return "", fmt.Errorf("error marshalling query gas prices request for denom=%s: %w", txs.denom, err) + return cosmossdk_io_math.LegacyZeroDec(), fmt.Errorf("error marshalling query gas prices request for denom=%s: %w", txs.denom, err) } simQuery := abci.RequestQuery{ Path: getPricesQueryPath, @@ -240,30 +241,33 @@ func (txs *TxSender) queryDynamicPrice(ctx context.Context) (string, error) { } res, err := txs.rpcClient.ABCIQueryWithOptions(ctx, simQuery.Path, simQuery.Data, rpcclient.DefaultABCIQueryOptions) if err != nil { - return "", fmt.Errorf("error making abci query: %w", err) + return cosmossdk_io_math.LegacyZeroDec(), fmt.Errorf("error making abci query: %w", err) } if res.Response.Code != 0 { - return "", fmt.Errorf("error fetching feemarket gas price for denom=%s log=%s", txs.denom, res.Response.Log) + return cosmossdk_io_math.LegacyZeroDec(), fmt.Errorf("error fetching feemarket gas price for denom=%s", txs.denom) } var response feemarkettypes.GasPriceResponse if err := response.Unmarshal(res.Response.Value); err != nil { - return "", fmt.Errorf("error unmarshalling GasPriceResponse for denom=%s: %w", txs.denom, err) + return cosmossdk_io_math.LegacyZeroDec(), fmt.Errorf("error unmarshalling GasPriceResponse for denom=%s: %w", txs.denom, err) } - gasPrice := response.Price.Amount.String() + txs.denom + gasPrice := response.Price.Amount return gasPrice, nil } -func (txs *TxSender) multiplyGas(gas string) (string, error) { - floatGas, err := strconv.ParseFloat(gas, 64) +func (txs *TxSender) multiplyGas(gas cosmossdk_io_math.LegacyDec) (string, error) { + floatGas, err := gas.Float64() if err != nil { return "", err } multipliedGas := txs.gasMultiplier * floatGas + if err != nil { + return "", err + } if multipliedGas > txs.maxGas { multipliedGas = txs.maxGas } @@ -280,7 +284,7 @@ func (txs *TxSender) multiplyGas(gas string) (string, error) { func (txs *TxSender) getGasPrice(ctx context.Context) (string, error) { gasPrice, err := txs.queryDynamicPrice(ctx) if err != nil { - return txs.gasPrices, err + return txs.gasPrices, nil } multipliedGas, err := txs.multiplyGas(gasPrice) @@ -288,7 +292,7 @@ func (txs *TxSender) getGasPrice(ctx context.Context) (string, error) { return "", err } - return multipliedGas, nil + return multipliedGas + txs.denom, nil } func (txs *TxSender) signAndBuildTxBz(ctx context.Context, txf tx.Factory, msgs []sdk.Msg) ([]byte, error) { diff --git a/testutil/mocks/gomock.go b/testutil/mocks/gomock.go index 1fb48ab..10c8d1d 100644 --- a/testutil/mocks/gomock.go +++ b/testutil/mocks/gomock.go @@ -1,3 +1,4 @@ package mocks //go:generate mockgen -source=./../../internal/subscriber/clients.go -destination ./subscriber/expected_clients.go +//go:generate mockgen -source=$GOPATH/pkg/mod/github.com/cometbft/cometbft@v0.38.7/rpc/client/interface.go -destination ./submit/mock_client.go diff --git a/testutil/mocks/submit/mock_client.go b/testutil/mocks/submit/mock_client.go new file mode 100644 index 0000000..5a14840 --- /dev/null +++ b/testutil/mocks/submit/mock_client.go @@ -0,0 +1,1982 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/quasisamurai/go/pkg/mod/github.com/cometbft/cometbft@v0.38.7/rpc/client/interface.go + +// Package mock_client is a generated GoMock package. +package mock_client + +import ( + context "context" + reflect "reflect" + + bytes "github.com/cometbft/cometbft/libs/bytes" + log "github.com/cometbft/cometbft/libs/log" + client "github.com/cometbft/cometbft/rpc/client" + coretypes "github.com/cometbft/cometbft/rpc/core/types" + types "github.com/cometbft/cometbft/types" + gomock "github.com/golang/mock/gomock" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// ABCIInfo mocks base method. +func (m *MockClient) ABCIInfo(arg0 context.Context) (*coretypes.ResultABCIInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultABCIInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIInfo indicates an expected call of ABCIInfo. +func (mr *MockClientMockRecorder) ABCIInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIInfo", reflect.TypeOf((*MockClient)(nil).ABCIInfo), arg0) +} + +// ABCIQuery mocks base method. +func (m *MockClient) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQuery", ctx, path, data) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQuery indicates an expected call of ABCIQuery. +func (mr *MockClientMockRecorder) ABCIQuery(ctx, path, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQuery", reflect.TypeOf((*MockClient)(nil).ABCIQuery), ctx, path, data) +} + +// ABCIQueryWithOptions mocks base method. +func (m *MockClient) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQueryWithOptions", ctx, path, data, opts) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQueryWithOptions indicates an expected call of ABCIQueryWithOptions. +func (mr *MockClientMockRecorder) ABCIQueryWithOptions(ctx, path, data, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQueryWithOptions", reflect.TypeOf((*MockClient)(nil).ABCIQueryWithOptions), ctx, path, data, opts) +} + +// Block mocks base method. +func (m *MockClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Block", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Block indicates an expected call of Block. +func (mr *MockClientMockRecorder) Block(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockClient)(nil).Block), ctx, height) +} + +// BlockByHash mocks base method. +func (m *MockClient) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockByHash indicates an expected call of BlockByHash. +func (mr *MockClientMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockClient)(nil).BlockByHash), ctx, hash) +} + +// BlockResults mocks base method. +func (m *MockClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockResults", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlockResults) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockResults indicates an expected call of BlockResults. +func (mr *MockClientMockRecorder) BlockResults(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockResults", reflect.TypeOf((*MockClient)(nil).BlockResults), ctx, height) +} + +// BlockSearch mocks base method. +func (m *MockClient) BlockSearch(ctx context.Context, query string, page, perPage *int, orderBy string) (*coretypes.ResultBlockSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockSearch", ctx, query, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultBlockSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockSearch indicates an expected call of BlockSearch. +func (mr *MockClientMockRecorder) BlockSearch(ctx, query, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSearch", reflect.TypeOf((*MockClient)(nil).BlockSearch), ctx, query, page, perPage, orderBy) +} + +// BlockchainInfo mocks base method. +func (m *MockClient) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockchainInfo", ctx, minHeight, maxHeight) + ret0, _ := ret[0].(*coretypes.ResultBlockchainInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockchainInfo indicates an expected call of BlockchainInfo. +func (mr *MockClientMockRecorder) BlockchainInfo(ctx, minHeight, maxHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainInfo", reflect.TypeOf((*MockClient)(nil).BlockchainInfo), ctx, minHeight, maxHeight) +} + +// BroadcastEvidence mocks base method. +func (m *MockClient) BroadcastEvidence(arg0 context.Context, arg1 types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastEvidence", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastEvidence) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastEvidence indicates an expected call of BroadcastEvidence. +func (mr *MockClientMockRecorder) BroadcastEvidence(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastEvidence", reflect.TypeOf((*MockClient)(nil).BroadcastEvidence), arg0, arg1) +} + +// BroadcastTxAsync mocks base method. +func (m *MockClient) BroadcastTxAsync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxAsync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxAsync indicates an expected call of BroadcastTxAsync. +func (mr *MockClientMockRecorder) BroadcastTxAsync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxAsync", reflect.TypeOf((*MockClient)(nil).BroadcastTxAsync), arg0, arg1) +} + +// BroadcastTxCommit mocks base method. +func (m *MockClient) BroadcastTxCommit(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxCommit", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTxCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxCommit indicates an expected call of BroadcastTxCommit. +func (mr *MockClientMockRecorder) BroadcastTxCommit(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxCommit", reflect.TypeOf((*MockClient)(nil).BroadcastTxCommit), arg0, arg1) +} + +// BroadcastTxSync mocks base method. +func (m *MockClient) BroadcastTxSync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxSync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxSync indicates an expected call of BroadcastTxSync. +func (mr *MockClientMockRecorder) BroadcastTxSync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxSync", reflect.TypeOf((*MockClient)(nil).BroadcastTxSync), arg0, arg1) +} + +// CheckTx mocks base method. +func (m *MockClient) CheckTx(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultCheckTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckTx", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultCheckTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckTx indicates an expected call of CheckTx. +func (mr *MockClientMockRecorder) CheckTx(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTx", reflect.TypeOf((*MockClient)(nil).CheckTx), arg0, arg1) +} + +// Commit mocks base method. +func (m *MockClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Commit", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Commit indicates an expected call of Commit. +func (mr *MockClientMockRecorder) Commit(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockClient)(nil).Commit), ctx, height) +} + +// ConsensusParams mocks base method. +func (m *MockClient) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusParams", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultConsensusParams) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusParams indicates an expected call of ConsensusParams. +func (mr *MockClientMockRecorder) ConsensusParams(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusParams", reflect.TypeOf((*MockClient)(nil).ConsensusParams), ctx, height) +} + +// ConsensusState mocks base method. +func (m *MockClient) ConsensusState(arg0 context.Context) (*coretypes.ResultConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusState indicates an expected call of ConsensusState. +func (mr *MockClientMockRecorder) ConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusState", reflect.TypeOf((*MockClient)(nil).ConsensusState), arg0) +} + +// DumpConsensusState mocks base method. +func (m *MockClient) DumpConsensusState(arg0 context.Context) (*coretypes.ResultDumpConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DumpConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultDumpConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DumpConsensusState indicates an expected call of DumpConsensusState. +func (mr *MockClientMockRecorder) DumpConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpConsensusState", reflect.TypeOf((*MockClient)(nil).DumpConsensusState), arg0) +} + +// Genesis mocks base method. +func (m *MockClient) Genesis(arg0 context.Context) (*coretypes.ResultGenesis, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Genesis", arg0) + ret0, _ := ret[0].(*coretypes.ResultGenesis) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Genesis indicates an expected call of Genesis. +func (mr *MockClientMockRecorder) Genesis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Genesis", reflect.TypeOf((*MockClient)(nil).Genesis), arg0) +} + +// GenesisChunked mocks base method. +func (m *MockClient) GenesisChunked(arg0 context.Context, arg1 uint) (*coretypes.ResultGenesisChunk, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenesisChunked", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultGenesisChunk) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenesisChunked indicates an expected call of GenesisChunked. +func (mr *MockClientMockRecorder) GenesisChunked(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisChunked", reflect.TypeOf((*MockClient)(nil).GenesisChunked), arg0, arg1) +} + +// Header mocks base method. +func (m *MockClient) Header(ctx context.Context, height *int64) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockClientMockRecorder) Header(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockClient)(nil).Header), ctx, height) +} + +// HeaderByHash mocks base method. +func (m *MockClient) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeaderByHash indicates an expected call of HeaderByHash. +func (mr *MockClientMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockClient)(nil).HeaderByHash), ctx, hash) +} + +// Health mocks base method. +func (m *MockClient) Health(arg0 context.Context) (*coretypes.ResultHealth, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", arg0) + ret0, _ := ret[0].(*coretypes.ResultHealth) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health. +func (mr *MockClientMockRecorder) Health(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockClient)(nil).Health), arg0) +} + +// IsRunning mocks base method. +func (m *MockClient) IsRunning() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsRunning") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsRunning indicates an expected call of IsRunning. +func (mr *MockClientMockRecorder) IsRunning() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRunning", reflect.TypeOf((*MockClient)(nil).IsRunning)) +} + +// NetInfo mocks base method. +func (m *MockClient) NetInfo(arg0 context.Context) (*coretypes.ResultNetInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultNetInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NetInfo indicates an expected call of NetInfo. +func (mr *MockClientMockRecorder) NetInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetInfo", reflect.TypeOf((*MockClient)(nil).NetInfo), arg0) +} + +// NumUnconfirmedTxs mocks base method. +func (m *MockClient) NumUnconfirmedTxs(arg0 context.Context) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NumUnconfirmedTxs", arg0) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NumUnconfirmedTxs indicates an expected call of NumUnconfirmedTxs. +func (mr *MockClientMockRecorder) NumUnconfirmedTxs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumUnconfirmedTxs", reflect.TypeOf((*MockClient)(nil).NumUnconfirmedTxs), arg0) +} + +// OnReset mocks base method. +func (m *MockClient) OnReset() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OnReset") + ret0, _ := ret[0].(error) + return ret0 +} + +// OnReset indicates an expected call of OnReset. +func (mr *MockClientMockRecorder) OnReset() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnReset", reflect.TypeOf((*MockClient)(nil).OnReset)) +} + +// OnStart mocks base method. +func (m *MockClient) OnStart() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OnStart") + ret0, _ := ret[0].(error) + return ret0 +} + +// OnStart indicates an expected call of OnStart. +func (mr *MockClientMockRecorder) OnStart() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnStart", reflect.TypeOf((*MockClient)(nil).OnStart)) +} + +// OnStop mocks base method. +func (m *MockClient) OnStop() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "OnStop") +} + +// OnStop indicates an expected call of OnStop. +func (mr *MockClientMockRecorder) OnStop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnStop", reflect.TypeOf((*MockClient)(nil).OnStop)) +} + +// Quit mocks base method. +func (m *MockClient) Quit() <-chan struct{} { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit") + ret0, _ := ret[0].(<-chan struct{}) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockClientMockRecorder) Quit() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockClient)(nil).Quit)) +} + +// Reset mocks base method. +func (m *MockClient) Reset() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Reset") + ret0, _ := ret[0].(error) + return ret0 +} + +// Reset indicates an expected call of Reset. +func (mr *MockClientMockRecorder) Reset() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockClient)(nil).Reset)) +} + +// SetLogger mocks base method. +func (m *MockClient) SetLogger(arg0 log.Logger) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetLogger", arg0) +} + +// SetLogger indicates an expected call of SetLogger. +func (mr *MockClientMockRecorder) SetLogger(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogger", reflect.TypeOf((*MockClient)(nil).SetLogger), arg0) +} + +// Start mocks base method. +func (m *MockClient) Start() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Start") + ret0, _ := ret[0].(error) + return ret0 +} + +// Start indicates an expected call of Start. +func (mr *MockClientMockRecorder) Start() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockClient)(nil).Start)) +} + +// Status mocks base method. +func (m *MockClient) Status(arg0 context.Context) (*coretypes.ResultStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Status", arg0) + ret0, _ := ret[0].(*coretypes.ResultStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Status indicates an expected call of Status. +func (mr *MockClientMockRecorder) Status(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockClient)(nil).Status), arg0) +} + +// Stop mocks base method. +func (m *MockClient) Stop() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stop") + ret0, _ := ret[0].(error) + return ret0 +} + +// Stop indicates an expected call of Stop. +func (mr *MockClientMockRecorder) Stop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockClient)(nil).Stop)) +} + +// String mocks base method. +func (m *MockClient) String() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "String") + ret0, _ := ret[0].(string) + return ret0 +} + +// String indicates an expected call of String. +func (mr *MockClientMockRecorder) String() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockClient)(nil).String)) +} + +// Subscribe mocks base method. +func (m *MockClient) Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, subscriber, query} + for _, a := range outCapacity { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Subscribe", varargs...) + ret0, _ := ret[0].(<-chan coretypes.ResultEvent) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockClientMockRecorder) Subscribe(ctx, subscriber, query interface{}, outCapacity ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, subscriber, query}, outCapacity...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockClient)(nil).Subscribe), varargs...) +} + +// Tx mocks base method. +func (m *MockClient) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Tx", ctx, hash, prove) + ret0, _ := ret[0].(*coretypes.ResultTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Tx indicates an expected call of Tx. +func (mr *MockClientMockRecorder) Tx(ctx, hash, prove interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tx", reflect.TypeOf((*MockClient)(nil).Tx), ctx, hash, prove) +} + +// TxSearch mocks base method. +func (m *MockClient) TxSearch(ctx context.Context, query string, prove bool, page, perPage *int, orderBy string) (*coretypes.ResultTxSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxSearch", ctx, query, prove, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultTxSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxSearch indicates an expected call of TxSearch. +func (mr *MockClientMockRecorder) TxSearch(ctx, query, prove, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxSearch", reflect.TypeOf((*MockClient)(nil).TxSearch), ctx, query, prove, page, perPage, orderBy) +} + +// UnconfirmedTxs mocks base method. +func (m *MockClient) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnconfirmedTxs", ctx, limit) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnconfirmedTxs indicates an expected call of UnconfirmedTxs. +func (mr *MockClientMockRecorder) UnconfirmedTxs(ctx, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnconfirmedTxs", reflect.TypeOf((*MockClient)(nil).UnconfirmedTxs), ctx, limit) +} + +// Unsubscribe mocks base method. +func (m *MockClient) Unsubscribe(ctx context.Context, subscriber, query string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Unsubscribe", ctx, subscriber, query) + ret0, _ := ret[0].(error) + return ret0 +} + +// Unsubscribe indicates an expected call of Unsubscribe. +func (mr *MockClientMockRecorder) Unsubscribe(ctx, subscriber, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockClient)(nil).Unsubscribe), ctx, subscriber, query) +} + +// UnsubscribeAll mocks base method. +func (m *MockClient) UnsubscribeAll(ctx context.Context, subscriber string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnsubscribeAll", ctx, subscriber) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnsubscribeAll indicates an expected call of UnsubscribeAll. +func (mr *MockClientMockRecorder) UnsubscribeAll(ctx, subscriber interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeAll", reflect.TypeOf((*MockClient)(nil).UnsubscribeAll), ctx, subscriber) +} + +// Validators mocks base method. +func (m *MockClient) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Validators", ctx, height, page, perPage) + ret0, _ := ret[0].(*coretypes.ResultValidators) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Validators indicates an expected call of Validators. +func (mr *MockClientMockRecorder) Validators(ctx, height, page, perPage interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validators", reflect.TypeOf((*MockClient)(nil).Validators), ctx, height, page, perPage) +} + +// MockABCIClient is a mock of ABCIClient interface. +type MockABCIClient struct { + ctrl *gomock.Controller + recorder *MockABCIClientMockRecorder +} + +// MockABCIClientMockRecorder is the mock recorder for MockABCIClient. +type MockABCIClientMockRecorder struct { + mock *MockABCIClient +} + +// NewMockABCIClient creates a new mock instance. +func NewMockABCIClient(ctrl *gomock.Controller) *MockABCIClient { + mock := &MockABCIClient{ctrl: ctrl} + mock.recorder = &MockABCIClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockABCIClient) EXPECT() *MockABCIClientMockRecorder { + return m.recorder +} + +// ABCIInfo mocks base method. +func (m *MockABCIClient) ABCIInfo(arg0 context.Context) (*coretypes.ResultABCIInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultABCIInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIInfo indicates an expected call of ABCIInfo. +func (mr *MockABCIClientMockRecorder) ABCIInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIInfo", reflect.TypeOf((*MockABCIClient)(nil).ABCIInfo), arg0) +} + +// ABCIQuery mocks base method. +func (m *MockABCIClient) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQuery", ctx, path, data) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQuery indicates an expected call of ABCIQuery. +func (mr *MockABCIClientMockRecorder) ABCIQuery(ctx, path, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQuery", reflect.TypeOf((*MockABCIClient)(nil).ABCIQuery), ctx, path, data) +} + +// ABCIQueryWithOptions mocks base method. +func (m *MockABCIClient) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQueryWithOptions", ctx, path, data, opts) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQueryWithOptions indicates an expected call of ABCIQueryWithOptions. +func (mr *MockABCIClientMockRecorder) ABCIQueryWithOptions(ctx, path, data, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQueryWithOptions", reflect.TypeOf((*MockABCIClient)(nil).ABCIQueryWithOptions), ctx, path, data, opts) +} + +// BroadcastTxAsync mocks base method. +func (m *MockABCIClient) BroadcastTxAsync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxAsync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxAsync indicates an expected call of BroadcastTxAsync. +func (mr *MockABCIClientMockRecorder) BroadcastTxAsync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxAsync", reflect.TypeOf((*MockABCIClient)(nil).BroadcastTxAsync), arg0, arg1) +} + +// BroadcastTxCommit mocks base method. +func (m *MockABCIClient) BroadcastTxCommit(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxCommit", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTxCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxCommit indicates an expected call of BroadcastTxCommit. +func (mr *MockABCIClientMockRecorder) BroadcastTxCommit(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxCommit", reflect.TypeOf((*MockABCIClient)(nil).BroadcastTxCommit), arg0, arg1) +} + +// BroadcastTxSync mocks base method. +func (m *MockABCIClient) BroadcastTxSync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxSync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxSync indicates an expected call of BroadcastTxSync. +func (mr *MockABCIClientMockRecorder) BroadcastTxSync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxSync", reflect.TypeOf((*MockABCIClient)(nil).BroadcastTxSync), arg0, arg1) +} + +// MockSignClient is a mock of SignClient interface. +type MockSignClient struct { + ctrl *gomock.Controller + recorder *MockSignClientMockRecorder +} + +// MockSignClientMockRecorder is the mock recorder for MockSignClient. +type MockSignClientMockRecorder struct { + mock *MockSignClient +} + +// NewMockSignClient creates a new mock instance. +func NewMockSignClient(ctrl *gomock.Controller) *MockSignClient { + mock := &MockSignClient{ctrl: ctrl} + mock.recorder = &MockSignClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSignClient) EXPECT() *MockSignClientMockRecorder { + return m.recorder +} + +// Block mocks base method. +func (m *MockSignClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Block", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Block indicates an expected call of Block. +func (mr *MockSignClientMockRecorder) Block(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockSignClient)(nil).Block), ctx, height) +} + +// BlockByHash mocks base method. +func (m *MockSignClient) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockByHash indicates an expected call of BlockByHash. +func (mr *MockSignClientMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockSignClient)(nil).BlockByHash), ctx, hash) +} + +// BlockResults mocks base method. +func (m *MockSignClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockResults", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlockResults) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockResults indicates an expected call of BlockResults. +func (mr *MockSignClientMockRecorder) BlockResults(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockResults", reflect.TypeOf((*MockSignClient)(nil).BlockResults), ctx, height) +} + +// BlockSearch mocks base method. +func (m *MockSignClient) BlockSearch(ctx context.Context, query string, page, perPage *int, orderBy string) (*coretypes.ResultBlockSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockSearch", ctx, query, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultBlockSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockSearch indicates an expected call of BlockSearch. +func (mr *MockSignClientMockRecorder) BlockSearch(ctx, query, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSearch", reflect.TypeOf((*MockSignClient)(nil).BlockSearch), ctx, query, page, perPage, orderBy) +} + +// Commit mocks base method. +func (m *MockSignClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Commit", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Commit indicates an expected call of Commit. +func (mr *MockSignClientMockRecorder) Commit(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockSignClient)(nil).Commit), ctx, height) +} + +// Header mocks base method. +func (m *MockSignClient) Header(ctx context.Context, height *int64) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockSignClientMockRecorder) Header(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockSignClient)(nil).Header), ctx, height) +} + +// HeaderByHash mocks base method. +func (m *MockSignClient) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeaderByHash indicates an expected call of HeaderByHash. +func (mr *MockSignClientMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockSignClient)(nil).HeaderByHash), ctx, hash) +} + +// Tx mocks base method. +func (m *MockSignClient) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Tx", ctx, hash, prove) + ret0, _ := ret[0].(*coretypes.ResultTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Tx indicates an expected call of Tx. +func (mr *MockSignClientMockRecorder) Tx(ctx, hash, prove interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tx", reflect.TypeOf((*MockSignClient)(nil).Tx), ctx, hash, prove) +} + +// TxSearch mocks base method. +func (m *MockSignClient) TxSearch(ctx context.Context, query string, prove bool, page, perPage *int, orderBy string) (*coretypes.ResultTxSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxSearch", ctx, query, prove, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultTxSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxSearch indicates an expected call of TxSearch. +func (mr *MockSignClientMockRecorder) TxSearch(ctx, query, prove, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxSearch", reflect.TypeOf((*MockSignClient)(nil).TxSearch), ctx, query, prove, page, perPage, orderBy) +} + +// Validators mocks base method. +func (m *MockSignClient) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Validators", ctx, height, page, perPage) + ret0, _ := ret[0].(*coretypes.ResultValidators) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Validators indicates an expected call of Validators. +func (mr *MockSignClientMockRecorder) Validators(ctx, height, page, perPage interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validators", reflect.TypeOf((*MockSignClient)(nil).Validators), ctx, height, page, perPage) +} + +// MockHistoryClient is a mock of HistoryClient interface. +type MockHistoryClient struct { + ctrl *gomock.Controller + recorder *MockHistoryClientMockRecorder +} + +// MockHistoryClientMockRecorder is the mock recorder for MockHistoryClient. +type MockHistoryClientMockRecorder struct { + mock *MockHistoryClient +} + +// NewMockHistoryClient creates a new mock instance. +func NewMockHistoryClient(ctrl *gomock.Controller) *MockHistoryClient { + mock := &MockHistoryClient{ctrl: ctrl} + mock.recorder = &MockHistoryClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockHistoryClient) EXPECT() *MockHistoryClientMockRecorder { + return m.recorder +} + +// BlockchainInfo mocks base method. +func (m *MockHistoryClient) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockchainInfo", ctx, minHeight, maxHeight) + ret0, _ := ret[0].(*coretypes.ResultBlockchainInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockchainInfo indicates an expected call of BlockchainInfo. +func (mr *MockHistoryClientMockRecorder) BlockchainInfo(ctx, minHeight, maxHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainInfo", reflect.TypeOf((*MockHistoryClient)(nil).BlockchainInfo), ctx, minHeight, maxHeight) +} + +// Genesis mocks base method. +func (m *MockHistoryClient) Genesis(arg0 context.Context) (*coretypes.ResultGenesis, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Genesis", arg0) + ret0, _ := ret[0].(*coretypes.ResultGenesis) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Genesis indicates an expected call of Genesis. +func (mr *MockHistoryClientMockRecorder) Genesis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Genesis", reflect.TypeOf((*MockHistoryClient)(nil).Genesis), arg0) +} + +// GenesisChunked mocks base method. +func (m *MockHistoryClient) GenesisChunked(arg0 context.Context, arg1 uint) (*coretypes.ResultGenesisChunk, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenesisChunked", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultGenesisChunk) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenesisChunked indicates an expected call of GenesisChunked. +func (mr *MockHistoryClientMockRecorder) GenesisChunked(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisChunked", reflect.TypeOf((*MockHistoryClient)(nil).GenesisChunked), arg0, arg1) +} + +// MockStatusClient is a mock of StatusClient interface. +type MockStatusClient struct { + ctrl *gomock.Controller + recorder *MockStatusClientMockRecorder +} + +// MockStatusClientMockRecorder is the mock recorder for MockStatusClient. +type MockStatusClientMockRecorder struct { + mock *MockStatusClient +} + +// NewMockStatusClient creates a new mock instance. +func NewMockStatusClient(ctrl *gomock.Controller) *MockStatusClient { + mock := &MockStatusClient{ctrl: ctrl} + mock.recorder = &MockStatusClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStatusClient) EXPECT() *MockStatusClientMockRecorder { + return m.recorder +} + +// Status mocks base method. +func (m *MockStatusClient) Status(arg0 context.Context) (*coretypes.ResultStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Status", arg0) + ret0, _ := ret[0].(*coretypes.ResultStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Status indicates an expected call of Status. +func (mr *MockStatusClientMockRecorder) Status(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockStatusClient)(nil).Status), arg0) +} + +// MockNetworkClient is a mock of NetworkClient interface. +type MockNetworkClient struct { + ctrl *gomock.Controller + recorder *MockNetworkClientMockRecorder +} + +// MockNetworkClientMockRecorder is the mock recorder for MockNetworkClient. +type MockNetworkClientMockRecorder struct { + mock *MockNetworkClient +} + +// NewMockNetworkClient creates a new mock instance. +func NewMockNetworkClient(ctrl *gomock.Controller) *MockNetworkClient { + mock := &MockNetworkClient{ctrl: ctrl} + mock.recorder = &MockNetworkClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNetworkClient) EXPECT() *MockNetworkClientMockRecorder { + return m.recorder +} + +// ConsensusParams mocks base method. +func (m *MockNetworkClient) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusParams", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultConsensusParams) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusParams indicates an expected call of ConsensusParams. +func (mr *MockNetworkClientMockRecorder) ConsensusParams(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusParams", reflect.TypeOf((*MockNetworkClient)(nil).ConsensusParams), ctx, height) +} + +// ConsensusState mocks base method. +func (m *MockNetworkClient) ConsensusState(arg0 context.Context) (*coretypes.ResultConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusState indicates an expected call of ConsensusState. +func (mr *MockNetworkClientMockRecorder) ConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusState", reflect.TypeOf((*MockNetworkClient)(nil).ConsensusState), arg0) +} + +// DumpConsensusState mocks base method. +func (m *MockNetworkClient) DumpConsensusState(arg0 context.Context) (*coretypes.ResultDumpConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DumpConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultDumpConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DumpConsensusState indicates an expected call of DumpConsensusState. +func (mr *MockNetworkClientMockRecorder) DumpConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpConsensusState", reflect.TypeOf((*MockNetworkClient)(nil).DumpConsensusState), arg0) +} + +// Health mocks base method. +func (m *MockNetworkClient) Health(arg0 context.Context) (*coretypes.ResultHealth, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", arg0) + ret0, _ := ret[0].(*coretypes.ResultHealth) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health. +func (mr *MockNetworkClientMockRecorder) Health(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockNetworkClient)(nil).Health), arg0) +} + +// NetInfo mocks base method. +func (m *MockNetworkClient) NetInfo(arg0 context.Context) (*coretypes.ResultNetInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultNetInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NetInfo indicates an expected call of NetInfo. +func (mr *MockNetworkClientMockRecorder) NetInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetInfo", reflect.TypeOf((*MockNetworkClient)(nil).NetInfo), arg0) +} + +// MockEventsClient is a mock of EventsClient interface. +type MockEventsClient struct { + ctrl *gomock.Controller + recorder *MockEventsClientMockRecorder +} + +// MockEventsClientMockRecorder is the mock recorder for MockEventsClient. +type MockEventsClientMockRecorder struct { + mock *MockEventsClient +} + +// NewMockEventsClient creates a new mock instance. +func NewMockEventsClient(ctrl *gomock.Controller) *MockEventsClient { + mock := &MockEventsClient{ctrl: ctrl} + mock.recorder = &MockEventsClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEventsClient) EXPECT() *MockEventsClientMockRecorder { + return m.recorder +} + +// Subscribe mocks base method. +func (m *MockEventsClient) Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, subscriber, query} + for _, a := range outCapacity { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Subscribe", varargs...) + ret0, _ := ret[0].(<-chan coretypes.ResultEvent) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockEventsClientMockRecorder) Subscribe(ctx, subscriber, query interface{}, outCapacity ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, subscriber, query}, outCapacity...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockEventsClient)(nil).Subscribe), varargs...) +} + +// Unsubscribe mocks base method. +func (m *MockEventsClient) Unsubscribe(ctx context.Context, subscriber, query string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Unsubscribe", ctx, subscriber, query) + ret0, _ := ret[0].(error) + return ret0 +} + +// Unsubscribe indicates an expected call of Unsubscribe. +func (mr *MockEventsClientMockRecorder) Unsubscribe(ctx, subscriber, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockEventsClient)(nil).Unsubscribe), ctx, subscriber, query) +} + +// UnsubscribeAll mocks base method. +func (m *MockEventsClient) UnsubscribeAll(ctx context.Context, subscriber string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnsubscribeAll", ctx, subscriber) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnsubscribeAll indicates an expected call of UnsubscribeAll. +func (mr *MockEventsClientMockRecorder) UnsubscribeAll(ctx, subscriber interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeAll", reflect.TypeOf((*MockEventsClient)(nil).UnsubscribeAll), ctx, subscriber) +} + +// MockMempoolClient is a mock of MempoolClient interface. +type MockMempoolClient struct { + ctrl *gomock.Controller + recorder *MockMempoolClientMockRecorder +} + +// MockMempoolClientMockRecorder is the mock recorder for MockMempoolClient. +type MockMempoolClientMockRecorder struct { + mock *MockMempoolClient +} + +// NewMockMempoolClient creates a new mock instance. +func NewMockMempoolClient(ctrl *gomock.Controller) *MockMempoolClient { + mock := &MockMempoolClient{ctrl: ctrl} + mock.recorder = &MockMempoolClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMempoolClient) EXPECT() *MockMempoolClientMockRecorder { + return m.recorder +} + +// CheckTx mocks base method. +func (m *MockMempoolClient) CheckTx(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultCheckTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckTx", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultCheckTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckTx indicates an expected call of CheckTx. +func (mr *MockMempoolClientMockRecorder) CheckTx(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTx", reflect.TypeOf((*MockMempoolClient)(nil).CheckTx), arg0, arg1) +} + +// NumUnconfirmedTxs mocks base method. +func (m *MockMempoolClient) NumUnconfirmedTxs(arg0 context.Context) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NumUnconfirmedTxs", arg0) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NumUnconfirmedTxs indicates an expected call of NumUnconfirmedTxs. +func (mr *MockMempoolClientMockRecorder) NumUnconfirmedTxs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumUnconfirmedTxs", reflect.TypeOf((*MockMempoolClient)(nil).NumUnconfirmedTxs), arg0) +} + +// UnconfirmedTxs mocks base method. +func (m *MockMempoolClient) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnconfirmedTxs", ctx, limit) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnconfirmedTxs indicates an expected call of UnconfirmedTxs. +func (mr *MockMempoolClientMockRecorder) UnconfirmedTxs(ctx, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnconfirmedTxs", reflect.TypeOf((*MockMempoolClient)(nil).UnconfirmedTxs), ctx, limit) +} + +// MockEvidenceClient is a mock of EvidenceClient interface. +type MockEvidenceClient struct { + ctrl *gomock.Controller + recorder *MockEvidenceClientMockRecorder +} + +// MockEvidenceClientMockRecorder is the mock recorder for MockEvidenceClient. +type MockEvidenceClientMockRecorder struct { + mock *MockEvidenceClient +} + +// NewMockEvidenceClient creates a new mock instance. +func NewMockEvidenceClient(ctrl *gomock.Controller) *MockEvidenceClient { + mock := &MockEvidenceClient{ctrl: ctrl} + mock.recorder = &MockEvidenceClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEvidenceClient) EXPECT() *MockEvidenceClientMockRecorder { + return m.recorder +} + +// BroadcastEvidence mocks base method. +func (m *MockEvidenceClient) BroadcastEvidence(arg0 context.Context, arg1 types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastEvidence", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastEvidence) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastEvidence indicates an expected call of BroadcastEvidence. +func (mr *MockEvidenceClientMockRecorder) BroadcastEvidence(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastEvidence", reflect.TypeOf((*MockEvidenceClient)(nil).BroadcastEvidence), arg0, arg1) +} + +// MockRemoteClient is a mock of RemoteClient interface. +type MockRemoteClient struct { + ctrl *gomock.Controller + recorder *MockRemoteClientMockRecorder +} + +// MockRemoteClientMockRecorder is the mock recorder for MockRemoteClient. +type MockRemoteClientMockRecorder struct { + mock *MockRemoteClient +} + +// NewMockRemoteClient creates a new mock instance. +func NewMockRemoteClient(ctrl *gomock.Controller) *MockRemoteClient { + mock := &MockRemoteClient{ctrl: ctrl} + mock.recorder = &MockRemoteClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRemoteClient) EXPECT() *MockRemoteClientMockRecorder { + return m.recorder +} + +// ABCIInfo mocks base method. +func (m *MockRemoteClient) ABCIInfo(arg0 context.Context) (*coretypes.ResultABCIInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultABCIInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIInfo indicates an expected call of ABCIInfo. +func (mr *MockRemoteClientMockRecorder) ABCIInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIInfo", reflect.TypeOf((*MockRemoteClient)(nil).ABCIInfo), arg0) +} + +// ABCIQuery mocks base method. +func (m *MockRemoteClient) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQuery", ctx, path, data) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQuery indicates an expected call of ABCIQuery. +func (mr *MockRemoteClientMockRecorder) ABCIQuery(ctx, path, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQuery", reflect.TypeOf((*MockRemoteClient)(nil).ABCIQuery), ctx, path, data) +} + +// ABCIQueryWithOptions mocks base method. +func (m *MockRemoteClient) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ABCIQueryWithOptions", ctx, path, data, opts) + ret0, _ := ret[0].(*coretypes.ResultABCIQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ABCIQueryWithOptions indicates an expected call of ABCIQueryWithOptions. +func (mr *MockRemoteClientMockRecorder) ABCIQueryWithOptions(ctx, path, data, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQueryWithOptions", reflect.TypeOf((*MockRemoteClient)(nil).ABCIQueryWithOptions), ctx, path, data, opts) +} + +// Block mocks base method. +func (m *MockRemoteClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Block", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Block indicates an expected call of Block. +func (mr *MockRemoteClientMockRecorder) Block(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockRemoteClient)(nil).Block), ctx, height) +} + +// BlockByHash mocks base method. +func (m *MockRemoteClient) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultBlock) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockByHash indicates an expected call of BlockByHash. +func (mr *MockRemoteClientMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockRemoteClient)(nil).BlockByHash), ctx, hash) +} + +// BlockResults mocks base method. +func (m *MockRemoteClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockResults", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultBlockResults) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockResults indicates an expected call of BlockResults. +func (mr *MockRemoteClientMockRecorder) BlockResults(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockResults", reflect.TypeOf((*MockRemoteClient)(nil).BlockResults), ctx, height) +} + +// BlockSearch mocks base method. +func (m *MockRemoteClient) BlockSearch(ctx context.Context, query string, page, perPage *int, orderBy string) (*coretypes.ResultBlockSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockSearch", ctx, query, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultBlockSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockSearch indicates an expected call of BlockSearch. +func (mr *MockRemoteClientMockRecorder) BlockSearch(ctx, query, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSearch", reflect.TypeOf((*MockRemoteClient)(nil).BlockSearch), ctx, query, page, perPage, orderBy) +} + +// BlockchainInfo mocks base method. +func (m *MockRemoteClient) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BlockchainInfo", ctx, minHeight, maxHeight) + ret0, _ := ret[0].(*coretypes.ResultBlockchainInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BlockchainInfo indicates an expected call of BlockchainInfo. +func (mr *MockRemoteClientMockRecorder) BlockchainInfo(ctx, minHeight, maxHeight interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainInfo", reflect.TypeOf((*MockRemoteClient)(nil).BlockchainInfo), ctx, minHeight, maxHeight) +} + +// BroadcastEvidence mocks base method. +func (m *MockRemoteClient) BroadcastEvidence(arg0 context.Context, arg1 types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastEvidence", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastEvidence) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastEvidence indicates an expected call of BroadcastEvidence. +func (mr *MockRemoteClientMockRecorder) BroadcastEvidence(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastEvidence", reflect.TypeOf((*MockRemoteClient)(nil).BroadcastEvidence), arg0, arg1) +} + +// BroadcastTxAsync mocks base method. +func (m *MockRemoteClient) BroadcastTxAsync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxAsync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxAsync indicates an expected call of BroadcastTxAsync. +func (mr *MockRemoteClientMockRecorder) BroadcastTxAsync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxAsync", reflect.TypeOf((*MockRemoteClient)(nil).BroadcastTxAsync), arg0, arg1) +} + +// BroadcastTxCommit mocks base method. +func (m *MockRemoteClient) BroadcastTxCommit(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxCommit", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTxCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxCommit indicates an expected call of BroadcastTxCommit. +func (mr *MockRemoteClientMockRecorder) BroadcastTxCommit(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxCommit", reflect.TypeOf((*MockRemoteClient)(nil).BroadcastTxCommit), arg0, arg1) +} + +// BroadcastTxSync mocks base method. +func (m *MockRemoteClient) BroadcastTxSync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BroadcastTxSync", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultBroadcastTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BroadcastTxSync indicates an expected call of BroadcastTxSync. +func (mr *MockRemoteClientMockRecorder) BroadcastTxSync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastTxSync", reflect.TypeOf((*MockRemoteClient)(nil).BroadcastTxSync), arg0, arg1) +} + +// CheckTx mocks base method. +func (m *MockRemoteClient) CheckTx(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultCheckTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckTx", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultCheckTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckTx indicates an expected call of CheckTx. +func (mr *MockRemoteClientMockRecorder) CheckTx(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTx", reflect.TypeOf((*MockRemoteClient)(nil).CheckTx), arg0, arg1) +} + +// Commit mocks base method. +func (m *MockRemoteClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Commit", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Commit indicates an expected call of Commit. +func (mr *MockRemoteClientMockRecorder) Commit(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockRemoteClient)(nil).Commit), ctx, height) +} + +// ConsensusParams mocks base method. +func (m *MockRemoteClient) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusParams", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultConsensusParams) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusParams indicates an expected call of ConsensusParams. +func (mr *MockRemoteClientMockRecorder) ConsensusParams(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusParams", reflect.TypeOf((*MockRemoteClient)(nil).ConsensusParams), ctx, height) +} + +// ConsensusState mocks base method. +func (m *MockRemoteClient) ConsensusState(arg0 context.Context) (*coretypes.ResultConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConsensusState indicates an expected call of ConsensusState. +func (mr *MockRemoteClientMockRecorder) ConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusState", reflect.TypeOf((*MockRemoteClient)(nil).ConsensusState), arg0) +} + +// DumpConsensusState mocks base method. +func (m *MockRemoteClient) DumpConsensusState(arg0 context.Context) (*coretypes.ResultDumpConsensusState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DumpConsensusState", arg0) + ret0, _ := ret[0].(*coretypes.ResultDumpConsensusState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DumpConsensusState indicates an expected call of DumpConsensusState. +func (mr *MockRemoteClientMockRecorder) DumpConsensusState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpConsensusState", reflect.TypeOf((*MockRemoteClient)(nil).DumpConsensusState), arg0) +} + +// Genesis mocks base method. +func (m *MockRemoteClient) Genesis(arg0 context.Context) (*coretypes.ResultGenesis, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Genesis", arg0) + ret0, _ := ret[0].(*coretypes.ResultGenesis) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Genesis indicates an expected call of Genesis. +func (mr *MockRemoteClientMockRecorder) Genesis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Genesis", reflect.TypeOf((*MockRemoteClient)(nil).Genesis), arg0) +} + +// GenesisChunked mocks base method. +func (m *MockRemoteClient) GenesisChunked(arg0 context.Context, arg1 uint) (*coretypes.ResultGenesisChunk, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenesisChunked", arg0, arg1) + ret0, _ := ret[0].(*coretypes.ResultGenesisChunk) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenesisChunked indicates an expected call of GenesisChunked. +func (mr *MockRemoteClientMockRecorder) GenesisChunked(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisChunked", reflect.TypeOf((*MockRemoteClient)(nil).GenesisChunked), arg0, arg1) +} + +// Header mocks base method. +func (m *MockRemoteClient) Header(ctx context.Context, height *int64) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header", ctx, height) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockRemoteClientMockRecorder) Header(ctx, height interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockRemoteClient)(nil).Header), ctx, height) +} + +// HeaderByHash mocks base method. +func (m *MockRemoteClient) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash) + ret0, _ := ret[0].(*coretypes.ResultHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeaderByHash indicates an expected call of HeaderByHash. +func (mr *MockRemoteClientMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockRemoteClient)(nil).HeaderByHash), ctx, hash) +} + +// Health mocks base method. +func (m *MockRemoteClient) Health(arg0 context.Context) (*coretypes.ResultHealth, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Health", arg0) + ret0, _ := ret[0].(*coretypes.ResultHealth) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Health indicates an expected call of Health. +func (mr *MockRemoteClientMockRecorder) Health(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockRemoteClient)(nil).Health), arg0) +} + +// IsRunning mocks base method. +func (m *MockRemoteClient) IsRunning() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsRunning") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsRunning indicates an expected call of IsRunning. +func (mr *MockRemoteClientMockRecorder) IsRunning() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRunning", reflect.TypeOf((*MockRemoteClient)(nil).IsRunning)) +} + +// NetInfo mocks base method. +func (m *MockRemoteClient) NetInfo(arg0 context.Context) (*coretypes.ResultNetInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetInfo", arg0) + ret0, _ := ret[0].(*coretypes.ResultNetInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NetInfo indicates an expected call of NetInfo. +func (mr *MockRemoteClientMockRecorder) NetInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetInfo", reflect.TypeOf((*MockRemoteClient)(nil).NetInfo), arg0) +} + +// NumUnconfirmedTxs mocks base method. +func (m *MockRemoteClient) NumUnconfirmedTxs(arg0 context.Context) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NumUnconfirmedTxs", arg0) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NumUnconfirmedTxs indicates an expected call of NumUnconfirmedTxs. +func (mr *MockRemoteClientMockRecorder) NumUnconfirmedTxs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumUnconfirmedTxs", reflect.TypeOf((*MockRemoteClient)(nil).NumUnconfirmedTxs), arg0) +} + +// OnReset mocks base method. +func (m *MockRemoteClient) OnReset() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OnReset") + ret0, _ := ret[0].(error) + return ret0 +} + +// OnReset indicates an expected call of OnReset. +func (mr *MockRemoteClientMockRecorder) OnReset() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnReset", reflect.TypeOf((*MockRemoteClient)(nil).OnReset)) +} + +// OnStart mocks base method. +func (m *MockRemoteClient) OnStart() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OnStart") + ret0, _ := ret[0].(error) + return ret0 +} + +// OnStart indicates an expected call of OnStart. +func (mr *MockRemoteClientMockRecorder) OnStart() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnStart", reflect.TypeOf((*MockRemoteClient)(nil).OnStart)) +} + +// OnStop mocks base method. +func (m *MockRemoteClient) OnStop() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "OnStop") +} + +// OnStop indicates an expected call of OnStop. +func (mr *MockRemoteClientMockRecorder) OnStop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnStop", reflect.TypeOf((*MockRemoteClient)(nil).OnStop)) +} + +// Quit mocks base method. +func (m *MockRemoteClient) Quit() <-chan struct{} { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit") + ret0, _ := ret[0].(<-chan struct{}) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockRemoteClientMockRecorder) Quit() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockRemoteClient)(nil).Quit)) +} + +// Remote mocks base method. +func (m *MockRemoteClient) Remote() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Remote") + ret0, _ := ret[0].(string) + return ret0 +} + +// Remote indicates an expected call of Remote. +func (mr *MockRemoteClientMockRecorder) Remote() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remote", reflect.TypeOf((*MockRemoteClient)(nil).Remote)) +} + +// Reset mocks base method. +func (m *MockRemoteClient) Reset() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Reset") + ret0, _ := ret[0].(error) + return ret0 +} + +// Reset indicates an expected call of Reset. +func (mr *MockRemoteClientMockRecorder) Reset() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockRemoteClient)(nil).Reset)) +} + +// SetLogger mocks base method. +func (m *MockRemoteClient) SetLogger(arg0 log.Logger) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetLogger", arg0) +} + +// SetLogger indicates an expected call of SetLogger. +func (mr *MockRemoteClientMockRecorder) SetLogger(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogger", reflect.TypeOf((*MockRemoteClient)(nil).SetLogger), arg0) +} + +// Start mocks base method. +func (m *MockRemoteClient) Start() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Start") + ret0, _ := ret[0].(error) + return ret0 +} + +// Start indicates an expected call of Start. +func (mr *MockRemoteClientMockRecorder) Start() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockRemoteClient)(nil).Start)) +} + +// Status mocks base method. +func (m *MockRemoteClient) Status(arg0 context.Context) (*coretypes.ResultStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Status", arg0) + ret0, _ := ret[0].(*coretypes.ResultStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Status indicates an expected call of Status. +func (mr *MockRemoteClientMockRecorder) Status(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockRemoteClient)(nil).Status), arg0) +} + +// Stop mocks base method. +func (m *MockRemoteClient) Stop() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Stop") + ret0, _ := ret[0].(error) + return ret0 +} + +// Stop indicates an expected call of Stop. +func (mr *MockRemoteClientMockRecorder) Stop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockRemoteClient)(nil).Stop)) +} + +// String mocks base method. +func (m *MockRemoteClient) String() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "String") + ret0, _ := ret[0].(string) + return ret0 +} + +// String indicates an expected call of String. +func (mr *MockRemoteClientMockRecorder) String() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockRemoteClient)(nil).String)) +} + +// Subscribe mocks base method. +func (m *MockRemoteClient) Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, subscriber, query} + for _, a := range outCapacity { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Subscribe", varargs...) + ret0, _ := ret[0].(<-chan coretypes.ResultEvent) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockRemoteClientMockRecorder) Subscribe(ctx, subscriber, query interface{}, outCapacity ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, subscriber, query}, outCapacity...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockRemoteClient)(nil).Subscribe), varargs...) +} + +// Tx mocks base method. +func (m *MockRemoteClient) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Tx", ctx, hash, prove) + ret0, _ := ret[0].(*coretypes.ResultTx) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Tx indicates an expected call of Tx. +func (mr *MockRemoteClientMockRecorder) Tx(ctx, hash, prove interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tx", reflect.TypeOf((*MockRemoteClient)(nil).Tx), ctx, hash, prove) +} + +// TxSearch mocks base method. +func (m *MockRemoteClient) TxSearch(ctx context.Context, query string, prove bool, page, perPage *int, orderBy string) (*coretypes.ResultTxSearch, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxSearch", ctx, query, prove, page, perPage, orderBy) + ret0, _ := ret[0].(*coretypes.ResultTxSearch) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxSearch indicates an expected call of TxSearch. +func (mr *MockRemoteClientMockRecorder) TxSearch(ctx, query, prove, page, perPage, orderBy interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxSearch", reflect.TypeOf((*MockRemoteClient)(nil).TxSearch), ctx, query, prove, page, perPage, orderBy) +} + +// UnconfirmedTxs mocks base method. +func (m *MockRemoteClient) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnconfirmedTxs", ctx, limit) + ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnconfirmedTxs indicates an expected call of UnconfirmedTxs. +func (mr *MockRemoteClientMockRecorder) UnconfirmedTxs(ctx, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnconfirmedTxs", reflect.TypeOf((*MockRemoteClient)(nil).UnconfirmedTxs), ctx, limit) +} + +// Unsubscribe mocks base method. +func (m *MockRemoteClient) Unsubscribe(ctx context.Context, subscriber, query string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Unsubscribe", ctx, subscriber, query) + ret0, _ := ret[0].(error) + return ret0 +} + +// Unsubscribe indicates an expected call of Unsubscribe. +func (mr *MockRemoteClientMockRecorder) Unsubscribe(ctx, subscriber, query interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockRemoteClient)(nil).Unsubscribe), ctx, subscriber, query) +} + +// UnsubscribeAll mocks base method. +func (m *MockRemoteClient) UnsubscribeAll(ctx context.Context, subscriber string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnsubscribeAll", ctx, subscriber) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnsubscribeAll indicates an expected call of UnsubscribeAll. +func (mr *MockRemoteClientMockRecorder) UnsubscribeAll(ctx, subscriber interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeAll", reflect.TypeOf((*MockRemoteClient)(nil).UnsubscribeAll), ctx, subscriber) +} + +// Validators mocks base method. +func (m *MockRemoteClient) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Validators", ctx, height, page, perPage) + ret0, _ := ret[0].(*coretypes.ResultValidators) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Validators indicates an expected call of Validators. +func (mr *MockRemoteClientMockRecorder) Validators(ctx, height, page, perPage interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validators", reflect.TypeOf((*MockRemoteClient)(nil).Validators), ctx, height, page, perPage) +} diff --git a/testutil/mocks/subscriber/expected_clients.go b/testutil/mocks/subscriber/expected_clients.go index 6022863..56b8838 100644 --- a/testutil/mocks/subscriber/expected_clients.go +++ b/testutil/mocks/subscriber/expected_clients.go @@ -1,10 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./../../internal/subscriber/clients.go -// -// Generated by this command: -// -// mockgen -source=./../../internal/subscriber/clients.go -destination ./subscriber/expected_clients.go -// // Package mock_subscriber is a generated GoMock package. package mock_subscriber @@ -14,8 +9,8 @@ import ( reflect "reflect" coretypes "github.com/cometbft/cometbft/rpc/core/types" + gomock "github.com/golang/mock/gomock" query "github.com/neutron-org/neutron-query-relayer/internal/subscriber/querier/client/query" - gomock "go.uber.org/mock/gomock" ) // MockRpcHttpClient is a mock of RpcHttpClient interface. @@ -65,7 +60,7 @@ func (m *MockRpcHttpClient) Status(ctx context.Context) (*coretypes.ResultStatus } // Status indicates an expected call of Status. -func (mr *MockRpcHttpClientMockRecorder) Status(ctx any) *gomock.Call { +func (mr *MockRpcHttpClientMockRecorder) Status(ctx interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockRpcHttpClient)(nil).Status), ctx) } @@ -73,7 +68,7 @@ func (mr *MockRpcHttpClientMockRecorder) Status(ctx any) *gomock.Call { // Subscribe mocks base method. func (m *MockRpcHttpClient) Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) { m.ctrl.T.Helper() - varargs := []any{ctx, subscriber, query} + varargs := []interface{}{ctx, subscriber, query} for _, a := range outCapacity { varargs = append(varargs, a) } @@ -84,9 +79,9 @@ func (m *MockRpcHttpClient) Subscribe(ctx context.Context, subscriber, query str } // Subscribe indicates an expected call of Subscribe. -func (mr *MockRpcHttpClientMockRecorder) Subscribe(ctx, subscriber, query any, outCapacity ...any) *gomock.Call { +func (mr *MockRpcHttpClientMockRecorder) Subscribe(ctx, subscriber, query interface{}, outCapacity ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx, subscriber, query}, outCapacity...) + varargs := append([]interface{}{ctx, subscriber, query}, outCapacity...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockRpcHttpClient)(nil).Subscribe), varargs...) } @@ -99,7 +94,7 @@ func (m *MockRpcHttpClient) Unsubscribe(ctx context.Context, subscriber, query s } // Unsubscribe indicates an expected call of Unsubscribe. -func (mr *MockRpcHttpClientMockRecorder) Unsubscribe(ctx, subscriber, query any) *gomock.Call { +func (mr *MockRpcHttpClientMockRecorder) Unsubscribe(ctx, subscriber, query interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockRpcHttpClient)(nil).Unsubscribe), ctx, subscriber, query) } @@ -130,7 +125,7 @@ func (m *MockRestHttpQuery) EXPECT() *MockRestHttpQueryMockRecorder { // NeutronInterchainQueriesRegisteredQueries mocks base method. func (m *MockRestHttpQuery) NeutronInterchainQueriesRegisteredQueries(params *query.NeutronInterchainQueriesRegisteredQueriesParams, opts ...query.ClientOption) (*query.NeutronInterchainQueriesRegisteredQueriesOK, error) { m.ctrl.T.Helper() - varargs := []any{params} + varargs := []interface{}{params} for _, a := range opts { varargs = append(varargs, a) } @@ -141,16 +136,16 @@ func (m *MockRestHttpQuery) NeutronInterchainQueriesRegisteredQueries(params *qu } // NeutronInterchainQueriesRegisteredQueries indicates an expected call of NeutronInterchainQueriesRegisteredQueries. -func (mr *MockRestHttpQueryMockRecorder) NeutronInterchainQueriesRegisteredQueries(params any, opts ...any) *gomock.Call { +func (mr *MockRestHttpQueryMockRecorder) NeutronInterchainQueriesRegisteredQueries(params interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{params}, opts...) + varargs := append([]interface{}{params}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeutronInterchainQueriesRegisteredQueries", reflect.TypeOf((*MockRestHttpQuery)(nil).NeutronInterchainQueriesRegisteredQueries), varargs...) } // NeutronInterchainQueriesRegisteredQuery mocks base method. func (m *MockRestHttpQuery) NeutronInterchainQueriesRegisteredQuery(params *query.NeutronInterchainQueriesRegisteredQueryParams, opts ...query.ClientOption) (*query.NeutronInterchainQueriesRegisteredQueryOK, error) { m.ctrl.T.Helper() - varargs := []any{params} + varargs := []interface{}{params} for _, a := range opts { varargs = append(varargs, a) } @@ -161,8 +156,8 @@ func (m *MockRestHttpQuery) NeutronInterchainQueriesRegisteredQuery(params *quer } // NeutronInterchainQueriesRegisteredQuery indicates an expected call of NeutronInterchainQueriesRegisteredQuery. -func (mr *MockRestHttpQueryMockRecorder) NeutronInterchainQueriesRegisteredQuery(params any, opts ...any) *gomock.Call { +func (mr *MockRestHttpQueryMockRecorder) NeutronInterchainQueriesRegisteredQuery(params interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{params}, opts...) + varargs := append([]interface{}{params}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeutronInterchainQueriesRegisteredQuery", reflect.TypeOf((*MockRestHttpQuery)(nil).NeutronInterchainQueriesRegisteredQuery), varargs...) }