diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index d861a9168..daec02e88 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -14,6 +14,8 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi - Apps + - [abci] [\#4704](https://github.com/tendermint/tendermint/pull/4704) Add ABCI methods `ListSnapshots`, `LoadSnapshotChunk`, `OfferSnapshot`, and `ApplySnapshotChunk` for state sync snapshots. `ABCIVersion` bumped to 0.17.0. + - P2P Protocol - Go API diff --git a/abci/client/client.go b/abci/client/client.go index 4f7c7b69a..b65ce1993 100644 --- a/abci/client/client.go +++ b/abci/client/client.go @@ -35,6 +35,10 @@ type Client interface { InitChainAsync(types.RequestInitChain) *ReqRes BeginBlockAsync(types.RequestBeginBlock) *ReqRes EndBlockAsync(types.RequestEndBlock) *ReqRes + ListSnapshotsAsync(types.RequestListSnapshots) *ReqRes + OfferSnapshotAsync(types.RequestOfferSnapshot) *ReqRes + LoadSnapshotChunkAsync(types.RequestLoadSnapshotChunk) *ReqRes + ApplySnapshotChunkAsync(types.RequestApplySnapshotChunk) *ReqRes FlushSync() error EchoSync(msg string) (*types.ResponseEcho, error) @@ -47,6 +51,10 @@ type Client interface { InitChainSync(types.RequestInitChain) (*types.ResponseInitChain, error) BeginBlockSync(types.RequestBeginBlock) (*types.ResponseBeginBlock, error) EndBlockSync(types.RequestEndBlock) (*types.ResponseEndBlock, error) + ListSnapshotsSync(types.RequestListSnapshots) (*types.ResponseListSnapshots, error) + OfferSnapshotSync(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) + LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) + ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) } //---------------------------------------- diff --git a/abci/client/grpc_client.go b/abci/client/grpc_client.go index 01583bc1f..9d8e9ca3a 100644 --- a/abci/client/grpc_client.go +++ b/abci/client/grpc_client.go @@ -223,6 +223,42 @@ func (cli *grpcClient) EndBlockAsync(params types.RequestEndBlock) *ReqRes { return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}}) } +func (cli *grpcClient) ListSnapshotsAsync(params types.RequestListSnapshots) *ReqRes { + req := types.ToRequestListSnapshots(params) + res, err := cli.client.ListSnapshots(context.Background(), req.GetListSnapshots(), grpc.WaitForReady(true)) + if err != nil { + cli.StopForError(err) + } + return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ListSnapshots{ListSnapshots: res}}) +} + +func (cli *grpcClient) OfferSnapshotAsync(params types.RequestOfferSnapshot) *ReqRes { + req := types.ToRequestOfferSnapshot(params) + res, err := cli.client.OfferSnapshot(context.Background(), req.GetOfferSnapshot(), grpc.WaitForReady(true)) + if err != nil { + cli.StopForError(err) + } + return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_OfferSnapshot{OfferSnapshot: res}}) +} + +func (cli *grpcClient) LoadSnapshotChunkAsync(params types.RequestLoadSnapshotChunk) *ReqRes { + req := types.ToRequestLoadSnapshotChunk(params) + res, err := cli.client.LoadSnapshotChunk(context.Background(), req.GetLoadSnapshotChunk(), grpc.WaitForReady(true)) + if err != nil { + cli.StopForError(err) + } + return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_LoadSnapshotChunk{LoadSnapshotChunk: res}}) +} + +func (cli *grpcClient) ApplySnapshotChunkAsync(params types.RequestApplySnapshotChunk) *ReqRes { + req := types.ToRequestApplySnapshotChunk(params) + res, err := cli.client.ApplySnapshotChunk(context.Background(), req.GetApplySnapshotChunk(), grpc.WaitForReady(true)) + if err != nil { + cli.StopForError(err) + } + return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}}) +} + func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes { reqres := NewReqRes(req) reqres.Response = res // Set response @@ -304,3 +340,25 @@ func (cli *grpcClient) EndBlockSync(params types.RequestEndBlock) (*types.Respon reqres := cli.EndBlockAsync(params) return reqres.Response.GetEndBlock(), cli.Error() } + +func (cli *grpcClient) ListSnapshotsSync(params types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { + reqres := cli.ListSnapshotsAsync(params) + return reqres.Response.GetListSnapshots(), cli.Error() +} + +func (cli *grpcClient) OfferSnapshotSync(params types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { + reqres := cli.OfferSnapshotAsync(params) + return reqres.Response.GetOfferSnapshot(), cli.Error() +} + +func (cli *grpcClient) LoadSnapshotChunkSync( + params types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { + reqres := cli.LoadSnapshotChunkAsync(params) + return reqres.Response.GetLoadSnapshotChunk(), cli.Error() +} + +func (cli *grpcClient) ApplySnapshotChunkSync( + params types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { + reqres := cli.ApplySnapshotChunkAsync(params) + return reqres.Response.GetApplySnapshotChunk(), cli.Error() +} diff --git a/abci/client/local_client.go b/abci/client/local_client.go index 3946bfbc5..ccd407d07 100644 --- a/abci/client/local_client.go +++ b/abci/client/local_client.go @@ -158,6 +158,50 @@ func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes { ) } +func (app *localClient) ListSnapshotsAsync(req types.RequestListSnapshots) *ReqRes { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.ListSnapshots(req) + return app.callback( + types.ToRequestListSnapshots(req), + types.ToResponseListSnapshots(res), + ) +} + +func (app *localClient) OfferSnapshotAsync(req types.RequestOfferSnapshot) *ReqRes { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.OfferSnapshot(req) + return app.callback( + types.ToRequestOfferSnapshot(req), + types.ToResponseOfferSnapshot(res), + ) +} + +func (app *localClient) LoadSnapshotChunkAsync(req types.RequestLoadSnapshotChunk) *ReqRes { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.LoadSnapshotChunk(req) + return app.callback( + types.ToRequestLoadSnapshotChunk(req), + types.ToResponseLoadSnapshotChunk(res), + ) +} + +func (app *localClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotChunk) *ReqRes { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.ApplySnapshotChunk(req) + return app.callback( + types.ToRequestApplySnapshotChunk(req), + types.ToResponseApplySnapshotChunk(res), + ) +} + //------------------------------------------------------- func (app *localClient) FlushSync() error { @@ -240,6 +284,40 @@ func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.Response return &res, nil } +func (app *localClient) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.ListSnapshots(req) + return &res, nil +} + +func (app *localClient) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.OfferSnapshot(req) + return &res, nil +} + +func (app *localClient) LoadSnapshotChunkSync( + req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.LoadSnapshotChunk(req) + return &res, nil +} + +func (app *localClient) ApplySnapshotChunkSync( + req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.ApplySnapshotChunk(req) + return &res, nil +} + //------------------------------------------------------- func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes { diff --git a/abci/client/socket_client.go b/abci/client/socket_client.go index 7898a8f26..6b183a189 100644 --- a/abci/client/socket_client.go +++ b/abci/client/socket_client.go @@ -266,6 +266,22 @@ func (cli *socketClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes { return cli.queueRequest(types.ToRequestEndBlock(req)) } +func (cli *socketClient) ListSnapshotsAsync(req types.RequestListSnapshots) *ReqRes { + return cli.queueRequest(types.ToRequestListSnapshots(req)) +} + +func (cli *socketClient) OfferSnapshotAsync(req types.RequestOfferSnapshot) *ReqRes { + return cli.queueRequest(types.ToRequestOfferSnapshot(req)) +} + +func (cli *socketClient) LoadSnapshotChunkAsync(req types.RequestLoadSnapshotChunk) *ReqRes { + return cli.queueRequest(types.ToRequestLoadSnapshotChunk(req)) +} + +func (cli *socketClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotChunk) *ReqRes { + return cli.queueRequest(types.ToRequestApplySnapshotChunk(req)) +} + //---------------------------------------- func (cli *socketClient) FlushSync() error { @@ -337,6 +353,32 @@ func (cli *socketClient) EndBlockSync(req types.RequestEndBlock) (*types.Respons return reqres.Response.GetEndBlock(), cli.Error() } +func (cli *socketClient) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { + reqres := cli.queueRequest(types.ToRequestListSnapshots(req)) + cli.FlushSync() + return reqres.Response.GetListSnapshots(), cli.Error() +} + +func (cli *socketClient) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { + reqres := cli.queueRequest(types.ToRequestOfferSnapshot(req)) + cli.FlushSync() + return reqres.Response.GetOfferSnapshot(), cli.Error() +} + +func (cli *socketClient) LoadSnapshotChunkSync( + req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { + reqres := cli.queueRequest(types.ToRequestLoadSnapshotChunk(req)) + cli.FlushSync() + return reqres.Response.GetLoadSnapshotChunk(), cli.Error() +} + +func (cli *socketClient) ApplySnapshotChunkSync( + req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { + reqres := cli.queueRequest(types.ToRequestApplySnapshotChunk(req)) + cli.FlushSync() + return reqres.Response.GetApplySnapshotChunk(), cli.Error() +} + //---------------------------------------- func (cli *socketClient) queueRequest(req *types.Request) *ReqRes { diff --git a/abci/example/kvstore/persistent_kvstore.go b/abci/example/kvstore/persistent_kvstore.go index fffc617be..90eb337c3 100644 --- a/abci/example/kvstore/persistent_kvstore.go +++ b/abci/example/kvstore/persistent_kvstore.go @@ -144,6 +144,26 @@ func (app *PersistentKVStoreApplication) EndBlock(req types.RequestEndBlock) typ return types.ResponseEndBlock{ValidatorUpdates: app.ValUpdates} } +func (app *PersistentKVStoreApplication) ListSnapshots( + req types.RequestListSnapshots) types.ResponseListSnapshots { + return types.ResponseListSnapshots{} +} + +func (app *PersistentKVStoreApplication) LoadSnapshotChunk( + req types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk { + return types.ResponseLoadSnapshotChunk{} +} + +func (app *PersistentKVStoreApplication) OfferSnapshot( + req types.RequestOfferSnapshot) types.ResponseOfferSnapshot { + return types.ResponseOfferSnapshot{Result: types.ResponseOfferSnapshot_abort} +} + +func (app *PersistentKVStoreApplication) ApplySnapshotChunk( + req types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk { + return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_abort} +} + //--------------------------------------------- // update validators diff --git a/abci/server/socket_server.go b/abci/server/socket_server.go index e68d79599..20090b768 100644 --- a/abci/server/socket_server.go +++ b/abci/server/socket_server.go @@ -224,6 +224,18 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types case *types.Request_EndBlock: res := s.app.EndBlock(*r.EndBlock) responses <- types.ToResponseEndBlock(res) + case *types.Request_ListSnapshots: + res := s.app.ListSnapshots(*r.ListSnapshots) + responses <- types.ToResponseListSnapshots(res) + case *types.Request_OfferSnapshot: + res := s.app.OfferSnapshot(*r.OfferSnapshot) + responses <- types.ToResponseOfferSnapshot(res) + case *types.Request_LoadSnapshotChunk: + res := s.app.LoadSnapshotChunk(*r.LoadSnapshotChunk) + responses <- types.ToResponseLoadSnapshotChunk(res) + case *types.Request_ApplySnapshotChunk: + res := s.app.ApplySnapshotChunk(*r.ApplySnapshotChunk) + responses <- types.ToResponseApplySnapshotChunk(res) default: responses <- types.ToResponseException("Unknown request") } diff --git a/abci/types/application.go b/abci/types/application.go index 9dd77c4ef..51edffbd4 100644 --- a/abci/types/application.go +++ b/abci/types/application.go @@ -23,6 +23,12 @@ type Application interface { DeliverTx(RequestDeliverTx) ResponseDeliverTx // Deliver a tx for full processing EndBlock(RequestEndBlock) ResponseEndBlock // Signals the end of a block, returns changes to the validator set Commit() ResponseCommit // Commit the state and return the application Merkle root hash + + // State Sync Connection + ListSnapshots(RequestListSnapshots) ResponseListSnapshots // List available snapshots + OfferSnapshot(RequestOfferSnapshot) ResponseOfferSnapshot // Offer a snapshot to the application + LoadSnapshotChunk(RequestLoadSnapshotChunk) ResponseLoadSnapshotChunk // Load a snapshot chunk + ApplySnapshotChunk(RequestApplySnapshotChunk) ResponseApplySnapshotChunk // Apply a shapshot chunk } //------------------------------------------------------- @@ -73,6 +79,22 @@ func (BaseApplication) EndBlock(req RequestEndBlock) ResponseEndBlock { return ResponseEndBlock{} } +func (BaseApplication) ListSnapshots(req RequestListSnapshots) ResponseListSnapshots { + return ResponseListSnapshots{} +} + +func (BaseApplication) OfferSnapshot(req RequestOfferSnapshot) ResponseOfferSnapshot { + return ResponseOfferSnapshot{} +} + +func (BaseApplication) LoadSnapshotChunk(req RequestLoadSnapshotChunk) ResponseLoadSnapshotChunk { + return ResponseLoadSnapshotChunk{} +} + +func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) ResponseApplySnapshotChunk { + return ResponseApplySnapshotChunk{} +} + //------------------------------------------------------- // GRPCApplication is a GRPC wrapper for Application @@ -136,3 +158,27 @@ func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) res := app.app.EndBlock(*req) return &res, nil } + +func (app *GRPCApplication) ListSnapshots( + ctx context.Context, req *RequestListSnapshots) (*ResponseListSnapshots, error) { + res := app.app.ListSnapshots(*req) + return &res, nil +} + +func (app *GRPCApplication) OfferSnapshot( + ctx context.Context, req *RequestOfferSnapshot) (*ResponseOfferSnapshot, error) { + res := app.app.OfferSnapshot(*req) + return &res, nil +} + +func (app *GRPCApplication) LoadSnapshotChunk( + ctx context.Context, req *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error) { + res := app.app.LoadSnapshotChunk(*req) + return &res, nil +} + +func (app *GRPCApplication) ApplySnapshotChunk( + ctx context.Context, req *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) { + res := app.app.ApplySnapshotChunk(*req) + return &res, nil +} diff --git a/abci/types/messages.go b/abci/types/messages.go index ad18727a8..531f75fed 100644 --- a/abci/types/messages.go +++ b/abci/types/messages.go @@ -135,6 +135,30 @@ func ToRequestEndBlock(req RequestEndBlock) *Request { } } +func ToRequestListSnapshots(req RequestListSnapshots) *Request { + return &Request{ + Value: &Request_ListSnapshots{&req}, + } +} + +func ToRequestOfferSnapshot(req RequestOfferSnapshot) *Request { + return &Request{ + Value: &Request_OfferSnapshot{&req}, + } +} + +func ToRequestLoadSnapshotChunk(req RequestLoadSnapshotChunk) *Request { + return &Request{ + Value: &Request_LoadSnapshotChunk{&req}, + } +} + +func ToRequestApplySnapshotChunk(req RequestApplySnapshotChunk) *Request { + return &Request{ + Value: &Request_ApplySnapshotChunk{&req}, + } +} + //---------------------------------------- func ToResponseException(errStr string) *Response { @@ -208,3 +232,27 @@ func ToResponseEndBlock(res ResponseEndBlock) *Response { Value: &Response_EndBlock{&res}, } } + +func ToResponseListSnapshots(res ResponseListSnapshots) *Response { + return &Response{ + Value: &Response_ListSnapshots{&res}, + } +} + +func ToResponseOfferSnapshot(res ResponseOfferSnapshot) *Response { + return &Response{ + Value: &Response_OfferSnapshot{&res}, + } +} + +func ToResponseLoadSnapshotChunk(res ResponseLoadSnapshotChunk) *Response { + return &Response{ + Value: &Response_LoadSnapshotChunk{&res}, + } +} + +func ToResponseApplySnapshotChunk(res ResponseApplySnapshotChunk) *Response { + return &Response{ + Value: &Response_ApplySnapshotChunk{&res}, + } +} diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index 09bf63cb7..84263943b 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -61,6 +61,74 @@ func (CheckTxType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_9f1eaa49c51fa1ac, []int{0} } +type ResponseOfferSnapshot_Result int32 + +const ( + ResponseOfferSnapshot_accept ResponseOfferSnapshot_Result = 0 + ResponseOfferSnapshot_abort ResponseOfferSnapshot_Result = 1 + ResponseOfferSnapshot_reject ResponseOfferSnapshot_Result = 2 + ResponseOfferSnapshot_reject_format ResponseOfferSnapshot_Result = 3 + ResponseOfferSnapshot_reject_sender ResponseOfferSnapshot_Result = 4 +) + +var ResponseOfferSnapshot_Result_name = map[int32]string{ + 0: "accept", + 1: "abort", + 2: "reject", + 3: "reject_format", + 4: "reject_sender", +} + +var ResponseOfferSnapshot_Result_value = map[string]int32{ + "accept": 0, + "abort": 1, + "reject": 2, + "reject_format": 3, + "reject_sender": 4, +} + +func (x ResponseOfferSnapshot_Result) String() string { + return proto.EnumName(ResponseOfferSnapshot_Result_name, int32(x)) +} + +func (ResponseOfferSnapshot_Result) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{30, 0} +} + +type ResponseApplySnapshotChunk_Result int32 + +const ( + ResponseApplySnapshotChunk_accept ResponseApplySnapshotChunk_Result = 0 + ResponseApplySnapshotChunk_abort ResponseApplySnapshotChunk_Result = 1 + ResponseApplySnapshotChunk_retry ResponseApplySnapshotChunk_Result = 2 + ResponseApplySnapshotChunk_retry_snapshot ResponseApplySnapshotChunk_Result = 3 + ResponseApplySnapshotChunk_reject_snapshot ResponseApplySnapshotChunk_Result = 4 +) + +var ResponseApplySnapshotChunk_Result_name = map[int32]string{ + 0: "accept", + 1: "abort", + 2: "retry", + 3: "retry_snapshot", + 4: "reject_snapshot", +} + +var ResponseApplySnapshotChunk_Result_value = map[string]int32{ + "accept": 0, + "abort": 1, + "retry": 2, + "retry_snapshot": 3, + "reject_snapshot": 4, +} + +func (x ResponseApplySnapshotChunk_Result) String() string { + return proto.EnumName(ResponseApplySnapshotChunk_Result_name, int32(x)) +} + +func (ResponseApplySnapshotChunk_Result) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{32, 0} +} + type Request struct { // Types that are valid to be assigned to Value: // *Request_Echo @@ -74,6 +142,10 @@ type Request struct { // *Request_DeliverTx // *Request_EndBlock // *Request_Commit + // *Request_ListSnapshots + // *Request_OfferSnapshot + // *Request_LoadSnapshotChunk + // *Request_ApplySnapshotChunk Value isRequest_Value `protobuf_oneof:"value"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -153,18 +225,34 @@ type Request_EndBlock struct { type Request_Commit struct { Commit *RequestCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"` } +type Request_ListSnapshots struct { + ListSnapshots *RequestListSnapshots `protobuf:"bytes,13,opt,name=list_snapshots,json=listSnapshots,proto3,oneof" json:"list_snapshots,omitempty"` +} +type Request_OfferSnapshot struct { + OfferSnapshot *RequestOfferSnapshot `protobuf:"bytes,14,opt,name=offer_snapshot,json=offerSnapshot,proto3,oneof" json:"offer_snapshot,omitempty"` +} +type Request_LoadSnapshotChunk struct { + LoadSnapshotChunk *RequestLoadSnapshotChunk `protobuf:"bytes,15,opt,name=load_snapshot_chunk,json=loadSnapshotChunk,proto3,oneof" json:"load_snapshot_chunk,omitempty"` +} +type Request_ApplySnapshotChunk struct { + ApplySnapshotChunk *RequestApplySnapshotChunk `protobuf:"bytes,16,opt,name=apply_snapshot_chunk,json=applySnapshotChunk,proto3,oneof" json:"apply_snapshot_chunk,omitempty"` +} -func (*Request_Echo) isRequest_Value() {} -func (*Request_Flush) isRequest_Value() {} -func (*Request_Info) isRequest_Value() {} -func (*Request_SetOption) isRequest_Value() {} -func (*Request_InitChain) isRequest_Value() {} -func (*Request_Query) isRequest_Value() {} -func (*Request_BeginBlock) isRequest_Value() {} -func (*Request_CheckTx) isRequest_Value() {} -func (*Request_DeliverTx) isRequest_Value() {} -func (*Request_EndBlock) isRequest_Value() {} -func (*Request_Commit) isRequest_Value() {} +func (*Request_Echo) isRequest_Value() {} +func (*Request_Flush) isRequest_Value() {} +func (*Request_Info) isRequest_Value() {} +func (*Request_SetOption) isRequest_Value() {} +func (*Request_InitChain) isRequest_Value() {} +func (*Request_Query) isRequest_Value() {} +func (*Request_BeginBlock) isRequest_Value() {} +func (*Request_CheckTx) isRequest_Value() {} +func (*Request_DeliverTx) isRequest_Value() {} +func (*Request_EndBlock) isRequest_Value() {} +func (*Request_Commit) isRequest_Value() {} +func (*Request_ListSnapshots) isRequest_Value() {} +func (*Request_OfferSnapshot) isRequest_Value() {} +func (*Request_LoadSnapshotChunk) isRequest_Value() {} +func (*Request_ApplySnapshotChunk) isRequest_Value() {} func (m *Request) GetValue() isRequest_Value { if m != nil { @@ -250,6 +338,34 @@ func (m *Request) GetCommit() *RequestCommit { return nil } +func (m *Request) GetListSnapshots() *RequestListSnapshots { + if x, ok := m.GetValue().(*Request_ListSnapshots); ok { + return x.ListSnapshots + } + return nil +} + +func (m *Request) GetOfferSnapshot() *RequestOfferSnapshot { + if x, ok := m.GetValue().(*Request_OfferSnapshot); ok { + return x.OfferSnapshot + } + return nil +} + +func (m *Request) GetLoadSnapshotChunk() *RequestLoadSnapshotChunk { + if x, ok := m.GetValue().(*Request_LoadSnapshotChunk); ok { + return x.LoadSnapshotChunk + } + return nil +} + +func (m *Request) GetApplySnapshotChunk() *RequestApplySnapshotChunk { + if x, ok := m.GetValue().(*Request_ApplySnapshotChunk); ok { + return x.ApplySnapshotChunk + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Request) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -264,6 +380,10 @@ func (*Request) XXX_OneofWrappers() []interface{} { (*Request_DeliverTx)(nil), (*Request_EndBlock)(nil), (*Request_Commit)(nil), + (*Request_ListSnapshots)(nil), + (*Request_OfferSnapshot)(nil), + (*Request_LoadSnapshotChunk)(nil), + (*Request_ApplySnapshotChunk)(nil), } } @@ -881,6 +1001,230 @@ func (m *RequestCommit) XXX_DiscardUnknown() { var xxx_messageInfo_RequestCommit proto.InternalMessageInfo +// lists available snapshots +type RequestListSnapshots struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RequestListSnapshots) Reset() { *m = RequestListSnapshots{} } +func (m *RequestListSnapshots) String() string { return proto.CompactTextString(m) } +func (*RequestListSnapshots) ProtoMessage() {} +func (*RequestListSnapshots) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{12} +} +func (m *RequestListSnapshots) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestListSnapshots) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestListSnapshots.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RequestListSnapshots) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestListSnapshots.Merge(m, src) +} +func (m *RequestListSnapshots) XXX_Size() int { + return m.Size() +} +func (m *RequestListSnapshots) XXX_DiscardUnknown() { + xxx_messageInfo_RequestListSnapshots.DiscardUnknown(m) +} + +var xxx_messageInfo_RequestListSnapshots proto.InternalMessageInfo + +// offers a snapshot to the application +type RequestOfferSnapshot struct { + Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"` + AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RequestOfferSnapshot) Reset() { *m = RequestOfferSnapshot{} } +func (m *RequestOfferSnapshot) String() string { return proto.CompactTextString(m) } +func (*RequestOfferSnapshot) ProtoMessage() {} +func (*RequestOfferSnapshot) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{13} +} +func (m *RequestOfferSnapshot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestOfferSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestOfferSnapshot.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RequestOfferSnapshot) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestOfferSnapshot.Merge(m, src) +} +func (m *RequestOfferSnapshot) XXX_Size() int { + return m.Size() +} +func (m *RequestOfferSnapshot) XXX_DiscardUnknown() { + xxx_messageInfo_RequestOfferSnapshot.DiscardUnknown(m) +} + +var xxx_messageInfo_RequestOfferSnapshot proto.InternalMessageInfo + +func (m *RequestOfferSnapshot) GetSnapshot() *Snapshot { + if m != nil { + return m.Snapshot + } + return nil +} + +func (m *RequestOfferSnapshot) GetAppHash() []byte { + if m != nil { + return m.AppHash + } + return nil +} + +// loads a snapshot chunk +type RequestLoadSnapshotChunk struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + Format uint32 `protobuf:"varint,2,opt,name=format,proto3" json:"format,omitempty"` + Chunk uint32 `protobuf:"varint,3,opt,name=chunk,proto3" json:"chunk,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RequestLoadSnapshotChunk) Reset() { *m = RequestLoadSnapshotChunk{} } +func (m *RequestLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } +func (*RequestLoadSnapshotChunk) ProtoMessage() {} +func (*RequestLoadSnapshotChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{14} +} +func (m *RequestLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestLoadSnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestLoadSnapshotChunk.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RequestLoadSnapshotChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestLoadSnapshotChunk.Merge(m, src) +} +func (m *RequestLoadSnapshotChunk) XXX_Size() int { + return m.Size() +} +func (m *RequestLoadSnapshotChunk) XXX_DiscardUnknown() { + xxx_messageInfo_RequestLoadSnapshotChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_RequestLoadSnapshotChunk proto.InternalMessageInfo + +func (m *RequestLoadSnapshotChunk) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *RequestLoadSnapshotChunk) GetFormat() uint32 { + if m != nil { + return m.Format + } + return 0 +} + +func (m *RequestLoadSnapshotChunk) GetChunk() uint32 { + if m != nil { + return m.Chunk + } + return 0 +} + +// Applies a snapshot chunk +type RequestApplySnapshotChunk struct { + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + Chunk []byte `protobuf:"bytes,2,opt,name=chunk,proto3" json:"chunk,omitempty"` + Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RequestApplySnapshotChunk) Reset() { *m = RequestApplySnapshotChunk{} } +func (m *RequestApplySnapshotChunk) String() string { return proto.CompactTextString(m) } +func (*RequestApplySnapshotChunk) ProtoMessage() {} +func (*RequestApplySnapshotChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{15} +} +func (m *RequestApplySnapshotChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestApplySnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestApplySnapshotChunk.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RequestApplySnapshotChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestApplySnapshotChunk.Merge(m, src) +} +func (m *RequestApplySnapshotChunk) XXX_Size() int { + return m.Size() +} +func (m *RequestApplySnapshotChunk) XXX_DiscardUnknown() { + xxx_messageInfo_RequestApplySnapshotChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_RequestApplySnapshotChunk proto.InternalMessageInfo + +func (m *RequestApplySnapshotChunk) GetIndex() uint32 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *RequestApplySnapshotChunk) GetChunk() []byte { + if m != nil { + return m.Chunk + } + return nil +} + +func (m *RequestApplySnapshotChunk) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + type Response struct { // Types that are valid to be assigned to Value: // *Response_Exception @@ -895,6 +1239,10 @@ type Response struct { // *Response_DeliverTx // *Response_EndBlock // *Response_Commit + // *Response_ListSnapshots + // *Response_OfferSnapshot + // *Response_LoadSnapshotChunk + // *Response_ApplySnapshotChunk Value isResponse_Value `protobuf_oneof:"value"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -905,7 +1253,7 @@ func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{12} + return fileDescriptor_9f1eaa49c51fa1ac, []int{16} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -977,19 +1325,35 @@ type Response_EndBlock struct { type Response_Commit struct { Commit *ResponseCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"` } +type Response_ListSnapshots struct { + ListSnapshots *ResponseListSnapshots `protobuf:"bytes,13,opt,name=list_snapshots,json=listSnapshots,proto3,oneof" json:"list_snapshots,omitempty"` +} +type Response_OfferSnapshot struct { + OfferSnapshot *ResponseOfferSnapshot `protobuf:"bytes,14,opt,name=offer_snapshot,json=offerSnapshot,proto3,oneof" json:"offer_snapshot,omitempty"` +} +type Response_LoadSnapshotChunk struct { + LoadSnapshotChunk *ResponseLoadSnapshotChunk `protobuf:"bytes,15,opt,name=load_snapshot_chunk,json=loadSnapshotChunk,proto3,oneof" json:"load_snapshot_chunk,omitempty"` +} +type Response_ApplySnapshotChunk struct { + ApplySnapshotChunk *ResponseApplySnapshotChunk `protobuf:"bytes,16,opt,name=apply_snapshot_chunk,json=applySnapshotChunk,proto3,oneof" json:"apply_snapshot_chunk,omitempty"` +} -func (*Response_Exception) isResponse_Value() {} -func (*Response_Echo) isResponse_Value() {} -func (*Response_Flush) isResponse_Value() {} -func (*Response_Info) isResponse_Value() {} -func (*Response_SetOption) isResponse_Value() {} -func (*Response_InitChain) isResponse_Value() {} -func (*Response_Query) isResponse_Value() {} -func (*Response_BeginBlock) isResponse_Value() {} -func (*Response_CheckTx) isResponse_Value() {} -func (*Response_DeliverTx) isResponse_Value() {} -func (*Response_EndBlock) isResponse_Value() {} -func (*Response_Commit) isResponse_Value() {} +func (*Response_Exception) isResponse_Value() {} +func (*Response_Echo) isResponse_Value() {} +func (*Response_Flush) isResponse_Value() {} +func (*Response_Info) isResponse_Value() {} +func (*Response_SetOption) isResponse_Value() {} +func (*Response_InitChain) isResponse_Value() {} +func (*Response_Query) isResponse_Value() {} +func (*Response_BeginBlock) isResponse_Value() {} +func (*Response_CheckTx) isResponse_Value() {} +func (*Response_DeliverTx) isResponse_Value() {} +func (*Response_EndBlock) isResponse_Value() {} +func (*Response_Commit) isResponse_Value() {} +func (*Response_ListSnapshots) isResponse_Value() {} +func (*Response_OfferSnapshot) isResponse_Value() {} +func (*Response_LoadSnapshotChunk) isResponse_Value() {} +func (*Response_ApplySnapshotChunk) isResponse_Value() {} func (m *Response) GetValue() isResponse_Value { if m != nil { @@ -1082,6 +1446,34 @@ func (m *Response) GetCommit() *ResponseCommit { return nil } +func (m *Response) GetListSnapshots() *ResponseListSnapshots { + if x, ok := m.GetValue().(*Response_ListSnapshots); ok { + return x.ListSnapshots + } + return nil +} + +func (m *Response) GetOfferSnapshot() *ResponseOfferSnapshot { + if x, ok := m.GetValue().(*Response_OfferSnapshot); ok { + return x.OfferSnapshot + } + return nil +} + +func (m *Response) GetLoadSnapshotChunk() *ResponseLoadSnapshotChunk { + if x, ok := m.GetValue().(*Response_LoadSnapshotChunk); ok { + return x.LoadSnapshotChunk + } + return nil +} + +func (m *Response) GetApplySnapshotChunk() *ResponseApplySnapshotChunk { + if x, ok := m.GetValue().(*Response_ApplySnapshotChunk); ok { + return x.ApplySnapshotChunk + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Response) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -1097,6 +1489,10 @@ func (*Response) XXX_OneofWrappers() []interface{} { (*Response_DeliverTx)(nil), (*Response_EndBlock)(nil), (*Response_Commit)(nil), + (*Response_ListSnapshots)(nil), + (*Response_OfferSnapshot)(nil), + (*Response_LoadSnapshotChunk)(nil), + (*Response_ApplySnapshotChunk)(nil), } } @@ -1112,7 +1508,7 @@ func (m *ResponseException) Reset() { *m = ResponseException{} } func (m *ResponseException) String() string { return proto.CompactTextString(m) } func (*ResponseException) ProtoMessage() {} func (*ResponseException) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{13} + return fileDescriptor_9f1eaa49c51fa1ac, []int{17} } func (m *ResponseException) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1159,7 +1555,7 @@ func (m *ResponseEcho) Reset() { *m = ResponseEcho{} } func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } func (*ResponseEcho) ProtoMessage() {} func (*ResponseEcho) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{14} + return fileDescriptor_9f1eaa49c51fa1ac, []int{18} } func (m *ResponseEcho) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1205,7 +1601,7 @@ func (m *ResponseFlush) Reset() { *m = ResponseFlush{} } func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } func (*ResponseFlush) ProtoMessage() {} func (*ResponseFlush) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{15} + return fileDescriptor_9f1eaa49c51fa1ac, []int{19} } func (m *ResponseFlush) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1249,7 +1645,7 @@ func (m *ResponseInfo) Reset() { *m = ResponseInfo{} } func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } func (*ResponseInfo) ProtoMessage() {} func (*ResponseInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{16} + return fileDescriptor_9f1eaa49c51fa1ac, []int{20} } func (m *ResponseInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1328,7 +1724,7 @@ func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} } func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) } func (*ResponseSetOption) ProtoMessage() {} func (*ResponseSetOption) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{17} + return fileDescriptor_9f1eaa49c51fa1ac, []int{21} } func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1390,7 +1786,7 @@ func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} } func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } func (*ResponseInitChain) ProtoMessage() {} func (*ResponseInitChain) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{18} + return fileDescriptor_9f1eaa49c51fa1ac, []int{22} } func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1453,7 +1849,7 @@ func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } func (*ResponseQuery) ProtoMessage() {} func (*ResponseQuery) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{19} + return fileDescriptor_9f1eaa49c51fa1ac, []int{23} } func (m *ResponseQuery) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1556,7 +1952,7 @@ func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} } func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } func (*ResponseBeginBlock) ProtoMessage() {} func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{20} + return fileDescriptor_9f1eaa49c51fa1ac, []int{24} } func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1610,7 +2006,7 @@ func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } func (*ResponseCheckTx) ProtoMessage() {} func (*ResponseCheckTx) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{21} + return fileDescriptor_9f1eaa49c51fa1ac, []int{25} } func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1713,7 +2109,7 @@ func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } func (*ResponseDeliverTx) ProtoMessage() {} func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{22} + return fileDescriptor_9f1eaa49c51fa1ac, []int{26} } func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1811,7 +2207,7 @@ func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} } func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } func (*ResponseEndBlock) ProtoMessage() {} func (*ResponseEndBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{23} + return fileDescriptor_9f1eaa49c51fa1ac, []int{27} } func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1874,7 +2270,7 @@ func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } func (*ResponseCommit) ProtoMessage() {} func (*ResponseCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{24} + return fileDescriptor_9f1eaa49c51fa1ac, []int{28} } func (m *ResponseCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1917,29 +2313,25 @@ func (m *ResponseCommit) GetRetainHeight() int64 { return 0 } -// ConsensusParams contains all consensus-relevant parameters -// that can be adjusted by the abci app -type ConsensusParams struct { - Block *BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` - Evidence *EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"` - Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type ResponseListSnapshots struct { + Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots,proto3" json:"snapshots,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *ConsensusParams) Reset() { *m = ConsensusParams{} } -func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } -func (*ConsensusParams) ProtoMessage() {} -func (*ConsensusParams) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{25} +func (m *ResponseListSnapshots) Reset() { *m = ResponseListSnapshots{} } +func (m *ResponseListSnapshots) String() string { return proto.CompactTextString(m) } +func (*ResponseListSnapshots) ProtoMessage() {} +func (*ResponseListSnapshots) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{29} } -func (m *ConsensusParams) XXX_Unmarshal(b []byte) error { +func (m *ResponseListSnapshots) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ResponseListSnapshots) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ConsensusParams.Marshal(b, m, deterministic) + return xxx_messageInfo_ResponseListSnapshots.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1949,8 +2341,216 @@ func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return b[:n], nil } } -func (m *ConsensusParams) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConsensusParams.Merge(m, src) +func (m *ResponseListSnapshots) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseListSnapshots.Merge(m, src) +} +func (m *ResponseListSnapshots) XXX_Size() int { + return m.Size() +} +func (m *ResponseListSnapshots) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseListSnapshots.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseListSnapshots proto.InternalMessageInfo + +func (m *ResponseListSnapshots) GetSnapshots() []*Snapshot { + if m != nil { + return m.Snapshots + } + return nil +} + +type ResponseOfferSnapshot struct { + Result ResponseOfferSnapshot_Result `protobuf:"varint,1,opt,name=result,proto3,enum=tendermint.abci.types.ResponseOfferSnapshot_Result" json:"result,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResponseOfferSnapshot) Reset() { *m = ResponseOfferSnapshot{} } +func (m *ResponseOfferSnapshot) String() string { return proto.CompactTextString(m) } +func (*ResponseOfferSnapshot) ProtoMessage() {} +func (*ResponseOfferSnapshot) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{30} +} +func (m *ResponseOfferSnapshot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseOfferSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResponseOfferSnapshot.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResponseOfferSnapshot) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseOfferSnapshot.Merge(m, src) +} +func (m *ResponseOfferSnapshot) XXX_Size() int { + return m.Size() +} +func (m *ResponseOfferSnapshot) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseOfferSnapshot.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseOfferSnapshot proto.InternalMessageInfo + +func (m *ResponseOfferSnapshot) GetResult() ResponseOfferSnapshot_Result { + if m != nil { + return m.Result + } + return ResponseOfferSnapshot_accept +} + +type ResponseLoadSnapshotChunk struct { + Chunk []byte `protobuf:"bytes,1,opt,name=chunk,proto3" json:"chunk,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResponseLoadSnapshotChunk) Reset() { *m = ResponseLoadSnapshotChunk{} } +func (m *ResponseLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } +func (*ResponseLoadSnapshotChunk) ProtoMessage() {} +func (*ResponseLoadSnapshotChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{31} +} +func (m *ResponseLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseLoadSnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResponseLoadSnapshotChunk.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResponseLoadSnapshotChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseLoadSnapshotChunk.Merge(m, src) +} +func (m *ResponseLoadSnapshotChunk) XXX_Size() int { + return m.Size() +} +func (m *ResponseLoadSnapshotChunk) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseLoadSnapshotChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseLoadSnapshotChunk proto.InternalMessageInfo + +func (m *ResponseLoadSnapshotChunk) GetChunk() []byte { + if m != nil { + return m.Chunk + } + return nil +} + +type ResponseApplySnapshotChunk struct { + Result ResponseApplySnapshotChunk_Result `protobuf:"varint,1,opt,name=result,proto3,enum=tendermint.abci.types.ResponseApplySnapshotChunk_Result" json:"result,omitempty"` + RefetchChunks []uint32 `protobuf:"varint,2,rep,packed,name=refetch_chunks,json=refetchChunks,proto3" json:"refetch_chunks,omitempty"` + RejectSenders []string `protobuf:"bytes,3,rep,name=reject_senders,json=rejectSenders,proto3" json:"reject_senders,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResponseApplySnapshotChunk) Reset() { *m = ResponseApplySnapshotChunk{} } +func (m *ResponseApplySnapshotChunk) String() string { return proto.CompactTextString(m) } +func (*ResponseApplySnapshotChunk) ProtoMessage() {} +func (*ResponseApplySnapshotChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{32} +} +func (m *ResponseApplySnapshotChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseApplySnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResponseApplySnapshotChunk.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResponseApplySnapshotChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseApplySnapshotChunk.Merge(m, src) +} +func (m *ResponseApplySnapshotChunk) XXX_Size() int { + return m.Size() +} +func (m *ResponseApplySnapshotChunk) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseApplySnapshotChunk.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseApplySnapshotChunk proto.InternalMessageInfo + +func (m *ResponseApplySnapshotChunk) GetResult() ResponseApplySnapshotChunk_Result { + if m != nil { + return m.Result + } + return ResponseApplySnapshotChunk_accept +} + +func (m *ResponseApplySnapshotChunk) GetRefetchChunks() []uint32 { + if m != nil { + return m.RefetchChunks + } + return nil +} + +func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string { + if m != nil { + return m.RejectSenders + } + return nil +} + +// ConsensusParams contains all consensus-relevant parameters +// that can be adjusted by the abci app +type ConsensusParams struct { + Block *BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` + Evidence *EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"` + Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConsensusParams) Reset() { *m = ConsensusParams{} } +func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } +func (*ConsensusParams) ProtoMessage() {} +func (*ConsensusParams) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{33} +} +func (m *ConsensusParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConsensusParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ConsensusParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConsensusParams.Merge(m, src) } func (m *ConsensusParams) XXX_Size() int { return m.Size() @@ -1997,7 +2597,7 @@ func (m *BlockParams) Reset() { *m = BlockParams{} } func (m *BlockParams) String() string { return proto.CompactTextString(m) } func (*BlockParams) ProtoMessage() {} func (*BlockParams) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{26} + return fileDescriptor_9f1eaa49c51fa1ac, []int{34} } func (m *BlockParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2053,7 +2653,7 @@ func (m *EvidenceParams) Reset() { *m = EvidenceParams{} } func (m *EvidenceParams) String() string { return proto.CompactTextString(m) } func (*EvidenceParams) ProtoMessage() {} func (*EvidenceParams) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{27} + return fileDescriptor_9f1eaa49c51fa1ac, []int{35} } func (m *EvidenceParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2108,7 +2708,7 @@ func (m *ValidatorParams) Reset() { *m = ValidatorParams{} } func (m *ValidatorParams) String() string { return proto.CompactTextString(m) } func (*ValidatorParams) ProtoMessage() {} func (*ValidatorParams) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{28} + return fileDescriptor_9f1eaa49c51fa1ac, []int{36} } func (m *ValidatorParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2156,7 +2756,7 @@ func (m *LastCommitInfo) Reset() { *m = LastCommitInfo{} } func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) } func (*LastCommitInfo) ProtoMessage() {} func (*LastCommitInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{29} + return fileDescriptor_9f1eaa49c51fa1ac, []int{37} } func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2213,7 +2813,7 @@ func (m *EventAttribute) Reset() { *m = EventAttribute{} } func (m *EventAttribute) String() string { return proto.CompactTextString(m) } func (*EventAttribute) ProtoMessage() {} func (*EventAttribute) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{30} + return fileDescriptor_9f1eaa49c51fa1ac, []int{38} } func (m *EventAttribute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2275,7 +2875,7 @@ func (m *Event) Reset() { *m = Event{} } func (m *Event) String() string { return proto.CompactTextString(m) } func (*Event) ProtoMessage() {} func (*Event) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{31} + return fileDescriptor_9f1eaa49c51fa1ac, []int{39} } func (m *Event) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2347,7 +2947,7 @@ func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{32} + return fileDescriptor_9f1eaa49c51fa1ac, []int{40} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2486,7 +3086,7 @@ func (m *Version) Reset() { *m = Version{} } func (m *Version) String() string { return proto.CompactTextString(m) } func (*Version) ProtoMessage() {} func (*Version) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{33} + return fileDescriptor_9f1eaa49c51fa1ac, []int{41} } func (m *Version) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2541,7 +3141,7 @@ func (m *BlockID) Reset() { *m = BlockID{} } func (m *BlockID) String() string { return proto.CompactTextString(m) } func (*BlockID) ProtoMessage() {} func (*BlockID) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{34} + return fileDescriptor_9f1eaa49c51fa1ac, []int{42} } func (m *BlockID) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2596,7 +3196,7 @@ func (m *PartSetHeader) Reset() { *m = PartSetHeader{} } func (m *PartSetHeader) String() string { return proto.CompactTextString(m) } func (*PartSetHeader) ProtoMessage() {} func (*PartSetHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{35} + return fileDescriptor_9f1eaa49c51fa1ac, []int{43} } func (m *PartSetHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2653,7 +3253,7 @@ func (m *Validator) Reset() { *m = Validator{} } func (m *Validator) String() string { return proto.CompactTextString(m) } func (*Validator) ProtoMessage() {} func (*Validator) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{36} + return fileDescriptor_9f1eaa49c51fa1ac, []int{44} } func (m *Validator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2709,7 +3309,7 @@ func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} } func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) } func (*ValidatorUpdate) ProtoMessage() {} func (*ValidatorUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{37} + return fileDescriptor_9f1eaa49c51fa1ac, []int{45} } func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2765,7 +3365,7 @@ func (m *VoteInfo) Reset() { *m = VoteInfo{} } func (m *VoteInfo) String() string { return proto.CompactTextString(m) } func (*VoteInfo) ProtoMessage() {} func (*VoteInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{38} + return fileDescriptor_9f1eaa49c51fa1ac, []int{46} } func (m *VoteInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2820,7 +3420,7 @@ func (m *PubKey) Reset() { *m = PubKey{} } func (m *PubKey) String() string { return proto.CompactTextString(m) } func (*PubKey) ProtoMessage() {} func (*PubKey) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{39} + return fileDescriptor_9f1eaa49c51fa1ac, []int{47} } func (m *PubKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2878,7 +3478,7 @@ func (m *Evidence) Reset() { *m = Evidence{} } func (m *Evidence) String() string { return proto.CompactTextString(m) } func (*Evidence) ProtoMessage() {} func (*Evidence) Descriptor() ([]byte, []int) { - return fileDescriptor_9f1eaa49c51fa1ac, []int{40} + return fileDescriptor_9f1eaa49c51fa1ac, []int{48} } func (m *Evidence) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2942,9 +3542,92 @@ func (m *Evidence) GetTotalVotingPower() int64 { return 0 } +type Snapshot struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + Format uint32 `protobuf:"varint,2,opt,name=format,proto3" json:"format,omitempty"` + Chunks uint32 `protobuf:"varint,3,opt,name=chunks,proto3" json:"chunks,omitempty"` + Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` + Metadata []byte `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Snapshot) Reset() { *m = Snapshot{} } +func (m *Snapshot) String() string { return proto.CompactTextString(m) } +func (*Snapshot) ProtoMessage() {} +func (*Snapshot) Descriptor() ([]byte, []int) { + return fileDescriptor_9f1eaa49c51fa1ac, []int{49} +} +func (m *Snapshot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Snapshot) XXX_Merge(src proto.Message) { + xxx_messageInfo_Snapshot.Merge(m, src) +} +func (m *Snapshot) XXX_Size() int { + return m.Size() +} +func (m *Snapshot) XXX_DiscardUnknown() { + xxx_messageInfo_Snapshot.DiscardUnknown(m) +} + +var xxx_messageInfo_Snapshot proto.InternalMessageInfo + +func (m *Snapshot) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *Snapshot) GetFormat() uint32 { + if m != nil { + return m.Format + } + return 0 +} + +func (m *Snapshot) GetChunks() uint32 { + if m != nil { + return m.Chunks + } + return 0 +} + +func (m *Snapshot) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +func (m *Snapshot) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + func init() { proto.RegisterEnum("tendermint.abci.types.CheckTxType", CheckTxType_name, CheckTxType_value) golang_proto.RegisterEnum("tendermint.abci.types.CheckTxType", CheckTxType_name, CheckTxType_value) + proto.RegisterEnum("tendermint.abci.types.ResponseOfferSnapshot_Result", ResponseOfferSnapshot_Result_name, ResponseOfferSnapshot_Result_value) + golang_proto.RegisterEnum("tendermint.abci.types.ResponseOfferSnapshot_Result", ResponseOfferSnapshot_Result_name, ResponseOfferSnapshot_Result_value) + proto.RegisterEnum("tendermint.abci.types.ResponseApplySnapshotChunk_Result", ResponseApplySnapshotChunk_Result_name, ResponseApplySnapshotChunk_Result_value) + golang_proto.RegisterEnum("tendermint.abci.types.ResponseApplySnapshotChunk_Result", ResponseApplySnapshotChunk_Result_name, ResponseApplySnapshotChunk_Result_value) proto.RegisterType((*Request)(nil), "tendermint.abci.types.Request") golang_proto.RegisterType((*Request)(nil), "tendermint.abci.types.Request") proto.RegisterType((*RequestEcho)(nil), "tendermint.abci.types.RequestEcho") @@ -2969,6 +3652,14 @@ func init() { golang_proto.RegisterType((*RequestEndBlock)(nil), "tendermint.abci.types.RequestEndBlock") proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.types.RequestCommit") golang_proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.types.RequestCommit") + proto.RegisterType((*RequestListSnapshots)(nil), "tendermint.abci.types.RequestListSnapshots") + golang_proto.RegisterType((*RequestListSnapshots)(nil), "tendermint.abci.types.RequestListSnapshots") + proto.RegisterType((*RequestOfferSnapshot)(nil), "tendermint.abci.types.RequestOfferSnapshot") + golang_proto.RegisterType((*RequestOfferSnapshot)(nil), "tendermint.abci.types.RequestOfferSnapshot") + proto.RegisterType((*RequestLoadSnapshotChunk)(nil), "tendermint.abci.types.RequestLoadSnapshotChunk") + golang_proto.RegisterType((*RequestLoadSnapshotChunk)(nil), "tendermint.abci.types.RequestLoadSnapshotChunk") + proto.RegisterType((*RequestApplySnapshotChunk)(nil), "tendermint.abci.types.RequestApplySnapshotChunk") + golang_proto.RegisterType((*RequestApplySnapshotChunk)(nil), "tendermint.abci.types.RequestApplySnapshotChunk") proto.RegisterType((*Response)(nil), "tendermint.abci.types.Response") golang_proto.RegisterType((*Response)(nil), "tendermint.abci.types.Response") proto.RegisterType((*ResponseException)(nil), "tendermint.abci.types.ResponseException") @@ -2995,6 +3686,14 @@ func init() { golang_proto.RegisterType((*ResponseEndBlock)(nil), "tendermint.abci.types.ResponseEndBlock") proto.RegisterType((*ResponseCommit)(nil), "tendermint.abci.types.ResponseCommit") golang_proto.RegisterType((*ResponseCommit)(nil), "tendermint.abci.types.ResponseCommit") + proto.RegisterType((*ResponseListSnapshots)(nil), "tendermint.abci.types.ResponseListSnapshots") + golang_proto.RegisterType((*ResponseListSnapshots)(nil), "tendermint.abci.types.ResponseListSnapshots") + proto.RegisterType((*ResponseOfferSnapshot)(nil), "tendermint.abci.types.ResponseOfferSnapshot") + golang_proto.RegisterType((*ResponseOfferSnapshot)(nil), "tendermint.abci.types.ResponseOfferSnapshot") + proto.RegisterType((*ResponseLoadSnapshotChunk)(nil), "tendermint.abci.types.ResponseLoadSnapshotChunk") + golang_proto.RegisterType((*ResponseLoadSnapshotChunk)(nil), "tendermint.abci.types.ResponseLoadSnapshotChunk") + proto.RegisterType((*ResponseApplySnapshotChunk)(nil), "tendermint.abci.types.ResponseApplySnapshotChunk") + golang_proto.RegisterType((*ResponseApplySnapshotChunk)(nil), "tendermint.abci.types.ResponseApplySnapshotChunk") proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.types.ConsensusParams") golang_proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.types.ConsensusParams") proto.RegisterType((*BlockParams)(nil), "tendermint.abci.types.BlockParams") @@ -3027,163 +3726,198 @@ func init() { golang_proto.RegisterType((*PubKey)(nil), "tendermint.abci.types.PubKey") proto.RegisterType((*Evidence)(nil), "tendermint.abci.types.Evidence") golang_proto.RegisterType((*Evidence)(nil), "tendermint.abci.types.Evidence") + proto.RegisterType((*Snapshot)(nil), "tendermint.abci.types.Snapshot") + golang_proto.RegisterType((*Snapshot)(nil), "tendermint.abci.types.Snapshot") } func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) } func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) } var fileDescriptor_9f1eaa49c51fa1ac = []byte{ - // 2397 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x3d, 0x8c, 0x1b, 0xc7, - 0xf5, 0xbf, 0x25, 0x79, 0xfc, 0x78, 0xbc, 0x3b, 0xd2, 0x63, 0xd9, 0xa6, 0xf8, 0x97, 0xef, 0x84, - 0x3d, 0x4b, 0x3a, 0xd9, 0xfe, 0xdf, 0x39, 0x17, 0x38, 0xb0, 0x22, 0xc1, 0xc1, 0xf1, 0x24, 0x87, - 0x84, 0x25, 0x59, 0x5e, 0x7d, 0x44, 0x49, 0x00, 0x2f, 0x86, 0xdc, 0x11, 0xb9, 0x10, 0xb9, 0xbb, - 0xde, 0x1d, 0x9e, 0xc8, 0x20, 0x45, 0xba, 0x20, 0x40, 0x8a, 0x34, 0x01, 0xd2, 0xa4, 0x4f, 0x99, - 0x22, 0x85, 0xcb, 0x94, 0x2e, 0x52, 0xa4, 0x48, 0xad, 0x24, 0x97, 0x54, 0x81, 0xcb, 0x20, 0x48, - 0x19, 0xcc, 0x9b, 0xd9, 0x2f, 0x1e, 0x3f, 0x56, 0x8e, 0xba, 0x34, 0xe4, 0xce, 0xcc, 0x7b, 0x6f, - 0x66, 0xde, 0xcc, 0x7b, 0xbf, 0xf7, 0xde, 0xc0, 0xeb, 0xb4, 0xdb, 0xb3, 0x0f, 0xf8, 0xd4, 0x63, - 0x81, 0xfc, 0xdd, 0xf7, 0x7c, 0x97, 0xbb, 0xe4, 0x35, 0xce, 0x1c, 0x8b, 0xf9, 0x23, 0xdb, 0xe1, - 0xfb, 0x82, 0x64, 0x1f, 0x07, 0x9b, 0x97, 0xf9, 0xc0, 0xf6, 0x2d, 0xd3, 0xa3, 0x3e, 0x9f, 0x1e, - 0x20, 0xe5, 0x41, 0xdf, 0xed, 0xbb, 0xf1, 0x97, 0x64, 0x6f, 0x36, 0x7b, 0xfe, 0xd4, 0xe3, 0xee, - 0xc1, 0x88, 0xf9, 0x4f, 0x87, 0x4c, 0xfd, 0xa9, 0xb1, 0x9d, 0xbe, 0xeb, 0xf6, 0x87, 0x4c, 0xb2, - 0x77, 0xc7, 0x4f, 0x0e, 0xb8, 0x3d, 0x62, 0x01, 0xa7, 0x23, 0x4f, 0x11, 0x6c, 0xcf, 0x12, 0x58, - 0x63, 0x9f, 0x72, 0xdb, 0x75, 0xe4, 0xb8, 0xfe, 0xaf, 0x75, 0x28, 0x19, 0xec, 0xf3, 0x31, 0x0b, - 0x38, 0xf9, 0x00, 0x0a, 0xac, 0x37, 0x70, 0x1b, 0xb9, 0x8b, 0xda, 0x5e, 0xf5, 0x50, 0xdf, 0x9f, - 0xbb, 0xec, 0x7d, 0x45, 0x7d, 0xab, 0x37, 0x70, 0xdb, 0x6b, 0x06, 0x72, 0x90, 0xeb, 0xb0, 0xfe, - 0x64, 0x38, 0x0e, 0x06, 0x8d, 0x3c, 0xb2, 0xee, 0x2e, 0x67, 0xfd, 0x48, 0x90, 0xb6, 0xd7, 0x0c, - 0xc9, 0x23, 0xa6, 0xb5, 0x9d, 0x27, 0x6e, 0xa3, 0x90, 0x65, 0xda, 0x8e, 0xf3, 0x04, 0xa7, 0x15, - 0x1c, 0xa4, 0x0d, 0x10, 0x30, 0x6e, 0xba, 0x9e, 0xd8, 0x50, 0x63, 0x1d, 0xf9, 0xaf, 0x2c, 0xe7, - 0xbf, 0xcf, 0xf8, 0x27, 0x48, 0xde, 0x5e, 0x33, 0x2a, 0x41, 0xd8, 0x10, 0x92, 0x6c, 0xc7, 0xe6, - 0x66, 0x6f, 0x40, 0x6d, 0xa7, 0x51, 0xcc, 0x22, 0xa9, 0xe3, 0xd8, 0xfc, 0x58, 0x90, 0x0b, 0x49, - 0x76, 0xd8, 0x10, 0xaa, 0xf8, 0x7c, 0xcc, 0xfc, 0x69, 0xa3, 0x94, 0x45, 0x15, 0x9f, 0x0a, 0x52, - 0xa1, 0x0a, 0xe4, 0x21, 0x1f, 0x43, 0xb5, 0xcb, 0xfa, 0xb6, 0x63, 0x76, 0x87, 0x6e, 0xef, 0x69, - 0xa3, 0x8c, 0x22, 0xf6, 0x96, 0x8b, 0x68, 0x09, 0x86, 0x96, 0xa0, 0x6f, 0xaf, 0x19, 0xd0, 0x8d, - 0x5a, 0xa4, 0x05, 0xe5, 0xde, 0x80, 0xf5, 0x9e, 0x9a, 0x7c, 0xd2, 0xa8, 0xa0, 0xa4, 0x4b, 0xcb, - 0x25, 0x1d, 0x0b, 0xea, 0x07, 0x93, 0xf6, 0x9a, 0x51, 0xea, 0xc9, 0x4f, 0xa1, 0x17, 0x8b, 0x0d, - 0xed, 0x13, 0xe6, 0x0b, 0x29, 0xaf, 0x66, 0xd1, 0xcb, 0x4d, 0x49, 0x8f, 0x72, 0x2a, 0x56, 0xd8, - 0x20, 0xb7, 0xa0, 0xc2, 0x1c, 0x4b, 0x6d, 0xac, 0x8a, 0x82, 0x2e, 0xaf, 0xb8, 0x61, 0x8e, 0x15, - 0x6e, 0xab, 0xcc, 0xd4, 0x37, 0xf9, 0x10, 0x8a, 0x3d, 0x77, 0x34, 0xb2, 0x79, 0x63, 0x03, 0x65, - 0xbc, 0xb5, 0x62, 0x4b, 0x48, 0xdb, 0x5e, 0x33, 0x14, 0x57, 0xab, 0x04, 0xeb, 0x27, 0x74, 0x38, - 0x66, 0xfa, 0x15, 0xa8, 0x26, 0x6e, 0x32, 0x69, 0x40, 0x69, 0xc4, 0x82, 0x80, 0xf6, 0x59, 0x43, - 0xbb, 0xa8, 0xed, 0x55, 0x8c, 0xb0, 0xa9, 0x6f, 0xc1, 0x46, 0xf2, 0xde, 0xea, 0xa3, 0x88, 0x51, - 0xdc, 0x45, 0xc1, 0x78, 0xc2, 0xfc, 0x40, 0x5c, 0x40, 0xc5, 0xa8, 0x9a, 0x64, 0x17, 0x36, 0x71, - 0xb7, 0x66, 0x38, 0x2e, 0xec, 0xaa, 0x60, 0x6c, 0x60, 0xe7, 0x23, 0x45, 0xb4, 0x03, 0x55, 0xef, - 0xd0, 0x8b, 0x48, 0xf2, 0x48, 0x02, 0xde, 0xa1, 0xa7, 0x08, 0xf4, 0x6f, 0x43, 0x7d, 0xf6, 0xea, - 0x92, 0x3a, 0xe4, 0x9f, 0xb2, 0xa9, 0x9a, 0x4f, 0x7c, 0x92, 0x73, 0x6a, 0x5b, 0x38, 0x47, 0xc5, - 0x50, 0x7b, 0xfc, 0x6d, 0x2e, 0x62, 0x8e, 0x6e, 0xab, 0x30, 0x37, 0xe1, 0x24, 0x90, 0xbb, 0x7a, - 0xd8, 0xdc, 0x97, 0x0e, 0x62, 0x3f, 0x74, 0x10, 0xfb, 0x0f, 0x42, 0x0f, 0xd2, 0x2a, 0x7f, 0xf9, - 0x7c, 0x67, 0xed, 0x17, 0x7f, 0xde, 0xd1, 0x0c, 0xe4, 0x20, 0xe7, 0xc5, 0x85, 0xa2, 0xb6, 0x63, - 0xda, 0x96, 0x9a, 0xa7, 0x84, 0xed, 0x8e, 0x45, 0x3e, 0x85, 0x7a, 0xcf, 0x75, 0x02, 0xe6, 0x04, - 0xe3, 0x40, 0x78, 0x34, 0x3a, 0x0a, 0x94, 0x2f, 0x58, 0x74, 0xc8, 0xc7, 0x21, 0xf9, 0x3d, 0xa4, - 0x36, 0x6a, 0xbd, 0x74, 0x07, 0xb9, 0x0d, 0x70, 0x42, 0x87, 0xb6, 0x45, 0xb9, 0xeb, 0x07, 0x8d, - 0xc2, 0xc5, 0xfc, 0x12, 0x61, 0x8f, 0x42, 0xc2, 0x87, 0x9e, 0x45, 0x39, 0x6b, 0x15, 0xc4, 0xca, - 0x8d, 0x04, 0x3f, 0xb9, 0x0c, 0x35, 0xea, 0x79, 0x66, 0xc0, 0x29, 0x67, 0x66, 0x77, 0xca, 0x59, - 0x80, 0xfe, 0x62, 0xc3, 0xd8, 0xa4, 0x9e, 0x77, 0x5f, 0xf4, 0xb6, 0x44, 0xa7, 0x6e, 0x45, 0xa7, - 0x8d, 0xa6, 0x49, 0x08, 0x14, 0x2c, 0xca, 0x29, 0x6a, 0x6b, 0xc3, 0xc0, 0x6f, 0xd1, 0xe7, 0x51, - 0x3e, 0x50, 0x3a, 0xc0, 0x6f, 0xf2, 0x3a, 0x14, 0x07, 0xcc, 0xee, 0x0f, 0x38, 0x6e, 0x3b, 0x6f, - 0xa8, 0x96, 0x38, 0x18, 0xcf, 0x77, 0x4f, 0x18, 0x7a, 0xb7, 0xb2, 0x21, 0x1b, 0xfa, 0x2f, 0x73, - 0xf0, 0xca, 0x19, 0xf3, 0x15, 0x72, 0x07, 0x34, 0x18, 0x84, 0x73, 0x89, 0x6f, 0x72, 0x5d, 0xc8, - 0xa5, 0x16, 0xf3, 0x95, 0x57, 0x7e, 0x73, 0x81, 0x06, 0xda, 0x48, 0xa4, 0x36, 0xae, 0x58, 0xc8, - 0x43, 0xa8, 0x0f, 0x69, 0xc0, 0x4d, 0x79, 0xf7, 0x4d, 0xf4, 0xb2, 0xf9, 0xa5, 0x9e, 0xe0, 0x36, - 0x0d, 0x6d, 0x46, 0x5c, 0x6e, 0x25, 0x6e, 0x6b, 0x98, 0xea, 0x25, 0x8f, 0xe1, 0x5c, 0x77, 0xfa, - 0x23, 0xea, 0x70, 0xdb, 0x61, 0xe6, 0x99, 0x33, 0xda, 0x59, 0x20, 0xfa, 0xd6, 0x89, 0x6d, 0x31, - 0xa7, 0x17, 0x1e, 0xce, 0xab, 0x91, 0x88, 0xe8, 0xf0, 0x02, 0xfd, 0x31, 0x6c, 0xa5, 0x7d, 0x11, - 0xd9, 0x82, 0x1c, 0x9f, 0x28, 0x8d, 0xe4, 0xf8, 0x84, 0x7c, 0x0b, 0x0a, 0x42, 0x1c, 0x6a, 0x63, - 0x6b, 0x21, 0x58, 0x28, 0xee, 0x07, 0x53, 0x8f, 0x19, 0x48, 0xaf, 0xeb, 0x91, 0x25, 0x44, 0xfe, - 0x69, 0x56, 0xb6, 0x7e, 0x15, 0x6a, 0x33, 0xae, 0x27, 0x71, 0xac, 0x5a, 0xf2, 0x58, 0xf5, 0x1a, - 0x6c, 0xa6, 0x3c, 0x8c, 0xfe, 0x87, 0x22, 0x94, 0x0d, 0x16, 0x78, 0xe2, 0x12, 0x93, 0x36, 0x54, - 0xd8, 0xa4, 0xc7, 0x24, 0x2c, 0x69, 0x2b, 0x9c, 0xb8, 0xe4, 0xb9, 0x15, 0xd2, 0x0b, 0xaf, 0x19, - 0x31, 0x93, 0x6b, 0x29, 0x48, 0xde, 0x5d, 0x25, 0x24, 0x89, 0xc9, 0x37, 0xd2, 0x98, 0xfc, 0xd6, - 0x0a, 0xde, 0x19, 0x50, 0xbe, 0x96, 0x02, 0xe5, 0x55, 0x13, 0xa7, 0x50, 0xb9, 0x33, 0x07, 0x95, - 0x57, 0x6d, 0x7f, 0x01, 0x2c, 0x77, 0xe6, 0xc0, 0xf2, 0xde, 0xca, 0xb5, 0xcc, 0xc5, 0xe5, 0x1b, - 0x69, 0x5c, 0x5e, 0xa5, 0x8e, 0x19, 0x60, 0xbe, 0x3d, 0x0f, 0x98, 0xaf, 0xae, 0x90, 0xb1, 0x10, - 0x99, 0x8f, 0xcf, 0x20, 0xf3, 0xe5, 0x15, 0xa2, 0xe6, 0x40, 0x73, 0x27, 0x05, 0xcd, 0x90, 0x49, - 0x37, 0x0b, 0xb0, 0xf9, 0xa3, 0xb3, 0xd8, 0x7c, 0x65, 0xd5, 0x55, 0x9b, 0x07, 0xce, 0xdf, 0x99, - 0x01, 0xe7, 0x4b, 0xab, 0x76, 0xb5, 0x10, 0x9d, 0xaf, 0x0a, 0xff, 0x38, 0x63, 0x19, 0xc2, 0x97, - 0x32, 0xdf, 0x77, 0x7d, 0x05, 0x7c, 0xb2, 0xa1, 0xef, 0x09, 0x8f, 0x1d, 0xdf, 0xff, 0x25, 0x48, - 0x8e, 0x46, 0x9b, 0xb8, 0xed, 0xfa, 0x17, 0x5a, 0xcc, 0x8b, 0x9e, 0x2d, 0xe9, 0xed, 0x2b, 0xca, - 0xdb, 0x27, 0x00, 0x3e, 0x97, 0x06, 0xf8, 0x1d, 0xa8, 0x0a, 0x4c, 0x99, 0xc1, 0x6e, 0xea, 0x85, - 0xd8, 0x4d, 0xde, 0x86, 0x57, 0xd0, 0xff, 0xca, 0x30, 0x40, 0x39, 0x92, 0x02, 0x3a, 0x92, 0x9a, - 0x18, 0x90, 0x1a, 0x94, 0x40, 0xf1, 0xff, 0xf0, 0x6a, 0x82, 0x56, 0xc8, 0x45, 0x2c, 0x90, 0x20, - 0x55, 0x8f, 0xa8, 0x8f, 0x3c, 0xaf, 0x4d, 0x83, 0x81, 0x7e, 0x27, 0x56, 0x50, 0x1c, 0x17, 0x10, - 0x28, 0xf4, 0x5c, 0x4b, 0xee, 0x7b, 0xd3, 0xc0, 0x6f, 0x11, 0x2b, 0x0c, 0xdd, 0x3e, 0x2e, 0xae, - 0x62, 0x88, 0x4f, 0x41, 0x15, 0x99, 0x76, 0x45, 0xda, 0xac, 0xfe, 0x3b, 0x2d, 0x96, 0x17, 0x87, - 0x0a, 0xf3, 0x50, 0x5d, 0x7b, 0x99, 0xa8, 0x9e, 0xfb, 0xef, 0x50, 0x5d, 0xff, 0xa7, 0x16, 0x1f, - 0x69, 0x84, 0xd7, 0x5f, 0x4f, 0x05, 0xe2, 0x76, 0xd9, 0x8e, 0xc5, 0x26, 0xa8, 0xf2, 0xbc, 0x21, - 0x1b, 0x61, 0xa8, 0x55, 0xc4, 0x63, 0x48, 0x87, 0x5a, 0x25, 0xec, 0x93, 0x0d, 0xf2, 0x3e, 0xe2, - 0xbc, 0xfb, 0x44, 0xb9, 0x86, 0x14, 0x08, 0xca, 0xfc, 0x6d, 0x5f, 0x25, 0x6e, 0xf7, 0x04, 0x99, - 0x21, 0xa9, 0x13, 0xf8, 0x52, 0x49, 0x85, 0x0d, 0x17, 0xa0, 0x22, 0x96, 0x1e, 0x78, 0xb4, 0xc7, - 0xd0, 0xb6, 0x2b, 0x46, 0xdc, 0xa1, 0x5b, 0x40, 0xce, 0xfa, 0x18, 0x72, 0x17, 0x8a, 0xec, 0x84, - 0x39, 0x5c, 0x9c, 0x91, 0x50, 0xeb, 0x85, 0x85, 0x40, 0xcc, 0x1c, 0xde, 0x6a, 0x08, 0x65, 0xfe, - 0xe3, 0xf9, 0x4e, 0x5d, 0xf2, 0xbc, 0xeb, 0x8e, 0x6c, 0xce, 0x46, 0x1e, 0x9f, 0x1a, 0x4a, 0x8a, - 0xfe, 0xd3, 0x9c, 0xc0, 0xc3, 0x94, 0xff, 0x99, 0xab, 0xde, 0xd0, 0x68, 0x72, 0x89, 0x10, 0x29, - 0x9b, 0xca, 0xdf, 0x04, 0xe8, 0xd3, 0xc0, 0x7c, 0x46, 0x1d, 0xce, 0x2c, 0xa5, 0xf7, 0x4a, 0x9f, - 0x06, 0xdf, 0xc3, 0x0e, 0x11, 0x6f, 0x8a, 0xe1, 0x71, 0xc0, 0x2c, 0x3c, 0x80, 0xbc, 0x51, 0xea, - 0xd3, 0xe0, 0x61, 0xc0, 0xac, 0xc4, 0x5e, 0x4b, 0x2f, 0x63, 0xaf, 0x69, 0x7d, 0x97, 0x67, 0xf5, - 0xfd, 0xb3, 0x5c, 0x6c, 0x1d, 0x71, 0xf8, 0xf0, 0xbf, 0xa9, 0x8b, 0x5f, 0x63, 0x4e, 0x91, 0x06, - 0x01, 0xf2, 0x7d, 0x78, 0x25, 0xb2, 0x4a, 0x73, 0x8c, 0xd6, 0x1a, 0xde, 0xc2, 0x17, 0x33, 0xee, - 0xfa, 0x49, 0xba, 0x3b, 0x20, 0x9f, 0xc1, 0x1b, 0x33, 0x3e, 0x28, 0x9a, 0x20, 0xf7, 0x42, 0xae, - 0xe8, 0xb5, 0xb4, 0x2b, 0x0a, 0xe5, 0xc7, 0xda, 0xcb, 0xbf, 0x14, 0xab, 0xe9, 0x88, 0x10, 0x36, - 0x09, 0x6f, 0x73, 0xef, 0xc4, 0x2e, 0x6c, 0xfa, 0x8c, 0x8b, 0x5c, 0x2a, 0x95, 0x35, 0x6c, 0xc8, - 0x4e, 0x09, 0x09, 0xfa, 0x9f, 0x34, 0xa8, 0xcd, 0xec, 0x82, 0x7c, 0x00, 0xeb, 0x12, 0xa6, 0xb5, - 0xa5, 0xd5, 0x12, 0x3c, 0x16, 0xb5, 0x71, 0xc9, 0x40, 0x8e, 0xa0, 0xcc, 0x54, 0x08, 0xae, 0x34, - 0x77, 0x69, 0x45, 0xa4, 0xae, 0xf8, 0x23, 0x36, 0x72, 0x13, 0x2a, 0xd1, 0xf9, 0xac, 0x48, 0xef, - 0xa2, 0xe3, 0x55, 0x42, 0x62, 0x46, 0xfd, 0x18, 0xaa, 0x89, 0xe5, 0x91, 0xff, 0x83, 0xca, 0x88, - 0x4e, 0x54, 0x4e, 0x26, 0xa3, 0xec, 0xf2, 0x88, 0x4e, 0x30, 0x1d, 0x23, 0x6f, 0x40, 0x49, 0x0c, - 0xf6, 0xa9, 0x3c, 0xed, 0xbc, 0x51, 0x1c, 0xd1, 0xc9, 0x77, 0x69, 0xa0, 0xff, 0x5c, 0x83, 0xad, - 0xf4, 0x3a, 0xc9, 0x3b, 0x40, 0x04, 0x2d, 0xed, 0x33, 0xd3, 0x19, 0x8f, 0x24, 0x90, 0x86, 0x12, - 0x6b, 0x23, 0x3a, 0x39, 0xea, 0xb3, 0xbb, 0xe3, 0x11, 0x4e, 0x1d, 0x90, 0x3b, 0x50, 0x0f, 0x89, - 0xc3, 0x8a, 0x98, 0xd2, 0xca, 0xf9, 0x33, 0x19, 0xf1, 0x4d, 0x45, 0x20, 0x13, 0xe2, 0x5f, 0x89, - 0x84, 0x78, 0x4b, 0xca, 0x0b, 0x47, 0xf4, 0xf7, 0xa1, 0x36, 0xb3, 0x63, 0xa2, 0xc3, 0xa6, 0x37, - 0xee, 0x9a, 0x4f, 0xd9, 0xd4, 0x44, 0x95, 0xa0, 0x3d, 0x54, 0x8c, 0xaa, 0x37, 0xee, 0x7e, 0xcc, - 0xa6, 0x22, 0x35, 0x09, 0xf4, 0x1e, 0x6c, 0xa5, 0x33, 0x2e, 0x81, 0x2e, 0xbe, 0x3b, 0x76, 0x2c, - 0x5c, 0xf7, 0xba, 0x21, 0x1b, 0xe4, 0x3a, 0xac, 0x9f, 0xb8, 0xf2, 0xca, 0x2f, 0x4b, 0xb1, 0x1e, - 0xb9, 0x9c, 0x25, 0xf2, 0x36, 0xc9, 0xa3, 0xdf, 0x15, 0x9a, 0x62, 0x0e, 0x3f, 0xe2, 0xdc, 0xb7, - 0xbb, 0x63, 0xce, 0x92, 0xf5, 0x83, 0x8d, 0x39, 0xf5, 0x83, 0x08, 0xd4, 0x22, 0x48, 0xcc, 0xcb, - 0xe4, 0x15, 0x1b, 0xfa, 0x4f, 0x34, 0x58, 0x47, 0x81, 0xe2, 0x66, 0x63, 0x32, 0xa6, 0xc2, 0x25, - 0xf1, 0x4d, 0x7a, 0x00, 0x34, 0x9c, 0x28, 0x5c, 0xef, 0xa5, 0x65, 0x36, 0x15, 0x2d, 0xab, 0x75, - 0x41, 0x19, 0xd7, 0xb9, 0x58, 0x40, 0xc2, 0xc0, 0x12, 0x62, 0xf5, 0xaf, 0x0a, 0x50, 0x94, 0x19, - 0x2f, 0xf9, 0x30, 0x5d, 0x7f, 0xa9, 0x1e, 0x6e, 0x2f, 0x52, 0x8e, 0xa4, 0x52, 0xba, 0x89, 0x82, - 0xb8, 0xcb, 0xb3, 0x45, 0x8d, 0x56, 0xf5, 0xf4, 0xf9, 0x4e, 0x09, 0x03, 0xa0, 0xce, 0xcd, 0xb8, - 0xc2, 0xb1, 0x28, 0xc1, 0x0f, 0xcb, 0x29, 0x85, 0x17, 0x2e, 0xa7, 0xb4, 0x61, 0x33, 0x11, 0xf1, - 0xd9, 0x96, 0x4a, 0x95, 0xb6, 0x97, 0x99, 0x74, 0xe7, 0xa6, 0x5a, 0x7f, 0x35, 0x8a, 0x08, 0x3b, - 0x16, 0xd9, 0x4b, 0xe7, 0xf9, 0x18, 0x38, 0xca, 0x88, 0x25, 0x91, 0xba, 0x8b, 0xb0, 0x51, 0x18, - 0x9b, 0xf0, 0x3f, 0x92, 0x44, 0x06, 0x30, 0x65, 0xd1, 0x81, 0x83, 0x57, 0xa0, 0x16, 0xc7, 0x56, - 0x92, 0xa4, 0x2c, 0xa5, 0xc4, 0xdd, 0x48, 0xf8, 0x1e, 0x9c, 0x73, 0xd8, 0x84, 0x9b, 0xb3, 0xd4, - 0x15, 0xa4, 0x26, 0x62, 0xec, 0x51, 0x9a, 0xe3, 0x12, 0x6c, 0xc5, 0x5e, 0x1c, 0x69, 0x41, 0x56, - 0x5f, 0xa2, 0x5e, 0x24, 0x3b, 0x0f, 0xe5, 0x28, 0xf2, 0xad, 0x22, 0x41, 0x89, 0xca, 0x80, 0x37, - 0x8a, 0xa5, 0x7d, 0x16, 0x8c, 0x87, 0x5c, 0x09, 0xd9, 0x40, 0x1a, 0x8c, 0xa5, 0x0d, 0xd9, 0x8f, - 0xb4, 0xbb, 0xb0, 0x19, 0xfa, 0x2c, 0x49, 0xb7, 0x89, 0x74, 0x1b, 0x61, 0x27, 0x12, 0x5d, 0x85, - 0xba, 0xe7, 0xbb, 0x9e, 0x1b, 0x30, 0xdf, 0xa4, 0x96, 0xe5, 0xb3, 0x20, 0x68, 0x6c, 0x49, 0x79, - 0x61, 0xff, 0x91, 0xec, 0xd6, 0xbf, 0x01, 0xa5, 0x30, 0xa4, 0x3f, 0x07, 0xeb, 0xad, 0xc8, 0xff, - 0x16, 0x0c, 0xd9, 0x10, 0x06, 0x75, 0xe4, 0x79, 0xaa, 0xc0, 0x27, 0x3e, 0xf5, 0x21, 0x94, 0xd4, - 0x81, 0xcd, 0x2d, 0xeb, 0xdc, 0x81, 0x0d, 0x8f, 0xfa, 0x62, 0x1b, 0xc9, 0xe2, 0xce, 0xa2, 0xa4, - 0xf4, 0x1e, 0xf5, 0xf9, 0x7d, 0xc6, 0x53, 0x35, 0x9e, 0x2a, 0xf2, 0xcb, 0x2e, 0xfd, 0x1a, 0x6c, - 0xa6, 0x68, 0xc4, 0x32, 0xb9, 0xcb, 0xe9, 0x30, 0x74, 0x23, 0xd8, 0x88, 0x56, 0x92, 0x8b, 0x57, - 0xa2, 0x5f, 0x87, 0x4a, 0x74, 0x56, 0x22, 0xd7, 0x09, 0x55, 0xa1, 0x29, 0xf5, 0xcb, 0x26, 0xd6, - 0xb1, 0xdc, 0x67, 0xcc, 0x57, 0xb7, 0x5f, 0x36, 0x74, 0x96, 0x70, 0x7b, 0x12, 0x50, 0xc9, 0x0d, - 0x28, 0x29, 0xb7, 0xa7, 0xec, 0x71, 0x51, 0xc5, 0xea, 0x1e, 0xfa, 0xc1, 0xb0, 0x62, 0x25, 0xbd, - 0x62, 0x3c, 0x4d, 0x2e, 0x39, 0xcd, 0x8f, 0xa1, 0x1c, 0xba, 0xb6, 0x34, 0x06, 0xc9, 0x19, 0x2e, - 0xae, 0xc2, 0x20, 0x35, 0x49, 0xcc, 0x28, 0x6e, 0x53, 0x60, 0xf7, 0x1d, 0x66, 0x99, 0xb1, 0x09, - 0xe2, 0x9c, 0x65, 0xa3, 0x26, 0x07, 0x6e, 0x87, 0xf6, 0xa5, 0xbf, 0x07, 0x45, 0xb9, 0xd6, 0xb9, - 0xfe, 0x6e, 0x0e, 0xba, 0xeb, 0x7f, 0xd7, 0xa0, 0x1c, 0x82, 0xd3, 0x5c, 0xa6, 0xd4, 0x26, 0x72, - 0x5f, 0x77, 0x13, 0x2f, 0xdf, 0x25, 0xbd, 0x0b, 0x04, 0x6f, 0x8a, 0x79, 0xe2, 0x72, 0xdb, 0xe9, - 0x9b, 0xf2, 0x2c, 0x64, 0x30, 0x5a, 0xc7, 0x91, 0x47, 0x38, 0x70, 0x4f, 0xf4, 0xbf, 0xbd, 0x0b, - 0xd5, 0x44, 0xa1, 0x8d, 0x94, 0x20, 0x7f, 0x97, 0x3d, 0xab, 0xaf, 0x91, 0x2a, 0x94, 0x0c, 0x86, - 0x65, 0x8a, 0xba, 0x76, 0xf8, 0x55, 0x09, 0x6a, 0x47, 0xad, 0xe3, 0xce, 0x91, 0xe7, 0x0d, 0xed, - 0x1e, 0xa2, 0x25, 0xf9, 0x04, 0x0a, 0x98, 0xaa, 0x67, 0x78, 0x62, 0x6a, 0x66, 0xa9, 0x79, 0x11, - 0x03, 0xd6, 0x31, 0xa3, 0x27, 0x59, 0x5e, 0x9e, 0x9a, 0x99, 0x4a, 0x61, 0x62, 0x91, 0x78, 0xe1, - 0x32, 0x3c, 0x48, 0x35, 0xb3, 0xd4, 0xc7, 0xc8, 0x67, 0x50, 0x89, 0x53, 0xf5, 0xac, 0xcf, 0x54, - 0xcd, 0xcc, 0x95, 0x33, 0x21, 0x3f, 0x4e, 0x4e, 0xb2, 0x3e, 0xd2, 0x34, 0x33, 0x97, 0x8c, 0xc8, - 0x63, 0x28, 0x85, 0x69, 0x60, 0xb6, 0x87, 0xa4, 0x66, 0xc6, 0xaa, 0x96, 0x38, 0x3e, 0x99, 0xbd, - 0x67, 0x79, 0x2d, 0x6b, 0x66, 0x2a, 0xdd, 0x91, 0x87, 0x50, 0x54, 0xf1, 0x77, 0xa6, 0x27, 0xa2, - 0x66, 0xb6, 0x5a, 0x95, 0x50, 0x72, 0x5c, 0x1f, 0xc9, 0xfa, 0x42, 0xd8, 0xcc, 0x5c, 0xb3, 0x24, - 0x14, 0x20, 0x91, 0xd2, 0x67, 0x7e, 0xfa, 0x6b, 0x66, 0xaf, 0x45, 0x92, 0x1f, 0x42, 0x39, 0x4a, - 0xdc, 0x32, 0x3e, 0xc1, 0x35, 0xb3, 0x96, 0x03, 0x5b, 0x9d, 0x7f, 0xff, 0x75, 0x5b, 0xfb, 0xcd, - 0xe9, 0xb6, 0xf6, 0xc5, 0xe9, 0xb6, 0xf6, 0xe5, 0xe9, 0xb6, 0xf6, 0xc7, 0xd3, 0x6d, 0xed, 0x2f, - 0xa7, 0xdb, 0xda, 0xef, 0xff, 0xb6, 0xad, 0xfd, 0xe0, 0x9d, 0xbe, 0xcd, 0x07, 0xe3, 0xee, 0x7e, - 0xcf, 0x1d, 0x1d, 0xc4, 0x02, 0x93, 0x9f, 0xf1, 0x13, 0x7a, 0xb7, 0x88, 0x0e, 0xeb, 0x9b, 0xff, - 0x09, 0x00, 0x00, 0xff, 0xff, 0x61, 0xd2, 0x8e, 0xea, 0x57, 0x1f, 0x00, 0x00, + // 2928 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x3d, 0x90, 0x23, 0x47, + 0xf5, 0xdf, 0x91, 0xb4, 0x92, 0xe6, 0x69, 0xf5, 0x71, 0x7d, 0xeb, 0xb3, 0xac, 0xbf, 0xbd, 0x7b, + 0x35, 0xe7, 0xfb, 0xb2, 0xfd, 0xdf, 0x3d, 0xaf, 0xcb, 0x94, 0xcd, 0x19, 0x53, 0xab, 0xbd, 0x33, + 0xda, 0xf2, 0xf9, 0x7c, 0x9e, 0xfb, 0xc0, 0x40, 0x95, 0x87, 0xd6, 0x4c, 0xaf, 0x34, 0x3e, 0x69, + 0x66, 0x3c, 0xd3, 0x5a, 0xaf, 0x28, 0x02, 0x8a, 0x84, 0xa2, 0x8a, 0x00, 0x02, 0xaa, 0x48, 0xc8, + 0x09, 0x09, 0xa8, 0xb2, 0x43, 0x12, 0xaa, 0x1c, 0x12, 0x10, 0x9f, 0x61, 0x21, 0x02, 0x42, 0x02, + 0x42, 0xaa, 0x3f, 0xe6, 0x4b, 0x2b, 0x69, 0x46, 0xe6, 0x32, 0x92, 0xdd, 0xe9, 0x9e, 0xf7, 0x5e, + 0x77, 0xbf, 0x9e, 0xfe, 0xbd, 0xdf, 0x7b, 0x6a, 0xb8, 0x80, 0xfb, 0xa6, 0xbd, 0x4b, 0xa7, 0x1e, + 0x09, 0xc4, 0xdf, 0x1d, 0xcf, 0x77, 0xa9, 0x8b, 0x9e, 0xa1, 0xc4, 0xb1, 0x88, 0x3f, 0xb6, 0x1d, + 0xba, 0xc3, 0x44, 0x76, 0xf8, 0xcb, 0xce, 0x15, 0x3a, 0xb4, 0x7d, 0xcb, 0xf0, 0xb0, 0x4f, 0xa7, + 0xbb, 0x5c, 0x72, 0x77, 0xe0, 0x0e, 0xdc, 0xf8, 0x49, 0xa8, 0x77, 0x3a, 0xa6, 0x3f, 0xf5, 0xa8, + 0xbb, 0x3b, 0x26, 0xfe, 0xe3, 0x11, 0x91, 0xff, 0xe4, 0xbb, 0xed, 0x81, 0xeb, 0x0e, 0x46, 0x44, + 0xa8, 0xf7, 0x27, 0x47, 0xbb, 0xd4, 0x1e, 0x93, 0x80, 0xe2, 0xb1, 0x27, 0x05, 0xb6, 0x66, 0x05, + 0xac, 0x89, 0x8f, 0xa9, 0xed, 0x3a, 0xe2, 0xbd, 0xf6, 0x8f, 0x2a, 0x54, 0x74, 0xf2, 0xc9, 0x84, + 0x04, 0x14, 0xbd, 0x01, 0x25, 0x62, 0x0e, 0xdd, 0x76, 0xe1, 0xa2, 0x72, 0xad, 0xb6, 0xa7, 0xed, + 0xcc, 0x9d, 0xf6, 0x8e, 0x94, 0xbe, 0x6d, 0x0e, 0xdd, 0xde, 0x9a, 0xce, 0x35, 0xd0, 0x4d, 0x58, + 0x3f, 0x1a, 0x4d, 0x82, 0x61, 0xbb, 0xc8, 0x55, 0x2f, 0x2d, 0x57, 0x7d, 0x87, 0x89, 0xf6, 0xd6, + 0x74, 0xa1, 0xc3, 0x86, 0xb5, 0x9d, 0x23, 0xb7, 0x5d, 0xca, 0x33, 0xec, 0xa1, 0x73, 0xc4, 0x87, + 0x65, 0x1a, 0xa8, 0x07, 0x10, 0x10, 0x6a, 0xb8, 0x1e, 0x5b, 0x50, 0x7b, 0x9d, 0xeb, 0x5f, 0x5d, + 0xae, 0x7f, 0x9f, 0xd0, 0xf7, 0xb9, 0x78, 0x6f, 0x4d, 0x57, 0x83, 0xb0, 0xc1, 0x2c, 0xd9, 0x8e, + 0x4d, 0x0d, 0x73, 0x88, 0x6d, 0xa7, 0x5d, 0xce, 0x63, 0xe9, 0xd0, 0xb1, 0xe9, 0x01, 0x13, 0x67, + 0x96, 0xec, 0xb0, 0xc1, 0x5c, 0xf1, 0xc9, 0x84, 0xf8, 0xd3, 0x76, 0x25, 0x8f, 0x2b, 0x3e, 0x60, + 0xa2, 0xcc, 0x15, 0x5c, 0x07, 0xbd, 0x0b, 0xb5, 0x3e, 0x19, 0xd8, 0x8e, 0xd1, 0x1f, 0xb9, 0xe6, + 0xe3, 0x76, 0x95, 0x9b, 0xb8, 0xb6, 0xdc, 0x44, 0x97, 0x29, 0x74, 0x99, 0x7c, 0x6f, 0x4d, 0x87, + 0x7e, 0xd4, 0x42, 0x5d, 0xa8, 0x9a, 0x43, 0x62, 0x3e, 0x36, 0xe8, 0x49, 0x5b, 0xe5, 0x96, 0x2e, + 0x2f, 0xb7, 0x74, 0xc0, 0xa4, 0x1f, 0x9c, 0xf4, 0xd6, 0xf4, 0x8a, 0x29, 0x1e, 0x99, 0x5f, 0x2c, + 0x32, 0xb2, 0x8f, 0x89, 0xcf, 0xac, 0x9c, 0xcf, 0xe3, 0x97, 0x5b, 0x42, 0x9e, 0xdb, 0x51, 0xad, + 0xb0, 0x81, 0x6e, 0x83, 0x4a, 0x1c, 0x4b, 0x2e, 0xac, 0xc6, 0x0d, 0x5d, 0xc9, 0xf8, 0xc2, 0x1c, + 0x2b, 0x5c, 0x56, 0x95, 0xc8, 0x67, 0xf4, 0x36, 0x94, 0x4d, 0x77, 0x3c, 0xb6, 0x69, 0x7b, 0x83, + 0xdb, 0x78, 0x31, 0x63, 0x49, 0x5c, 0xb6, 0xb7, 0xa6, 0x4b, 0x2d, 0xf4, 0x00, 0x1a, 0x23, 0x3b, + 0xa0, 0x46, 0xe0, 0x60, 0x2f, 0x18, 0xba, 0x34, 0x68, 0xd7, 0xb9, 0x9d, 0x97, 0x97, 0xdb, 0xb9, + 0x63, 0x07, 0xf4, 0x7e, 0xa8, 0xd2, 0x5b, 0xd3, 0xeb, 0xa3, 0x64, 0x07, 0xb3, 0xea, 0x1e, 0x1d, + 0x11, 0x3f, 0x32, 0xdb, 0x6e, 0xe4, 0xb1, 0xfa, 0x3e, 0xd3, 0x09, 0xad, 0x30, 0xab, 0x6e, 0xb2, + 0x03, 0x61, 0x38, 0x3f, 0x72, 0xb1, 0x15, 0x19, 0x35, 0xcc, 0xe1, 0xc4, 0x79, 0xdc, 0x6e, 0x72, + 0xd3, 0xbb, 0x19, 0x13, 0x76, 0xb1, 0x15, 0x1a, 0x3a, 0x60, 0x6a, 0xbd, 0x35, 0xfd, 0xdc, 0x68, + 0xb6, 0x13, 0x59, 0xb0, 0x89, 0x3d, 0x6f, 0x34, 0x9d, 0x1d, 0xa3, 0xc5, 0xc7, 0xb8, 0xb1, 0x7c, + 0x8c, 0x7d, 0xa6, 0x39, 0x3b, 0x08, 0xc2, 0x67, 0x7a, 0xbb, 0x15, 0x58, 0x3f, 0xc6, 0xa3, 0x09, + 0xd1, 0xae, 0x42, 0x2d, 0x01, 0x1f, 0xa8, 0x0d, 0x95, 0x31, 0x09, 0x02, 0x3c, 0x20, 0x6d, 0xe5, + 0xa2, 0x72, 0x4d, 0xd5, 0xc3, 0xa6, 0xd6, 0x80, 0x8d, 0x24, 0x58, 0x68, 0xe3, 0x48, 0x91, 0x01, + 0x00, 0x53, 0x3c, 0x26, 0x7e, 0xc0, 0x4e, 0xbd, 0x54, 0x94, 0x4d, 0x74, 0x09, 0xea, 0xfc, 0x13, + 0x33, 0xc2, 0xf7, 0x0c, 0xcc, 0x4a, 0xfa, 0x06, 0xef, 0x7c, 0x24, 0x85, 0xb6, 0xa1, 0xe6, 0xed, + 0x79, 0x91, 0x48, 0x91, 0x8b, 0x80, 0xb7, 0xe7, 0x49, 0x01, 0xed, 0xeb, 0xd0, 0x9a, 0xc5, 0x0b, + 0xd4, 0x82, 0xe2, 0x63, 0x32, 0x95, 0xe3, 0xb1, 0x47, 0xb4, 0x29, 0x97, 0xc5, 0xc7, 0x50, 0x75, + 0xb9, 0xc6, 0xdf, 0x16, 0x22, 0xe5, 0x08, 0x22, 0x18, 0xc6, 0x31, 0x64, 0xe6, 0xda, 0xb5, 0xbd, + 0xce, 0x8e, 0x40, 0xe5, 0x9d, 0x10, 0x95, 0x77, 0x1e, 0x84, 0xb0, 0xdd, 0xad, 0x7e, 0xf1, 0x64, + 0x7b, 0xed, 0xe7, 0x5f, 0x6e, 0x2b, 0x3a, 0xd7, 0x40, 0xcf, 0xb1, 0x53, 0x8c, 0x6d, 0xc7, 0xb0, + 0x2d, 0x39, 0x4e, 0x85, 0xb7, 0x0f, 0x2d, 0xf4, 0x01, 0xb4, 0x4c, 0xd7, 0x09, 0x88, 0x13, 0x4c, + 0x02, 0x16, 0x46, 0xf0, 0x38, 0x90, 0x00, 0xbc, 0xe8, 0x64, 0x1d, 0x84, 0xe2, 0xf7, 0xb8, 0xb4, + 0xde, 0x34, 0xd3, 0x1d, 0xe8, 0x0e, 0xc0, 0x31, 0x1e, 0xd9, 0x16, 0xa6, 0xae, 0x1f, 0xb4, 0x4b, + 0x17, 0x8b, 0x4b, 0x8c, 0x3d, 0x0a, 0x05, 0x1f, 0x7a, 0x16, 0xa6, 0xa4, 0x5b, 0x62, 0x33, 0xd7, + 0x13, 0xfa, 0xe8, 0x0a, 0x34, 0xb1, 0xe7, 0x19, 0x01, 0xc5, 0x94, 0x18, 0xfd, 0x29, 0x25, 0x01, + 0x07, 0xe9, 0x0d, 0xbd, 0x8e, 0x3d, 0xef, 0x3e, 0xeb, 0xed, 0xb2, 0x4e, 0xcd, 0x8a, 0x76, 0x9b, + 0xe3, 0x21, 0x42, 0x50, 0xb2, 0x30, 0xc5, 0xdc, 0x5b, 0x1b, 0x3a, 0x7f, 0x66, 0x7d, 0x1e, 0xa6, + 0x43, 0xe9, 0x03, 0xfe, 0x8c, 0x2e, 0x40, 0x79, 0x48, 0xec, 0xc1, 0x90, 0xf2, 0x65, 0x17, 0x75, + 0xd9, 0x62, 0x1b, 0xe3, 0xf9, 0xee, 0x31, 0xe1, 0x21, 0xa5, 0xaa, 0x8b, 0x86, 0xf6, 0xcb, 0x02, + 0x9c, 0x3b, 0x83, 0x99, 0xcc, 0xee, 0x10, 0x07, 0xc3, 0x70, 0x2c, 0xf6, 0x8c, 0x6e, 0x32, 0xbb, + 0xd8, 0x22, 0xbe, 0x0c, 0x85, 0x2f, 0x2c, 0xf0, 0x40, 0x8f, 0x0b, 0xc9, 0x85, 0x4b, 0x15, 0xf4, + 0x10, 0x5a, 0x23, 0x1c, 0x50, 0x43, 0x00, 0x8e, 0xc1, 0x43, 0x5b, 0x71, 0x29, 0xfc, 0xde, 0xc1, + 0x21, 0x50, 0xb1, 0x8f, 0x5b, 0x9a, 0x6b, 0x8c, 0x52, 0xbd, 0xe8, 0x43, 0xd8, 0xec, 0x4f, 0x7f, + 0x80, 0x1d, 0x6a, 0x3b, 0xc4, 0x38, 0xb3, 0x47, 0xdb, 0x0b, 0x4c, 0xdf, 0x3e, 0xb6, 0x2d, 0xe2, + 0x98, 0xe1, 0xe6, 0x9c, 0x8f, 0x4c, 0x44, 0x9b, 0x17, 0x68, 0x1f, 0x42, 0x23, 0x1d, 0x00, 0x50, + 0x03, 0x0a, 0xf4, 0x44, 0x7a, 0xa4, 0x40, 0x4f, 0xd0, 0xd7, 0xa0, 0xc4, 0xcc, 0x71, 0x6f, 0x34, + 0x16, 0x46, 0x68, 0xa9, 0xfd, 0x60, 0xea, 0x11, 0x9d, 0xcb, 0x6b, 0x5a, 0x74, 0x12, 0xa2, 0xa0, + 0x30, 0x6b, 0x5b, 0xbb, 0x0e, 0xcd, 0x19, 0xbc, 0x4f, 0x6c, 0xab, 0x92, 0xdc, 0x56, 0xad, 0x09, + 0xf5, 0x14, 0xac, 0x6b, 0x17, 0x60, 0x73, 0x1e, 0x3e, 0x6b, 0x4e, 0xd4, 0x9f, 0x42, 0x58, 0x74, + 0x13, 0xaa, 0x11, 0x40, 0x8b, 0x93, 0xb8, 0xc8, 0x6f, 0xa1, 0x8a, 0x1e, 0x29, 0xb0, 0x83, 0xc8, + 0x3e, 0x66, 0xfe, 0xb1, 0x14, 0xf8, 0xf4, 0x2b, 0xd8, 0xf3, 0x7a, 0x38, 0x18, 0x6a, 0xdf, 0x87, + 0xf6, 0x22, 0xd8, 0x9d, 0x59, 0x4c, 0x29, 0xfa, 0x46, 0x2f, 0x40, 0xf9, 0xc8, 0xf5, 0xc7, 0x98, + 0x72, 0x63, 0x75, 0x5d, 0xb6, 0xd8, 0xb7, 0x2b, 0x20, 0xb8, 0xc8, 0xbb, 0x45, 0x43, 0x33, 0xe0, + 0xb9, 0x85, 0xa0, 0xcb, 0x54, 0x6c, 0xc7, 0x22, 0xc2, 0xab, 0x75, 0x5d, 0x34, 0x62, 0x43, 0x62, + 0xb2, 0xa2, 0xc1, 0x86, 0x0d, 0xf8, 0x8a, 0xb9, 0x7d, 0x55, 0x97, 0x2d, 0xed, 0x0f, 0x2a, 0x54, + 0x75, 0x12, 0x78, 0x0c, 0x0f, 0x50, 0x0f, 0x54, 0x72, 0x62, 0x12, 0x41, 0xab, 0x94, 0x0c, 0x12, + 0x22, 0x74, 0x6e, 0x87, 0xf2, 0x2c, 0xea, 0x47, 0xca, 0xe8, 0xcd, 0x14, 0xa5, 0xbc, 0x94, 0x65, + 0x24, 0xc9, 0x29, 0xdf, 0x4a, 0x73, 0xca, 0x17, 0x33, 0x74, 0x67, 0x48, 0xe5, 0x9b, 0x29, 0x52, + 0x99, 0x35, 0x70, 0x8a, 0x55, 0x1e, 0xce, 0x61, 0x95, 0x59, 0xcb, 0x5f, 0x40, 0x2b, 0x0f, 0xe7, + 0xd0, 0xca, 0x6b, 0x99, 0x73, 0x99, 0xcb, 0x2b, 0xdf, 0x4a, 0xf3, 0xca, 0x2c, 0x77, 0xcc, 0x10, + 0xcb, 0x3b, 0xf3, 0x88, 0xe5, 0xf5, 0x0c, 0x1b, 0x0b, 0x99, 0xe5, 0xc1, 0x19, 0x66, 0x79, 0x25, + 0xc3, 0xd4, 0x1c, 0x6a, 0x79, 0x98, 0xa2, 0x96, 0x90, 0xcb, 0x37, 0x0b, 0xb8, 0xe5, 0x3b, 0x67, + 0xb9, 0xe5, 0xd5, 0xac, 0x4f, 0x6d, 0x1e, 0xb9, 0xfc, 0xe6, 0x0c, 0xb9, 0xbc, 0x9c, 0xb5, 0xaa, + 0x59, 0x76, 0xf9, 0x70, 0x01, 0xbb, 0x7c, 0x25, 0xc3, 0x50, 0x06, 0xbd, 0x7c, 0xb8, 0x80, 0x5e, + 0x66, 0x99, 0xcd, 0xe0, 0x97, 0xfd, 0x65, 0xfc, 0xf2, 0x46, 0xd6, 0x94, 0xf3, 0x11, 0x4c, 0xb2, + 0x94, 0x60, 0xbe, 0x9a, 0x31, 0xc8, 0xea, 0x0c, 0xf3, 0x3a, 0x8b, 0xf1, 0x33, 0x90, 0xc4, 0xa0, + 0x90, 0xf8, 0xbe, 0xeb, 0x4b, 0xf2, 0x26, 0x1a, 0xda, 0x35, 0xc6, 0x3a, 0x62, 0xe0, 0x59, 0xc2, + 0x46, 0x79, 0xe0, 0x49, 0xc0, 0x8c, 0xf6, 0xb9, 0x12, 0xeb, 0xf2, 0xe8, 0x9c, 0x64, 0x2c, 0xaa, + 0x64, 0x2c, 0x09, 0x92, 0x5a, 0x48, 0x93, 0xd4, 0x6d, 0xa8, 0xb1, 0x50, 0x32, 0xc3, 0x3f, 0xb1, + 0x17, 0xf2, 0x4f, 0xf4, 0x12, 0x9c, 0xe3, 0x1c, 0x42, 0x50, 0x59, 0x19, 0x3f, 0x4a, 0x3c, 0x18, + 0x36, 0xd9, 0x0b, 0xf1, 0xe9, 0x8a, 0x40, 0xf2, 0xff, 0x70, 0x3e, 0x21, 0x1b, 0x85, 0x28, 0x41, + 0xb4, 0x5a, 0x91, 0xf4, 0xbe, 0x8c, 0x55, 0xef, 0xc5, 0x0e, 0x8a, 0xb9, 0x2d, 0x82, 0x92, 0xe9, + 0x5a, 0x44, 0x06, 0x10, 0xfe, 0xcc, 0xf8, 0xee, 0xc8, 0x1d, 0xc8, 0x30, 0xc1, 0x1e, 0x99, 0x54, + 0x84, 0xa9, 0xaa, 0x00, 0x4b, 0xed, 0x77, 0x4a, 0x6c, 0x2f, 0xa6, 0xbb, 0xf3, 0x98, 0xa9, 0xf2, + 0x34, 0x99, 0x69, 0xe1, 0xbf, 0x63, 0xa6, 0xda, 0xbf, 0x94, 0x78, 0x4b, 0x23, 0xce, 0xf9, 0xd5, + 0x5c, 0x10, 0x87, 0xdf, 0x75, 0xbe, 0x41, 0x32, 0xfc, 0xca, 0x74, 0xa1, 0xcc, 0xb7, 0x21, 0x9d, + 0x2e, 0x54, 0x44, 0x40, 0xe6, 0x0d, 0xf4, 0x3a, 0xe7, 0xaa, 0xee, 0x91, 0xc4, 0xe4, 0x14, 0x21, + 0x11, 0x85, 0x9f, 0x1d, 0x59, 0xf1, 0xb9, 0xc7, 0xc4, 0x74, 0x21, 0x9d, 0xa0, 0x15, 0x6a, 0x8a, + 0xfa, 0x3e, 0x0f, 0x2a, 0x9b, 0x7a, 0xe0, 0x61, 0x93, 0x70, 0x50, 0x55, 0xf5, 0xb8, 0x43, 0xb3, + 0x00, 0x9d, 0x05, 0x77, 0x74, 0x17, 0xca, 0xe4, 0x98, 0x38, 0x94, 0xed, 0x11, 0x73, 0xeb, 0xf3, + 0x0b, 0xc9, 0x24, 0x71, 0x68, 0xb7, 0xcd, 0x9c, 0xf9, 0xf7, 0x27, 0xdb, 0x2d, 0xa1, 0xf3, 0x8a, + 0x3b, 0xb6, 0x29, 0x19, 0x7b, 0x74, 0xaa, 0x4b, 0x2b, 0xda, 0x4f, 0x0a, 0x8c, 0xd3, 0xa5, 0x80, + 0x7f, 0xae, 0x7b, 0xc3, 0x43, 0x53, 0x48, 0xd0, 0xfc, 0x7c, 0x2e, 0x7f, 0x01, 0x60, 0x80, 0x03, + 0xe3, 0x53, 0xec, 0x50, 0x62, 0x49, 0xbf, 0xab, 0x03, 0x1c, 0x7c, 0x9b, 0x77, 0x30, 0xaa, 0xc6, + 0x5e, 0x4f, 0x02, 0x62, 0xf1, 0x0d, 0x28, 0xea, 0x95, 0x01, 0x0e, 0x1e, 0x06, 0xc4, 0x4a, 0xac, + 0xb5, 0xf2, 0x34, 0xd6, 0x9a, 0xf6, 0x77, 0x75, 0xd6, 0xdf, 0x3f, 0x2d, 0xc4, 0xa7, 0x23, 0xa6, + 0xc0, 0xff, 0x9b, 0xbe, 0xf8, 0x35, 0xcf, 0x8b, 0xd3, 0xd1, 0x17, 0x7d, 0x07, 0xce, 0x45, 0xa7, + 0xd2, 0x98, 0xf0, 0xd3, 0x1a, 0x7e, 0x85, 0xab, 0x1d, 0xee, 0xd6, 0x71, 0xba, 0x3b, 0x40, 0x1f, + 0xc1, 0xb3, 0x33, 0x18, 0x14, 0x0d, 0x50, 0x58, 0x09, 0x8a, 0x9e, 0x49, 0x43, 0x51, 0x68, 0x3f, + 0xf6, 0x5e, 0xf1, 0xa9, 0x9c, 0x9a, 0x43, 0x96, 0x86, 0x25, 0x79, 0xc5, 0xdc, 0x6f, 0xe2, 0x12, + 0xd4, 0x7d, 0x42, 0xb1, 0xed, 0x18, 0xa9, 0xcc, 0x77, 0x43, 0x74, 0x8a, 0x90, 0xa0, 0x3d, 0x82, + 0x67, 0xe6, 0x32, 0x0b, 0xf4, 0x0d, 0x50, 0x63, 0x6a, 0xa2, 0x2c, 0xcd, 0x1c, 0xa3, 0x0c, 0x28, + 0xd6, 0xd0, 0x3e, 0x53, 0x62, 0xc3, 0xe9, 0xcc, 0xea, 0x5d, 0x28, 0xfb, 0x24, 0x98, 0x8c, 0x44, + 0x96, 0xd3, 0xd8, 0x7b, 0x6d, 0x15, 0x66, 0xc2, 0x7a, 0x27, 0x23, 0xaa, 0x4b, 0x13, 0xda, 0x07, + 0x50, 0x16, 0x3d, 0x08, 0xa0, 0x8c, 0x4d, 0x16, 0xc5, 0x5b, 0x6b, 0x48, 0x85, 0x75, 0xdc, 0x77, + 0x7d, 0xda, 0x52, 0x58, 0xb7, 0x4f, 0x3e, 0x26, 0x26, 0x6d, 0x15, 0xd0, 0x39, 0xe6, 0x10, 0xf6, + 0x6c, 0x88, 0x04, 0xaa, 0x55, 0x4c, 0x74, 0x89, 0xe4, 0xa6, 0x55, 0xd2, 0x5e, 0x65, 0xf9, 0xd3, + 0x02, 0xe2, 0x12, 0x67, 0x4a, 0x4a, 0x22, 0x53, 0xd2, 0x7e, 0x51, 0x80, 0xce, 0x62, 0x1e, 0x82, + 0xee, 0xcd, 0xac, 0xf8, 0x8d, 0x95, 0xa9, 0xcc, 0xcc, 0xb2, 0xd1, 0x65, 0x68, 0xf8, 0xe4, 0x88, + 0x50, 0x73, 0x28, 0x38, 0x92, 0x88, 0x72, 0x75, 0xbd, 0x2e, 0x7b, 0xb9, 0x52, 0x20, 0xc4, 0x12, + 0xab, 0x13, 0xdf, 0x9f, 0xaa, 0xcb, 0x35, 0xdf, 0x17, 0x9d, 0xda, 0xfd, 0x2c, 0x27, 0xaa, 0xb0, + 0xee, 0x13, 0xea, 0x4f, 0x5b, 0x05, 0x84, 0x98, 0x49, 0xea, 0xc7, 0x24, 0xad, 0x55, 0x44, 0xe7, + 0xa1, 0x19, 0x0e, 0x13, 0x76, 0x96, 0xb4, 0x3f, 0x29, 0xd0, 0x9c, 0x39, 0x1e, 0xe8, 0x0d, 0x58, + 0x17, 0xc4, 0x5b, 0x59, 0x5a, 0xbf, 0xe7, 0xe7, 0x5d, 0x9e, 0x28, 0xa1, 0x80, 0xf6, 0xa1, 0x4a, + 0x64, 0x7d, 0x42, 0x1e, 0xc9, 0xcb, 0x19, 0x65, 0x0c, 0xa9, 0x1f, 0xa9, 0xa1, 0x5b, 0xa0, 0x46, + 0x07, 0x3f, 0xa3, 0xf6, 0x15, 0xe1, 0x86, 0x34, 0x12, 0x2b, 0x6a, 0x07, 0x50, 0x4b, 0x4c, 0x0f, + 0xfd, 0x1f, 0xa8, 0x63, 0x7c, 0x22, 0x0b, 0x56, 0xa2, 0x04, 0x51, 0x1d, 0xe3, 0x13, 0x5e, 0xab, + 0x42, 0xcf, 0x42, 0x85, 0xbd, 0x1c, 0x60, 0x01, 0x23, 0x45, 0xbd, 0x3c, 0xc6, 0x27, 0xdf, 0xc2, + 0x81, 0xf6, 0x33, 0x05, 0x1a, 0xe9, 0x79, 0xa2, 0x97, 0x01, 0x31, 0x59, 0x3c, 0x20, 0x86, 0x33, + 0x19, 0x0b, 0x86, 0x16, 0x5a, 0x6c, 0x8e, 0xf1, 0xc9, 0xfe, 0x80, 0xdc, 0x9d, 0x8c, 0xf9, 0xd0, + 0x01, 0x7a, 0x0f, 0x5a, 0xa1, 0x70, 0xf8, 0x1b, 0x8d, 0xf4, 0xca, 0x73, 0x67, 0xca, 0x85, 0xb7, + 0xa4, 0x80, 0xa8, 0x16, 0xfe, 0xea, 0xcb, 0x6d, 0x45, 0x6f, 0x08, 0x7b, 0xe1, 0x1b, 0xed, 0x75, + 0x68, 0xce, 0xac, 0x18, 0x69, 0x50, 0xf7, 0x26, 0x7d, 0xe3, 0x31, 0x99, 0x1a, 0xdc, 0x25, 0x1c, + 0x01, 0x54, 0xbd, 0xe6, 0x4d, 0xfa, 0xef, 0x92, 0xe9, 0x03, 0xd6, 0xa5, 0x99, 0xd0, 0x48, 0x97, + 0xa3, 0xd8, 0xe9, 0xf0, 0xdd, 0x89, 0x63, 0xf1, 0x79, 0xaf, 0xeb, 0xa2, 0x81, 0x6e, 0xc2, 0xfa, + 0xb1, 0x2b, 0xb0, 0x74, 0x19, 0x8a, 0x3c, 0x72, 0x29, 0x49, 0x14, 0xb5, 0x84, 0x8e, 0x76, 0x97, + 0x79, 0x8a, 0x38, 0x74, 0x9f, 0x52, 0xdf, 0xee, 0x4f, 0x28, 0x49, 0x16, 0x57, 0x37, 0xe6, 0x14, + 0x57, 0x23, 0xb6, 0x14, 0x71, 0xad, 0xa2, 0xa8, 0xec, 0xf1, 0x86, 0xf6, 0x23, 0x05, 0xd6, 0xb9, + 0x41, 0x06, 0x99, 0xbc, 0x52, 0x25, 0x79, 0x38, 0x7b, 0x46, 0x26, 0x00, 0x0e, 0x07, 0x0a, 0xe7, + 0x7b, 0x79, 0x19, 0x58, 0x47, 0xd3, 0xea, 0x3e, 0x2f, 0x51, 0x7b, 0x33, 0x36, 0x90, 0x40, 0xee, + 0x84, 0x59, 0xed, 0x9f, 0x25, 0x28, 0x8b, 0x72, 0x20, 0x7a, 0x3b, 0x5d, 0x9c, 0xae, 0xed, 0x6d, + 0x2d, 0x72, 0x8e, 0x90, 0x92, 0xbe, 0x89, 0xb2, 0x83, 0x2b, 0xb3, 0x15, 0xdf, 0x6e, 0xed, 0xf4, + 0xc9, 0x76, 0x85, 0x33, 0xeb, 0xc3, 0x5b, 0x71, 0xf9, 0x77, 0x51, 0xf5, 0x33, 0xac, 0x35, 0x97, + 0x56, 0xae, 0x35, 0xf7, 0xa0, 0x9e, 0x48, 0x25, 0x6c, 0x4b, 0x16, 0x3f, 0xb6, 0x96, 0x1d, 0xe9, + 0xc3, 0x5b, 0x72, 0xfe, 0xb5, 0x28, 0xd5, 0x38, 0xb4, 0xd0, 0xb5, 0x74, 0x11, 0x94, 0x67, 0x24, + 0x82, 0x0a, 0x27, 0xea, 0x9a, 0x2c, 0x1f, 0x61, 0x87, 0x8d, 0x05, 0x36, 0x21, 0x22, 0x98, 0x71, + 0x95, 0x75, 0xf0, 0x97, 0x57, 0xa1, 0x19, 0x93, 0x76, 0x21, 0x52, 0x15, 0x56, 0xe2, 0x6e, 0x2e, + 0x78, 0x03, 0x36, 0x1d, 0x72, 0x42, 0x8d, 0x59, 0x69, 0x95, 0x4b, 0x23, 0xf6, 0xee, 0x51, 0x5a, + 0xe3, 0x32, 0x34, 0x62, 0x7a, 0xc0, 0x65, 0x41, 0x94, 0xa6, 0xa3, 0x5e, 0x2e, 0x96, 0xac, 0xfa, + 0xd5, 0x52, 0x55, 0xbf, 0x28, 0x49, 0x13, 0xf0, 0x2d, 0x8d, 0x6c, 0x70, 0x19, 0x9e, 0xa4, 0x09, + 0xf8, 0x15, 0x66, 0x2e, 0x41, 0x3d, 0xc4, 0x2c, 0x21, 0x57, 0xe7, 0x72, 0x1b, 0x61, 0x27, 0x17, + 0xba, 0x0e, 0x2d, 0xcf, 0x77, 0x3d, 0x37, 0x20, 0xbe, 0x81, 0x2d, 0xcb, 0x27, 0x41, 0xc0, 0x13, + 0xfd, 0x0d, 0xbd, 0x19, 0xf6, 0xef, 0x8b, 0x6e, 0xed, 0x55, 0xa8, 0x84, 0xb9, 0xe2, 0x26, 0xac, + 0x77, 0x23, 0xfc, 0x2d, 0xe9, 0xa2, 0xc1, 0x0e, 0xd4, 0xbe, 0xe7, 0xc9, 0x5f, 0x3f, 0xd8, 0xa3, + 0x36, 0x82, 0x8a, 0xdc, 0xb0, 0xb9, 0x35, 0xef, 0xf7, 0x60, 0xc3, 0xc3, 0x3e, 0x5b, 0x46, 0xb2, + 0xf2, 0xbd, 0xa8, 0xcc, 0x74, 0x0f, 0xfb, 0xf4, 0x3e, 0xa1, 0xa9, 0x02, 0x78, 0x8d, 0xeb, 0x8b, + 0x2e, 0xed, 0x4d, 0xa8, 0xa7, 0x64, 0xd8, 0x34, 0xa9, 0x4b, 0xf1, 0x28, 0x84, 0x11, 0xde, 0x88, + 0x66, 0x52, 0x88, 0x67, 0xa2, 0xdd, 0x04, 0x35, 0xda, 0x2b, 0x96, 0x44, 0x87, 0xae, 0x50, 0xa4, + 0xfb, 0x45, 0x93, 0x17, 0xf9, 0xdd, 0x4f, 0x65, 0x21, 0xb3, 0xa8, 0x8b, 0x86, 0x46, 0x12, 0xb0, + 0x27, 0x98, 0x1a, 0x7a, 0x0b, 0x2a, 0x12, 0xf6, 0xe4, 0x79, 0x5c, 0x54, 0xce, 0xbf, 0xc7, 0x71, + 0x30, 0x2c, 0xe7, 0x0b, 0x54, 0x8c, 0x87, 0x29, 0x24, 0x87, 0xf9, 0x21, 0x54, 0x43, 0x68, 0x4b, + 0xc7, 0x20, 0x31, 0xc2, 0xc5, 0xac, 0x18, 0x24, 0x07, 0x89, 0x15, 0xd9, 0xd7, 0x14, 0xd8, 0x03, + 0x87, 0x58, 0x46, 0x7c, 0x04, 0xf9, 0x98, 0x55, 0xbd, 0x29, 0x5e, 0xdc, 0x09, 0xcf, 0x97, 0x76, + 0x03, 0xca, 0x62, 0xae, 0x73, 0xf1, 0x6e, 0x0e, 0x6d, 0xd4, 0xfe, 0xa6, 0x40, 0x35, 0x0c, 0x4e, + 0x73, 0x95, 0x52, 0x8b, 0x28, 0x7c, 0xd5, 0x45, 0x3c, 0x7d, 0x48, 0x7a, 0x05, 0x10, 0xff, 0x52, + 0x8c, 0x63, 0x97, 0xda, 0xce, 0xc0, 0x10, 0x7b, 0x21, 0xb2, 0x9c, 0x16, 0x7f, 0xf3, 0x88, 0xbf, + 0xb8, 0xc7, 0xb7, 0xe5, 0xc7, 0x0a, 0x54, 0x23, 0x4e, 0xba, 0x6a, 0xe5, 0xfd, 0x02, 0x94, 0x25, + 0xef, 0x12, 0xa5, 0x77, 0xd9, 0x8a, 0xbe, 0xd1, 0x52, 0xe2, 0xb4, 0x74, 0xa0, 0x3a, 0x26, 0x14, + 0x73, 0x3f, 0x8b, 0x4a, 0x4b, 0xd4, 0x7e, 0xe9, 0x12, 0xd4, 0x12, 0x3f, 0x85, 0xa0, 0x0a, 0x14, + 0xef, 0x92, 0x4f, 0x5b, 0x6b, 0xa8, 0x06, 0x15, 0x9d, 0xf0, 0xea, 0x67, 0x4b, 0xd9, 0xfb, 0xac, + 0x06, 0xcd, 0xfd, 0xee, 0xc1, 0x21, 0xa3, 0x85, 0xb6, 0xc9, 0x43, 0x36, 0x7a, 0x1f, 0x4a, 0xbc, + 0x10, 0x95, 0xe3, 0xe6, 0x45, 0x27, 0x4f, 0x29, 0x1d, 0xe9, 0xb0, 0xce, 0xeb, 0x55, 0x28, 0xcf, + 0x85, 0x8c, 0x4e, 0xae, 0x0a, 0x3b, 0x9b, 0x24, 0xff, 0xea, 0x73, 0xdc, 0xd3, 0xe8, 0xe4, 0x29, + 0xbb, 0xa3, 0x8f, 0x40, 0x8d, 0x0b, 0x51, 0x79, 0x6f, 0x6f, 0x74, 0x72, 0x17, 0xe4, 0x99, 0xfd, + 0x38, 0xf5, 0xce, 0x7b, 0x77, 0xa1, 0x93, 0xbb, 0x12, 0x8d, 0x3e, 0x84, 0x4a, 0x58, 0xe4, 0xc8, + 0x77, 0xbf, 0xa2, 0x93, 0xb3, 0x58, 0xce, 0xb6, 0x4f, 0xd4, 0xa6, 0xf2, 0x5c, 0x22, 0xe9, 0xe4, + 0xfa, 0x45, 0x00, 0x3d, 0x84, 0xb2, 0xcc, 0x2e, 0x73, 0xdd, 0x9c, 0xe8, 0xe4, 0x2b, 0x81, 0x33, + 0x27, 0xc7, 0xd5, 0xbf, 0xbc, 0x17, 0x67, 0x3a, 0xb9, 0x7f, 0x0a, 0x41, 0x18, 0x20, 0x51, 0xb0, + 0xca, 0x7d, 0x23, 0xa6, 0x93, 0xff, 0x27, 0x0e, 0xf4, 0x3d, 0xa8, 0x46, 0x65, 0x89, 0x9c, 0x37, + 0x53, 0x3a, 0x79, 0x7f, 0x65, 0x40, 0x1f, 0x43, 0x3d, 0x9d, 0x89, 0xaf, 0x72, 0xdf, 0xa4, 0xb3, + 0xd2, 0xcf, 0x07, 0x6c, 0xac, 0x74, 0x72, 0xbe, 0xca, 0x2d, 0x94, 0xce, 0x4a, 0xbf, 0x29, 0xa0, + 0x63, 0x38, 0x77, 0x36, 0x9f, 0x5e, 0xf5, 0x6a, 0x4a, 0x67, 0xe5, 0xdf, 0x1a, 0xd0, 0x14, 0xd0, + 0x9c, 0x9c, 0x7c, 0xe5, 0xfb, 0x2a, 0x9d, 0xd5, 0x7f, 0x80, 0xe8, 0x1e, 0xfe, 0xfb, 0x2f, 0x5b, + 0xca, 0x6f, 0x4e, 0xb7, 0x94, 0xcf, 0x4f, 0xb7, 0x94, 0x2f, 0x4e, 0xb7, 0x94, 0x3f, 0x9e, 0x6e, + 0x29, 0x7f, 0x3e, 0xdd, 0x52, 0x7e, 0xff, 0xd7, 0x2d, 0xe5, 0xbb, 0x2f, 0x0f, 0x6c, 0x3a, 0x9c, + 0xf4, 0x77, 0x4c, 0x77, 0xbc, 0x1b, 0x9b, 0x4e, 0x3e, 0xc6, 0x97, 0x04, 0xfb, 0x65, 0x1e, 0x00, + 0x5f, 0xfb, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3d, 0xc7, 0x11, 0xb1, 0x39, 0x28, 0x00, 0x00, } func (this *Request) Equal(that interface{}) bool { @@ -3483,14 +4217,14 @@ func (this *Request_Commit) Equal(that interface{}) bool { } return true } -func (this *RequestEcho) Equal(that interface{}) bool { +func (this *Request_ListSnapshots) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*RequestEcho) + that1, ok := that.(*Request_ListSnapshots) if !ok { - that2, ok := that.(RequestEcho) + that2, ok := that.(Request_ListSnapshots) if ok { that1 = &that2 } else { @@ -3502,22 +4236,19 @@ func (this *RequestEcho) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Message != that1.Message { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.ListSnapshots.Equal(that1.ListSnapshots) { return false } return true } -func (this *RequestFlush) Equal(that interface{}) bool { +func (this *Request_OfferSnapshot) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*RequestFlush) + that1, ok := that.(*Request_OfferSnapshot) if !ok { - that2, ok := that.(RequestFlush) + that2, ok := that.(Request_OfferSnapshot) if ok { that1 = &that2 } else { @@ -3529,19 +4260,19 @@ func (this *RequestFlush) Equal(that interface{}) bool { } else if this == nil { return false } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.OfferSnapshot.Equal(that1.OfferSnapshot) { return false } return true } -func (this *RequestInfo) Equal(that interface{}) bool { +func (this *Request_LoadSnapshotChunk) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*RequestInfo) + that1, ok := that.(*Request_LoadSnapshotChunk) if !ok { - that2, ok := that.(RequestInfo) + that2, ok := that.(Request_LoadSnapshotChunk) if ok { that1 = &that2 } else { @@ -3553,28 +4284,19 @@ func (this *RequestInfo) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Version != that1.Version { - return false - } - if this.BlockVersion != that1.BlockVersion { - return false - } - if this.P2PVersion != that1.P2PVersion { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.LoadSnapshotChunk.Equal(that1.LoadSnapshotChunk) { return false } return true } -func (this *RequestSetOption) Equal(that interface{}) bool { +func (this *Request_ApplySnapshotChunk) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*RequestSetOption) + that1, ok := that.(*Request_ApplySnapshotChunk) if !ok { - that2, ok := that.(RequestSetOption) + that2, ok := that.(Request_ApplySnapshotChunk) if ok { that1 = &that2 } else { @@ -3586,25 +4308,19 @@ func (this *RequestSetOption) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Key != that1.Key { - return false - } - if this.Value != that1.Value { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.ApplySnapshotChunk.Equal(that1.ApplySnapshotChunk) { return false } return true } -func (this *RequestInitChain) Equal(that interface{}) bool { +func (this *RequestEcho) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*RequestInitChain) + that1, ok := that.(*RequestEcho) if !ok { - that2, ok := that.(RequestInitChain) + that2, ok := that.(RequestEcho) if ok { that1 = &that2 } else { @@ -3616,14 +4332,128 @@ func (this *RequestInitChain) Equal(that interface{}) bool { } else if this == nil { return false } - if !this.Time.Equal(that1.Time) { + if this.Message != that1.Message { return false } - if this.ChainId != that1.ChainId { + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { return false } - if !this.ConsensusParams.Equal(that1.ConsensusParams) { - return false + return true +} +func (this *RequestFlush) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestFlush) + if !ok { + that2, ok := that.(RequestFlush) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestInfo) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestInfo) + if !ok { + that2, ok := that.(RequestInfo) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Version != that1.Version { + return false + } + if this.BlockVersion != that1.BlockVersion { + return false + } + if this.P2PVersion != that1.P2PVersion { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestSetOption) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestSetOption) + if !ok { + that2, ok := that.(RequestSetOption) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Key != that1.Key { + return false + } + if this.Value != that1.Value { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestInitChain) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestInitChain) + if !ok { + that2, ok := that.(RequestInitChain) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Time.Equal(that1.Time) { + return false + } + if this.ChainId != that1.ChainId { + return false + } + if !this.ConsensusParams.Equal(that1.ConsensusParams) { + return false } if len(this.Validators) != len(that1.Validators) { return false @@ -3826,6 +4656,126 @@ func (this *RequestCommit) Equal(that interface{}) bool { } return true } +func (this *RequestListSnapshots) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestListSnapshots) + if !ok { + that2, ok := that.(RequestListSnapshots) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestOfferSnapshot) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestOfferSnapshot) + if !ok { + that2, ok := that.(RequestOfferSnapshot) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Snapshot.Equal(that1.Snapshot) { + return false + } + if !bytes.Equal(this.AppHash, that1.AppHash) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestLoadSnapshotChunk) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestLoadSnapshotChunk) + if !ok { + that2, ok := that.(RequestLoadSnapshotChunk) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Height != that1.Height { + return false + } + if this.Format != that1.Format { + return false + } + if this.Chunk != that1.Chunk { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *RequestApplySnapshotChunk) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RequestApplySnapshotChunk) + if !ok { + that2, ok := that.(RequestApplySnapshotChunk) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Index != that1.Index { + return false + } + if !bytes.Equal(this.Chunk, that1.Chunk) { + return false + } + if this.Sender != that1.Sender { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} func (this *Response) Equal(that interface{}) bool { if that == nil { return this == nil @@ -4147,14 +5097,14 @@ func (this *Response_Commit) Equal(that interface{}) bool { } return true } -func (this *ResponseException) Equal(that interface{}) bool { +func (this *Response_ListSnapshots) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ResponseException) + that1, ok := that.(*Response_ListSnapshots) if !ok { - that2, ok := that.(ResponseException) + that2, ok := that.(Response_ListSnapshots) if ok { that1 = &that2 } else { @@ -4166,22 +5116,19 @@ func (this *ResponseException) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Error != that1.Error { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.ListSnapshots.Equal(that1.ListSnapshots) { return false } return true } -func (this *ResponseEcho) Equal(that interface{}) bool { +func (this *Response_OfferSnapshot) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ResponseEcho) + that1, ok := that.(*Response_OfferSnapshot) if !ok { - that2, ok := that.(ResponseEcho) + that2, ok := that.(Response_OfferSnapshot) if ok { that1 = &that2 } else { @@ -4193,22 +5140,19 @@ func (this *ResponseEcho) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Message != that1.Message { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.OfferSnapshot.Equal(that1.OfferSnapshot) { return false } return true } -func (this *ResponseFlush) Equal(that interface{}) bool { +func (this *Response_LoadSnapshotChunk) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ResponseFlush) + that1, ok := that.(*Response_LoadSnapshotChunk) if !ok { - that2, ok := that.(ResponseFlush) + that2, ok := that.(Response_LoadSnapshotChunk) if ok { that1 = &that2 } else { @@ -4220,19 +5164,19 @@ func (this *ResponseFlush) Equal(that interface{}) bool { } else if this == nil { return false } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.LoadSnapshotChunk.Equal(that1.LoadSnapshotChunk) { return false } return true } -func (this *ResponseInfo) Equal(that interface{}) bool { +func (this *Response_ApplySnapshotChunk) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*ResponseInfo) + that1, ok := that.(*Response_ApplySnapshotChunk) if !ok { - that2, ok := that.(ResponseInfo) + that2, ok := that.(Response_ApplySnapshotChunk) if ok { that1 = &that2 } else { @@ -4244,22 +5188,124 @@ func (this *ResponseInfo) Equal(that interface{}) bool { } else if this == nil { return false } - if this.Data != that1.Data { - return false - } - if this.Version != that1.Version { - return false - } - if this.AppVersion != that1.AppVersion { - return false - } - if this.LastBlockHeight != that1.LastBlockHeight { - return false - } - if !bytes.Equal(this.LastBlockAppHash, that1.LastBlockAppHash) { - return false - } - if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + if !this.ApplySnapshotChunk.Equal(that1.ApplySnapshotChunk) { + return false + } + return true +} +func (this *ResponseException) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseException) + if !ok { + that2, ok := that.(ResponseException) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Error != that1.Error { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseEcho) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseEcho) + if !ok { + that2, ok := that.(ResponseEcho) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Message != that1.Message { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseFlush) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseFlush) + if !ok { + that2, ok := that.(ResponseFlush) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseInfo) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseInfo) + if !ok { + that2, ok := that.(ResponseInfo) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Data != that1.Data { + return false + } + if this.Version != that1.Version { + return false + } + if this.AppVersion != that1.AppVersion { + return false + } + if this.LastBlockHeight != that1.LastBlockHeight { + return false + } + if !bytes.Equal(this.LastBlockAppHash, that1.LastBlockAppHash) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { return false } return true @@ -4594,6 +5640,135 @@ func (this *ResponseCommit) Equal(that interface{}) bool { } return true } +func (this *ResponseListSnapshots) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseListSnapshots) + if !ok { + that2, ok := that.(ResponseListSnapshots) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if len(this.Snapshots) != len(that1.Snapshots) { + return false + } + for i := range this.Snapshots { + if !this.Snapshots[i].Equal(that1.Snapshots[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseOfferSnapshot) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseOfferSnapshot) + if !ok { + that2, ok := that.(ResponseOfferSnapshot) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Result != that1.Result { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseLoadSnapshotChunk) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseLoadSnapshotChunk) + if !ok { + that2, ok := that.(ResponseLoadSnapshotChunk) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !bytes.Equal(this.Chunk, that1.Chunk) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ResponseApplySnapshotChunk) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ResponseApplySnapshotChunk) + if !ok { + that2, ok := that.(ResponseApplySnapshotChunk) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Result != that1.Result { + return false + } + if len(this.RefetchChunks) != len(that1.RefetchChunks) { + return false + } + for i := range this.RefetchChunks { + if this.RefetchChunks[i] != that1.RefetchChunks[i] { + return false + } + } + if len(this.RejectSenders) != len(that1.RejectSenders) { + return false + } + for i := range this.RejectSenders { + if this.RejectSenders[i] != that1.RejectSenders[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} func (this *ConsensusParams) Equal(that interface{}) bool { if that == nil { return this == nil @@ -5137,6 +6312,45 @@ func (this *Evidence) Equal(that interface{}) bool { } return true } +func (this *Snapshot) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Snapshot) + if !ok { + that2, ok := that.(Snapshot) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Height != that1.Height { + return false + } + if this.Format != that1.Format { + return false + } + if this.Chunks != that1.Chunks { + return false + } + if !bytes.Equal(this.Hash, that1.Hash) { + return false + } + if !bytes.Equal(this.Metadata, that1.Metadata) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} // Reference imports to suppress errors if they are not otherwise used. var _ context.Context @@ -5161,6 +6375,10 @@ type ABCIApplicationClient interface { InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) + ListSnapshots(ctx context.Context, in *RequestListSnapshots, opts ...grpc.CallOption) (*ResponseListSnapshots, error) + OfferSnapshot(ctx context.Context, in *RequestOfferSnapshot, opts ...grpc.CallOption) (*ResponseOfferSnapshot, error) + LoadSnapshotChunk(ctx context.Context, in *RequestLoadSnapshotChunk, opts ...grpc.CallOption) (*ResponseLoadSnapshotChunk, error) + ApplySnapshotChunk(ctx context.Context, in *RequestApplySnapshotChunk, opts ...grpc.CallOption) (*ResponseApplySnapshotChunk, error) } type aBCIApplicationClient struct { @@ -5270,7 +6488,43 @@ func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBloc return out, nil } -// ABCIApplicationServer is the server API for ABCIApplication service. +func (c *aBCIApplicationClient) ListSnapshots(ctx context.Context, in *RequestListSnapshots, opts ...grpc.CallOption) (*ResponseListSnapshots, error) { + out := new(ResponseListSnapshots) + err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/ListSnapshots", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aBCIApplicationClient) OfferSnapshot(ctx context.Context, in *RequestOfferSnapshot, opts ...grpc.CallOption) (*ResponseOfferSnapshot, error) { + out := new(ResponseOfferSnapshot) + err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/OfferSnapshot", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aBCIApplicationClient) LoadSnapshotChunk(ctx context.Context, in *RequestLoadSnapshotChunk, opts ...grpc.CallOption) (*ResponseLoadSnapshotChunk, error) { + out := new(ResponseLoadSnapshotChunk) + err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/LoadSnapshotChunk", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aBCIApplicationClient) ApplySnapshotChunk(ctx context.Context, in *RequestApplySnapshotChunk, opts ...grpc.CallOption) (*ResponseApplySnapshotChunk, error) { + out := new(ResponseApplySnapshotChunk) + err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/ApplySnapshotChunk", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ABCIApplicationServer is the server API for ABCIApplication service. type ABCIApplicationServer interface { Echo(context.Context, *RequestEcho) (*ResponseEcho, error) Flush(context.Context, *RequestFlush) (*ResponseFlush, error) @@ -5283,6 +6537,10 @@ type ABCIApplicationServer interface { InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error) BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error) EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error) + ListSnapshots(context.Context, *RequestListSnapshots) (*ResponseListSnapshots, error) + OfferSnapshot(context.Context, *RequestOfferSnapshot) (*ResponseOfferSnapshot, error) + LoadSnapshotChunk(context.Context, *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error) + ApplySnapshotChunk(context.Context, *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) } // UnimplementedABCIApplicationServer can be embedded to have forward compatible implementations. @@ -5322,6 +6580,18 @@ func (*UnimplementedABCIApplicationServer) BeginBlock(ctx context.Context, req * func (*UnimplementedABCIApplicationServer) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) { return nil, status.Errorf(codes.Unimplemented, "method EndBlock not implemented") } +func (*UnimplementedABCIApplicationServer) ListSnapshots(ctx context.Context, req *RequestListSnapshots) (*ResponseListSnapshots, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListSnapshots not implemented") +} +func (*UnimplementedABCIApplicationServer) OfferSnapshot(ctx context.Context, req *RequestOfferSnapshot) (*ResponseOfferSnapshot, error) { + return nil, status.Errorf(codes.Unimplemented, "method OfferSnapshot not implemented") +} +func (*UnimplementedABCIApplicationServer) LoadSnapshotChunk(ctx context.Context, req *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error) { + return nil, status.Errorf(codes.Unimplemented, "method LoadSnapshotChunk not implemented") +} +func (*UnimplementedABCIApplicationServer) ApplySnapshotChunk(ctx context.Context, req *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) { + return nil, status.Errorf(codes.Unimplemented, "method ApplySnapshotChunk not implemented") +} func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) { s.RegisterService(&_ABCIApplication_serviceDesc, srv) @@ -5525,6 +6795,78 @@ func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _ABCIApplication_ListSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequestListSnapshots) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ABCIApplicationServer).ListSnapshots(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/tendermint.abci.types.ABCIApplication/ListSnapshots", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ABCIApplicationServer).ListSnapshots(ctx, req.(*RequestListSnapshots)) + } + return interceptor(ctx, in, info, handler) +} + +func _ABCIApplication_OfferSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequestOfferSnapshot) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ABCIApplicationServer).OfferSnapshot(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/tendermint.abci.types.ABCIApplication/OfferSnapshot", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ABCIApplicationServer).OfferSnapshot(ctx, req.(*RequestOfferSnapshot)) + } + return interceptor(ctx, in, info, handler) +} + +func _ABCIApplication_LoadSnapshotChunk_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequestLoadSnapshotChunk) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ABCIApplicationServer).LoadSnapshotChunk(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/tendermint.abci.types.ABCIApplication/LoadSnapshotChunk", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ABCIApplicationServer).LoadSnapshotChunk(ctx, req.(*RequestLoadSnapshotChunk)) + } + return interceptor(ctx, in, info, handler) +} + +func _ABCIApplication_ApplySnapshotChunk_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequestApplySnapshotChunk) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ABCIApplicationServer).ApplySnapshotChunk(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/tendermint.abci.types.ABCIApplication/ApplySnapshotChunk", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ABCIApplicationServer).ApplySnapshotChunk(ctx, req.(*RequestApplySnapshotChunk)) + } + return interceptor(ctx, in, info, handler) +} + var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ ServiceName: "tendermint.abci.types.ABCIApplication", HandlerType: (*ABCIApplicationServer)(nil), @@ -5573,6 +6915,22 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ MethodName: "EndBlock", Handler: _ABCIApplication_EndBlock_Handler, }, + { + MethodName: "ListSnapshots", + Handler: _ABCIApplication_ListSnapshots_Handler, + }, + { + MethodName: "OfferSnapshot", + Handler: _ABCIApplication_OfferSnapshot_Handler, + }, + { + MethodName: "LoadSnapshotChunk", + Handler: _ABCIApplication_LoadSnapshotChunk_Handler, + }, + { + MethodName: "ApplySnapshotChunk", + Handler: _ABCIApplication_ApplySnapshotChunk_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "abci/types/types.proto", @@ -5824,6 +7182,92 @@ func (m *Request_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } +func (m *Request_ListSnapshots) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Request_ListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ListSnapshots != nil { + { + size, err := m.ListSnapshots.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *Request_OfferSnapshot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Request_OfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.OfferSnapshot != nil { + { + size, err := m.OfferSnapshot.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *Request_LoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Request_LoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LoadSnapshotChunk != nil { + { + size, err := m.LoadSnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *Request_ApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Request_ApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ApplySnapshotChunk != nil { + { + size, err := m.ApplySnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} func (m *Request_DeliverTx) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) @@ -6057,12 +7501,12 @@ func (m *RequestInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) - if err13 != nil { - return 0, err13 + n17, err17 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) + if err17 != nil { + return 0, err17 } - i -= n13 - i = encodeVarintTypes(dAtA, i, uint64(n13)) + i -= n17 + i = encodeVarintTypes(dAtA, i, uint64(n17)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil @@ -6324,7 +7768,7 @@ func (m *RequestCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Response) Marshal() (dAtA []byte, err error) { +func (m *RequestListSnapshots) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6334,12 +7778,12 @@ func (m *Response) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Response) MarshalTo(dAtA []byte) (int, error) { +func (m *RequestListSnapshots) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RequestListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6348,28 +7792,43 @@ func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Value != nil { - { - size := m.Value.Size() - i -= size - if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } return len(dAtA) - i, nil } -func (m *Response_Exception) MarshalTo(dAtA []byte) (int, error) { +func (m *RequestOfferSnapshot) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RequestOfferSnapshot) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RequestOfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Exception != nil { + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.AppHash) > 0 { + i -= len(m.AppHash) + copy(dAtA[i:], m.AppHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) + i-- + dAtA[i] = 0x12 + } + if m.Snapshot != nil { { - size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -6381,44 +7840,190 @@ func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Response_Echo) MarshalTo(dAtA []byte) (int, error) { + +func (m *RequestLoadSnapshotChunk) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RequestLoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RequestLoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Echo != nil { - { - size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Chunk != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Chunk)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x18 + } + if m.Format != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Format)) + i-- + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *Response_Flush) MarshalTo(dAtA []byte) (int, error) { + +func (m *RequestApplySnapshotChunk) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RequestApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RequestApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Flush != nil { - { - size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x1a + } + if len(m.Chunk) > 0 { + i -= len(m.Chunk) + copy(dAtA[i:], m.Chunk) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Chunk))) + i-- + dAtA[i] = 0x12 + } + if m.Index != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Response) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Response) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Value != nil { + { + size := m.Value.Size() + i -= size + if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *Response_Exception) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Exception != nil { + { + size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *Response_Echo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Echo != nil { + { + size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *Response_Flush) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Flush != nil { + { + size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil @@ -6612,6 +8217,92 @@ func (m *Response_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } +func (m *Response_ListSnapshots) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_ListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ListSnapshots != nil { + { + size, err := m.ListSnapshots.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *Response_OfferSnapshot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_OfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.OfferSnapshot != nil { + { + size, err := m.OfferSnapshot.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *Response_LoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_LoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LoadSnapshotChunk != nil { + { + size, err := m.LoadSnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *Response_ApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_ApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ApplySnapshotChunk != nil { + { + size, err := m.ApplySnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} func (m *ResponseException) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7268,7 +8959,7 @@ func (m *ResponseCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ConsensusParams) Marshal() (dAtA []byte, err error) { +func (m *ResponseListSnapshots) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7278,12 +8969,12 @@ func (m *ConsensusParams) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ConsensusParams) MarshalTo(dAtA []byte) (int, error) { +func (m *ResponseListSnapshots) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResponseListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7292,46 +8983,24 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Validator != nil { - { - size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Evidence != nil { - { - size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Block != nil { - { - size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Snapshots) > 0 { + for iNdEx := len(m.Snapshots) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Snapshots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *BlockParams) Marshal() (dAtA []byte, err error) { +func (m *ResponseOfferSnapshot) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7341,12 +9010,12 @@ func (m *BlockParams) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BlockParams) MarshalTo(dAtA []byte) (int, error) { +func (m *ResponseOfferSnapshot) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResponseOfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7355,20 +9024,15 @@ func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.MaxGas != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) - i-- - dAtA[i] = 0x10 - } - if m.MaxBytes != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) + if m.Result != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Result)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *EvidenceParams) Marshal() (dAtA []byte, err error) { +func (m *ResponseLoadSnapshotChunk) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7378,12 +9042,12 @@ func (m *EvidenceParams) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *EvidenceParams) MarshalTo(dAtA []byte) (int, error) { +func (m *ResponseLoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResponseLoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7392,23 +9056,17 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n34, err34 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):]) - if err34 != nil { - return 0, err34 - } - i -= n34 - i = encodeVarintTypes(dAtA, i, uint64(n34)) - i-- - dAtA[i] = 0x12 - if m.MaxAgeNumBlocks != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.MaxAgeNumBlocks)) + if len(m.Chunk) > 0 { + i -= len(m.Chunk) + copy(dAtA[i:], m.Chunk) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Chunk))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ValidatorParams) Marshal() (dAtA []byte, err error) { +func (m *ResponseApplySnapshotChunk) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7418,12 +9076,12 @@ func (m *ValidatorParams) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ValidatorParams) MarshalTo(dAtA []byte) (int, error) { +func (m *ResponseApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResponseApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7432,11 +9090,210 @@ func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.PubKeyTypes) > 0 { - for iNdEx := len(m.PubKeyTypes) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.PubKeyTypes[iNdEx]) - copy(dAtA[i:], m.PubKeyTypes[iNdEx]) - i = encodeVarintTypes(dAtA, i, uint64(len(m.PubKeyTypes[iNdEx]))) + if len(m.RejectSenders) > 0 { + for iNdEx := len(m.RejectSenders) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RejectSenders[iNdEx]) + copy(dAtA[i:], m.RejectSenders[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.RejectSenders[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.RefetchChunks) > 0 { + dAtA41 := make([]byte, len(m.RefetchChunks)*10) + var j40 int + for _, num := range m.RefetchChunks { + for num >= 1<<7 { + dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j40++ + } + dAtA41[j40] = uint8(num) + j40++ + } + i -= j40 + copy(dAtA[i:], dAtA41[:j40]) + i = encodeVarintTypes(dAtA, i, uint64(j40)) + i-- + dAtA[i] = 0x12 + } + if m.Result != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Result)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ConsensusParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConsensusParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Validator != nil { + { + size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Evidence != nil { + { + size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + { + size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.MaxGas != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) + i-- + dAtA[i] = 0x10 + } + if m.MaxBytes != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EvidenceParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EvidenceParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + n45, err45 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):]) + if err45 != nil { + return 0, err45 + } + i -= n45 + i = encodeVarintTypes(dAtA, i, uint64(n45)) + i-- + dAtA[i] = 0x12 + if m.MaxAgeNumBlocks != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.MaxAgeNumBlocks)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ValidatorParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidatorParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.PubKeyTypes) > 0 { + for iNdEx := len(m.PubKeyTypes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.PubKeyTypes[iNdEx]) + copy(dAtA[i:], m.PubKeyTypes[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.PubKeyTypes[iNdEx]))) i-- dAtA[i] = 0xa } @@ -7686,12 +9543,12 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x2a - n36, err36 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) - if err36 != nil { - return 0, err36 + n47, err47 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) + if err47 != nil { + return 0, err47 } - i -= n36 - i = encodeVarintTypes(dAtA, i, uint64(n36)) + i -= n47 + i = encodeVarintTypes(dAtA, i, uint64(n47)) i-- dAtA[i] = 0x22 if m.Height != 0 { @@ -8037,12 +9894,12 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x28 } - n41, err41 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) - if err41 != nil { - return 0, err41 + n52, err52 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) + if err52 != nil { + return 0, err52 } - i -= n41 - i = encodeVarintTypes(dAtA, i, uint64(n41)) + i -= n52 + i = encodeVarintTypes(dAtA, i, uint64(n52)) i-- dAtA[i] = 0x22 if m.Height != 0 { @@ -8070,6 +9927,62 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Snapshot) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Snapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Metadata) > 0 { + i -= len(m.Metadata) + copy(dAtA[i:], m.Metadata) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Metadata))) + i-- + dAtA[i] = 0x2a + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x22 + } + if m.Chunks != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Chunks)) + i-- + dAtA[i] = 0x18 + } + if m.Format != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Format)) + i-- + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -8083,7 +9996,7 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { } func NewPopulatedRequest(r randyTypes, easy bool) *Request { this := &Request{} - oneofNumber_Value := []int32{2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 19}[r.Intn(11)] + oneofNumber_Value := []int32{2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 19}[r.Intn(15)] switch oneofNumber_Value { case 2: this.Value = NewPopulatedRequest_Echo(r, easy) @@ -8105,6 +10018,14 @@ func NewPopulatedRequest(r randyTypes, easy bool) *Request { this.Value = NewPopulatedRequest_EndBlock(r, easy) case 12: this.Value = NewPopulatedRequest_Commit(r, easy) + case 13: + this.Value = NewPopulatedRequest_ListSnapshots(r, easy) + case 14: + this.Value = NewPopulatedRequest_OfferSnapshot(r, easy) + case 15: + this.Value = NewPopulatedRequest_LoadSnapshotChunk(r, easy) + case 16: + this.Value = NewPopulatedRequest_ApplySnapshotChunk(r, easy) case 19: this.Value = NewPopulatedRequest_DeliverTx(r, easy) } @@ -8164,6 +10085,26 @@ func NewPopulatedRequest_Commit(r randyTypes, easy bool) *Request_Commit { this.Commit = NewPopulatedRequestCommit(r, easy) return this } +func NewPopulatedRequest_ListSnapshots(r randyTypes, easy bool) *Request_ListSnapshots { + this := &Request_ListSnapshots{} + this.ListSnapshots = NewPopulatedRequestListSnapshots(r, easy) + return this +} +func NewPopulatedRequest_OfferSnapshot(r randyTypes, easy bool) *Request_OfferSnapshot { + this := &Request_OfferSnapshot{} + this.OfferSnapshot = NewPopulatedRequestOfferSnapshot(r, easy) + return this +} +func NewPopulatedRequest_LoadSnapshotChunk(r randyTypes, easy bool) *Request_LoadSnapshotChunk { + this := &Request_LoadSnapshotChunk{} + this.LoadSnapshotChunk = NewPopulatedRequestLoadSnapshotChunk(r, easy) + return this +} +func NewPopulatedRequest_ApplySnapshotChunk(r randyTypes, easy bool) *Request_ApplySnapshotChunk { + this := &Request_ApplySnapshotChunk{} + this.ApplySnapshotChunk = NewPopulatedRequestApplySnapshotChunk(r, easy) + return this +} func NewPopulatedRequest_DeliverTx(r randyTypes, easy bool) *Request_DeliverTx { this := &Request_DeliverTx{} this.DeliverTx = NewPopulatedRequestDeliverTx(r, easy) @@ -8325,37 +10266,95 @@ func NewPopulatedRequestCommit(r randyTypes, easy bool) *RequestCommit { return this } -func NewPopulatedResponse(r randyTypes, easy bool) *Response { - this := &Response{} - oneofNumber_Value := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}[r.Intn(12)] - switch oneofNumber_Value { - case 1: - this.Value = NewPopulatedResponse_Exception(r, easy) - case 2: - this.Value = NewPopulatedResponse_Echo(r, easy) - case 3: - this.Value = NewPopulatedResponse_Flush(r, easy) - case 4: - this.Value = NewPopulatedResponse_Info(r, easy) - case 5: - this.Value = NewPopulatedResponse_SetOption(r, easy) - case 6: - this.Value = NewPopulatedResponse_InitChain(r, easy) - case 7: - this.Value = NewPopulatedResponse_Query(r, easy) - case 8: - this.Value = NewPopulatedResponse_BeginBlock(r, easy) - case 9: - this.Value = NewPopulatedResponse_CheckTx(r, easy) - case 10: - this.Value = NewPopulatedResponse_DeliverTx(r, easy) - case 11: +func NewPopulatedRequestListSnapshots(r randyTypes, easy bool) *RequestListSnapshots { + this := &RequestListSnapshots{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 1) + } + return this +} + +func NewPopulatedRequestOfferSnapshot(r randyTypes, easy bool) *RequestOfferSnapshot { + this := &RequestOfferSnapshot{} + if r.Intn(5) != 0 { + this.Snapshot = NewPopulatedSnapshot(r, easy) + } + v13 := r.Intn(100) + this.AppHash = make([]byte, v13) + for i := 0; i < v13; i++ { + this.AppHash[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 3) + } + return this +} + +func NewPopulatedRequestLoadSnapshotChunk(r randyTypes, easy bool) *RequestLoadSnapshotChunk { + this := &RequestLoadSnapshotChunk{} + this.Height = uint64(uint64(r.Uint32())) + this.Format = uint32(r.Uint32()) + this.Chunk = uint32(r.Uint32()) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 4) + } + return this +} + +func NewPopulatedRequestApplySnapshotChunk(r randyTypes, easy bool) *RequestApplySnapshotChunk { + this := &RequestApplySnapshotChunk{} + this.Index = uint32(r.Uint32()) + v14 := r.Intn(100) + this.Chunk = make([]byte, v14) + for i := 0; i < v14; i++ { + this.Chunk[i] = byte(r.Intn(256)) + } + this.Sender = string(randStringTypes(r)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 4) + } + return this +} + +func NewPopulatedResponse(r randyTypes, easy bool) *Response { + this := &Response{} + oneofNumber_Value := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_Value { + case 1: + this.Value = NewPopulatedResponse_Exception(r, easy) + case 2: + this.Value = NewPopulatedResponse_Echo(r, easy) + case 3: + this.Value = NewPopulatedResponse_Flush(r, easy) + case 4: + this.Value = NewPopulatedResponse_Info(r, easy) + case 5: + this.Value = NewPopulatedResponse_SetOption(r, easy) + case 6: + this.Value = NewPopulatedResponse_InitChain(r, easy) + case 7: + this.Value = NewPopulatedResponse_Query(r, easy) + case 8: + this.Value = NewPopulatedResponse_BeginBlock(r, easy) + case 9: + this.Value = NewPopulatedResponse_CheckTx(r, easy) + case 10: + this.Value = NewPopulatedResponse_DeliverTx(r, easy) + case 11: this.Value = NewPopulatedResponse_EndBlock(r, easy) case 12: this.Value = NewPopulatedResponse_Commit(r, easy) + case 13: + this.Value = NewPopulatedResponse_ListSnapshots(r, easy) + case 14: + this.Value = NewPopulatedResponse_OfferSnapshot(r, easy) + case 15: + this.Value = NewPopulatedResponse_LoadSnapshotChunk(r, easy) + case 16: + this.Value = NewPopulatedResponse_ApplySnapshotChunk(r, easy) } if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 13) + this.XXX_unrecognized = randUnrecognizedTypes(r, 17) } return this } @@ -8420,6 +10419,26 @@ func NewPopulatedResponse_Commit(r randyTypes, easy bool) *Response_Commit { this.Commit = NewPopulatedResponseCommit(r, easy) return this } +func NewPopulatedResponse_ListSnapshots(r randyTypes, easy bool) *Response_ListSnapshots { + this := &Response_ListSnapshots{} + this.ListSnapshots = NewPopulatedResponseListSnapshots(r, easy) + return this +} +func NewPopulatedResponse_OfferSnapshot(r randyTypes, easy bool) *Response_OfferSnapshot { + this := &Response_OfferSnapshot{} + this.OfferSnapshot = NewPopulatedResponseOfferSnapshot(r, easy) + return this +} +func NewPopulatedResponse_LoadSnapshotChunk(r randyTypes, easy bool) *Response_LoadSnapshotChunk { + this := &Response_LoadSnapshotChunk{} + this.LoadSnapshotChunk = NewPopulatedResponseLoadSnapshotChunk(r, easy) + return this +} +func NewPopulatedResponse_ApplySnapshotChunk(r randyTypes, easy bool) *Response_ApplySnapshotChunk { + this := &Response_ApplySnapshotChunk{} + this.ApplySnapshotChunk = NewPopulatedResponseApplySnapshotChunk(r, easy) + return this +} func NewPopulatedResponseException(r randyTypes, easy bool) *ResponseException { this := &ResponseException{} this.Error = string(randStringTypes(r)) @@ -8455,9 +10474,9 @@ func NewPopulatedResponseInfo(r randyTypes, easy bool) *ResponseInfo { if r.Intn(2) == 0 { this.LastBlockHeight *= -1 } - v13 := r.Intn(100) - this.LastBlockAppHash = make([]byte, v13) - for i := 0; i < v13; i++ { + v15 := r.Intn(100) + this.LastBlockAppHash = make([]byte, v15) + for i := 0; i < v15; i++ { this.LastBlockAppHash[i] = byte(r.Intn(256)) } if !easy && r.Intn(10) != 0 { @@ -8483,11 +10502,11 @@ func NewPopulatedResponseInitChain(r randyTypes, easy bool) *ResponseInitChain { this.ConsensusParams = NewPopulatedConsensusParams(r, easy) } if r.Intn(5) != 0 { - v14 := r.Intn(5) - this.Validators = make([]ValidatorUpdate, v14) - for i := 0; i < v14; i++ { - v15 := NewPopulatedValidatorUpdate(r, easy) - this.Validators[i] = *v15 + v16 := r.Intn(5) + this.Validators = make([]ValidatorUpdate, v16) + for i := 0; i < v16; i++ { + v17 := NewPopulatedValidatorUpdate(r, easy) + this.Validators[i] = *v17 } } if !easy && r.Intn(10) != 0 { @@ -8505,14 +10524,14 @@ func NewPopulatedResponseQuery(r randyTypes, easy bool) *ResponseQuery { if r.Intn(2) == 0 { this.Index *= -1 } - v16 := r.Intn(100) - this.Key = make([]byte, v16) - for i := 0; i < v16; i++ { + v18 := r.Intn(100) + this.Key = make([]byte, v18) + for i := 0; i < v18; i++ { this.Key[i] = byte(r.Intn(256)) } - v17 := r.Intn(100) - this.Value = make([]byte, v17) - for i := 0; i < v17; i++ { + v19 := r.Intn(100) + this.Value = make([]byte, v19) + for i := 0; i < v19; i++ { this.Value[i] = byte(r.Intn(256)) } if r.Intn(5) != 0 { @@ -8532,11 +10551,11 @@ func NewPopulatedResponseQuery(r randyTypes, easy bool) *ResponseQuery { func NewPopulatedResponseBeginBlock(r randyTypes, easy bool) *ResponseBeginBlock { this := &ResponseBeginBlock{} if r.Intn(5) != 0 { - v18 := r.Intn(5) - this.Events = make([]Event, v18) - for i := 0; i < v18; i++ { - v19 := NewPopulatedEvent(r, easy) - this.Events[i] = *v19 + v20 := r.Intn(5) + this.Events = make([]Event, v20) + for i := 0; i < v20; i++ { + v21 := NewPopulatedEvent(r, easy) + this.Events[i] = *v21 } } if !easy && r.Intn(10) != 0 { @@ -8548,9 +10567,9 @@ func NewPopulatedResponseBeginBlock(r randyTypes, easy bool) *ResponseBeginBlock func NewPopulatedResponseCheckTx(r randyTypes, easy bool) *ResponseCheckTx { this := &ResponseCheckTx{} this.Code = uint32(r.Uint32()) - v20 := r.Intn(100) - this.Data = make([]byte, v20) - for i := 0; i < v20; i++ { + v22 := r.Intn(100) + this.Data = make([]byte, v22) + for i := 0; i < v22; i++ { this.Data[i] = byte(r.Intn(256)) } this.Log = string(randStringTypes(r)) @@ -8564,11 +10583,11 @@ func NewPopulatedResponseCheckTx(r randyTypes, easy bool) *ResponseCheckTx { this.GasUsed *= -1 } if r.Intn(5) != 0 { - v21 := r.Intn(5) - this.Events = make([]Event, v21) - for i := 0; i < v21; i++ { - v22 := NewPopulatedEvent(r, easy) - this.Events[i] = *v22 + v23 := r.Intn(5) + this.Events = make([]Event, v23) + for i := 0; i < v23; i++ { + v24 := NewPopulatedEvent(r, easy) + this.Events[i] = *v24 } } this.Codespace = string(randStringTypes(r)) @@ -8581,9 +10600,9 @@ func NewPopulatedResponseCheckTx(r randyTypes, easy bool) *ResponseCheckTx { func NewPopulatedResponseDeliverTx(r randyTypes, easy bool) *ResponseDeliverTx { this := &ResponseDeliverTx{} this.Code = uint32(r.Uint32()) - v23 := r.Intn(100) - this.Data = make([]byte, v23) - for i := 0; i < v23; i++ { + v25 := r.Intn(100) + this.Data = make([]byte, v25) + for i := 0; i < v25; i++ { this.Data[i] = byte(r.Intn(256)) } this.Log = string(randStringTypes(r)) @@ -8597,11 +10616,11 @@ func NewPopulatedResponseDeliverTx(r randyTypes, easy bool) *ResponseDeliverTx { this.GasUsed *= -1 } if r.Intn(5) != 0 { - v24 := r.Intn(5) - this.Events = make([]Event, v24) - for i := 0; i < v24; i++ { - v25 := NewPopulatedEvent(r, easy) - this.Events[i] = *v25 + v26 := r.Intn(5) + this.Events = make([]Event, v26) + for i := 0; i < v26; i++ { + v27 := NewPopulatedEvent(r, easy) + this.Events[i] = *v27 } } this.Codespace = string(randStringTypes(r)) @@ -8614,22 +10633,22 @@ func NewPopulatedResponseDeliverTx(r randyTypes, easy bool) *ResponseDeliverTx { func NewPopulatedResponseEndBlock(r randyTypes, easy bool) *ResponseEndBlock { this := &ResponseEndBlock{} if r.Intn(5) != 0 { - v26 := r.Intn(5) - this.ValidatorUpdates = make([]ValidatorUpdate, v26) - for i := 0; i < v26; i++ { - v27 := NewPopulatedValidatorUpdate(r, easy) - this.ValidatorUpdates[i] = *v27 + v28 := r.Intn(5) + this.ValidatorUpdates = make([]ValidatorUpdate, v28) + for i := 0; i < v28; i++ { + v29 := NewPopulatedValidatorUpdate(r, easy) + this.ValidatorUpdates[i] = *v29 } } if r.Intn(5) != 0 { this.ConsensusParamUpdates = NewPopulatedConsensusParams(r, easy) } if r.Intn(5) != 0 { - v28 := r.Intn(5) - this.Events = make([]Event, v28) - for i := 0; i < v28; i++ { - v29 := NewPopulatedEvent(r, easy) - this.Events[i] = *v29 + v30 := r.Intn(5) + this.Events = make([]Event, v30) + for i := 0; i < v30; i++ { + v31 := NewPopulatedEvent(r, easy) + this.Events[i] = *v31 } } if !easy && r.Intn(10) != 0 { @@ -8640,9 +10659,9 @@ func NewPopulatedResponseEndBlock(r randyTypes, easy bool) *ResponseEndBlock { func NewPopulatedResponseCommit(r randyTypes, easy bool) *ResponseCommit { this := &ResponseCommit{} - v30 := r.Intn(100) - this.Data = make([]byte, v30) - for i := 0; i < v30; i++ { + v32 := r.Intn(100) + this.Data = make([]byte, v32) + for i := 0; i < v32; i++ { this.Data[i] = byte(r.Intn(256)) } this.RetainHeight = int64(r.Int63()) @@ -8655,6 +10674,62 @@ func NewPopulatedResponseCommit(r randyTypes, easy bool) *ResponseCommit { return this } +func NewPopulatedResponseListSnapshots(r randyTypes, easy bool) *ResponseListSnapshots { + this := &ResponseListSnapshots{} + if r.Intn(5) != 0 { + v33 := r.Intn(5) + this.Snapshots = make([]*Snapshot, v33) + for i := 0; i < v33; i++ { + this.Snapshots[i] = NewPopulatedSnapshot(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 2) + } + return this +} + +func NewPopulatedResponseOfferSnapshot(r randyTypes, easy bool) *ResponseOfferSnapshot { + this := &ResponseOfferSnapshot{} + this.Result = ResponseOfferSnapshot_Result([]int32{0, 1, 2, 3, 4}[r.Intn(5)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 2) + } + return this +} + +func NewPopulatedResponseLoadSnapshotChunk(r randyTypes, easy bool) *ResponseLoadSnapshotChunk { + this := &ResponseLoadSnapshotChunk{} + v34 := r.Intn(100) + this.Chunk = make([]byte, v34) + for i := 0; i < v34; i++ { + this.Chunk[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 2) + } + return this +} + +func NewPopulatedResponseApplySnapshotChunk(r randyTypes, easy bool) *ResponseApplySnapshotChunk { + this := &ResponseApplySnapshotChunk{} + this.Result = ResponseApplySnapshotChunk_Result([]int32{0, 1, 2, 3, 4}[r.Intn(5)]) + v35 := r.Intn(10) + this.RefetchChunks = make([]uint32, v35) + for i := 0; i < v35; i++ { + this.RefetchChunks[i] = uint32(r.Uint32()) + } + v36 := r.Intn(10) + this.RejectSenders = make([]string, v36) + for i := 0; i < v36; i++ { + this.RejectSenders[i] = string(randStringTypes(r)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 4) + } + return this +} + func NewPopulatedConsensusParams(r randyTypes, easy bool) *ConsensusParams { this := &ConsensusParams{} if r.Intn(5) != 0 { @@ -8694,8 +10769,8 @@ func NewPopulatedEvidenceParams(r randyTypes, easy bool) *EvidenceParams { if r.Intn(2) == 0 { this.MaxAgeNumBlocks *= -1 } - v31 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy) - this.MaxAgeDuration = *v31 + v37 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy) + this.MaxAgeDuration = *v37 if !easy && r.Intn(10) != 0 { this.XXX_unrecognized = randUnrecognizedTypes(r, 3) } @@ -8704,9 +10779,9 @@ func NewPopulatedEvidenceParams(r randyTypes, easy bool) *EvidenceParams { func NewPopulatedValidatorParams(r randyTypes, easy bool) *ValidatorParams { this := &ValidatorParams{} - v32 := r.Intn(10) - this.PubKeyTypes = make([]string, v32) - for i := 0; i < v32; i++ { + v38 := r.Intn(10) + this.PubKeyTypes = make([]string, v38) + for i := 0; i < v38; i++ { this.PubKeyTypes[i] = string(randStringTypes(r)) } if !easy && r.Intn(10) != 0 { @@ -8722,11 +10797,11 @@ func NewPopulatedLastCommitInfo(r randyTypes, easy bool) *LastCommitInfo { this.Round *= -1 } if r.Intn(5) != 0 { - v33 := r.Intn(5) - this.Votes = make([]VoteInfo, v33) - for i := 0; i < v33; i++ { - v34 := NewPopulatedVoteInfo(r, easy) - this.Votes[i] = *v34 + v39 := r.Intn(5) + this.Votes = make([]VoteInfo, v39) + for i := 0; i < v39; i++ { + v40 := NewPopulatedVoteInfo(r, easy) + this.Votes[i] = *v40 } } if !easy && r.Intn(10) != 0 { @@ -8737,14 +10812,14 @@ func NewPopulatedLastCommitInfo(r randyTypes, easy bool) *LastCommitInfo { func NewPopulatedEventAttribute(r randyTypes, easy bool) *EventAttribute { this := &EventAttribute{} - v35 := r.Intn(100) - this.Key = make([]byte, v35) - for i := 0; i < v35; i++ { + v41 := r.Intn(100) + this.Key = make([]byte, v41) + for i := 0; i < v41; i++ { this.Key[i] = byte(r.Intn(256)) } - v36 := r.Intn(100) - this.Value = make([]byte, v36) - for i := 0; i < v36; i++ { + v42 := r.Intn(100) + this.Value = make([]byte, v42) + for i := 0; i < v42; i++ { this.Value[i] = byte(r.Intn(256)) } this.Index = bool(bool(r.Intn(2) == 0)) @@ -8758,11 +10833,11 @@ func NewPopulatedEvent(r randyTypes, easy bool) *Event { this := &Event{} this.Type = string(randStringTypes(r)) if r.Intn(5) != 0 { - v37 := r.Intn(5) - this.Attributes = make([]EventAttribute, v37) - for i := 0; i < v37; i++ { - v38 := NewPopulatedEventAttribute(r, easy) - this.Attributes[i] = *v38 + v43 := r.Intn(5) + this.Attributes = make([]EventAttribute, v43) + for i := 0; i < v43; i++ { + v44 := NewPopulatedEventAttribute(r, easy) + this.Attributes[i] = *v44 } } if !easy && r.Intn(10) != 0 { @@ -8773,60 +10848,60 @@ func NewPopulatedEvent(r randyTypes, easy bool) *Event { func NewPopulatedHeader(r randyTypes, easy bool) *Header { this := &Header{} - v39 := NewPopulatedVersion(r, easy) - this.Version = *v39 + v45 := NewPopulatedVersion(r, easy) + this.Version = *v45 this.ChainID = string(randStringTypes(r)) this.Height = int64(r.Int63()) if r.Intn(2) == 0 { this.Height *= -1 } - v40 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) - this.Time = *v40 - v41 := NewPopulatedBlockID(r, easy) - this.LastBlockId = *v41 - v42 := r.Intn(100) - this.LastCommitHash = make([]byte, v42) - for i := 0; i < v42; i++ { + v46 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) + this.Time = *v46 + v47 := NewPopulatedBlockID(r, easy) + this.LastBlockId = *v47 + v48 := r.Intn(100) + this.LastCommitHash = make([]byte, v48) + for i := 0; i < v48; i++ { this.LastCommitHash[i] = byte(r.Intn(256)) } - v43 := r.Intn(100) - this.DataHash = make([]byte, v43) - for i := 0; i < v43; i++ { + v49 := r.Intn(100) + this.DataHash = make([]byte, v49) + for i := 0; i < v49; i++ { this.DataHash[i] = byte(r.Intn(256)) } - v44 := r.Intn(100) - this.ValidatorsHash = make([]byte, v44) - for i := 0; i < v44; i++ { + v50 := r.Intn(100) + this.ValidatorsHash = make([]byte, v50) + for i := 0; i < v50; i++ { this.ValidatorsHash[i] = byte(r.Intn(256)) } - v45 := r.Intn(100) - this.NextValidatorsHash = make([]byte, v45) - for i := 0; i < v45; i++ { + v51 := r.Intn(100) + this.NextValidatorsHash = make([]byte, v51) + for i := 0; i < v51; i++ { this.NextValidatorsHash[i] = byte(r.Intn(256)) } - v46 := r.Intn(100) - this.ConsensusHash = make([]byte, v46) - for i := 0; i < v46; i++ { + v52 := r.Intn(100) + this.ConsensusHash = make([]byte, v52) + for i := 0; i < v52; i++ { this.ConsensusHash[i] = byte(r.Intn(256)) } - v47 := r.Intn(100) - this.AppHash = make([]byte, v47) - for i := 0; i < v47; i++ { + v53 := r.Intn(100) + this.AppHash = make([]byte, v53) + for i := 0; i < v53; i++ { this.AppHash[i] = byte(r.Intn(256)) } - v48 := r.Intn(100) - this.LastResultsHash = make([]byte, v48) - for i := 0; i < v48; i++ { + v54 := r.Intn(100) + this.LastResultsHash = make([]byte, v54) + for i := 0; i < v54; i++ { this.LastResultsHash[i] = byte(r.Intn(256)) } - v49 := r.Intn(100) - this.EvidenceHash = make([]byte, v49) - for i := 0; i < v49; i++ { + v55 := r.Intn(100) + this.EvidenceHash = make([]byte, v55) + for i := 0; i < v55; i++ { this.EvidenceHash[i] = byte(r.Intn(256)) } - v50 := r.Intn(100) - this.ProposerAddress = make([]byte, v50) - for i := 0; i < v50; i++ { + v56 := r.Intn(100) + this.ProposerAddress = make([]byte, v56) + for i := 0; i < v56; i++ { this.ProposerAddress[i] = byte(r.Intn(256)) } if !easy && r.Intn(10) != 0 { @@ -8847,13 +10922,13 @@ func NewPopulatedVersion(r randyTypes, easy bool) *Version { func NewPopulatedBlockID(r randyTypes, easy bool) *BlockID { this := &BlockID{} - v51 := r.Intn(100) - this.Hash = make([]byte, v51) - for i := 0; i < v51; i++ { + v57 := r.Intn(100) + this.Hash = make([]byte, v57) + for i := 0; i < v57; i++ { this.Hash[i] = byte(r.Intn(256)) } - v52 := NewPopulatedPartSetHeader(r, easy) - this.PartsHeader = *v52 + v58 := NewPopulatedPartSetHeader(r, easy) + this.PartsHeader = *v58 if !easy && r.Intn(10) != 0 { this.XXX_unrecognized = randUnrecognizedTypes(r, 3) } @@ -8866,9 +10941,9 @@ func NewPopulatedPartSetHeader(r randyTypes, easy bool) *PartSetHeader { if r.Intn(2) == 0 { this.Total *= -1 } - v53 := r.Intn(100) - this.Hash = make([]byte, v53) - for i := 0; i < v53; i++ { + v59 := r.Intn(100) + this.Hash = make([]byte, v59) + for i := 0; i < v59; i++ { this.Hash[i] = byte(r.Intn(256)) } if !easy && r.Intn(10) != 0 { @@ -8879,9 +10954,9 @@ func NewPopulatedPartSetHeader(r randyTypes, easy bool) *PartSetHeader { func NewPopulatedValidator(r randyTypes, easy bool) *Validator { this := &Validator{} - v54 := r.Intn(100) - this.Address = make([]byte, v54) - for i := 0; i < v54; i++ { + v60 := r.Intn(100) + this.Address = make([]byte, v60) + for i := 0; i < v60; i++ { this.Address[i] = byte(r.Intn(256)) } this.Power = int64(r.Int63()) @@ -8896,8 +10971,8 @@ func NewPopulatedValidator(r randyTypes, easy bool) *Validator { func NewPopulatedValidatorUpdate(r randyTypes, easy bool) *ValidatorUpdate { this := &ValidatorUpdate{} - v55 := NewPopulatedPubKey(r, easy) - this.PubKey = *v55 + v61 := NewPopulatedPubKey(r, easy) + this.PubKey = *v61 this.Power = int64(r.Int63()) if r.Intn(2) == 0 { this.Power *= -1 @@ -8910,8 +10985,8 @@ func NewPopulatedValidatorUpdate(r randyTypes, easy bool) *ValidatorUpdate { func NewPopulatedVoteInfo(r randyTypes, easy bool) *VoteInfo { this := &VoteInfo{} - v56 := NewPopulatedValidator(r, easy) - this.Validator = *v56 + v62 := NewPopulatedValidator(r, easy) + this.Validator = *v62 this.SignedLastBlock = bool(bool(r.Intn(2) == 0)) if !easy && r.Intn(10) != 0 { this.XXX_unrecognized = randUnrecognizedTypes(r, 3) @@ -8922,9 +10997,9 @@ func NewPopulatedVoteInfo(r randyTypes, easy bool) *VoteInfo { func NewPopulatedPubKey(r randyTypes, easy bool) *PubKey { this := &PubKey{} this.Type = string(randStringTypes(r)) - v57 := r.Intn(100) - this.Data = make([]byte, v57) - for i := 0; i < v57; i++ { + v63 := r.Intn(100) + this.Data = make([]byte, v63) + for i := 0; i < v63; i++ { this.Data[i] = byte(r.Intn(256)) } if !easy && r.Intn(10) != 0 { @@ -8936,14 +11011,14 @@ func NewPopulatedPubKey(r randyTypes, easy bool) *PubKey { func NewPopulatedEvidence(r randyTypes, easy bool) *Evidence { this := &Evidence{} this.Type = string(randStringTypes(r)) - v58 := NewPopulatedValidator(r, easy) - this.Validator = *v58 + v64 := NewPopulatedValidator(r, easy) + this.Validator = *v64 this.Height = int64(r.Int63()) if r.Intn(2) == 0 { this.Height *= -1 } - v59 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) - this.Time = *v59 + v65 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) + this.Time = *v65 this.TotalVotingPower = int64(r.Int63()) if r.Intn(2) == 0 { this.TotalVotingPower *= -1 @@ -8954,6 +11029,27 @@ func NewPopulatedEvidence(r randyTypes, easy bool) *Evidence { return this } +func NewPopulatedSnapshot(r randyTypes, easy bool) *Snapshot { + this := &Snapshot{} + this.Height = uint64(uint64(r.Uint32())) + this.Format = uint32(r.Uint32()) + this.Chunks = uint32(r.Uint32()) + v66 := r.Intn(100) + this.Hash = make([]byte, v66) + for i := 0; i < v66; i++ { + this.Hash[i] = byte(r.Intn(256)) + } + v67 := r.Intn(100) + this.Metadata = make([]byte, v67) + for i := 0; i < v67; i++ { + this.Metadata[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTypes(r, 6) + } + return this +} + type randyTypes interface { Float32() float32 Float64() float64 @@ -8973,9 +11069,9 @@ func randUTF8RuneTypes(r randyTypes) rune { return rune(ru + 61) } func randStringTypes(r randyTypes) string { - v60 := r.Intn(100) - tmps := make([]rune, v60) - for i := 0; i < v60; i++ { + v68 := r.Intn(100) + tmps := make([]rune, v68) + for i := 0; i < v68; i++ { tmps[i] = randUTF8RuneTypes(r) } return string(tmps) @@ -8997,11 +11093,11 @@ func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte switch wire { case 0: dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) - v61 := r.Int63() + v69 := r.Int63() if r.Intn(2) == 0 { - v61 *= -1 + v69 *= -1 } - dAtA = encodeVarintPopulateTypes(dAtA, uint64(v61)) + dAtA = encodeVarintPopulateTypes(dAtA, uint64(v69)) case 1: dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) @@ -9161,6 +11257,54 @@ func (m *Request_Commit) Size() (n int) { } return n } +func (m *Request_ListSnapshots) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ListSnapshots != nil { + l = m.ListSnapshots.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Request_OfferSnapshot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OfferSnapshot != nil { + l = m.OfferSnapshot.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Request_LoadSnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LoadSnapshotChunk != nil { + l = m.LoadSnapshotChunk.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Request_ApplySnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ApplySnapshotChunk != nil { + l = m.ApplySnapshotChunk.Size() + n += 2 + l + sovTypes(uint64(l)) + } + return n +} func (m *Request_DeliverTx) Size() (n int) { if m == nil { return 0 @@ -9389,89 +11533,165 @@ func (m *RequestCommit) Size() (n int) { return n } -func (m *Response) Size() (n int) { +func (m *RequestListSnapshots) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Value != nil { - n += m.Value.Size() - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *Response_Exception) Size() (n int) { +func (m *RequestOfferSnapshot) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Exception != nil { - l = m.Exception.Size() + if m.Snapshot != nil { + l = m.Snapshot.Size() + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.AppHash) + if l > 0 { n += 1 + l + sovTypes(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } -func (m *Response_Echo) Size() (n int) { + +func (m *RequestLoadSnapshotChunk) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Echo != nil { - l = m.Echo.Size() - n += 1 + l + sovTypes(uint64(l)) + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Format != 0 { + n += 1 + sovTypes(uint64(m.Format)) + } + if m.Chunk != 0 { + n += 1 + sovTypes(uint64(m.Chunk)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } return n } -func (m *Response_Flush) Size() (n int) { + +func (m *RequestApplySnapshotChunk) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Flush != nil { - l = m.Flush.Size() + if m.Index != 0 { + n += 1 + sovTypes(uint64(m.Index)) + } + l = len(m.Chunk) + if l > 0 { n += 1 + l + sovTypes(uint64(l)) } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } -func (m *Response_Info) Size() (n int) { + +func (m *Response) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Info != nil { - l = m.Info.Size() - n += 1 + l + sovTypes(uint64(l)) + if m.Value != nil { + n += m.Value.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } return n } -func (m *Response_SetOption) Size() (n int) { + +func (m *Response_Exception) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.SetOption != nil { - l = m.SetOption.Size() + if m.Exception != nil { + l = m.Exception.Size() n += 1 + l + sovTypes(uint64(l)) } return n } -func (m *Response_InitChain) Size() (n int) { +func (m *Response_Echo) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.InitChain != nil { - l = m.InitChain.Size() + if m.Echo != nil { + l = m.Echo.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_Flush) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Flush != nil { + l = m.Flush.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_Info) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Info != nil { + l = m.Info.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_SetOption) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SetOption != nil { + l = m.SetOption.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_InitChain) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.InitChain != nil { + l = m.InitChain.Size() n += 1 + l + sovTypes(uint64(l)) } return n @@ -9548,6 +11768,54 @@ func (m *Response_Commit) Size() (n int) { } return n } +func (m *Response_ListSnapshots) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ListSnapshots != nil { + l = m.ListSnapshots.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_OfferSnapshot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OfferSnapshot != nil { + l = m.OfferSnapshot.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_LoadSnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LoadSnapshotChunk != nil { + l = m.LoadSnapshotChunk.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} +func (m *Response_ApplySnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ApplySnapshotChunk != nil { + l = m.ApplySnapshotChunk.Size() + n += 2 + l + sovTypes(uint64(l)) + } + return n +} func (m *ResponseException) Size() (n int) { if m == nil { return 0 @@ -9863,6 +12131,83 @@ func (m *ResponseCommit) Size() (n int) { return n } +func (m *ResponseListSnapshots) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Snapshots) > 0 { + for _, e := range m.Snapshots { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ResponseOfferSnapshot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Result != 0 { + n += 1 + sovTypes(uint64(m.Result)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ResponseLoadSnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Chunk) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ResponseApplySnapshotChunk) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Result != 0 { + n += 1 + sovTypes(uint64(m.Result)) + } + if len(m.RefetchChunks) > 0 { + l = 0 + for _, e := range m.RefetchChunks { + l += sovTypes(uint64(e)) + } + n += 1 + sovTypes(uint64(l)) + l + } + if len(m.RejectSenders) > 0 { + for _, s := range m.RejectSenders { + l = len(s) + n += 1 + l + sovTypes(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *ConsensusParams) Size() (n int) { if m == nil { return 0 @@ -10221,6 +12566,35 @@ func (m *Evidence) Size() (n int) { return n } +func (m *Snapshot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Format != 0 { + n += 1 + sovTypes(uint64(m.Format)) + } + if m.Chunks != 0 { + n += 1 + sovTypes(uint64(m.Chunks)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Metadata) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -10606,9 +12980,9 @@ func (m *Request) Unmarshal(dAtA []byte) error { } m.Value = &Request_Commit{v} iNdEx = postIndex - case 19: + case 13: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ListSnapshots", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10635,71 +13009,52 @@ func (m *Request) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &RequestDeliverTx{} + v := &RequestListSnapshots{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Request_DeliverTx{v} + m.Value = &Request_ListSnapshots{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { - return err + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OfferSnapshot", wireType) } - if skippy < 0 { - return ErrInvalidLengthTypes + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RequestEcho) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + v := &RequestOfferSnapshot{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RequestEcho: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RequestEcho: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.Value = &Request_OfferSnapshot{v} + iNdEx = postIndex + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LoadSnapshotChunk", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -10709,24 +13064,183 @@ func (m *RequestEcho) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Message = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + v := &RequestLoadSnapshotChunk{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Request_LoadSnapshotChunk{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ApplySnapshotChunk", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &RequestApplySnapshotChunk{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Request_ApplySnapshotChunk{v} + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &RequestDeliverTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Request_DeliverTx{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestEcho) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestEcho: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestEcho: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -11940,7 +14454,7 @@ func (m *RequestCommit) Unmarshal(dAtA []byte) error { } return nil } -func (m *Response) Unmarshal(dAtA []byte) error { +func (m *RequestListSnapshots) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11963,50 +14477,69 @@ func (m *Response) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Response: wiretype end group for non-group") + return fmt.Errorf("proto: RequestListSnapshots: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RequestListSnapshots: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err } - if msglen < 0 { + if skippy < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthTypes } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - v := &ResponseException{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestOfferSnapshot) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes } - m.Value = &Response_Exception{v} - iNdEx = postIndex - case 2: + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestOfferSnapshot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestOfferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12033,17 +14566,18 @@ func (m *Response) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseEcho{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Snapshot == nil { + m.Snapshot = &Snapshot{} + } + if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Response_Echo{v} iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12053,30 +14587,788 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseFlush{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) + if m.AppHash == nil { + m.AppHash = []byte{} } - m.Value = &Response_Flush{v} iNdEx = postIndex - case 4: + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestLoadSnapshotChunk) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestLoadSnapshotChunk: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestLoadSnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType) + } + m.Format = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Format |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) + } + m.Chunk = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Chunk |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestApplySnapshotChunk) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestApplySnapshotChunk: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestApplySnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Chunk = append(m.Chunk[:0], dAtA[iNdEx:postIndex]...) + if m.Chunk == nil { + m.Chunk = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Response) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Response: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseException{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Exception{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseEcho{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Echo{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseFlush{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Flush{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseInfo{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Info{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetOption", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseSetOption{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_SetOption{v} + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitChain", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseInitChain{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_InitChain{v} + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseQuery{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Query{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseBeginBlock{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_BeginBlock{v} + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseCheckTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_CheckTx{v} + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseDeliverTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_DeliverTx{v} + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseEndBlock{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_EndBlock{v} + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseCommit{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_Commit{v} + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListSnapshots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseListSnapshots{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_ListSnapshots{v} + iNdEx = postIndex + case 14: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field OfferSnapshot", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12103,15 +15395,15 @@ func (m *Response) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseInfo{} + v := &ResponseOfferSnapshot{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Response_Info{v} + m.Value = &Response_OfferSnapshot{v} iNdEx = postIndex - case 5: + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SetOption", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LoadSnapshotChunk", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12138,15 +15430,15 @@ func (m *Response) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseSetOption{} + v := &ResponseLoadSnapshotChunk{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Response_SetOption{v} + m.Value = &Response_LoadSnapshotChunk{v} iNdEx = postIndex - case 6: + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InitChain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ApplySnapshotChunk", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12163,62 +15455,307 @@ func (m *Response) Unmarshal(dAtA []byte) error { break } } - if msglen < 0 { + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseApplySnapshotChunk{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_ApplySnapshotChunk{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseException) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseException: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseException: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Error = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseEcho) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseEcho: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseEcho: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseFlush) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseFlush: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseFlush: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthTypes } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - v := &ResponseInitChain{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Response_InitChain{v} - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &ResponseQuery{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.Value = &Response_Query{v} - iNdEx = postIndex - case 8: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12228,32 +15765,29 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseBeginBlock{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Response_BeginBlock{v} + m.Data = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 9: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12263,32 +15797,29 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseCheckTx{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Response_CheckTx{v} + m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 10: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType) } - var msglen int + m.AppVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12298,32 +15829,16 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.AppVersion |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ResponseDeliverTx{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Response_DeliverTx{v} - iNdEx = postIndex - case 11: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastBlockHeight", wireType) } - var msglen int + m.LastBlockHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12333,32 +15848,16 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.LastBlockHeight |= int64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &ResponseEndBlock{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Response_EndBlock{v} - iNdEx = postIndex - case 12: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LastBlockAppHash", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12368,26 +15867,25 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - v := &ResponseCommit{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.LastBlockAppHash = append(m.LastBlockAppHash[:0], dAtA[iNdEx:postIndex]...) + if m.LastBlockAppHash == nil { + m.LastBlockAppHash = []byte{} } - m.Value = &Response_Commit{v} iNdEx = postIndex default: iNdEx = preIndex @@ -12414,7 +15912,7 @@ func (m *Response) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseException) Unmarshal(dAtA []byte) error { +func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12427,25 +15925,76 @@ func (m *ResponseException) Unmarshal(dAtA []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseSetOption: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseSetOption: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ResponseException: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseException: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.Log = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12473,7 +16022,7 @@ func (m *ResponseException) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Error = string(dAtA[iNdEx:postIndex]) + m.Info = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -12500,7 +16049,7 @@ func (m *ResponseException) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseEcho) Unmarshal(dAtA []byte) error { +func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12523,17 +16072,17 @@ func (m *ResponseEcho) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseEcho: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseInitChain: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseEcho: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseInitChain: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12543,78 +16092,62 @@ func (m *ResponseEcho) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Message = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { + if m.ConsensusParams == nil { + m.ConsensusParams = &ConsensusParams{} + } + if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { - return ErrInvalidLengthTypes + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthTypes + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthTypes } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ResponseFlush) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.Validators = append(m.Validators, ValidatorUpdate{}) + if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ResponseFlush: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseFlush: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -12640,7 +16173,7 @@ func (m *ResponseFlush) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseInfo) Unmarshal(dAtA []byte) error { +func (m *ResponseQuery) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12663,15 +16196,34 @@ func (m *ResponseInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseInfo: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseQuery: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseQuery: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12699,11 +16251,11 @@ func (m *ResponseInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = string(dAtA[iNdEx:postIndex]) + m.Log = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12731,32 +16283,13 @@ func (m *ResponseInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Version = string(dAtA[iNdEx:postIndex]) + m.Info = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType) - } - m.AppVersion = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppVersion |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LastBlockHeight", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } - m.LastBlockHeight = 0 + m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12766,14 +16299,14 @@ func (m *ResponseInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LastBlockHeight |= int64(b&0x7F) << shift + m.Index |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 5: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastBlockAppHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12793,77 +16326,23 @@ func (m *ResponseInfo) Unmarshal(dAtA []byte) error { if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.LastBlockAppHash = append(m.LastBlockAppHash[:0], dAtA[iNdEx:postIndex]...) - if m.LastBlockAppHash == nil { - m.LastBlockAppHash = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthTypes - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthTypes - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ResponseSetOption: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseSetOption: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes } - m.Code = 0 + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12873,16 +16352,31 @@ func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Code |= uint32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -12892,27 +16386,50 @@ func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Log = string(dAtA[iNdEx:postIndex]) + if m.Proof == nil { + m.Proof = &merkle.Proof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 4: + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12940,7 +16457,7 @@ func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Info = string(dAtA[iNdEx:postIndex]) + m.Codespace = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -12967,7 +16484,7 @@ func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { +func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12990,51 +16507,15 @@ func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseInitChain: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseBeginBlock: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseInitChain: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ConsensusParams == nil { - m.ConsensusParams = &ConsensusParams{} - } - if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13061,8 +16542,8 @@ func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Validators = append(m.Validators, ValidatorUpdate{}) - if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Events = append(m.Events, Event{}) + if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13091,7 +16572,7 @@ func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseQuery) Unmarshal(dAtA []byte) error { +func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13114,10 +16595,10 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseQuery: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseCheckTx: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseQuery: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13139,11 +16620,11 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { break } } - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13153,27 +16634,29 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Log = string(dAtA[iNdEx:postIndex]) + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13201,66 +16684,13 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Info = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) - } - m.Index = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Index |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} - } + m.Log = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13270,31 +16700,29 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) - if m.Value == nil { - m.Value = []byte{} - } + m.Info = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) } - var msglen int + m.GasWanted = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13304,33 +16732,16 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.GasWanted |= int64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Proof == nil { - m.Proof = &merkle.Proof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: + case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) } - m.Height = 0 + m.GasUsed = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13340,16 +16751,16 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Height |= int64(b&0x7F) << shift + m.GasUsed |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 10: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13359,83 +16770,31 @@ func (m *ResponseQuery) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Codespace = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { + m.Events = append(m.Events, Event{}) + if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { - return ErrInvalidLengthTypes - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthTypes - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ResponseBeginBlock: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13445,25 +16804,23 @@ func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Events = append(m.Events, Event{}) - if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Codespace = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -13490,7 +16847,7 @@ func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { +func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13513,10 +16870,10 @@ func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseCheckTx: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseDeliverTx: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13722,23 +17079,181 @@ func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Codespace = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseEndBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorUpdates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorUpdates = append(m.ValidatorUpdates, ValidatorUpdate{}) + if err := m.ValidatorUpdates[len(m.ValidatorUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParamUpdates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConsensusParamUpdates == nil { + m.ConsensusParamUpdates = &ConsensusParams{} + } + if err := m.ConsensusParamUpdates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Codespace = string(dAtA[iNdEx:postIndex]) + m.Events = append(m.Events, Event{}) + if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -13765,7 +17280,7 @@ func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { +func (m *ResponseCommit) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13788,31 +17303,12 @@ func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseDeliverTx: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseCommit: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseCommit: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) - } - m.Code = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Code |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) @@ -13848,10 +17344,10 @@ func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RetainHeight", wireType) } - var stringLen uint64 + m.RetainHeight = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -13861,97 +17357,68 @@ func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.RetainHeight |= int64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Log = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err } - intStringLen := int(stringLen) - if intStringLen < 0 { + if skippy < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthTypes } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Info = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) - } - m.GasWanted = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.GasWanted |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseListSnapshots) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.GasUsed = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.GasUsed |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 7: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseListSnapshots: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseListSnapshots: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Snapshots", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13978,43 +17445,11 @@ func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Events = append(m.Events, Event{}) - if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Snapshots = append(m.Snapshots, &Snapshot{}) + if err := m.Snapshots[len(m.Snapshots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Codespace = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -14040,7 +17475,7 @@ func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { +func (m *ResponseOfferSnapshot) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14063,17 +17498,17 @@ func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseEndBlock: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseOfferSnapshot: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseOfferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorUpdates", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) } - var msglen int + m.Result = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -14083,67 +17518,70 @@ func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Result |= ResponseOfferSnapshot_Result(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthTypes } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.ValidatorUpdates = append(m.ValidatorUpdates, ValidatorUpdate{}) - if err := m.ValidatorUpdates[len(m.ValidatorUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParamUpdates", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseLoadSnapshotChunk) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if m.ConsensusParamUpdates == nil { - m.ConsensusParamUpdates = &ConsensusParams{} - } - if err := m.ConsensusParamUpdates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 3: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseLoadSnapshotChunk: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseLoadSnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -14153,24 +17591,24 @@ func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Events = append(m.Events, Event{}) - if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Chunk = append(m.Chunk[:0], dAtA[iNdEx:postIndex]...) + if m.Chunk == nil { + m.Chunk = []byte{} } iNdEx = postIndex default: @@ -14198,7 +17636,7 @@ func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseCommit) Unmarshal(dAtA []byte) error { +func (m *ResponseApplySnapshotChunk) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14221,17 +17659,17 @@ func (m *ResponseCommit) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseCommit: wiretype end group for non-group") + return fmt.Errorf("proto: ResponseApplySnapshotChunk: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseCommit: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ResponseApplySnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) } - var byteLen int + m.Result = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -14241,31 +17679,92 @@ func (m *ResponseCommit) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.Result |= ResponseApplySnapshotChunk_Result(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + case 2: + if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RefetchChunks = append(m.RefetchChunks, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.RefetchChunks) == 0 { + m.RefetchChunks = make([]uint32, 0, elementCount) + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RefetchChunks = append(m.RefetchChunks, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field RefetchChunks", wireType) } - iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RetainHeight", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RejectSenders", wireType) } - m.RetainHeight = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -14275,11 +17774,24 @@ func (m *ResponseCommit) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RetainHeight |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RejectSenders = append(m.RejectSenders, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -16580,6 +20092,185 @@ func (m *Evidence) Unmarshal(dAtA []byte) error { } return nil } +func (m *Snapshot) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Snapshot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType) + } + m.Format = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Format |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) + } + m.Chunks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Chunks |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Metadata = append(m.Metadata[:0], dAtA[iNdEx:postIndex]...) + if m.Metadata == nil { + m.Metadata = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTypes(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/abci/types/types.proto b/abci/types/types.proto index 2a9cbc4d6..5683acb29 100644 --- a/abci/types/types.proto +++ b/abci/types/types.proto @@ -27,17 +27,21 @@ option (gogoproto.testgen_all) = true; message Request { oneof value { - RequestEcho echo = 2; - RequestFlush flush = 3; - RequestInfo info = 4; - RequestSetOption set_option = 5; - RequestInitChain init_chain = 6; - RequestQuery query = 7; - RequestBeginBlock begin_block = 8; - RequestCheckTx check_tx = 9; - RequestDeliverTx deliver_tx = 19; - RequestEndBlock end_block = 11; - RequestCommit commit = 12; + RequestEcho echo = 2; + RequestFlush flush = 3; + RequestInfo info = 4; + RequestSetOption set_option = 5; + RequestInitChain init_chain = 6; + RequestQuery query = 7; + RequestBeginBlock begin_block = 8; + RequestCheckTx check_tx = 9; + RequestDeliverTx deliver_tx = 19; + RequestEndBlock end_block = 11; + RequestCommit commit = 12; + RequestListSnapshots list_snapshots = 13; + RequestOfferSnapshot offer_snapshot = 14; + RequestLoadSnapshotChunk load_snapshot_chunk = 15; + RequestApplySnapshotChunk apply_snapshot_chunk = 16; } } @@ -101,23 +105,51 @@ message RequestEndBlock { message RequestCommit {} +// lists available snapshots +message RequestListSnapshots { +} + +// offers a snapshot to the application +message RequestOfferSnapshot { + Snapshot snapshot = 1; // snapshot offered by peers + bytes app_hash = 2; // light client-verified app hash for snapshot height +} + +// loads a snapshot chunk +message RequestLoadSnapshotChunk { + uint64 height = 1; + uint32 format = 2; + uint32 chunk = 3; +} + +// Applies a snapshot chunk +message RequestApplySnapshotChunk { + uint32 index = 1; + bytes chunk = 2; + string sender = 3; +} + //---------------------------------------- // Response types message Response { oneof value { - ResponseException exception = 1; - ResponseEcho echo = 2; - ResponseFlush flush = 3; - ResponseInfo info = 4; - ResponseSetOption set_option = 5; - ResponseInitChain init_chain = 6; - ResponseQuery query = 7; - ResponseBeginBlock begin_block = 8; - ResponseCheckTx check_tx = 9; - ResponseDeliverTx deliver_tx = 10; - ResponseEndBlock end_block = 11; - ResponseCommit commit = 12; + ResponseException exception = 1; + ResponseEcho echo = 2; + ResponseFlush flush = 3; + ResponseInfo info = 4; + ResponseSetOption set_option = 5; + ResponseInitChain init_chain = 6; + ResponseQuery query = 7; + ResponseBeginBlock begin_block = 8; + ResponseCheckTx check_tx = 9; + ResponseDeliverTx deliver_tx = 10; + ResponseEndBlock end_block = 11; + ResponseCommit commit = 12; + ResponseListSnapshots list_snapshots = 13; + ResponseOfferSnapshot offer_snapshot = 14; + ResponseLoadSnapshotChunk load_snapshot_chunk = 15; + ResponseApplySnapshotChunk apply_snapshot_chunk = 16; } } @@ -210,6 +242,40 @@ message ResponseCommit { int64 retain_height = 3; } +message ResponseListSnapshots { + repeated Snapshot snapshots = 1; +} + +message ResponseOfferSnapshot { + Result result = 1; + + enum Result { + accept = 0; // Snapshot accepted, apply chunks + abort = 1; // Abort all snapshot restoration + reject = 2; // Reject this specific snapshot, and try a different one + reject_format = 3; // Reject all snapshots of this format, and try a different one + reject_sender = 4; // Reject all snapshots from the sender(s), and try a different one + } +} + +message ResponseLoadSnapshotChunk { + bytes chunk = 1; +} + +message ResponseApplySnapshotChunk { + Result result = 1; + repeated uint32 refetch_chunks = 2; // Chunks to refetch and reapply (regardless of result) + repeated string reject_senders = 3; // Chunk senders to reject and ban (regardless of result) + + enum Result { + accept = 0; // Chunk successfully accepted + abort = 1; // Abort all snapshot restoration + retry = 2; // Retry chunk, combine with refetch and reject as appropriate + retry_snapshot = 3; // Retry snapshot, combine with refetch and reject as appropriate + reject_snapshot = 4; // Reject this snapshot, try a different one but keep sender rejections + } +} + //---------------------------------------- // Misc. @@ -336,6 +402,17 @@ message Evidence { int64 total_voting_power = 5; } +//---------------------------------------- +// State Sync Types + +message Snapshot { + uint64 height = 1; // The height at which the snapshot was taken + uint32 format = 2; // The application-specific snapshot format + uint32 chunks = 3; // Number of chunks in the snapshot + bytes hash = 4; // Arbitrary snapshot hash - should be equal only for identical snapshots + bytes metadata = 5; // Arbitrary application metadata +} + //---------------------------------------- // Service Definition @@ -351,4 +428,8 @@ service ABCIApplication { rpc InitChain(RequestInitChain) returns (ResponseInitChain); rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock); rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock); + rpc ListSnapshots(RequestListSnapshots) returns (ResponseListSnapshots); + rpc OfferSnapshot(RequestOfferSnapshot) returns (ResponseOfferSnapshot); + rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) returns (ResponseLoadSnapshotChunk); + rpc ApplySnapshotChunk(RequestApplySnapshotChunk) returns (ResponseApplySnapshotChunk); } diff --git a/abci/types/typespb_test.go b/abci/types/typespb_test.go index 7a79ad8a9..fcb8d025f 100644 --- a/abci/types/typespb_test.go +++ b/abci/types/typespb_test.go @@ -697,15 +697,15 @@ func TestRequestCommitMarshalTo(t *testing.T) { } } -func TestResponseProto(t *testing.T) { +func TestRequestListSnapshotsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponse(popr, false) + p := NewPopulatedRequestListSnapshots(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Response{} + msg := &RequestListSnapshots{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -728,10 +728,10 @@ func TestResponseProto(t *testing.T) { } } -func TestResponseMarshalTo(t *testing.T) { +func TestRequestListSnapshotsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponse(popr, false) + p := NewPopulatedRequestListSnapshots(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -741,7 +741,7 @@ func TestResponseMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Response{} + msg := &RequestListSnapshots{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -753,15 +753,15 @@ func TestResponseMarshalTo(t *testing.T) { } } -func TestResponseExceptionProto(t *testing.T) { +func TestRequestOfferSnapshotProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseException(popr, false) + p := NewPopulatedRequestOfferSnapshot(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseException{} + msg := &RequestOfferSnapshot{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -784,10 +784,10 @@ func TestResponseExceptionProto(t *testing.T) { } } -func TestResponseExceptionMarshalTo(t *testing.T) { +func TestRequestOfferSnapshotMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseException(popr, false) + p := NewPopulatedRequestOfferSnapshot(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -797,7 +797,7 @@ func TestResponseExceptionMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseException{} + msg := &RequestOfferSnapshot{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -809,15 +809,15 @@ func TestResponseExceptionMarshalTo(t *testing.T) { } } -func TestResponseEchoProto(t *testing.T) { +func TestRequestLoadSnapshotChunkProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEcho(popr, false) + p := NewPopulatedRequestLoadSnapshotChunk(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseEcho{} + msg := &RequestLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -840,10 +840,10 @@ func TestResponseEchoProto(t *testing.T) { } } -func TestResponseEchoMarshalTo(t *testing.T) { +func TestRequestLoadSnapshotChunkMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEcho(popr, false) + p := NewPopulatedRequestLoadSnapshotChunk(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -853,7 +853,7 @@ func TestResponseEchoMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseEcho{} + msg := &RequestLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -865,15 +865,15 @@ func TestResponseEchoMarshalTo(t *testing.T) { } } -func TestResponseFlushProto(t *testing.T) { +func TestRequestApplySnapshotChunkProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseFlush(popr, false) + p := NewPopulatedRequestApplySnapshotChunk(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseFlush{} + msg := &RequestApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -896,10 +896,10 @@ func TestResponseFlushProto(t *testing.T) { } } -func TestResponseFlushMarshalTo(t *testing.T) { +func TestRequestApplySnapshotChunkMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseFlush(popr, false) + p := NewPopulatedRequestApplySnapshotChunk(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -909,7 +909,7 @@ func TestResponseFlushMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseFlush{} + msg := &RequestApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -921,15 +921,15 @@ func TestResponseFlushMarshalTo(t *testing.T) { } } -func TestResponseInfoProto(t *testing.T) { +func TestResponseProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInfo(popr, false) + p := NewPopulatedResponse(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInfo{} + msg := &Response{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -952,10 +952,10 @@ func TestResponseInfoProto(t *testing.T) { } } -func TestResponseInfoMarshalTo(t *testing.T) { +func TestResponseMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInfo(popr, false) + p := NewPopulatedResponse(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -965,7 +965,7 @@ func TestResponseInfoMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInfo{} + msg := &Response{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -977,15 +977,15 @@ func TestResponseInfoMarshalTo(t *testing.T) { } } -func TestResponseSetOptionProto(t *testing.T) { +func TestResponseExceptionProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseSetOption(popr, false) + p := NewPopulatedResponseException(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseSetOption{} + msg := &ResponseException{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1008,10 +1008,10 @@ func TestResponseSetOptionProto(t *testing.T) { } } -func TestResponseSetOptionMarshalTo(t *testing.T) { +func TestResponseExceptionMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseSetOption(popr, false) + p := NewPopulatedResponseException(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1021,7 +1021,7 @@ func TestResponseSetOptionMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseSetOption{} + msg := &ResponseException{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1033,15 +1033,15 @@ func TestResponseSetOptionMarshalTo(t *testing.T) { } } -func TestResponseInitChainProto(t *testing.T) { +func TestResponseEchoProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInitChain(popr, false) + p := NewPopulatedResponseEcho(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInitChain{} + msg := &ResponseEcho{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1064,10 +1064,10 @@ func TestResponseInitChainProto(t *testing.T) { } } -func TestResponseInitChainMarshalTo(t *testing.T) { +func TestResponseEchoMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInitChain(popr, false) + p := NewPopulatedResponseEcho(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1077,7 +1077,7 @@ func TestResponseInitChainMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInitChain{} + msg := &ResponseEcho{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1089,15 +1089,15 @@ func TestResponseInitChainMarshalTo(t *testing.T) { } } -func TestResponseQueryProto(t *testing.T) { +func TestResponseFlushProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseQuery(popr, false) + p := NewPopulatedResponseFlush(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseQuery{} + msg := &ResponseFlush{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1120,10 +1120,10 @@ func TestResponseQueryProto(t *testing.T) { } } -func TestResponseQueryMarshalTo(t *testing.T) { +func TestResponseFlushMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseQuery(popr, false) + p := NewPopulatedResponseFlush(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1133,7 +1133,7 @@ func TestResponseQueryMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseQuery{} + msg := &ResponseFlush{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1145,15 +1145,15 @@ func TestResponseQueryMarshalTo(t *testing.T) { } } -func TestResponseBeginBlockProto(t *testing.T) { +func TestResponseInfoProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBeginBlock(popr, false) + p := NewPopulatedResponseInfo(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseBeginBlock{} + msg := &ResponseInfo{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1176,10 +1176,10 @@ func TestResponseBeginBlockProto(t *testing.T) { } } -func TestResponseBeginBlockMarshalTo(t *testing.T) { +func TestResponseInfoMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBeginBlock(popr, false) + p := NewPopulatedResponseInfo(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1189,7 +1189,7 @@ func TestResponseBeginBlockMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseBeginBlock{} + msg := &ResponseInfo{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1201,15 +1201,15 @@ func TestResponseBeginBlockMarshalTo(t *testing.T) { } } -func TestResponseCheckTxProto(t *testing.T) { +func TestResponseSetOptionProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCheckTx(popr, false) + p := NewPopulatedResponseSetOption(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCheckTx{} + msg := &ResponseSetOption{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1232,10 +1232,10 @@ func TestResponseCheckTxProto(t *testing.T) { } } -func TestResponseCheckTxMarshalTo(t *testing.T) { +func TestResponseSetOptionMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCheckTx(popr, false) + p := NewPopulatedResponseSetOption(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1245,7 +1245,7 @@ func TestResponseCheckTxMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCheckTx{} + msg := &ResponseSetOption{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1257,15 +1257,15 @@ func TestResponseCheckTxMarshalTo(t *testing.T) { } } -func TestResponseDeliverTxProto(t *testing.T) { +func TestResponseInitChainProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseDeliverTx(popr, false) + p := NewPopulatedResponseInitChain(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseDeliverTx{} + msg := &ResponseInitChain{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1288,10 +1288,10 @@ func TestResponseDeliverTxProto(t *testing.T) { } } -func TestResponseDeliverTxMarshalTo(t *testing.T) { +func TestResponseInitChainMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseDeliverTx(popr, false) + p := NewPopulatedResponseInitChain(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1301,7 +1301,7 @@ func TestResponseDeliverTxMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseDeliverTx{} + msg := &ResponseInitChain{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1313,15 +1313,15 @@ func TestResponseDeliverTxMarshalTo(t *testing.T) { } } -func TestResponseEndBlockProto(t *testing.T) { +func TestResponseQueryProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEndBlock(popr, false) + p := NewPopulatedResponseQuery(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseEndBlock{} + msg := &ResponseQuery{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1344,10 +1344,10 @@ func TestResponseEndBlockProto(t *testing.T) { } } -func TestResponseEndBlockMarshalTo(t *testing.T) { +func TestResponseQueryMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEndBlock(popr, false) + p := NewPopulatedResponseQuery(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1357,7 +1357,7 @@ func TestResponseEndBlockMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseEndBlock{} + msg := &ResponseQuery{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1369,15 +1369,15 @@ func TestResponseEndBlockMarshalTo(t *testing.T) { } } -func TestResponseCommitProto(t *testing.T) { +func TestResponseBeginBlockProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCommit(popr, false) + p := NewPopulatedResponseBeginBlock(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCommit{} + msg := &ResponseBeginBlock{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1400,10 +1400,10 @@ func TestResponseCommitProto(t *testing.T) { } } -func TestResponseCommitMarshalTo(t *testing.T) { +func TestResponseBeginBlockMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCommit(popr, false) + p := NewPopulatedResponseBeginBlock(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1413,7 +1413,7 @@ func TestResponseCommitMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCommit{} + msg := &ResponseBeginBlock{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1425,15 +1425,15 @@ func TestResponseCommitMarshalTo(t *testing.T) { } } -func TestConsensusParamsProto(t *testing.T) { +func TestResponseCheckTxProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedConsensusParams(popr, false) + p := NewPopulatedResponseCheckTx(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ConsensusParams{} + msg := &ResponseCheckTx{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1456,10 +1456,10 @@ func TestConsensusParamsProto(t *testing.T) { } } -func TestConsensusParamsMarshalTo(t *testing.T) { +func TestResponseCheckTxMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedConsensusParams(popr, false) + p := NewPopulatedResponseCheckTx(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1469,7 +1469,7 @@ func TestConsensusParamsMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ConsensusParams{} + msg := &ResponseCheckTx{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1481,15 +1481,15 @@ func TestConsensusParamsMarshalTo(t *testing.T) { } } -func TestBlockParamsProto(t *testing.T) { +func TestResponseDeliverTxProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedBlockParams(popr, false) + p := NewPopulatedResponseDeliverTx(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &BlockParams{} + msg := &ResponseDeliverTx{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1512,10 +1512,10 @@ func TestBlockParamsProto(t *testing.T) { } } -func TestBlockParamsMarshalTo(t *testing.T) { +func TestResponseDeliverTxMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedBlockParams(popr, false) + p := NewPopulatedResponseDeliverTx(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1525,7 +1525,7 @@ func TestBlockParamsMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &BlockParams{} + msg := &ResponseDeliverTx{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1537,15 +1537,15 @@ func TestBlockParamsMarshalTo(t *testing.T) { } } -func TestEvidenceParamsProto(t *testing.T) { +func TestResponseEndBlockProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEvidenceParams(popr, false) + p := NewPopulatedResponseEndBlock(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &EvidenceParams{} + msg := &ResponseEndBlock{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1568,10 +1568,10 @@ func TestEvidenceParamsProto(t *testing.T) { } } -func TestEvidenceParamsMarshalTo(t *testing.T) { +func TestResponseEndBlockMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEvidenceParams(popr, false) + p := NewPopulatedResponseEndBlock(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1581,7 +1581,7 @@ func TestEvidenceParamsMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &EvidenceParams{} + msg := &ResponseEndBlock{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1593,15 +1593,15 @@ func TestEvidenceParamsMarshalTo(t *testing.T) { } } -func TestValidatorParamsProto(t *testing.T) { +func TestResponseCommitProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedValidatorParams(popr, false) + p := NewPopulatedResponseCommit(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ValidatorParams{} + msg := &ResponseCommit{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1624,10 +1624,10 @@ func TestValidatorParamsProto(t *testing.T) { } } -func TestValidatorParamsMarshalTo(t *testing.T) { +func TestResponseCommitMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedValidatorParams(popr, false) + p := NewPopulatedResponseCommit(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1637,7 +1637,7 @@ func TestValidatorParamsMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ValidatorParams{} + msg := &ResponseCommit{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1649,15 +1649,15 @@ func TestValidatorParamsMarshalTo(t *testing.T) { } } -func TestLastCommitInfoProto(t *testing.T) { +func TestResponseListSnapshotsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedLastCommitInfo(popr, false) + p := NewPopulatedResponseListSnapshots(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &LastCommitInfo{} + msg := &ResponseListSnapshots{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1680,10 +1680,10 @@ func TestLastCommitInfoProto(t *testing.T) { } } -func TestLastCommitInfoMarshalTo(t *testing.T) { +func TestResponseListSnapshotsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedLastCommitInfo(popr, false) + p := NewPopulatedResponseListSnapshots(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1693,7 +1693,7 @@ func TestLastCommitInfoMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &LastCommitInfo{} + msg := &ResponseListSnapshots{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1705,15 +1705,15 @@ func TestLastCommitInfoMarshalTo(t *testing.T) { } } -func TestEventAttributeProto(t *testing.T) { +func TestResponseOfferSnapshotProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, false) + p := NewPopulatedResponseOfferSnapshot(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &EventAttribute{} + msg := &ResponseOfferSnapshot{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1736,10 +1736,10 @@ func TestEventAttributeProto(t *testing.T) { } } -func TestEventAttributeMarshalTo(t *testing.T) { +func TestResponseOfferSnapshotMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEventAttribute(popr, false) + p := NewPopulatedResponseOfferSnapshot(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1749,7 +1749,7 @@ func TestEventAttributeMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &EventAttribute{} + msg := &ResponseOfferSnapshot{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1761,15 +1761,15 @@ func TestEventAttributeMarshalTo(t *testing.T) { } } -func TestEventProto(t *testing.T) { +func TestResponseLoadSnapshotChunkProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEvent(popr, false) + p := NewPopulatedResponseLoadSnapshotChunk(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Event{} + msg := &ResponseLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1792,10 +1792,10 @@ func TestEventProto(t *testing.T) { } } -func TestEventMarshalTo(t *testing.T) { +func TestResponseLoadSnapshotChunkMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedEvent(popr, false) + p := NewPopulatedResponseLoadSnapshotChunk(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1805,7 +1805,7 @@ func TestEventMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Event{} + msg := &ResponseLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1817,15 +1817,15 @@ func TestEventMarshalTo(t *testing.T) { } } -func TestHeaderProto(t *testing.T) { +func TestResponseApplySnapshotChunkProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedHeader(popr, false) + p := NewPopulatedResponseApplySnapshotChunk(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Header{} + msg := &ResponseApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1848,10 +1848,10 @@ func TestHeaderProto(t *testing.T) { } } -func TestHeaderMarshalTo(t *testing.T) { +func TestResponseApplySnapshotChunkMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedHeader(popr, false) + p := NewPopulatedResponseApplySnapshotChunk(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1861,7 +1861,7 @@ func TestHeaderMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Header{} + msg := &ResponseApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1873,15 +1873,15 @@ func TestHeaderMarshalTo(t *testing.T) { } } -func TestVersionProto(t *testing.T) { +func TestConsensusParamsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedVersion(popr, false) + p := NewPopulatedConsensusParams(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Version{} + msg := &ConsensusParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1904,10 +1904,10 @@ func TestVersionProto(t *testing.T) { } } -func TestVersionMarshalTo(t *testing.T) { +func TestConsensusParamsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedVersion(popr, false) + p := NewPopulatedConsensusParams(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1917,7 +1917,7 @@ func TestVersionMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Version{} + msg := &ConsensusParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1929,15 +1929,15 @@ func TestVersionMarshalTo(t *testing.T) { } } -func TestBlockIDProto(t *testing.T) { +func TestBlockParamsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedBlockID(popr, false) + p := NewPopulatedBlockParams(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &BlockID{} + msg := &BlockParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1960,10 +1960,10 @@ func TestBlockIDProto(t *testing.T) { } } -func TestBlockIDMarshalTo(t *testing.T) { +func TestBlockParamsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedBlockID(popr, false) + p := NewPopulatedBlockParams(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -1973,7 +1973,7 @@ func TestBlockIDMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &BlockID{} + msg := &BlockParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -1985,15 +1985,15 @@ func TestBlockIDMarshalTo(t *testing.T) { } } -func TestPartSetHeaderProto(t *testing.T) { +func TestEvidenceParamsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPartSetHeader(popr, false) + p := NewPopulatedEvidenceParams(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &PartSetHeader{} + msg := &EvidenceParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -2016,10 +2016,10 @@ func TestPartSetHeaderProto(t *testing.T) { } } -func TestPartSetHeaderMarshalTo(t *testing.T) { +func TestEvidenceParamsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedPartSetHeader(popr, false) + p := NewPopulatedEvidenceParams(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -2029,7 +2029,7 @@ func TestPartSetHeaderMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &PartSetHeader{} + msg := &EvidenceParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -2041,15 +2041,15 @@ func TestPartSetHeaderMarshalTo(t *testing.T) { } } -func TestValidatorProto(t *testing.T) { +func TestValidatorParamsProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedValidator(popr, false) + p := NewPopulatedValidatorParams(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Validator{} + msg := &ValidatorParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -2072,10 +2072,10 @@ func TestValidatorProto(t *testing.T) { } } -func TestValidatorMarshalTo(t *testing.T) { +func TestValidatorParamsMarshalTo(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedValidator(popr, false) + p := NewPopulatedValidatorParams(popr, false) size := p.Size() dAtA := make([]byte, size) for i := range dAtA { @@ -2085,7 +2085,7 @@ func TestValidatorMarshalTo(t *testing.T) { if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &Validator{} + msg := &ValidatorParams{} if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -2097,10 +2097,458 @@ func TestValidatorMarshalTo(t *testing.T) { } } -func TestValidatorUpdateProto(t *testing.T) { +func TestLastCommitInfoProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedValidatorUpdate(popr, false) + p := NewPopulatedLastCommitInfo(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &LastCommitInfo{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestLastCommitInfoMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLastCommitInfo(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &LastCommitInfo{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestEventAttributeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedEventAttribute(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &EventAttribute{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestEventAttributeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedEventAttribute(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &EventAttribute{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestEventProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedEvent(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Event{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestEventMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedEvent(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Event{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestHeaderProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedHeader(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Header{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestHeaderMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedHeader(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Header{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestVersionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedVersion(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Version{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestVersionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedVersion(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Version{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBlockIDProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBlockID(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &BlockID{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestBlockIDMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBlockID(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &BlockID{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestPartSetHeaderProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedPartSetHeader(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &PartSetHeader{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestPartSetHeaderMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedPartSetHeader(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &PartSetHeader{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestValidatorProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedValidator(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Validator{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestValidatorMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedValidator(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Validator{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestValidatorUpdateProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedValidatorUpdate(popr, false) dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2321,6 +2769,62 @@ func TestEvidenceMarshalTo(t *testing.T) { } } +func TestSnapshotProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, false) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Snapshot{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(dAtA)) + copy(littlefuzz, dAtA) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSnapshotMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, false) + size := p.Size() + dAtA := make([]byte, size) + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(dAtA) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Snapshot{} + if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range dAtA { + dAtA[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + func TestRequestJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -2537,6 +3041,78 @@ func TestRequestCommitJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } +func TestRequestListSnapshotsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestListSnapshots(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &RequestListSnapshots{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestRequestOfferSnapshotJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestOfferSnapshot(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &RequestOfferSnapshot{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestRequestLoadSnapshotChunkJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestLoadSnapshotChunk(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &RequestLoadSnapshotChunk{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestRequestApplySnapshotChunkJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestApplySnapshotChunk(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &RequestApplySnapshotChunk{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} func TestResponseJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -2612,13 +3188,85 @@ func TestResponseFlushJSON(t *testing.T) { func TestResponseInfoJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInfo(popr, true) + p := NewPopulatedResponseInfo(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ResponseInfo{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestResponseSetOptionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseSetOption(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ResponseSetOption{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestResponseInitChainJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseInitChain(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ResponseInitChain{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestResponseQueryJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseQuery(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ResponseQuery{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestResponseBeginBlockJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseBeginBlock(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInfo{} + msg := &ResponseBeginBlock{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2627,16 +3275,16 @@ func TestResponseInfoJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseSetOptionJSON(t *testing.T) { +func TestResponseCheckTxJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseSetOption(popr, true) + p := NewPopulatedResponseCheckTx(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseSetOption{} + msg := &ResponseCheckTx{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2645,16 +3293,16 @@ func TestResponseSetOptionJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseInitChainJSON(t *testing.T) { +func TestResponseDeliverTxJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInitChain(popr, true) + p := NewPopulatedResponseDeliverTx(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseInitChain{} + msg := &ResponseDeliverTx{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2663,16 +3311,16 @@ func TestResponseInitChainJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseQueryJSON(t *testing.T) { +func TestResponseEndBlockJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseQuery(popr, true) + p := NewPopulatedResponseEndBlock(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseQuery{} + msg := &ResponseEndBlock{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2681,16 +3329,16 @@ func TestResponseQueryJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseBeginBlockJSON(t *testing.T) { +func TestResponseCommitJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBeginBlock(popr, true) + p := NewPopulatedResponseCommit(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseBeginBlock{} + msg := &ResponseCommit{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2699,16 +3347,16 @@ func TestResponseBeginBlockJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseCheckTxJSON(t *testing.T) { +func TestResponseListSnapshotsJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCheckTx(popr, true) + p := NewPopulatedResponseListSnapshots(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCheckTx{} + msg := &ResponseListSnapshots{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2717,16 +3365,16 @@ func TestResponseCheckTxJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseDeliverTxJSON(t *testing.T) { +func TestResponseOfferSnapshotJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseDeliverTx(popr, true) + p := NewPopulatedResponseOfferSnapshot(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseDeliverTx{} + msg := &ResponseOfferSnapshot{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2735,16 +3383,16 @@ func TestResponseDeliverTxJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseEndBlockJSON(t *testing.T) { +func TestResponseLoadSnapshotChunkJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEndBlock(popr, true) + p := NewPopulatedResponseLoadSnapshotChunk(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseEndBlock{} + msg := &ResponseLoadSnapshotChunk{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -2753,16 +3401,16 @@ func TestResponseEndBlockJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } -func TestResponseCommitJSON(t *testing.T) { +func TestResponseApplySnapshotChunkJSON(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCommit(popr, true) + p := NewPopulatedResponseApplySnapshotChunk(popr, true) marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} jsondata, err := marshaler.MarshalToString(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } - msg := &ResponseCommit{} + msg := &ResponseApplySnapshotChunk{} err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) @@ -3059,6 +3707,24 @@ func TestEvidenceJSON(t *testing.T) { t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) } } +func TestSnapshotJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Snapshot{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} func TestRequestProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -3395,6 +4061,118 @@ func TestRequestCommitProtoCompactText(t *testing.T) { } } +func TestRequestListSnapshotsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestListSnapshots(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &RequestListSnapshots{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestListSnapshotsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestListSnapshots(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &RequestListSnapshots{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestOfferSnapshotProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestOfferSnapshot(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &RequestOfferSnapshot{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestOfferSnapshotProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestOfferSnapshot(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &RequestOfferSnapshot{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestLoadSnapshotChunkProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestLoadSnapshotChunk(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &RequestLoadSnapshotChunk{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestLoadSnapshotChunkProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestLoadSnapshotChunk(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &RequestLoadSnapshotChunk{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestApplySnapshotChunkProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestApplySnapshotChunk(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &RequestApplySnapshotChunk{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRequestApplySnapshotChunkProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestApplySnapshotChunk(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &RequestApplySnapshotChunk{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + func TestResponseProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -3577,12 +4355,124 @@ func TestResponseInitChainProtoText(t *testing.T) { } } -func TestResponseInitChainProtoCompactText(t *testing.T) { +func TestResponseInitChainProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseInitChain(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ResponseInitChain{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseQueryProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseQuery(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ResponseQuery{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseQueryProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseQuery(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ResponseQuery{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseBeginBlockProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseBeginBlock(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ResponseBeginBlock{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseBeginBlockProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseBeginBlock(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ResponseBeginBlock{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseCheckTxProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseCheckTx(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ResponseCheckTx{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseCheckTxProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseCheckTx(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ResponseCheckTx{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseDeliverTxProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseDeliverTx(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ResponseDeliverTx{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestResponseDeliverTxProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseInitChain(popr, true) + p := NewPopulatedResponseDeliverTx(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseInitChain{} + msg := &ResponseDeliverTx{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3591,12 +4481,12 @@ func TestResponseInitChainProtoCompactText(t *testing.T) { } } -func TestResponseQueryProtoText(t *testing.T) { +func TestResponseEndBlockProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseQuery(popr, true) + p := NewPopulatedResponseEndBlock(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseQuery{} + msg := &ResponseEndBlock{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3605,12 +4495,12 @@ func TestResponseQueryProtoText(t *testing.T) { } } -func TestResponseQueryProtoCompactText(t *testing.T) { +func TestResponseEndBlockProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseQuery(popr, true) + p := NewPopulatedResponseEndBlock(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseQuery{} + msg := &ResponseEndBlock{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3619,12 +4509,12 @@ func TestResponseQueryProtoCompactText(t *testing.T) { } } -func TestResponseBeginBlockProtoText(t *testing.T) { +func TestResponseCommitProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBeginBlock(popr, true) + p := NewPopulatedResponseCommit(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseBeginBlock{} + msg := &ResponseCommit{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3633,12 +4523,12 @@ func TestResponseBeginBlockProtoText(t *testing.T) { } } -func TestResponseBeginBlockProtoCompactText(t *testing.T) { +func TestResponseCommitProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseBeginBlock(popr, true) + p := NewPopulatedResponseCommit(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseBeginBlock{} + msg := &ResponseCommit{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3647,12 +4537,12 @@ func TestResponseBeginBlockProtoCompactText(t *testing.T) { } } -func TestResponseCheckTxProtoText(t *testing.T) { +func TestResponseListSnapshotsProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCheckTx(popr, true) + p := NewPopulatedResponseListSnapshots(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseCheckTx{} + msg := &ResponseListSnapshots{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3661,12 +4551,12 @@ func TestResponseCheckTxProtoText(t *testing.T) { } } -func TestResponseCheckTxProtoCompactText(t *testing.T) { +func TestResponseListSnapshotsProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCheckTx(popr, true) + p := NewPopulatedResponseListSnapshots(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseCheckTx{} + msg := &ResponseListSnapshots{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3675,12 +4565,12 @@ func TestResponseCheckTxProtoCompactText(t *testing.T) { } } -func TestResponseDeliverTxProtoText(t *testing.T) { +func TestResponseOfferSnapshotProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseDeliverTx(popr, true) + p := NewPopulatedResponseOfferSnapshot(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseDeliverTx{} + msg := &ResponseOfferSnapshot{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3689,12 +4579,12 @@ func TestResponseDeliverTxProtoText(t *testing.T) { } } -func TestResponseDeliverTxProtoCompactText(t *testing.T) { +func TestResponseOfferSnapshotProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseDeliverTx(popr, true) + p := NewPopulatedResponseOfferSnapshot(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseDeliverTx{} + msg := &ResponseOfferSnapshot{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3703,12 +4593,12 @@ func TestResponseDeliverTxProtoCompactText(t *testing.T) { } } -func TestResponseEndBlockProtoText(t *testing.T) { +func TestResponseLoadSnapshotChunkProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEndBlock(popr, true) + p := NewPopulatedResponseLoadSnapshotChunk(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseEndBlock{} + msg := &ResponseLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3717,12 +4607,12 @@ func TestResponseEndBlockProtoText(t *testing.T) { } } -func TestResponseEndBlockProtoCompactText(t *testing.T) { +func TestResponseLoadSnapshotChunkProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseEndBlock(popr, true) + p := NewPopulatedResponseLoadSnapshotChunk(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseEndBlock{} + msg := &ResponseLoadSnapshotChunk{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3731,12 +4621,12 @@ func TestResponseEndBlockProtoCompactText(t *testing.T) { } } -func TestResponseCommitProtoText(t *testing.T) { +func TestResponseApplySnapshotChunkProtoText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCommit(popr, true) + p := NewPopulatedResponseApplySnapshotChunk(popr, true) dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) - msg := &ResponseCommit{} + msg := &ResponseApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -3745,12 +4635,12 @@ func TestResponseCommitProtoText(t *testing.T) { } } -func TestResponseCommitProtoCompactText(t *testing.T) { +func TestResponseApplySnapshotChunkProtoCompactText(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) - p := NewPopulatedResponseCommit(popr, true) + p := NewPopulatedResponseApplySnapshotChunk(popr, true) dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) - msg := &ResponseCommit{} + msg := &ResponseApplySnapshotChunk{} if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } @@ -4207,6 +5097,34 @@ func TestEvidenceProtoCompactText(t *testing.T) { } } +func TestSnapshotProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, true) + dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Snapshot{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSnapshotProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, true) + dAtA := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Snapshot{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + func TestRequestSize(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -4471,6 +5389,94 @@ func TestRequestCommitSize(t *testing.T) { } } +func TestRequestListSnapshotsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestListSnapshots(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestRequestOfferSnapshotSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestOfferSnapshot(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestRequestLoadSnapshotChunkSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestLoadSnapshotChunk(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestRequestApplySnapshotChunkSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedRequestApplySnapshotChunk(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + func TestResponseSize(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -4757,6 +5763,94 @@ func TestResponseCommitSize(t *testing.T) { } } +func TestResponseListSnapshotsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseListSnapshots(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestResponseOfferSnapshotSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseOfferSnapshot(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestResponseLoadSnapshotChunkSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseLoadSnapshotChunk(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestResponseApplySnapshotChunkSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedResponseApplySnapshotChunk(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + func TestConsensusParamsSize(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) @@ -5109,4 +6203,26 @@ func TestEvidenceSize(t *testing.T) { } } +func TestSnapshotSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSnapshot(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + dAtA, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(dAtA) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + //These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/proxy/app_conn.go b/proxy/app_conn.go index 066d17295..32e647cd6 100644 --- a/proxy/app_conn.go +++ b/proxy/app_conn.go @@ -5,6 +5,8 @@ import ( "github.com/tendermint/tendermint/abci/types" ) +//go:generate mockery -case underscore -name AppConnConsensus|AppConnMempool|AppConnQuery|AppConnSnapshot + //---------------------------------------------------------------------------------------- // Enforce which abci msgs can be sent on a connection at the type level @@ -40,6 +42,15 @@ type AppConnQuery interface { // SetOptionSync(key string, value string) (res types.Result) } +type AppConnSnapshot interface { + Error() error + + ListSnapshotsSync(types.RequestListSnapshots) (*types.ResponseListSnapshots, error) + OfferSnapshotSync(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) + LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) + ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) +} + //----------------------------------------------------------------------------------------- // Implements AppConnConsensus (subset of abcicli.Client) @@ -142,3 +153,38 @@ func (app *appConnQuery) InfoSync(req types.RequestInfo) (*types.ResponseInfo, e func (app *appConnQuery) QuerySync(reqQuery types.RequestQuery) (*types.ResponseQuery, error) { return app.appConn.QuerySync(reqQuery) } + +//------------------------------------------------ +// Implements AppConnSnapshot (subset of abcicli.Client) + +type appConnSnapshot struct { + appConn abcicli.Client +} + +func NewAppConnSnapshot(appConn abcicli.Client) AppConnSnapshot { + return &appConnSnapshot{ + appConn: appConn, + } +} + +func (app *appConnSnapshot) Error() error { + return app.appConn.Error() +} + +func (app *appConnSnapshot) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { + return app.appConn.ListSnapshotsSync(req) +} + +func (app *appConnSnapshot) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { + return app.appConn.OfferSnapshotSync(req) +} + +func (app *appConnSnapshot) LoadSnapshotChunkSync( + req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { + return app.appConn.LoadSnapshotChunkSync(req) +} + +func (app *appConnSnapshot) ApplySnapshotChunkSync( + req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { + return app.appConn.ApplySnapshotChunkSync(req) +} diff --git a/proxy/mocks/app_conn_consensus.go b/proxy/mocks/app_conn_consensus.go new file mode 100644 index 000000000..3727c372f --- /dev/null +++ b/proxy/mocks/app_conn_consensus.go @@ -0,0 +1,142 @@ +// Code generated by mockery v1.0.0. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + abcicli "github.com/tendermint/tendermint/abci/client" + + types "github.com/tendermint/tendermint/abci/types" +) + +// AppConnConsensus is an autogenerated mock type for the AppConnConsensus type +type AppConnConsensus struct { + mock.Mock +} + +// BeginBlockSync provides a mock function with given fields: _a0 +func (_m *AppConnConsensus) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseBeginBlock + if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *types.ResponseBeginBlock); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseBeginBlock) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestBeginBlock) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CommitSync provides a mock function with given fields: +func (_m *AppConnConsensus) CommitSync() (*types.ResponseCommit, error) { + ret := _m.Called() + + var r0 *types.ResponseCommit + if rf, ok := ret.Get(0).(func() *types.ResponseCommit); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseCommit) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DeliverTxAsync provides a mock function with given fields: _a0 +func (_m *AppConnConsensus) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes { + ret := _m.Called(_a0) + + var r0 *abcicli.ReqRes + if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *abcicli.ReqRes); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*abcicli.ReqRes) + } + } + + return r0 +} + +// EndBlockSync provides a mock function with given fields: _a0 +func (_m *AppConnConsensus) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlock, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseEndBlock + if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *types.ResponseEndBlock); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseEndBlock) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestEndBlock) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Error provides a mock function with given fields: +func (_m *AppConnConsensus) Error() 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 +} + +// InitChainSync provides a mock function with given fields: _a0 +func (_m *AppConnConsensus) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInitChain, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseInitChain + if rf, ok := ret.Get(0).(func(types.RequestInitChain) *types.ResponseInitChain); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseInitChain) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestInitChain) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SetResponseCallback provides a mock function with given fields: _a0 +func (_m *AppConnConsensus) SetResponseCallback(_a0 abcicli.Callback) { + _m.Called(_a0) +} diff --git a/proxy/mocks/app_conn_mempool.go b/proxy/mocks/app_conn_mempool.go new file mode 100644 index 000000000..e98fbe465 --- /dev/null +++ b/proxy/mocks/app_conn_mempool.go @@ -0,0 +1,80 @@ +// Code generated by mockery v1.0.0. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + abcicli "github.com/tendermint/tendermint/abci/client" + + types "github.com/tendermint/tendermint/abci/types" +) + +// AppConnMempool is an autogenerated mock type for the AppConnMempool type +type AppConnMempool struct { + mock.Mock +} + +// CheckTxAsync provides a mock function with given fields: _a0 +func (_m *AppConnMempool) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes { + ret := _m.Called(_a0) + + var r0 *abcicli.ReqRes + if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *abcicli.ReqRes); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*abcicli.ReqRes) + } + } + + return r0 +} + +// Error provides a mock function with given fields: +func (_m *AppConnMempool) Error() 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 +} + +// FlushAsync provides a mock function with given fields: +func (_m *AppConnMempool) FlushAsync() *abcicli.ReqRes { + ret := _m.Called() + + var r0 *abcicli.ReqRes + if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*abcicli.ReqRes) + } + } + + return r0 +} + +// FlushSync provides a mock function with given fields: +func (_m *AppConnMempool) FlushSync() 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 +} + +// SetResponseCallback provides a mock function with given fields: _a0 +func (_m *AppConnMempool) SetResponseCallback(_a0 abcicli.Callback) { + _m.Called(_a0) +} diff --git a/proxy/mocks/app_conn_query.go b/proxy/mocks/app_conn_query.go new file mode 100644 index 000000000..5274a72b9 --- /dev/null +++ b/proxy/mocks/app_conn_query.go @@ -0,0 +1,97 @@ +// Code generated by mockery v1.0.0. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + types "github.com/tendermint/tendermint/abci/types" +) + +// AppConnQuery is an autogenerated mock type for the AppConnQuery type +type AppConnQuery struct { + mock.Mock +} + +// EchoSync provides a mock function with given fields: _a0 +func (_m *AppConnQuery) EchoSync(_a0 string) (*types.ResponseEcho, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseEcho + if rf, ok := ret.Get(0).(func(string) *types.ResponseEcho); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseEcho) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Error provides a mock function with given fields: +func (_m *AppConnQuery) Error() 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 +} + +// InfoSync provides a mock function with given fields: _a0 +func (_m *AppConnQuery) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseInfo + if rf, ok := ret.Get(0).(func(types.RequestInfo) *types.ResponseInfo); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseInfo) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestInfo) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// QuerySync provides a mock function with given fields: _a0 +func (_m *AppConnQuery) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseQuery + if rf, ok := ret.Get(0).(func(types.RequestQuery) *types.ResponseQuery); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseQuery) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestQuery) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/proxy/mocks/app_conn_snapshot.go b/proxy/mocks/app_conn_snapshot.go new file mode 100644 index 000000000..e5ad235cf --- /dev/null +++ b/proxy/mocks/app_conn_snapshot.go @@ -0,0 +1,120 @@ +// Code generated by mockery v1.0.0. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + types "github.com/tendermint/tendermint/abci/types" +) + +// AppConnSnapshot is an autogenerated mock type for the AppConnSnapshot type +type AppConnSnapshot struct { + mock.Mock +} + +// ApplySnapshotChunkSync provides a mock function with given fields: _a0 +func (_m *AppConnSnapshot) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseApplySnapshotChunk + if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseApplySnapshotChunk) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestApplySnapshotChunk) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Error provides a mock function with given fields: +func (_m *AppConnSnapshot) Error() 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 +} + +// ListSnapshotsSync provides a mock function with given fields: _a0 +func (_m *AppConnSnapshot) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseListSnapshots + if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *types.ResponseListSnapshots); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseListSnapshots) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestListSnapshots) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// LoadSnapshotChunkSync provides a mock function with given fields: _a0 +func (_m *AppConnSnapshot) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseLoadSnapshotChunk + if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseLoadSnapshotChunk) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestLoadSnapshotChunk) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OfferSnapshotSync provides a mock function with given fields: _a0 +func (_m *AppConnSnapshot) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { + ret := _m.Called(_a0) + + var r0 *types.ResponseOfferSnapshot + if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseOfferSnapshot) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(types.RequestOfferSnapshot) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/proxy/multi_app_conn.go b/proxy/multi_app_conn.go index 364114115..753d9a55e 100644 --- a/proxy/multi_app_conn.go +++ b/proxy/multi_app_conn.go @@ -1,7 +1,7 @@ package proxy import ( - "github.com/pkg/errors" + "fmt" "github.com/tendermint/tendermint/libs/service" ) @@ -15,6 +15,7 @@ type AppConns interface { Mempool() AppConnMempool Consensus() AppConnConsensus Query() AppConnQuery + Snapshot() AppConnSnapshot } func NewAppConns(clientCreator ClientCreator) AppConns { @@ -33,6 +34,7 @@ type multiAppConn struct { mempoolConn AppConnMempool consensusConn AppConnConsensus queryConn AppConnQuery + snapshotConn AppConnSnapshot clientCreator ClientCreator } @@ -61,37 +63,53 @@ func (app *multiAppConn) Query() AppConnQuery { return app.queryConn } +// Returns the snapshot Connection +func (app *multiAppConn) Snapshot() AppConnSnapshot { + return app.snapshotConn +} + func (app *multiAppConn) OnStart() error { // query connection querycli, err := app.clientCreator.NewABCIClient() if err != nil { - return errors.Wrap(err, "Error creating ABCI client (query connection)") + return fmt.Errorf("error creating ABCI client (query connection): %w", err) } querycli.SetLogger(app.Logger.With("module", "abci-client", "connection", "query")) if err := querycli.Start(); err != nil { - return errors.Wrap(err, "Error starting ABCI client (query connection)") + return fmt.Errorf("error starting ABCI client (query connection): %w", err) } app.queryConn = NewAppConnQuery(querycli) + // snapshot connection + snapshotcli, err := app.clientCreator.NewABCIClient() + if err != nil { + return fmt.Errorf("error creating ABCI client (snapshot connection): %w", err) + } + snapshotcli.SetLogger(app.Logger.With("module", "abci-client", "connection", "snapshot")) + if err := snapshotcli.Start(); err != nil { + return fmt.Errorf("error starting ABCI client (snapshot connection): %w", err) + } + app.snapshotConn = NewAppConnSnapshot(snapshotcli) + // mempool connection memcli, err := app.clientCreator.NewABCIClient() if err != nil { - return errors.Wrap(err, "Error creating ABCI client (mempool connection)") + return fmt.Errorf("error creating ABCI client (mempool connection): %w", err) } memcli.SetLogger(app.Logger.With("module", "abci-client", "connection", "mempool")) if err := memcli.Start(); err != nil { - return errors.Wrap(err, "Error starting ABCI client (mempool connection)") + return fmt.Errorf("error starting ABCI client (mempool connection): %w", err) } app.mempoolConn = NewAppConnMempool(memcli) // consensus connection concli, err := app.clientCreator.NewABCIClient() if err != nil { - return errors.Wrap(err, "Error creating ABCI client (consensus connection)") + return fmt.Errorf("error creating ABCI client (consensus connection): %w", err) } concli.SetLogger(app.Logger.With("module", "abci-client", "connection", "consensus")) if err := concli.Start(); err != nil { - return errors.Wrap(err, "Error starting ABCI client (consensus connection)") + return fmt.Errorf("error starting ABCI client (consensus connection): %w", err) } app.consensusConn = NewAppConnConsensus(concli) diff --git a/version/version.go b/version/version.go index b0521c2c1..f4968484b 100644 --- a/version/version.go +++ b/version/version.go @@ -23,7 +23,7 @@ const ( TMCoreSemVer = "0.33.4" // ABCISemVer is the semantic version of the ABCI library - ABCISemVer = "0.16.2" + ABCISemVer = "0.17.0" ABCIVersion = ABCISemVer )