Anton Kaliaev
4 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 1151 additions and 225 deletions
Split View
Diff Options
-
+27 -1cmd/tendermint/commands/light.go
-
+1 -1crypto/merkle/proof_op.go
-
+3 -2go.mod
-
+42 -0go.sum
-
+10 -3light/proxy/routes.go
-
+58 -44light/rpc/client.go
-
+152 -0light/rpc/client_test.go
-
+78 -0light/rpc/mocks/light_client.go
-
+0 -14light/rpc/proof.go
-
+0 -160light/rpc/query_test.go
-
+780 -0rpc/client/mocks/client.go
cmd/tendermint/commands/lite.go → cmd/tendermint/commands/light.go
View File
+ 1
- 1
crypto/merkle/proof_op.go
View File
+ 3
- 2
go.mod
View File
+ 42
- 0
go.sum
View File
+ 10
- 3
light/proxy/routes.go
View File
+ 58
- 44
light/rpc/client.go
View File
+ 152
- 0
light/rpc/client_test.go
View File
| @ -0,0 +1,152 @@ | |||
| package rpc | |||
| import ( | |||
| "context" | |||
| "encoding/hex" | |||
| "fmt" | |||
| "testing" | |||
| ics23 "github.com/confio/ics23/go" | |||
| "github.com/cosmos/iavl" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/stretchr/testify/mock" | |||
| "github.com/stretchr/testify/require" | |||
| dbm "github.com/tendermint/tm-db" | |||
| abci "github.com/tendermint/tendermint/abci/types" | |||
| "github.com/tendermint/tendermint/crypto/merkle" | |||
| "github.com/tendermint/tendermint/libs/bytes" | |||
| lcmock "github.com/tendermint/tendermint/light/rpc/mocks" | |||
| tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto" | |||
| rpcmock "github.com/tendermint/tendermint/rpc/client/mocks" | |||
| ctypes "github.com/tendermint/tendermint/rpc/core/types" | |||
| "github.com/tendermint/tendermint/types" | |||
| ) | |||
| // TestABCIQuery tests ABCIQuery requests and verifies proofs. HAPPY PATH 😀 | |||
| func TestABCIQuery(t *testing.T) { | |||
| tree, err := iavl.NewMutableTree(dbm.NewMemDB(), 100) | |||
| require.NoError(t, err) | |||
| var ( | |||
| key = []byte("foo") | |||
| value = []byte("bar") | |||
| ) | |||
| tree.Set(key, value) | |||
| commitmentProof, err := tree.GetMembershipProof(key) | |||
| require.NoError(t, err) | |||
| op := &testOp{ | |||
| Spec: ics23.IavlSpec, | |||
| Key: key, | |||
| Proof: commitmentProof, | |||
| } | |||
| next := &rpcmock.Client{} | |||
| next.On( | |||
| "ABCIQueryWithOptions", | |||
| context.Background(), | |||
| mock.AnythingOfType("string"), | |||
| bytes.HexBytes(key), | |||
| mock.AnythingOfType("client.ABCIQueryOptions"), | |||
| ).Return(&ctypes.ResultABCIQuery{ | |||
| Response: abci.ResponseQuery{ | |||
| Code: 0, | |||
| Key: key, | |||
| Value: value, | |||
| Height: 1, | |||
| ProofOps: &tmcrypto.ProofOps{ | |||
| Ops: []tmcrypto.ProofOp{op.ProofOp()}, | |||
| }, | |||
| }, | |||
| }, nil) | |||
| lc := &lcmock.LightClient{} | |||
| appHash, _ := hex.DecodeString("5EFD44055350B5CC34DBD26085347A9DBBE44EA192B9286A9FC107F40EA1FAC5") | |||
| lc.On("VerifyLightBlockAtHeight", context.Background(), int64(2), mock.AnythingOfType("time.Time")).Return( | |||
| &types.LightBlock{ | |||
| SignedHeader: &types.SignedHeader{ | |||
| Header: &types.Header{AppHash: appHash}, | |||
| }, | |||
| }, | |||
| nil, | |||
| ) | |||
| c := NewClient(next, lc, | |||
| KeyPathFn(func(_ string, key []byte) (merkle.KeyPath, error) { | |||
| kp := merkle.KeyPath{} | |||
| kp = kp.AppendKey(key, merkle.KeyEncodingURL) | |||
| return kp, nil | |||
| })) | |||
| c.RegisterOpDecoder("ics23:iavl", testOpDecoder) | |||
| res, err := c.ABCIQuery(context.Background(), "/store/accounts/key", key) | |||
| require.NoError(t, err) | |||
| assert.NotNil(t, res) | |||
| } | |||
| type testOp struct { | |||
| Spec *ics23.ProofSpec | |||
| Key []byte | |||
| Proof *ics23.CommitmentProof | |||
| } | |||
| var _ merkle.ProofOperator = testOp{} | |||
| func (op testOp) GetKey() []byte { | |||
| return op.Key | |||
| } | |||
| func (op testOp) ProofOp() tmcrypto.ProofOp { | |||
| bz, err := op.Proof.Marshal() | |||
| if err != nil { | |||
| panic(err.Error()) | |||
| } | |||
| return tmcrypto.ProofOp{ | |||
| Type: "ics23:iavl", | |||
| Key: op.Key, | |||
| Data: bz, | |||
| } | |||
| } | |||
| func (op testOp) Run(args [][]byte) ([][]byte, error) { | |||
| // calculate root from proof | |||
| root, err := op.Proof.Calculate() | |||
| if err != nil { | |||
| return nil, fmt.Errorf("could not calculate root for proof: %v", err) | |||
| } | |||
| // Only support an existence proof or nonexistence proof (batch proofs currently unsupported) | |||
| switch len(args) { | |||
| case 0: | |||
| // Args are nil, so we verify the absence of the key. | |||
| absent := ics23.VerifyNonMembership(op.Spec, root, op.Proof, op.Key) | |||
| if !absent { | |||
| return nil, fmt.Errorf("proof did not verify absence of key: %s", string(op.Key)) | |||
| } | |||
| case 1: | |||
| // Args is length 1, verify existence of key with value args[0] | |||
| if !ics23.VerifyMembership(op.Spec, root, op.Proof, op.Key, args[0]) { | |||
| return nil, fmt.Errorf("proof did not verify existence of key %s with given value %x", op.Key, args[0]) | |||
| } | |||
| default: | |||
| return nil, fmt.Errorf("args must be length 0 or 1, got: %d", len(args)) | |||
| } | |||
| return [][]byte{root}, nil | |||
| } | |||
| func testOpDecoder(pop tmcrypto.ProofOp) (merkle.ProofOperator, error) { | |||
| proof := &ics23.CommitmentProof{} | |||
| err := proof.Unmarshal(pop.Data) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| op := testOp{ | |||
| Key: pop.Key, | |||
| Spec: ics23.IavlSpec, | |||
| Proof: proof, | |||
| } | |||
| return op, nil | |||
| } | |||
+ 78
- 0
light/rpc/mocks/light_client.go
View File
| @ -0,0 +1,78 @@ | |||
| // Code generated by mockery v2.3.0. DO NOT EDIT. | |||
| package mocks | |||
| import ( | |||
| context "context" | |||
| mock "github.com/stretchr/testify/mock" | |||
| time "time" | |||
| types "github.com/tendermint/tendermint/types" | |||
| ) | |||
| // LightClient is an autogenerated mock type for the LightClient type | |||
| type LightClient struct { | |||
| mock.Mock | |||
| } | |||
| // ChainID provides a mock function with given fields: | |||
| func (_m *LightClient) ChainID() string { | |||
| ret := _m.Called() | |||
| var r0 string | |||
| if rf, ok := ret.Get(0).(func() string); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Get(0).(string) | |||
| } | |||
| return r0 | |||
| } | |||
| // TrustedLightBlock provides a mock function with given fields: height | |||
| func (_m *LightClient) TrustedLightBlock(height int64) (*types.LightBlock, error) { | |||
| ret := _m.Called(height) | |||
| var r0 *types.LightBlock | |||
| if rf, ok := ret.Get(0).(func(int64) *types.LightBlock); ok { | |||
| r0 = rf(height) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*types.LightBlock) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(int64) error); ok { | |||
| r1 = rf(height) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // VerifyLightBlockAtHeight provides a mock function with given fields: ctx, height, now | |||
| func (_m *LightClient) VerifyLightBlockAtHeight(ctx context.Context, height int64, now time.Time) (*types.LightBlock, error) { | |||
| ret := _m.Called(ctx, height, now) | |||
| var r0 *types.LightBlock | |||
| if rf, ok := ret.Get(0).(func(context.Context, int64, time.Time) *types.LightBlock); ok { | |||
| r0 = rf(ctx, height, now) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*types.LightBlock) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, int64, time.Time) error); ok { | |||
| r1 = rf(ctx, height, now) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
+ 0
- 14
light/rpc/proof.go
View File
| @ -1,14 +0,0 @@ | |||
| package rpc | |||
| import ( | |||
| "github.com/tendermint/tendermint/crypto/merkle" | |||
| ) | |||
| func defaultProofRuntime() *merkle.ProofRuntime { | |||
| prt := merkle.NewProofRuntime() | |||
| prt.RegisterOpDecoder( | |||
| merkle.ProofOpValue, | |||
| merkle.ValueOpDecoder, | |||
| ) | |||
| return prt | |||
| } | |||
+ 0
- 160
light/rpc/query_test.go
View File
| @ -1,160 +0,0 @@ | |||
| package rpc | |||
| //import ( | |||
| // "fmt" | |||
| // "os" | |||
| // "testing" | |||
| // "time" | |||
| // "github.com/stretchr/testify/assert" | |||
| // "github.com/stretchr/testify/require" | |||
| // "github.com/tendermint/tendermint/abci/example/kvstore" | |||
| // "github.com/tendermint/tendermint/crypto/merkle" | |||
| // nm "github.com/tendermint/tendermint/node" | |||
| // "github.com/tendermint/tendermint/rpc/client" | |||
| // rpctest "github.com/tendermint/tendermint/rpc/test" | |||
| // "github.com/tendermint/tendermint/types" | |||
| //) | |||
| //var node *nm.Node | |||
| //var chainID = "tendermint_test" // TODO use from config. | |||
| ////nolint:unused | |||
| //var waitForEventTimeout = 5 * time.Second | |||
| //// TODO fix tests!! | |||
| //func TestMain(m *testing.M) { | |||
| // app := kvstore.NewKVStoreApplication() | |||
| // node = rpctest.StartTendermint(app) | |||
| // code := m.Run() | |||
| // rpctest.StopTendermint(node) | |||
| // os.Exit(code) | |||
| //} | |||
| //func kvstoreTx(k, v []byte) []byte { | |||
| // return []byte(fmt.Sprintf("%s=%s", k, v)) | |||
| //} | |||
| //// TODO: enable it after general proof format has been adapted | |||
| //// in abci/examples/kvstore.go | |||
| ////nolint:unused,deadcode | |||
| //func _TestAppProofs(t *testing.T) { | |||
| // assert, require := assert.New(t), require.New(t) | |||
| // prt := defaultProofRuntime() | |||
| // cl := client.NewLocal(node) | |||
| // client.WaitForHeight(cl, 1, nil) | |||
| // // This sets up our trust on the node based on some past point. | |||
| // source := certclient.NewProvider(chainID, cl) | |||
| // seed, err := source.LatestFullCommit(chainID, 1, 1) | |||
| // require.NoError(err, "%#v", err) | |||
| // cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators) | |||
| // // Wait for tx confirmation. | |||
| // done := make(chan int64) | |||
| // go func() { | |||
| // evtTyp := types.EventTx | |||
| // _, err = client.WaitForOneEvent(cl, evtTyp, waitForEventTimeout) | |||
| // require.Nil(err, "%#v", err) | |||
| // close(done) | |||
| // }() | |||
| // // Submit a transaction. | |||
| // k := []byte("my-key") | |||
| // v := []byte("my-value") | |||
| // tx := kvstoreTx(k, v) | |||
| // br, err := cl.BroadcastTxCommit(tx) | |||
| // require.NoError(err, "%#v", err) | |||
| // require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx) | |||
| // require.EqualValues(0, br.DeliverTx.Code) | |||
| // brh := br.Height | |||
| // // Fetch latest after tx commit. | |||
| // <-done | |||
| // latest, err := source.LatestFullCommit(chainID, 1, 1<<63-1) | |||
| // require.NoError(err, "%#v", err) | |||
| // rootHash := latest.SignedHeader.AppHash | |||
| // if rootHash == nil { | |||
| // // Fetch one block later, AppHash hasn't been committed yet. | |||
| // // TODO find a way to avoid doing this. | |||
| // client.WaitForHeight(cl, latest.SignedHeader.Height+1, nil) | |||
| // latest, err = source.LatestFullCommit(chainID, latest.SignedHeader.Height+1, 1<<63-1) | |||
| // require.NoError(err, "%#v", err) | |||
| // rootHash = latest.SignedHeader.AppHash | |||
| // } | |||
| // require.NotNil(rootHash) | |||
| // // verify a query before the tx block has no data (and valid non-exist proof) | |||
| // bs, height, proof, err := GetWithProof(prt, k, brh-1, cl, cert) | |||
| // require.NoError(err, "%#v", err) | |||
| // require.NotNil(proof) | |||
| // require.Equal(height, brh-1) | |||
| // // require.NotNil(proof) | |||
| // // TODO: Ensure that *some* keys will be there, ensuring that proof is nil, | |||
| // // (currently there's a race condition) | |||
| // // and ensure that proof proves absence of k. | |||
| // require.Nil(bs) | |||
| // // but given that block it is good | |||
| // bs, height, proof, err = GetWithProof(prt, k, brh, cl, cert) | |||
| // require.NoError(err, "%#v", err) | |||
| // require.NotNil(proof) | |||
| // require.Equal(height, brh) | |||
| // assert.EqualValues(v, bs) | |||
| // err = prt.VerifyValue(proof, rootHash, string(k), bs) // XXX key encoding | |||
| // assert.NoError(err, "%#v", err) | |||
| // // Test non-existing key. | |||
| // missing := []byte("my-missing-key") | |||
| // bs, _, proof, err = GetWithProof(prt, missing, 0, cl, cert) | |||
| // require.NoError(err) | |||
| // require.Nil(bs) | |||
| // require.NotNil(proof) | |||
| // err = prt.VerifyAbsence(proof, rootHash, string(missing)) // XXX VerifyAbsence(), keyencoding | |||
| // assert.NoError(err, "%#v", err) | |||
| // err = prt.VerifyAbsence(proof, rootHash, string(k)) // XXX VerifyAbsence(), keyencoding | |||
| // assert.Error(err, "%#v", err) | |||
| //} | |||
| //func TestTxProofs(t *testing.T) { | |||
| // assert, require := assert.New(t), require.New(t) | |||
| // cl := client.NewLocal(node) | |||
| // client.WaitForHeight(cl, 1, nil) | |||
| // tx := kvstoreTx([]byte("key-a"), []byte("value-a")) | |||
| // br, err := cl.BroadcastTxCommit(tx) | |||
| // require.NoError(err, "%#v", err) | |||
| // require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx) | |||
| // require.EqualValues(0, br.DeliverTx.Code) | |||
| // brh := br.Height | |||
| // source := certclient.NewProvider(chainID, cl) | |||
| // seed, err := source.LatestFullCommit(chainID, brh-2, brh-2) | |||
| // require.NoError(err, "%#v", err) | |||
| // cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators) | |||
| // // First let's make sure a bogus transaction hash returns a valid non-existence proof. | |||
| // key := types.Tx([]byte("bogus")).Hash() | |||
| // _, err = cl.Tx(key, true) | |||
| // require.NotNil(err) | |||
| // require.Contains(err.Error(), "not found") | |||
| // // Now let's check with the real tx root hash. | |||
| // key = types.Tx(tx).Hash() | |||
| // res, err := cl.Tx(key, true) | |||
| // require.NoError(err, "%#v", err) | |||
| // require.NotNil(res) | |||
| // keyHash := merkle.SimpleHashFromByteSlices([][]byte{key}) | |||
| // err = res.Proof.Validate(keyHash) | |||
| // assert.NoError(err, "%#v", err) | |||
| // commit, err := GetCertifiedCommit(br.Height, cl, cert) | |||
| // require.Nil(err, "%#v", err) | |||
| // require.Equal(res.Proof.RootHash, commit.Header.DataHash) | |||
| //} | |||
+ 780
- 0
rpc/client/mocks/client.go
View File
| @ -0,0 +1,780 @@ | |||
| // Code generated by mockery v2.3.0. DO NOT EDIT. | |||
| package mocks | |||
| import ( | |||
| bytes "github.com/tendermint/tendermint/libs/bytes" | |||
| client "github.com/tendermint/tendermint/rpc/client" | |||
| context "context" | |||
| coretypes "github.com/tendermint/tendermint/rpc/core/types" | |||
| log "github.com/tendermint/tendermint/libs/log" | |||
| mock "github.com/stretchr/testify/mock" | |||
| types "github.com/tendermint/tendermint/types" | |||
| ) | |||
| // Client is an autogenerated mock type for the Client type | |||
| type Client struct { | |||
| mock.Mock | |||
| } | |||
| // ABCIInfo provides a mock function with given fields: _a0 | |||
| func (_m *Client) ABCIInfo(_a0 context.Context) (*coretypes.ResultABCIInfo, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultABCIInfo | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultABCIInfo); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultABCIInfo) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // ABCIQuery provides a mock function with given fields: ctx, path, data | |||
| func (_m *Client) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { | |||
| ret := _m.Called(ctx, path, data) | |||
| var r0 *coretypes.ResultABCIQuery | |||
| if rf, ok := ret.Get(0).(func(context.Context, string, bytes.HexBytes) *coretypes.ResultABCIQuery); ok { | |||
| r0 = rf(ctx, path, data) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultABCIQuery) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, string, bytes.HexBytes) error); ok { | |||
| r1 = rf(ctx, path, data) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // ABCIQueryWithOptions provides a mock function with given fields: ctx, path, data, opts | |||
| func (_m *Client) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { | |||
| ret := _m.Called(ctx, path, data, opts) | |||
| var r0 *coretypes.ResultABCIQuery | |||
| if rf, ok := ret.Get(0).(func(context.Context, string, bytes.HexBytes, client.ABCIQueryOptions) *coretypes.ResultABCIQuery); ok { | |||
| r0 = rf(ctx, path, data, opts) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultABCIQuery) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, string, bytes.HexBytes, client.ABCIQueryOptions) error); ok { | |||
| r1 = rf(ctx, path, data, opts) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Block provides a mock function with given fields: ctx, height | |||
| func (_m *Client) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { | |||
| ret := _m.Called(ctx, height) | |||
| var r0 *coretypes.ResultBlock | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int64) *coretypes.ResultBlock); ok { | |||
| r0 = rf(ctx, height) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBlock) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int64) error); ok { | |||
| r1 = rf(ctx, height) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BlockByHash provides a mock function with given fields: ctx, hash | |||
| func (_m *Client) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) { | |||
| ret := _m.Called(ctx, hash) | |||
| var r0 *coretypes.ResultBlock | |||
| if rf, ok := ret.Get(0).(func(context.Context, []byte) *coretypes.ResultBlock); ok { | |||
| r0 = rf(ctx, hash) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBlock) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, []byte) error); ok { | |||
| r1 = rf(ctx, hash) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BlockResults provides a mock function with given fields: ctx, height | |||
| func (_m *Client) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { | |||
| ret := _m.Called(ctx, height) | |||
| var r0 *coretypes.ResultBlockResults | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int64) *coretypes.ResultBlockResults); ok { | |||
| r0 = rf(ctx, height) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBlockResults) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int64) error); ok { | |||
| r1 = rf(ctx, height) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BlockchainInfo provides a mock function with given fields: ctx, minHeight, maxHeight | |||
| func (_m *Client) BlockchainInfo(ctx context.Context, minHeight int64, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { | |||
| ret := _m.Called(ctx, minHeight, maxHeight) | |||
| var r0 *coretypes.ResultBlockchainInfo | |||
| if rf, ok := ret.Get(0).(func(context.Context, int64, int64) *coretypes.ResultBlockchainInfo); ok { | |||
| r0 = rf(ctx, minHeight, maxHeight) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBlockchainInfo) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, int64, int64) error); ok { | |||
| r1 = rf(ctx, minHeight, maxHeight) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BroadcastEvidence provides a mock function with given fields: _a0, _a1 | |||
| func (_m *Client) BroadcastEvidence(_a0 context.Context, _a1 types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { | |||
| ret := _m.Called(_a0, _a1) | |||
| var r0 *coretypes.ResultBroadcastEvidence | |||
| if rf, ok := ret.Get(0).(func(context.Context, types.Evidence) *coretypes.ResultBroadcastEvidence); ok { | |||
| r0 = rf(_a0, _a1) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBroadcastEvidence) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, types.Evidence) error); ok { | |||
| r1 = rf(_a0, _a1) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BroadcastTxAsync provides a mock function with given fields: _a0, _a1 | |||
| func (_m *Client) BroadcastTxAsync(_a0 context.Context, _a1 types.Tx) (*coretypes.ResultBroadcastTx, error) { | |||
| ret := _m.Called(_a0, _a1) | |||
| var r0 *coretypes.ResultBroadcastTx | |||
| if rf, ok := ret.Get(0).(func(context.Context, types.Tx) *coretypes.ResultBroadcastTx); ok { | |||
| r0 = rf(_a0, _a1) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBroadcastTx) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, types.Tx) error); ok { | |||
| r1 = rf(_a0, _a1) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BroadcastTxCommit provides a mock function with given fields: _a0, _a1 | |||
| func (_m *Client) BroadcastTxCommit(_a0 context.Context, _a1 types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { | |||
| ret := _m.Called(_a0, _a1) | |||
| var r0 *coretypes.ResultBroadcastTxCommit | |||
| if rf, ok := ret.Get(0).(func(context.Context, types.Tx) *coretypes.ResultBroadcastTxCommit); ok { | |||
| r0 = rf(_a0, _a1) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBroadcastTxCommit) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, types.Tx) error); ok { | |||
| r1 = rf(_a0, _a1) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // BroadcastTxSync provides a mock function with given fields: _a0, _a1 | |||
| func (_m *Client) BroadcastTxSync(_a0 context.Context, _a1 types.Tx) (*coretypes.ResultBroadcastTx, error) { | |||
| ret := _m.Called(_a0, _a1) | |||
| var r0 *coretypes.ResultBroadcastTx | |||
| if rf, ok := ret.Get(0).(func(context.Context, types.Tx) *coretypes.ResultBroadcastTx); ok { | |||
| r0 = rf(_a0, _a1) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultBroadcastTx) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, types.Tx) error); ok { | |||
| r1 = rf(_a0, _a1) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // CheckTx provides a mock function with given fields: _a0, _a1 | |||
| func (_m *Client) CheckTx(_a0 context.Context, _a1 types.Tx) (*coretypes.ResultCheckTx, error) { | |||
| ret := _m.Called(_a0, _a1) | |||
| var r0 *coretypes.ResultCheckTx | |||
| if rf, ok := ret.Get(0).(func(context.Context, types.Tx) *coretypes.ResultCheckTx); ok { | |||
| r0 = rf(_a0, _a1) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultCheckTx) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, types.Tx) error); ok { | |||
| r1 = rf(_a0, _a1) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Commit provides a mock function with given fields: ctx, height | |||
| func (_m *Client) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { | |||
| ret := _m.Called(ctx, height) | |||
| var r0 *coretypes.ResultCommit | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int64) *coretypes.ResultCommit); ok { | |||
| r0 = rf(ctx, height) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultCommit) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int64) error); ok { | |||
| r1 = rf(ctx, height) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // ConsensusParams provides a mock function with given fields: ctx, height | |||
| func (_m *Client) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { | |||
| ret := _m.Called(ctx, height) | |||
| var r0 *coretypes.ResultConsensusParams | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int64) *coretypes.ResultConsensusParams); ok { | |||
| r0 = rf(ctx, height) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultConsensusParams) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int64) error); ok { | |||
| r1 = rf(ctx, height) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // ConsensusState provides a mock function with given fields: _a0 | |||
| func (_m *Client) ConsensusState(_a0 context.Context) (*coretypes.ResultConsensusState, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultConsensusState | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultConsensusState); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultConsensusState) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // DumpConsensusState provides a mock function with given fields: _a0 | |||
| func (_m *Client) DumpConsensusState(_a0 context.Context) (*coretypes.ResultDumpConsensusState, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultDumpConsensusState | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultDumpConsensusState); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultDumpConsensusState) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Genesis provides a mock function with given fields: _a0 | |||
| func (_m *Client) Genesis(_a0 context.Context) (*coretypes.ResultGenesis, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultGenesis | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultGenesis); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultGenesis) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Health provides a mock function with given fields: _a0 | |||
| func (_m *Client) Health(_a0 context.Context) (*coretypes.ResultHealth, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultHealth | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultHealth); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultHealth) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // IsRunning provides a mock function with given fields: | |||
| func (_m *Client) IsRunning() bool { | |||
| ret := _m.Called() | |||
| var r0 bool | |||
| if rf, ok := ret.Get(0).(func() bool); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Get(0).(bool) | |||
| } | |||
| return r0 | |||
| } | |||
| // NetInfo provides a mock function with given fields: _a0 | |||
| func (_m *Client) NetInfo(_a0 context.Context) (*coretypes.ResultNetInfo, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultNetInfo | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultNetInfo); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultNetInfo) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // NumUnconfirmedTxs provides a mock function with given fields: _a0 | |||
| func (_m *Client) NumUnconfirmedTxs(_a0 context.Context) (*coretypes.ResultUnconfirmedTxs, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultUnconfirmedTxs | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultUnconfirmedTxs); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultUnconfirmedTxs) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // OnReset provides a mock function with given fields: | |||
| func (_m *Client) OnReset() error { | |||
| ret := _m.Called() | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func() error); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // OnStart provides a mock function with given fields: | |||
| func (_m *Client) OnStart() error { | |||
| ret := _m.Called() | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func() error); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // OnStop provides a mock function with given fields: | |||
| func (_m *Client) OnStop() { | |||
| _m.Called() | |||
| } | |||
| // Quit provides a mock function with given fields: | |||
| func (_m *Client) Quit() <-chan struct{} { | |||
| ret := _m.Called() | |||
| var r0 <-chan struct{} | |||
| if rf, ok := ret.Get(0).(func() <-chan struct{}); ok { | |||
| r0 = rf() | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(<-chan struct{}) | |||
| } | |||
| } | |||
| return r0 | |||
| } | |||
| // Reset provides a mock function with given fields: | |||
| func (_m *Client) Reset() error { | |||
| ret := _m.Called() | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func() error); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // SetLogger provides a mock function with given fields: _a0 | |||
| func (_m *Client) SetLogger(_a0 log.Logger) { | |||
| _m.Called(_a0) | |||
| } | |||
| // Start provides a mock function with given fields: | |||
| func (_m *Client) Start() error { | |||
| ret := _m.Called() | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func() error); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // Status provides a mock function with given fields: _a0 | |||
| func (_m *Client) Status(_a0 context.Context) (*coretypes.ResultStatus, error) { | |||
| ret := _m.Called(_a0) | |||
| var r0 *coretypes.ResultStatus | |||
| if rf, ok := ret.Get(0).(func(context.Context) *coretypes.ResultStatus); ok { | |||
| r0 = rf(_a0) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultStatus) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context) error); ok { | |||
| r1 = rf(_a0) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Stop provides a mock function with given fields: | |||
| func (_m *Client) Stop() error { | |||
| ret := _m.Called() | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func() error); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // String provides a mock function with given fields: | |||
| func (_m *Client) String() string { | |||
| ret := _m.Called() | |||
| var r0 string | |||
| if rf, ok := ret.Get(0).(func() string); ok { | |||
| r0 = rf() | |||
| } else { | |||
| r0 = ret.Get(0).(string) | |||
| } | |||
| return r0 | |||
| } | |||
| // Subscribe provides a mock function with given fields: ctx, subscriber, query, outCapacity | |||
| func (_m *Client) Subscribe(ctx context.Context, subscriber string, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) { | |||
| _va := make([]interface{}, len(outCapacity)) | |||
| for _i := range outCapacity { | |||
| _va[_i] = outCapacity[_i] | |||
| } | |||
| var _ca []interface{} | |||
| _ca = append(_ca, ctx, subscriber, query) | |||
| _ca = append(_ca, _va...) | |||
| ret := _m.Called(_ca...) | |||
| var r0 <-chan coretypes.ResultEvent | |||
| if rf, ok := ret.Get(0).(func(context.Context, string, string, ...int) <-chan coretypes.ResultEvent); ok { | |||
| r0 = rf(ctx, subscriber, query, outCapacity...) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(<-chan coretypes.ResultEvent) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, string, string, ...int) error); ok { | |||
| r1 = rf(ctx, subscriber, query, outCapacity...) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Tx provides a mock function with given fields: ctx, hash, prove | |||
| func (_m *Client) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { | |||
| ret := _m.Called(ctx, hash, prove) | |||
| var r0 *coretypes.ResultTx | |||
| if rf, ok := ret.Get(0).(func(context.Context, []byte, bool) *coretypes.ResultTx); ok { | |||
| r0 = rf(ctx, hash, prove) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultTx) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, []byte, bool) error); ok { | |||
| r1 = rf(ctx, hash, prove) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // TxSearch provides a mock function with given fields: ctx, query, prove, page, perPage, orderBy | |||
| func (_m *Client) TxSearch(ctx context.Context, query string, prove bool, page *int, perPage *int, orderBy string) (*coretypes.ResultTxSearch, error) { | |||
| ret := _m.Called(ctx, query, prove, page, perPage, orderBy) | |||
| var r0 *coretypes.ResultTxSearch | |||
| if rf, ok := ret.Get(0).(func(context.Context, string, bool, *int, *int, string) *coretypes.ResultTxSearch); ok { | |||
| r0 = rf(ctx, query, prove, page, perPage, orderBy) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultTxSearch) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, string, bool, *int, *int, string) error); ok { | |||
| r1 = rf(ctx, query, prove, page, perPage, orderBy) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // UnconfirmedTxs provides a mock function with given fields: ctx, limit | |||
| func (_m *Client) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { | |||
| ret := _m.Called(ctx, limit) | |||
| var r0 *coretypes.ResultUnconfirmedTxs | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int) *coretypes.ResultUnconfirmedTxs); ok { | |||
| r0 = rf(ctx, limit) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultUnconfirmedTxs) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int) error); ok { | |||
| r1 = rf(ctx, limit) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||
| // Unsubscribe provides a mock function with given fields: ctx, subscriber, query | |||
| func (_m *Client) Unsubscribe(ctx context.Context, subscriber string, query string) error { | |||
| ret := _m.Called(ctx, subscriber, query) | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { | |||
| r0 = rf(ctx, subscriber, query) | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // UnsubscribeAll provides a mock function with given fields: ctx, subscriber | |||
| func (_m *Client) UnsubscribeAll(ctx context.Context, subscriber string) error { | |||
| ret := _m.Called(ctx, subscriber) | |||
| var r0 error | |||
| if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { | |||
| r0 = rf(ctx, subscriber) | |||
| } else { | |||
| r0 = ret.Error(0) | |||
| } | |||
| return r0 | |||
| } | |||
| // Validators provides a mock function with given fields: ctx, height, page, perPage | |||
| func (_m *Client) Validators(ctx context.Context, height *int64, page *int, perPage *int) (*coretypes.ResultValidators, error) { | |||
| ret := _m.Called(ctx, height, page, perPage) | |||
| var r0 *coretypes.ResultValidators | |||
| if rf, ok := ret.Get(0).(func(context.Context, *int64, *int, *int) *coretypes.ResultValidators); ok { | |||
| r0 = rf(ctx, height, page, perPage) | |||
| } else { | |||
| if ret.Get(0) != nil { | |||
| r0 = ret.Get(0).(*coretypes.ResultValidators) | |||
| } | |||
| } | |||
| var r1 error | |||
| if rf, ok := ret.Get(1).(func(context.Context, *int64, *int, *int) error); ok { | |||
| r1 = rf(ctx, height, page, perPage) | |||
| } else { | |||
| r1 = ret.Error(1) | |||
| } | |||
| return r0, r1 | |||
| } | |||