mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-05-23 23:51:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

work on abci, proxy and mempool

Browse Source
This commit is contained in:
marbar3778
2021-06-08 17:53:31 +02:00
parent ffb1fc32ea
commit 3e006e6bc1
15 changed files with 252 additions and 628 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
abci/client/client.go
View File

@@ -35,13 +35,10 @@ type Client interface {
FlushAsync(context.Context) (*ReqRes, error)
EchoAsync(ctx context.Context, msg string) (*ReqRes, error)
InfoAsync(context.Context, types.RequestInfo) (*ReqRes, error)
DeliverTxAsync(context.Context, types.RequestDeliverTx) (*ReqRes, error)
CheckTxAsync(context.Context, types.RequestCheckTx) (*ReqRes, error)
QueryAsync(context.Context, types.RequestQuery) (*ReqRes, error)
CommitAsync(context.Context) (*ReqRes, error)
InitChainAsync(context.Context, types.RequestInitChain) (*ReqRes, error)
BeginBlockAsync(context.Context, types.RequestBeginBlock) (*ReqRes, error)
EndBlockAsync(context.Context, types.RequestEndBlock) (*ReqRes, error)
ListSnapshotsAsync(context.Context, types.RequestListSnapshots) (*ReqRes, error)
OfferSnapshotAsync(context.Context, types.RequestOfferSnapshot) (*ReqRes, error)
LoadSnapshotChunkAsync(context.Context, types.RequestLoadSnapshotChunk) (*ReqRes, error)
@@ -52,13 +49,10 @@ type Client interface {
FlushSync(context.Context) error
EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error)
InfoSync(context.Context, types.RequestInfo) (*types.ResponseInfo, error)
DeliverTxSync(context.Context, types.RequestDeliverTx) (*types.ResponseDeliverTx, error)
CheckTxSync(context.Context, types.RequestCheckTx) (*types.ResponseCheckTx, error)
QuerySync(context.Context, types.RequestQuery) (*types.ResponseQuery, error)
CommitSync(context.Context) (*types.ResponseCommit, error)
InitChainSync(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
BeginBlockSync(context.Context, types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
EndBlockSync(context.Context, types.RequestEndBlock) (*types.ResponseEndBlock, error)
ListSnapshotsSync(context.Context, types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
OfferSnapshotSync(context.Context, types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
LoadSnapshotChunkSync(context.Context, types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)

66
abci/client/grpc_client.go
View File

@@ -194,16 +194,6 @@ func (cli *grpcClient) InfoAsync(ctx context.Context, params types.RequestInfo)
return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Info{Info: res}})
}
// NOTE: call is synchronous, use ctx to break early if needed
func (cli *grpcClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
req := types.ToRequestDeliverTx(params)
res, err := cli.client.DeliverTx(ctx, req.GetDeliverTx(), grpc.WaitForReady(true))
if err != nil {
return nil, err
}
return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_DeliverTx{DeliverTx: res}})
}
// NOTE: call is synchronous, use ctx to break early if needed
func (cli *grpcClient) CheckTxAsync(ctx context.Context, params types.RequestCheckTx) (*ReqRes, error) {
req := types.ToRequestCheckTx(params)
@@ -244,26 +234,6 @@ func (cli *grpcClient) InitChainAsync(ctx context.Context, params types.RequestI
return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_InitChain{InitChain: res}})
}
// NOTE: call is synchronous, use ctx to break early if needed
func (cli *grpcClient) BeginBlockAsync(ctx context.Context, params types.RequestBeginBlock) (*ReqRes, error) {
req := types.ToRequestBeginBlock(params)
res, err := cli.client.BeginBlock(ctx, req.GetBeginBlock(), grpc.WaitForReady(true))
if err != nil {
return nil, err
}
return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_BeginBlock{BeginBlock: res}})
}
// NOTE: call is synchronous, use ctx to break early if needed
func (cli *grpcClient) EndBlockAsync(ctx context.Context, params types.RequestEndBlock) (*ReqRes, error) {
req := types.ToRequestEndBlock(params)
res, err := cli.client.EndBlock(ctx, req.GetEndBlock(), grpc.WaitForReady(true))
if err != nil {
return nil, err
}
return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}})
}
// NOTE: call is synchronous, use ctx to break early if needed
func (cli *grpcClient) ListSnapshotsAsync(ctx context.Context, params types.RequestListSnapshots) (*ReqRes, error) {
req := types.ToRequestListSnapshots(params)
@@ -396,18 +366,6 @@ func (cli *grpcClient) InfoSync(
return cli.finishSyncCall(reqres).GetInfo(), cli.Error()
}
func (cli *grpcClient) DeliverTxSync(
ctx context.Context,
params types.RequestDeliverTx,
) (*types.ResponseDeliverTx, error) {
reqres, err := cli.DeliverTxAsync(ctx, params)
if err != nil {
return nil, err
}
return cli.finishSyncCall(reqres).GetDeliverTx(), cli.Error()
}
func (cli *grpcClient) CheckTxSync(
ctx context.Context,
params types.RequestCheckTx,
@@ -451,30 +409,6 @@ func (cli *grpcClient) InitChainSync(
return cli.finishSyncCall(reqres).GetInitChain(), cli.Error()
}
func (cli *grpcClient) BeginBlockSync(
ctx context.Context,
params types.RequestBeginBlock,
) (*types.ResponseBeginBlock, error) {
reqres, err := cli.BeginBlockAsync(ctx, params)
if err != nil {
return nil, err
}
return cli.finishSyncCall(reqres).GetBeginBlock(), cli.Error()
}
func (cli *grpcClient) EndBlockSync(
ctx context.Context,
params types.RequestEndBlock,
) (*types.ResponseEndBlock, error) {
reqres, err := cli.EndBlockAsync(ctx, params)
if err != nil {
return nil, err
}
return cli.finishSyncCall(reqres).GetEndBlock(), cli.Error()
}
func (cli *grpcClient) ListSnapshotsSync(
ctx context.Context,
params types.RequestListSnapshots,

69
abci/client/local_client.go
View File

@@ -77,17 +77,6 @@ func (app *localClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*
), nil
}
func (app *localClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.DeliverTx(params)
return app.callback(
types.ToRequestDeliverTx(params),
types.ToResponseDeliverTx(res),
), nil
}
func (app *localClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
@@ -132,28 +121,6 @@ func (app *localClient) InitChainAsync(ctx context.Context, req types.RequestIni
), nil
}
func (app *localClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.BeginBlock(req)
return app.callback(
types.ToRequestBeginBlock(req),
types.ToResponseBeginBlock(res),
), nil
}
func (app *localClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.EndBlock(req)
return app.callback(
types.ToRequestEndBlock(req),
types.ToResponseEndBlock(res),
), nil
}
func (app *localClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
@@ -236,18 +203,6 @@ func (app *localClient) InfoSync(ctx context.Context, req types.RequestInfo) (*t
return &res, nil
}
func (app *localClient) DeliverTxSync(
ctx context.Context,
req types.RequestDeliverTx,
) (*types.ResponseDeliverTx, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.DeliverTx(req)
return &res, nil
}
func (app *localClient) CheckTxSync(
ctx context.Context,
req types.RequestCheckTx,
@@ -290,30 +245,6 @@ func (app *localClient) InitChainSync(
return &res, nil
}
func (app *localClient) BeginBlockSync(
ctx context.Context,
req types.RequestBeginBlock,
) (*types.ResponseBeginBlock, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.BeginBlock(req)
return &res, nil
}
func (app *localClient) EndBlockSync(
ctx context.Context,
req types.RequestEndBlock,
) (*types.ResponseEndBlock, error) {
app.mtx.Lock()
defer app.mtx.Unlock()
res := app.Application.EndBlock(req)
return &res, nil
}
func (app *localClient) ListSnapshotsSync(
ctx context.Context,
req types.RequestListSnapshots,

54
abci/client/socket_client.go
View File

@@ -245,10 +245,6 @@ func (cli *socketClient) InfoAsync(ctx context.Context, req types.RequestInfo) (
return cli.queueRequestAsync(ctx, types.ToRequestInfo(req))
}
func (cli *socketClient) DeliverTxAsync(ctx context.Context, req types.RequestDeliverTx) (*ReqRes, error) {
return cli.queueRequestAsync(ctx, types.ToRequestDeliverTx(req))
}
func (cli *socketClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
return cli.queueRequestAsync(ctx, types.ToRequestCheckTx(req))
}
@@ -265,14 +261,6 @@ func (cli *socketClient) InitChainAsync(ctx context.Context, req types.RequestIn
return cli.queueRequestAsync(ctx, types.ToRequestInitChain(req))
}
func (cli *socketClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
return cli.queueRequestAsync(ctx, types.ToRequestBeginBlock(req))
}
func (cli *socketClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
return cli.queueRequestAsync(ctx, types.ToRequestEndBlock(req))
}
func (cli *socketClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
return cli.queueRequestAsync(ctx, types.ToRequestListSnapshots(req))
}
@@ -348,18 +336,6 @@ func (cli *socketClient) InfoSync(
return reqres.Response.GetInfo(), nil
}
func (cli *socketClient) DeliverTxSync(
ctx context.Context,
req types.RequestDeliverTx,
) (*types.ResponseDeliverTx, error) {
reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestDeliverTx(req))
if err != nil {
return nil, err
}
return reqres.Response.GetDeliverTx(), nil
}
func (cli *socketClient) CheckTxSync(
ctx context.Context,
req types.RequestCheckTx,
@@ -402,30 +378,6 @@ func (cli *socketClient) InitChainSync(
return reqres.Response.GetInitChain(), nil
}
func (cli *socketClient) BeginBlockSync(
ctx context.Context,
req types.RequestBeginBlock,
) (*types.ResponseBeginBlock, error) {
reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestBeginBlock(req))
if err != nil {
return nil, err
}
return reqres.Response.GetBeginBlock(), nil
}
func (cli *socketClient) EndBlockSync(
ctx context.Context,
req types.RequestEndBlock,
) (*types.ResponseEndBlock, error) {
reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestEndBlock(req))
if err != nil {
return nil, err
}
return reqres.Response.GetEndBlock(), nil
}
func (cli *socketClient) ListSnapshotsSync(
ctx context.Context,
req types.RequestListSnapshots,
@@ -587,8 +539,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
_, ok = res.Value.(*types.Response_Flush)
case *types.Request_Info:
_, ok = res.Value.(*types.Response_Info)
case *types.Request_DeliverTx:
_, ok = res.Value.(*types.Response_DeliverTx)
case *types.Request_CheckTx:
_, ok = res.Value.(*types.Response_CheckTx)
case *types.Request_Commit:
@@ -597,10 +547,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
_, ok = res.Value.(*types.Response_Query)
case *types.Request_InitChain:
_, ok = res.Value.(*types.Response_InitChain)
case *types.Request_BeginBlock:
_, ok = res.Value.(*types.Response_BeginBlock)
case *types.Request_EndBlock:
_, ok = res.Value.(*types.Response_EndBlock)
case *types.Request_ApplySnapshotChunk:
_, ok = res.Value.(*types.Response_ApplySnapshotChunk)
case *types.Request_LoadSnapshotChunk:

8
abci/client/socket_client_test.go
View File

@@ -37,11 +37,11 @@ func TestProperSyncCalls(t *testing.T) {
resp := make(chan error, 1)
go func() {
// This is BeginBlockSync unrolled....
reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
reqres, err := c.FinalizeBlockAsync(ctx, types.RequestFinalizeBlock{})
assert.NoError(t, err)
err = c.FlushSync(context.Background())
assert.NoError(t, err)
res := reqres.Response.GetBeginBlock()
res := reqres.Response.GetFinalizeBlock()
assert.NotNil(t, res)
resp <- c.Error()
}()
@@ -73,7 +73,7 @@ func TestHangingSyncCalls(t *testing.T) {
resp := make(chan error, 1)
go func() {
// Start BeginBlock and flush it
reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
reqres, err := c.FinalizeBlockAsync(ctx, types.RequestFinalizeBlock{})
assert.NoError(t, err)
flush, err := c.FlushAsync(ctx)
assert.NoError(t, err)
@@ -84,7 +84,7 @@ func TestHangingSyncCalls(t *testing.T) {
err = s.Stop()
assert.NoError(t, err)
// wait for the response from BeginBlock
// wait for the response from FinalizeBlock
reqres.Wait()
flush.Wait()
resp <- c.Error()

16
abci/cmd/abci-cli/abci-cli.go
View File

@@ -507,16 +507,18 @@ func cmdDeliverTx(cmd *cobra.Command, args []string) error {
if err != nil {
return err
}
res, err := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
res, err := client.FinalizeBlockSync(ctx, types.RequestFinalizeBlock{Txs: [][]byte{txBytes}})
if err != nil {
return err
}
printResponse(cmd, args, response{
Code: res.Code,
Data: res.Data,
Info: res.Info,
Log: res.Log,
})
for _, tx := range res.Txs {
printResponse(cmd, args, response{
Code: tx.Code,
Data: tx.Data,
Info: tx.Info,
Log: tx.Log,
})
}
return nil
}

30
abci/example/example_test.go
View File

@@ -103,7 +103,8 @@ func testStream(t *testing.T, app types.Application) {
// Write requests
for counter := 0; counter < numDeliverTxs; counter++ {
// Send request
_, err = client.DeliverTxAsync(ctx, types.RequestDeliverTx{Tx: []byte("test")})
tx := []byte("test")
_, err = client.FinalizeBlockAsync(ctx, types.RequestFinalizeBlock{Txs: [][]byte{tx}})
require.NoError(t, err)
// Sometimes send flush messages
@@ -163,22 +164,25 @@ func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
// Write requests
for counter := 0; counter < numDeliverTxs; counter++ {
// Send request
response, err := client.DeliverTx(context.Background(), &types.RequestDeliverTx{Tx: []byte("test")})
txt := []byte("test")
response, err := client.FinalizeBlock(context.Background(), &types.RequestFinalizeBlock{Txs: [][]byte{txt}})
if err != nil {
t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
}
counter++
if response.Code != code.CodeTypeOK {
t.Error("DeliverTx failed with ret_code", response.Code)
}
if counter > numDeliverTxs {
t.Fatal("Too many DeliverTx responses")
}
t.Log("response", counter)
if counter == numDeliverTxs {
go func() {
time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
}()
for _, tx := range response.Txs {
if tx.Code != code.CodeTypeOK {
t.Error("DeliverTx failed with ret_code", tx.Code)
}
if counter > numDeliverTxs {
t.Fatal("Too many DeliverTx responses")
}
t.Log("response", counter)
if counter == numDeliverTxs {
go func() {
time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
}()
}
}
}

44
abci/example/kvstore/kvstore_test.go
View File

@@ -27,12 +27,16 @@ const (
var ctx = context.Background()
func testKVStore(t *testing.T, app types.Application, tx []byte, key, value string) {
req := types.RequestDeliverTx{Tx: tx}
ar := app.DeliverTx(req)
require.False(t, ar.IsErr(), ar)
req := types.RequestFinalizeBlock{Txs: [][]byte{tx}}
ar := app.FinalizeBlock(req)
for _, tx := range ar.Txs {
require.False(t, tx.IsErr(), ar)
}
// repeating tx doesn't raise error
ar = app.DeliverTx(req)
require.False(t, ar.IsErr(), ar)
ar = app.FinalizeBlock(req)
for _, tx := range ar.Txs {
require.False(t, tx.IsErr(), ar)
}
// commit
app.Commit()
@@ -200,16 +204,15 @@ func makeApplyBlock(
Height: height,
}
kvstore.BeginBlock(types.RequestBeginBlock{Hash: hash, Header: header})
for _, tx := range txs {
if r := kvstore.DeliverTx(types.RequestDeliverTx{Tx: tx}); r.IsErr() {
t.Fatal(r)
}
}
resEndBlock := kvstore.EndBlock(types.RequestEndBlock{Height: header.Height})
resFinalizeBlock := kvstore.FinalizeBlock(types.RequestFinalizeBlock{
Hash: hash,
Header: header,
Txs: txs,
})
kvstore.Commit()
valsEqual(t, diff, resEndBlock.ValidatorUpdates)
valsEqual(t, diff, resFinalizeBlock.ValidatorUpdates)
}
@@ -326,13 +329,16 @@ func runClientTests(t *testing.T, client abcicli.Client) {
}
func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string) {
ar, err := app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
ar, err := app.FinalizeBlockSync(ctx, types.RequestFinalizeBlock{Txs: [][]byte{tx}})
for _, tx := range ar.Txs {
require.False(t, tx.IsErr(), ar)
}
ar, err = app.FinalizeBlockSync(ctx, types.RequestFinalizeBlock{Txs: [][]byte{tx}}) // repeating tx doesn't raise error
require.NoError(t, err)
require.False(t, ar.IsErr(), ar)
// repeating tx doesn't raise error
ar, err = app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
require.NoError(t, err)
require.False(t, ar.IsErr(), ar)
for _, tx := range ar.Txs {
require.False(t, tx.IsErr(), ar)
}
// commit
_, err = app.CommitSync(ctx)
require.NoError(t, err)

9
abci/server/socket_server.go
View File

@@ -200,9 +200,6 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
case *types.Request_Info:
res := s.app.Info(*r.Info)
responses <- types.ToResponseInfo(res)
case *types.Request_DeliverTx:
res := s.app.DeliverTx(*r.DeliverTx)
responses <- types.ToResponseDeliverTx(res)
case *types.Request_CheckTx:
res := s.app.CheckTx(*r.CheckTx)
responses <- types.ToResponseCheckTx(res)
@@ -215,12 +212,6 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
case *types.Request_InitChain:
res := s.app.InitChain(*r.InitChain)
responses <- types.ToResponseInitChain(res)
case *types.Request_BeginBlock:
res := s.app.BeginBlock(*r.BeginBlock)
responses <- types.ToResponseBeginBlock(res)
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)

32
abci/types/application.go
View File

@@ -17,10 +17,7 @@ type Application interface {
CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool
// Consensus Connection
InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
BeginBlock(RequestBeginBlock) ResponseBeginBlock // Signals the beginning of a block
DeliverTx(RequestDeliverTx) ResponseDeliverTx // Deliver a tx for full processing
EndBlock(RequestEndBlock) ResponseEndBlock // Signals the end of a block, returns changes to the validator set
InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
FinalizeBlock(RequestFinalizeBlock) ResponseFinalizeBlock
Commit() ResponseCommit // Commit the state and return the application Merkle root hash
@@ -47,10 +44,6 @@ func (BaseApplication) Info(req RequestInfo) ResponseInfo {
return ResponseInfo{}
}
func (BaseApplication) DeliverTx(req RequestDeliverTx) ResponseDeliverTx {
return ResponseDeliverTx{Code: CodeTypeOK}
}
func (BaseApplication) CheckTx(req RequestCheckTx) ResponseCheckTx {
return ResponseCheckTx{Code: CodeTypeOK}
}
@@ -67,14 +60,6 @@ func (BaseApplication) InitChain(req RequestInitChain) ResponseInitChain {
return ResponseInitChain{}
}
func (BaseApplication) BeginBlock(req RequestBeginBlock) ResponseBeginBlock {
return ResponseBeginBlock{}
}
func (BaseApplication) EndBlock(req RequestEndBlock) ResponseEndBlock {
return ResponseEndBlock{}
}
func (BaseApplication) ListSnapshots(req RequestListSnapshots) ResponseListSnapshots {
return ResponseListSnapshots{}
}
@@ -119,11 +104,6 @@ func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*Respon
return &res, nil
}
func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
res := app.app.DeliverTx(*req)
return &res, nil
}
func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) {
res := app.app.CheckTx(*req)
return &res, nil
@@ -144,16 +124,6 @@ func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain
return &res, nil
}
func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
res := app.app.BeginBlock(*req)
return &res, nil
}
func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) {
res := app.app.EndBlock(*req)
return &res, nil
}
func (app *GRPCApplication) ListSnapshots(
ctx context.Context, req *RequestListSnapshots) (*ResponseListSnapshots, error) {
res := app.app.ListSnapshots(*req)

35
abci/types/messages.go
View File

@@ -48,12 +48,6 @@ func ToRequestInfo(req RequestInfo) *Request {
}
}
func ToRequestDeliverTx(req RequestDeliverTx) *Request {
return &Request{
Value: &Request_DeliverTx{&req},
}
}
func ToRequestCheckTx(req RequestCheckTx) *Request {
return &Request{
Value: &Request_CheckTx{&req},
@@ -78,18 +72,6 @@ func ToRequestInitChain(req RequestInitChain) *Request {
}
}
func ToRequestBeginBlock(req RequestBeginBlock) *Request {
return &Request{
Value: &Request_BeginBlock{&req},
}
}
func ToRequestEndBlock(req RequestEndBlock) *Request {
return &Request{
Value: &Request_EndBlock{&req},
}
}
func ToRequestListSnapshots(req RequestListSnapshots) *Request {
return &Request{
Value: &Request_ListSnapshots{&req},
@@ -145,11 +127,6 @@ func ToResponseInfo(res ResponseInfo) *Response {
Value: &Response_Info{&res},
}
}
func ToResponseDeliverTx(res ResponseDeliverTx) *Response {
return &Response{
Value: &Response_DeliverTx{&res},
}
}
func ToResponseCheckTx(res ResponseCheckTx) *Response {
return &Response{
@@ -175,18 +152,6 @@ func ToResponseInitChain(res ResponseInitChain) *Response {
}
}
func ToResponseBeginBlock(res ResponseBeginBlock) *Response {
return &Response{
Value: &Response_BeginBlock{&res},
}
}
func ToResponseEndBlock(res ResponseEndBlock) *Response {
return &Response{
Value: &Response_EndBlock{&res},
}
}
func ToResponseListSnapshots(res ResponseListSnapshots) *Response {
return &Response{
Value: &Response_ListSnapshots{&res},

455
abci/types/types.pb.go
View File

@@ -3126,178 +3126,175 @@ func init() {
func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
var fileDescriptor_252557cfdd89a31a = []byte{
// 2722 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcb, 0x73, 0x1b, 0xc7,
0xd1, 0xc7, 0xfb, 0xd1, 0x20, 0x40, 0x70, 0x44, 0xcb, 0x30, 0x2c, 0x93, 0xf4, 0xaa, 0xe4, 0x4f,
0x92, 0x6d, 0xf2, 0x33, 0x15, 0x29, 0x72, 0x39, 0x0f, 0x13, 0x10, 0x18, 0xd0, 0x62, 0x08, 0x66,
0x09, 0xc9, 0xe5, 0x24, 0xd6, 0x7a, 0x81, 0x1d, 0x02, 0x6b, 0x01, 0xbb, 0xeb, 0xdd, 0x01, 0x45,
0xea, 0x98, 0x4a, 0x2e, 0xaa, 0x54, 0x45, 0xc7, 0xe4, 0xa0, 0xbf, 0x23, 0x39, 0xe5, 0x94, 0xaa,
0xf8, 0x90, 0x83, 0x8f, 0x39, 0x39, 0x29, 0xe9, 0x96, 0x5b, 0x4e, 0x39, 0xa5, 0x2a, 0x35, 0x8f,
0x7d, 0x01, 0x58, 0x00, 0x8c, 0xec, 0x53, 0x6e, 0x33, 0xbd, 0xdd, 0x8d, 0x99, 0x9e, 0xe9, 0xee,
0x5f, 0xf7, 0x00, 0x5e, 0x27, 0xd8, 0xd0, 0xb0, 0x3d, 0xd4, 0x0d, 0xb2, 0xa5, 0x76, 0xba, 0xfa,
0x16, 0x39, 0xb3, 0xb0, 0xb3, 0x69, 0xd9, 0x26, 0x31, 0xd1, 0xb2, 0xff, 0x71, 0x93, 0x7e, 0xac,
0xbe, 0x11, 0xe0, 0xee, 0xda, 0x67, 0x16, 0x31, 0xb7, 0x2c, 0xdb, 0x34, 0x8f, 0x39, 0x7f, 0xf5,
0x52, 0xe0, 0x33, 0xd3, 0x13, 0xd4, 0x16, 0xfa, 0x2a, 0x84, 0x1f, 0xe2, 0x33, 0xf7, 0xeb, 0x1b,
0x13, 0xb2, 0x96, 0x6a, 0xab, 0x43, 0xf7, 0xf3, 0x7a, 0xcf, 0x34, 0x7b, 0x03, 0xbc, 0xc5, 0x66,
0x9d, 0xd1, 0xf1, 0x16, 0xd1, 0x87, 0xd8, 0x21, 0xea, 0xd0, 0x12, 0x0c, 0xab, 0x3d, 0xb3, 0x67,
0xb2, 0xe1, 0x16, 0x1d, 0x71, 0xaa, 0xf4, 0x2c, 0x07, 0x59, 0x19, 0x7f, 0x31, 0xc2, 0x0e, 0x41,
0xdb, 0x90, 0xc2, 0xdd, 0xbe, 0x59, 0x89, 0x6f, 0xc4, 0xaf, 0x16, 0xb6, 0x2f, 0x6d, 0x8e, 0x6d,
0x6e, 0x53, 0xf0, 0x35, 0xba, 0x7d, 0xb3, 0x19, 0x93, 0x19, 0x2f, 0xba, 0x09, 0xe9, 0xe3, 0xc1,
0xc8, 0xe9, 0x57, 0x12, 0x4c, 0xe8, 0x8d, 0x28, 0xa1, 0x5d, 0xca, 0xd4, 0x8c, 0xc9, 0x9c, 0x9b,
0xfe, 0x94, 0x6e, 0x1c, 0x9b, 0x95, 0xe4, 0xec, 0x9f, 0xda, 0x33, 0x8e, 0xd9, 0x4f, 0x51, 0x5e,
0x54, 0x03, 0xd0, 0x0d, 0x9d, 0x28, 0xdd, 0xbe, 0xaa, 0x1b, 0x95, 0x14, 0x93, 0x7c, 0x33, 0x5a,
0x52, 0x27, 0x75, 0xca, 0xd8, 0x8c, 0xc9, 0x79, 0xdd, 0x9d, 0xd0, 0xe5, 0x7e, 0x31, 0xc2, 0xf6,
0x59, 0x25, 0x3d, 0x7b, 0xb9, 0x3f, 0xa1, 0x4c, 0x74, 0xb9, 0x8c, 0x1b, 0x35, 0xa0, 0xd0, 0xc1,
0x3d, 0xdd, 0x50, 0x3a, 0x03, 0xb3, 0xfb, 0xb0, 0x92, 0x61, 0xc2, 0x52, 0x94, 0x70, 0x8d, 0xb2,
0xd6, 0x28, 0x67, 0x33, 0x26, 0x43, 0xc7, 0x9b, 0xa1, 0xef, 0x41, 0xae, 0xdb, 0xc7, 0xdd, 0x87,
0x0a, 0x39, 0xad, 0x64, 0x99, 0x8e, 0xf5, 0x28, 0x1d, 0x75, 0xca, 0xd7, 0x3e, 0x6d, 0xc6, 0xe4,
0x6c, 0x97, 0x0f, 0xe9, 0xfe, 0x35, 0x3c, 0xd0, 0x4f, 0xb0, 0x4d, 0xe5, 0x73, 0xb3, 0xf7, 0x7f,
0x87, 0x73, 0x32, 0x0d, 0x79, 0xcd, 0x9d, 0xa0, 0x1f, 0x42, 0x1e, 0x1b, 0x9a, 0xd8, 0x46, 0x9e,
0xa9, 0xd8, 0x88, 0x3c, 0x67, 0x43, 0x73, 0x37, 0x91, 0xc3, 0x62, 0x8c, 0x6e, 0x43, 0xa6, 0x6b,
0x0e, 0x87, 0x3a, 0xa9, 0x00, 0x93, 0x5e, 0x8b, 0xdc, 0x00, 0xe3, 0x6a, 0xc6, 0x64, 0xc1, 0x8f,
0x0e, 0xa0, 0x34, 0xd0, 0x1d, 0xa2, 0x38, 0x86, 0x6a, 0x39, 0x7d, 0x93, 0x38, 0x95, 0x02, 0xd3,
0x70, 0x25, 0x4a, 0xc3, 0xbe, 0xee, 0x90, 0x23, 0x97, 0xb9, 0x19, 0x93, 0x8b, 0x83, 0x20, 0x81,
0xea, 0x33, 0x8f, 0x8f, 0xb1, 0xed, 0x29, 0xac, 0x2c, 0xcd, 0xd6, 0xd7, 0xa2, 0xdc, 0xae, 0x3c,
0xd5, 0x67, 0x06, 0x09, 0xe8, 0x67, 0x70, 0x61, 0x60, 0xaa, 0x9a, 0xa7, 0x4e, 0xe9, 0xf6, 0x47,
0xc6, 0xc3, 0x4a, 0x91, 0x29, 0xbd, 0x16, 0xb9, 0x48, 0x53, 0xd5, 0x5c, 0x15, 0x75, 0x2a, 0xd0,
0x8c, 0xc9, 0x2b, 0x83, 0x71, 0x22, 0x7a, 0x00, 0xab, 0xaa, 0x65, 0x0d, 0xce, 0xc6, 0xb5, 0x97,
0x98, 0xf6, 0xeb, 0x51, 0xda, 0x77, 0xa8, 0xcc, 0xb8, 0x7a, 0xa4, 0x4e, 0x50, 0xa9, 0x31, 0x8e,
0x75, 0x43, 0x1d, 0xe8, 0x8f, 0xb1, 0x38, 0xdc, 0xe5, 0xd9, 0xc6, 0xd8, 0x15, 0xdc, 0xee, 0x09,
0x17, 0x8f, 0x83, 0x84, 0x5a, 0x16, 0xd2, 0x27, 0xea, 0x60, 0x84, 0xa5, 0xff, 0x83, 0x42, 0xc0,
0xed, 0x51, 0x05, 0xb2, 0x43, 0xec, 0x38, 0x6a, 0x0f, 0xb3, 0x28, 0x91, 0x97, 0xdd, 0xa9, 0x54,
0x82, 0xa5, 0xa0, 0xab, 0x4b, 0x4f, 0xe3, 0x9e, 0x24, 0xf5, 0x62, 0x2a, 0x79, 0x82, 0x6d, 0x47,
0x37, 0x0d, 0x57, 0x52, 0x4c, 0xd1, 0x65, 0x28, 0xb2, 0x25, 0x2b, 0xee, 0x77, 0x1a, 0x4a, 0x52,
0xf2, 0x12, 0x23, 0xde, 0x17, 0x4c, 0xeb, 0x50, 0xb0, 0xb6, 0x2d, 0x8f, 0x25, 0xc9, 0x58, 0xc0,
0xda, 0xb6, 0x5c, 0x86, 0x37, 0x61, 0x89, 0xee, 0xcf, 0xe3, 0x48, 0xb1, 0x1f, 0x29, 0x50, 0x9a,
0x60, 0x91, 0xfe, 0x92, 0x80, 0xf2, 0x78, 0x78, 0x40, 0xb7, 0x21, 0x45, 0x23, 0xa5, 0x08, 0x7a,
0xd5, 0x4d, 0x1e, 0x46, 0x37, 0xdd, 0x30, 0xba, 0xd9, 0x76, 0xc3, 0x68, 0x2d, 0xf7, 0xe5, 0xd7,
0xeb, 0xb1, 0xa7, 0x7f, 0x5b, 0x8f, 0xcb, 0x4c, 0x02, 0xbd, 0x46, 0xbd, 0x59, 0xd5, 0x0d, 0x45,
0xd7, 0xd8, 0x92, 0xf3, 0xd4, 0x55, 0x55, 0xdd, 0xd8, 0xd3, 0xd0, 0x3e, 0x94, 0xbb, 0xa6, 0xe1,
0x60, 0xc3, 0x19, 0x39, 0x0a, 0x0f, 0xd3, 0x22, 0xd4, 0x85, 0x1c, 0x96, 0x07, 0xff, 0xba, 0xcb,
0x79, 0xc8, 0x18, 0xe5, 0xe5, 0x6e, 0x98, 0x80, 0x76, 0x01, 0x4e, 0xd4, 0x81, 0xae, 0xa9, 0xc4,
0xb4, 0x9d, 0x4a, 0x6a, 0x23, 0x39, 0xd5, 0x6b, 0xef, 0xbb, 0x2c, 0xf7, 0x2c, 0x4d, 0x25, 0xb8,
0x96, 0xa2, 0xcb, 0x95, 0x03, 0x92, 0xe8, 0x2d, 0x58, 0x56, 0x2d, 0x4b, 0x71, 0x88, 0x4a, 0xb0,
0xd2, 0x39, 0x23, 0xd8, 0x61, 0x61, 0x70, 0x49, 0x2e, 0xaa, 0x96, 0x75, 0x44, 0xa9, 0x35, 0x4a,
0x44, 0x57, 0xa0, 0x44, 0x23, 0xa6, 0xae, 0x0e, 0x94, 0x3e, 0xd6, 0x7b, 0x7d, 0xc2, 0x02, 0x5e,
0x52, 0x2e, 0x0a, 0x6a, 0x93, 0x11, 0x25, 0xcd, 0x3b, 0x71, 0x16, 0x2d, 0x11, 0x82, 0x94, 0xa6,
0x12, 0x95, 0x59, 0x72, 0x49, 0x66, 0x63, 0x4a, 0xb3, 0x54, 0xd2, 0x17, 0xf6, 0x61, 0x63, 0x74,
0x11, 0x32, 0x42, 0x6d, 0x92, 0xa9, 0x15, 0x33, 0xb4, 0x0a, 0x69, 0xcb, 0x36, 0x4f, 0x30, 0x3b,
0xba, 0x9c, 0xcc, 0x27, 0xd2, 0x2f, 0x13, 0xb0, 0x32, 0x11, 0x57, 0xa9, 0xde, 0xbe, 0xea, 0xf4,
0xdd, 0xdf, 0xa2, 0x63, 0x74, 0x8b, 0xea, 0x55, 0x35, 0x6c, 0x8b, 0x5c, 0x54, 0x99, 0x34, 0x75,
0x93, 0x7d, 0x17, 0xa6, 0x11, 0xdc, 0xa8, 0x05, 0xe5, 0x81, 0xea, 0x10, 0x85, 0xc7, 0x29, 0x25,
0x90, 0x97, 0x26, 0xa3, 0xf3, 0xbe, 0xea, 0x46, 0x36, 0x7a, 0xa9, 0x85, 0xa2, 0xd2, 0x20, 0x44,
0x45, 0x32, 0xac, 0x76, 0xce, 0x1e, 0xab, 0x06, 0xd1, 0x0d, 0xac, 0x4c, 0x9c, 0xdc, 0x6b, 0x13,
0x4a, 0x1b, 0x27, 0xba, 0x86, 0x8d, 0xae, 0x7b, 0x64, 0x17, 0x3c, 0x61, 0xef, 0x48, 0x1d, 0x49,
0x86, 0x52, 0x38, 0x33, 0xa0, 0x12, 0x24, 0xc8, 0xa9, 0x30, 0x40, 0x82, 0x9c, 0xa2, 0xff, 0x87,
0x14, 0xdd, 0x24, 0xdb, 0x7c, 0x69, 0x4a, 0x4a, 0x15, 0x72, 0xed, 0x33, 0x0b, 0xcb, 0x8c, 0x53,
0x92, 0x3c, 0x77, 0xf0, 0xb2, 0xc5, 0xb8, 0x56, 0xe9, 0x1a, 0x2c, 0x8f, 0xa5, 0x83, 0xc0, 0xf9,
0xc5, 0x83, 0xe7, 0x27, 0x2d, 0x43, 0x31, 0x14, 0xfb, 0xa5, 0x8b, 0xb0, 0x3a, 0x2d, 0x94, 0x4b,
0x7d, 0x8f, 0x1e, 0x0a, 0xc9, 0xe8, 0x26, 0xe4, 0xbc, 0x58, 0xce, 0xdd, 0x71, 0xd2, 0x56, 0x2e,
0xb3, 0xec, 0xb1, 0x52, 0x3f, 0xa4, 0xd7, 0x9a, 0xdd, 0x87, 0x04, 0x5b, 0x78, 0x56, 0xb5, 0xac,
0xa6, 0xea, 0xf4, 0xa5, 0xcf, 0xa0, 0x12, 0x15, 0xa7, 0xc7, 0xb6, 0x91, 0xf2, 0xae, 0xe1, 0x45,
0xc8, 0x1c, 0x9b, 0xf6, 0x50, 0x25, 0x4c, 0x59, 0x51, 0x16, 0x33, 0x7a, 0x3d, 0x79, 0xcc, 0x4e,
0x32, 0x32, 0x9f, 0x48, 0x0a, 0xbc, 0x16, 0x19, 0xab, 0xa9, 0x88, 0x6e, 0x68, 0x98, 0xdb, 0xb3,
0x28, 0xf3, 0x89, 0xaf, 0x88, 0x2f, 0x96, 0x4f, 0xe8, 0xcf, 0x3a, 0x6c, 0xaf, 0x4c, 0x7f, 0x5e,
0x16, 0x33, 0xe9, 0x77, 0x09, 0xcf, 0x5a, 0xa1, 0x98, 0x8d, 0xca, 0x90, 0x24, 0xa7, 0x4e, 0x25,
0xbe, 0x91, 0xbc, 0xba, 0x24, 0xd3, 0xa1, 0xe7, 0x14, 0x89, 0xa9, 0x4e, 0x91, 0x7c, 0x69, 0xa7,
0x48, 0x7d, 0x1b, 0x4e, 0x91, 0x7e, 0x09, 0xa7, 0xf8, 0x67, 0x0e, 0x72, 0x32, 0x76, 0x2c, 0x1a,
0x2f, 0x51, 0x0d, 0xf2, 0xf8, 0xb4, 0x8b, 0x2d, 0xe2, 0xa6, 0x98, 0xe9, 0x08, 0x8d, 0x73, 0x37,
0x5c, 0x4e, 0x0a, 0x8f, 0x3c, 0x31, 0x74, 0x43, 0x20, 0xe0, 0x68, 0x30, 0x2b, 0xc4, 0x83, 0x10,
0xf8, 0x96, 0x0b, 0x81, 0x93, 0x91, 0x88, 0x88, 0x4b, 0x8d, 0x61, 0xe0, 0x1b, 0x02, 0x03, 0xa7,
0xe6, 0xfc, 0x58, 0x08, 0x04, 0xd7, 0x43, 0x20, 0x38, 0x3d, 0x67, 0x9b, 0x11, 0x28, 0xf8, 0x96,
0x8b, 0x82, 0x33, 0x73, 0x56, 0x3c, 0x06, 0x83, 0x77, 0xc3, 0x30, 0x98, 0x43, 0xd8, 0xcb, 0x91,
0xd2, 0x91, 0x38, 0xf8, 0xfb, 0x01, 0x1c, 0x9c, 0x8b, 0x04, 0xa1, 0x5c, 0xc9, 0x14, 0x20, 0x5c,
0x0f, 0x01, 0xe1, 0xfc, 0x1c, 0x1b, 0x44, 0x20, 0xe1, 0x0f, 0x83, 0x48, 0x18, 0x22, 0xc1, 0xb4,
0x38, 0xef, 0x69, 0x50, 0xf8, 0x7d, 0x0f, 0x0a, 0x17, 0x22, 0xb1, 0xbc, 0xd8, 0xc3, 0x38, 0x16,
0x6e, 0x4d, 0x60, 0x61, 0x8e, 0x5d, 0xdf, 0x8a, 0x54, 0x31, 0x07, 0x0c, 0xb7, 0x26, 0xc0, 0x70,
0x71, 0x8e, 0xc2, 0x39, 0x68, 0xf8, 0xe7, 0xd3, 0xd1, 0x70, 0x34, 0x5e, 0x15, 0xcb, 0x5c, 0x0c,
0x0e, 0x2b, 0x11, 0x70, 0x98, 0x83, 0xd6, 0xb7, 0x23, 0xd5, 0x2f, 0x8c, 0x87, 0x5b, 0x13, 0x78,
0xb8, 0x3c, 0xc7, 0x1e, 0x8b, 0x02, 0xe2, 0x6b, 0x14, 0x8e, 0x8c, 0x05, 0x11, 0x1a, 0xd2, 0xb1,
0x6d, 0x9b, 0xb6, 0x80, 0xb6, 0x7c, 0x22, 0x5d, 0xa5, 0x00, 0xc9, 0x0f, 0x18, 0x33, 0xc0, 0x33,
0x4b, 0x9d, 0x81, 0x20, 0x21, 0xfd, 0x21, 0xee, 0xcb, 0xb2, 0xf0, 0x19, 0x04, 0x57, 0x79, 0x01,
0xae, 0x02, 0x90, 0x3a, 0x11, 0x86, 0xd4, 0xeb, 0x50, 0xa0, 0x29, 0x71, 0x0c, 0x2d, 0xab, 0x96,
0x87, 0x96, 0xaf, 0xc3, 0x0a, 0x0b, 0xef, 0x1c, 0x78, 0x8b, 0x3c, 0x98, 0x62, 0xe9, 0x7c, 0x99,
0x7e, 0xe0, 0x56, 0xe0, 0x09, 0xf1, 0x5d, 0xb8, 0x10, 0xe0, 0xf5, 0x52, 0x2d, 0x87, 0x8e, 0x65,
0x8f, 0x7b, 0x47, 0xe4, 0xdc, 0x3f, 0xc5, 0x7d, 0x0b, 0xf9, 0x30, 0x7b, 0x1a, 0x22, 0x8e, 0x7f,
0x43, 0x88, 0x38, 0xf1, 0x5f, 0x23, 0xe2, 0x20, 0x74, 0x48, 0x86, 0xa1, 0xc3, 0xbf, 0xe2, 0xfe,
0x99, 0x78, 0xf8, 0xb6, 0x6b, 0x6a, 0x58, 0x24, 0x73, 0x36, 0xa6, 0x49, 0x78, 0x60, 0xf6, 0x44,
0xca, 0xa6, 0x43, 0xca, 0xe5, 0x45, 0xf5, 0xbc, 0x08, 0xda, 0x1e, 0x0e, 0x48, 0x33, 0x0b, 0x0b,
0x1c, 0x50, 0x86, 0xe4, 0x43, 0xcc, 0x63, 0xf0, 0x92, 0x4c, 0x87, 0x94, 0x8f, 0x5d, 0x32, 0x16,
0x59, 0x97, 0x64, 0x3e, 0x41, 0xb7, 0x21, 0xcf, 0x7a, 0x48, 0x8a, 0x69, 0x39, 0x22, 0x5c, 0xbe,
0x1e, 0xdc, 0x2b, 0x6f, 0x15, 0x6d, 0x1e, 0x52, 0x9e, 0x96, 0xe5, 0xc8, 0x39, 0x4b, 0x8c, 0x02,
0x10, 0x27, 0x1f, 0x42, 0xda, 0x97, 0x20, 0x4f, 0x57, 0xef, 0x58, 0x6a, 0x17, 0xb3, 0xd8, 0x97,
0x97, 0x7d, 0x82, 0xf4, 0x00, 0xd0, 0x64, 0x04, 0x47, 0x4d, 0xc8, 0xe0, 0x13, 0x6c, 0x10, 0x8e,
0x38, 0x0a, 0xdb, 0x17, 0xa7, 0x64, 0x6c, 0x6c, 0x90, 0x5a, 0x85, 0x1a, 0xf9, 0x1f, 0x5f, 0xaf,
0x97, 0x39, 0xf7, 0x3b, 0xe6, 0x50, 0x27, 0x78, 0x68, 0x91, 0x33, 0x59, 0xc8, 0x4b, 0xbf, 0x4f,
0x50, 0x4c, 0x19, 0x8a, 0xee, 0x53, 0x6d, 0xeb, 0x5e, 0xf9, 0x44, 0xa0, 0x9e, 0x58, 0xcc, 0xde,
0x6b, 0x00, 0x3d, 0xd5, 0x51, 0x1e, 0xa9, 0x06, 0xc1, 0x9a, 0x30, 0x7a, 0x80, 0x82, 0xaa, 0x90,
0xa3, 0xb3, 0x91, 0x83, 0x35, 0x51, 0xda, 0x78, 0xf3, 0xc0, 0x3e, 0xb3, 0x2f, 0xb7, 0xcf, 0xb0,
0x95, 0x73, 0x63, 0x56, 0x0e, 0xe0, 0xbd, 0x7c, 0x10, 0xef, 0xd1, 0xb5, 0x59, 0xb6, 0x6e, 0xda,
0x3a, 0x39, 0x63, 0x47, 0x93, 0x94, 0xbd, 0xb9, 0xf4, 0xab, 0x84, 0xef, 0x5a, 0x3e, 0x64, 0xff,
0x9f, 0xb3, 0x9d, 0xf4, 0x6b, 0x56, 0xc8, 0x87, 0x53, 0x33, 0x3a, 0x82, 0x15, 0xcf, 0xb3, 0x95,
0x11, 0xf3, 0x78, 0xf7, 0xae, 0x2e, 0x1a, 0x1a, 0xca, 0x27, 0x61, 0xb2, 0x83, 0x3e, 0x81, 0x57,
0xc7, 0xc2, 0x96, 0xa7, 0x3a, 0xb1, 0x68, 0xf4, 0x7a, 0x25, 0x1c, 0xbd, 0x5c, 0xd5, 0xbe, 0xb1,
0x92, 0x2f, 0xe9, 0x50, 0x7b, 0xb4, 0x36, 0x0c, 0x22, 0x8d, 0xa9, 0xc7, 0x7f, 0x19, 0x8a, 0x36,
0x26, 0xaa, 0x6e, 0x28, 0xa1, 0xea, 0x7b, 0x89, 0x13, 0x45, 0x4d, 0x7f, 0x08, 0xaf, 0x4c, 0x45,
0x1c, 0xe8, 0xbb, 0x90, 0xf7, 0xc1, 0x4a, 0x3c, 0x02, 0xb3, 0x7b, 0xc5, 0x99, 0xcf, 0x2b, 0xfd,
0x31, 0xee, 0xab, 0x0c, 0x97, 0x7b, 0x0d, 0xc8, 0xd8, 0xd8, 0x19, 0x0d, 0x78, 0x01, 0x56, 0xda,
0x7e, 0x77, 0x31, 0xac, 0x42, 0xa9, 0xa3, 0x01, 0x91, 0x85, 0xb0, 0xf4, 0x00, 0x32, 0x9c, 0x82,
0x0a, 0x90, 0xbd, 0x77, 0x70, 0xf7, 0xa0, 0xf5, 0xf1, 0x41, 0x39, 0x86, 0x00, 0x32, 0x3b, 0xf5,
0x7a, 0xe3, 0xb0, 0x5d, 0x8e, 0xa3, 0x3c, 0xa4, 0x77, 0x6a, 0x2d, 0xb9, 0x5d, 0x4e, 0x50, 0xb2,
0xdc, 0xf8, 0xa8, 0x51, 0x6f, 0x97, 0x93, 0x68, 0x05, 0x8a, 0x7c, 0xac, 0xec, 0xb6, 0xe4, 0x1f,
0xef, 0xb4, 0xcb, 0xa9, 0x00, 0xe9, 0xa8, 0x71, 0x70, 0xa7, 0x21, 0x97, 0xd3, 0xd2, 0x7b, 0xb4,
0xc2, 0x8b, 0x40, 0x37, 0x7e, 0x2d, 0x17, 0x0f, 0xd4, 0x72, 0xd2, 0x6f, 0x13, 0x50, 0x8d, 0x86,
0x2c, 0xe8, 0xa3, 0xb1, 0x8d, 0x6f, 0x9f, 0x03, 0xef, 0x8c, 0xed, 0x1e, 0x5d, 0x81, 0x92, 0x8d,
0x8f, 0x31, 0xe9, 0xf6, 0x39, 0x84, 0xe2, 0xd9, 0xb0, 0x28, 0x17, 0x05, 0x95, 0x09, 0x39, 0x9c,
0xed, 0x73, 0xdc, 0x25, 0x0a, 0x0f, 0x33, 0xfc, 0xd2, 0xe5, 0x29, 0x1b, 0xa5, 0x1e, 0x71, 0xa2,
0xf4, 0xd9, 0xb9, 0x6c, 0x99, 0x87, 0xb4, 0xdc, 0x68, 0xcb, 0x9f, 0x94, 0x93, 0x08, 0x41, 0x89,
0x0d, 0x95, 0xa3, 0x83, 0x9d, 0xc3, 0xa3, 0x66, 0x8b, 0xda, 0xf2, 0x02, 0x2c, 0xbb, 0xb6, 0x74,
0x89, 0x69, 0xe9, 0xcf, 0x09, 0xff, 0x3a, 0x84, 0xeb, 0xd9, 0xef, 0xf8, 0xf5, 0xec, 0x42, 0x70,
0x9e, 0xd7, 0xbc, 0x53, 0xbd, 0x3e, 0xf1, 0xed, 0x79, 0x7d, 0xf2, 0x1b, 0xf3, 0xfa, 0xd4, 0x4b,
0x7a, 0xfd, 0xa7, 0x50, 0x0a, 0x17, 0xde, 0xf4, 0x32, 0xda, 0xe6, 0xc8, 0xd0, 0xd8, 0xb5, 0x4a,
0xcb, 0x7c, 0x82, 0x6e, 0x42, 0xfa, 0xc4, 0xf4, 0xad, 0x32, 0xe9, 0xb5, 0xf7, 0x4d, 0x82, 0x03,
0x85, 0x3b, 0xe7, 0x96, 0x1e, 0x43, 0x9a, 0xad, 0x84, 0xc6, 0x12, 0xd6, 0x57, 0x12, 0xc8, 0x93,
0x8e, 0xd1, 0xa7, 0x00, 0x2a, 0x21, 0xb6, 0xde, 0x19, 0xf9, 0x8a, 0xd7, 0xa7, 0xef, 0x64, 0xc7,
0xe5, 0xab, 0x5d, 0x12, 0x5b, 0x5a, 0xf5, 0x45, 0x03, 0xdb, 0x0a, 0x28, 0x94, 0x0e, 0xa0, 0x14,
0x96, 0x75, 0xb1, 0x12, 0x5f, 0x43, 0x18, 0x2b, 0x71, 0xe8, 0x2b, 0xb0, 0x92, 0x87, 0xb4, 0x92,
0xbc, 0x87, 0xc8, 0x26, 0xd2, 0x93, 0x38, 0xe4, 0xda, 0xa7, 0xe2, 0x66, 0x47, 0xb4, 0xaf, 0x7c,
0xd1, 0x44, 0xb0, 0x59, 0xc3, 0xfb, 0x61, 0x49, 0xaf, 0xcb, 0xf6, 0xa1, 0xe7, 0xbb, 0xa9, 0x45,
0xeb, 0x4e, 0xb7, 0xb3, 0x22, 0xe2, 0xd5, 0x07, 0x90, 0xf7, 0xee, 0x21, 0x85, 0xf0, 0xaa, 0xa6,
0xd9, 0xd8, 0x71, 0x44, 0x04, 0x71, 0xa7, 0xac, 0x1b, 0x6a, 0x3e, 0x12, 0x7d, 0x9b, 0xa4, 0xcc,
0x27, 0x92, 0x06, 0xcb, 0x63, 0x97, 0x18, 0x7d, 0x00, 0x59, 0x6b, 0xd4, 0x51, 0x5c, 0xf3, 0x8c,
0xbd, 0xa6, 0xb9, 0xe0, 0x70, 0xd4, 0x19, 0xe8, 0xdd, 0xbb, 0xf8, 0xcc, 0x5d, 0x8c, 0x35, 0xea,
0xdc, 0xe5, 0x56, 0xe4, 0xbf, 0x92, 0x08, 0xfe, 0xca, 0x09, 0xe4, 0xdc, 0x4b, 0x81, 0x7e, 0x00,
0x79, 0xcf, 0x3f, 0xbc, 0x26, 0x79, 0xa4, 0x63, 0x09, 0xf5, 0xbe, 0x08, 0xad, 0x34, 0x1c, 0xbd,
0x67, 0x60, 0x4d, 0xf1, 0x8b, 0x08, 0xf6, 0x6b, 0x39, 0x79, 0x99, 0x7f, 0xd8, 0x77, 0x2b, 0x08,
0xe9, 0xdf, 0x71, 0xc8, 0xb9, 0x7d, 0x1f, 0xf4, 0x5e, 0xe0, 0xde, 0x95, 0xa6, 0xb4, 0x47, 0x5c,
0x46, 0xbf, 0xa1, 0x19, 0x5e, 0x6b, 0xe2, 0xfc, 0x6b, 0x8d, 0xea, 0x4c, 0xbb, 0x6f, 0x04, 0xa9,
0x73, 0xbf, 0x11, 0xbc, 0x03, 0x88, 0x98, 0x44, 0x1d, 0x28, 0x27, 0x26, 0xd1, 0x8d, 0x9e, 0xc2,
0x8d, 0xcd, 0x51, 0x55, 0x99, 0x7d, 0xb9, 0xcf, 0x3e, 0x1c, 0x32, 0xbb, 0xff, 0x22, 0x0e, 0x39,
0x2f, 0x3d, 0x9e, 0xb7, 0x3f, 0x79, 0x11, 0x32, 0x22, 0x03, 0xf0, 0x06, 0xa5, 0x98, 0x79, 0x5d,
0xc1, 0x54, 0xa0, 0x2b, 0x58, 0x85, 0xdc, 0x10, 0x13, 0x95, 0x61, 0x04, 0x5e, 0xc7, 0x79, 0xf3,
0xeb, 0xef, 0x43, 0x21, 0xd0, 0x2a, 0xa6, 0x9e, 0x77, 0xd0, 0xf8, 0xb8, 0x1c, 0xab, 0x66, 0x9f,
0x3c, 0xdb, 0x48, 0x1e, 0xe0, 0x47, 0xf4, 0xce, 0xca, 0x8d, 0x7a, 0xb3, 0x51, 0xbf, 0x5b, 0x8e,
0x57, 0x0b, 0x4f, 0x9e, 0x6d, 0x64, 0x65, 0xcc, 0x5a, 0x33, 0xd7, 0x9b, 0xb0, 0x14, 0x3c, 0x95,
0x70, 0x12, 0x41, 0x50, 0xba, 0x73, 0xef, 0x70, 0x7f, 0xaf, 0xbe, 0xd3, 0x6e, 0x28, 0xf7, 0x5b,
0xed, 0x46, 0x39, 0x8e, 0x5e, 0x85, 0x0b, 0xfb, 0x7b, 0x3f, 0x6a, 0xb6, 0x95, 0xfa, 0xfe, 0x5e,
0xe3, 0xa0, 0xad, 0xec, 0xb4, 0xdb, 0x3b, 0xf5, 0xbb, 0xe5, 0xc4, 0xf6, 0x6f, 0x00, 0x96, 0x77,
0x6a, 0xf5, 0x3d, 0x9a, 0x00, 0xf5, 0xae, 0xca, 0x8a, 0xec, 0x3a, 0xa4, 0x58, 0x19, 0x3d, 0xf3,
0x61, 0xba, 0x3a, 0xbb, 0x69, 0x87, 0x76, 0x21, 0xcd, 0x2a, 0x6c, 0x34, 0xfb, 0xa5, 0xba, 0x3a,
0xa7, 0x8b, 0x47, 0x17, 0xc3, 0xdc, 0x63, 0xe6, 0xd3, 0x75, 0x75, 0x76, 0x53, 0x0f, 0xc9, 0x90,
0xf7, 0x61, 0xfc, 0xfc, 0xa7, 0xdc, 0xea, 0x02, 0xc1, 0x06, 0xed, 0x43, 0xd6, 0x2d, 0xaa, 0xe6,
0x3d, 0x2e, 0x57, 0xe7, 0x76, 0xdd, 0xa8, 0xb9, 0x78, 0xf1, 0x3b, 0xfb, 0xa5, 0xbc, 0x3a, 0xa7,
0x85, 0x88, 0xf6, 0x20, 0x23, 0xa0, 0xe9, 0x9c, 0x07, 0xe3, 0xea, 0xbc, 0x2e, 0x1a, 0x35, 0x9a,
0xdf, 0x56, 0x98, 0xff, 0xfe, 0x5f, 0x5d, 0xa0, 0x3b, 0x8a, 0xee, 0x01, 0x04, 0x4a, 0xdd, 0x05,
0x1e, 0xf6, 0xab, 0x8b, 0x74, 0x3d, 0x51, 0x0b, 0x72, 0x5e, 0x79, 0x32, 0xf7, 0x99, 0xbd, 0x3a,
0xbf, 0xfd, 0x88, 0x1e, 0x40, 0x31, 0x0c, 0xcb, 0x17, 0x7b, 0x3c, 0xaf, 0x2e, 0xd8, 0x57, 0xa4,
0xfa, 0xc3, 0x18, 0x7d, 0xb1, 0xc7, 0xf4, 0xea, 0x82, 0x6d, 0x46, 0xf4, 0x39, 0xac, 0x4c, 0x62,
0xe8, 0xc5, 0xdf, 0xd6, 0xab, 0xe7, 0x68, 0x3c, 0xa2, 0x21, 0xa0, 0x29, 0xd8, 0xfb, 0x1c, 0x4f,
0xed, 0xd5, 0xf3, 0xf4, 0x21, 0xa9, 0xe9, 0xc2, 0x78, 0x76, 0xb1, 0xa7, 0xf7, 0xea, 0x82, 0x1d,
0xc9, 0x5a, 0xe3, 0xcb, 0xe7, 0x6b, 0xf1, 0xaf, 0x9e, 0xaf, 0xc5, 0xff, 0xfe, 0x7c, 0x2d, 0xfe,
0xf4, 0xc5, 0x5a, 0xec, 0xab, 0x17, 0x6b, 0xb1, 0xbf, 0xbe, 0x58, 0x8b, 0xfd, 0xf4, 0xed, 0x9e,
0x4e, 0xfa, 0xa3, 0xce, 0x66, 0xd7, 0x1c, 0x6e, 0x05, 0xff, 0x23, 0x34, 0xed, 0x7f, 0x4b, 0x9d,
0x0c, 0x4b, 0x5a, 0x37, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x91, 0x0f, 0xaf, 0xd7, 0x24,
0x00, 0x00,
// 2687 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcf, 0x73, 0x23, 0xc5,
0xf5, 0xd7, 0xef, 0x1f, 0x4f, 0x96, 0x2c, 0xf7, 0x9a, 0x45, 0x88, 0xc5, 0x36, 0x43, 0xc1, 0x17,
0x16, 0xb0, 0xbf, 0x98, 0x40, 0xa0, 0xc8, 0x0f, 0x2c, 0x21, 0x47, 0x66, 0x1d, 0xdb, 0x69, 0x8b,
0xa5, 0x48, 0xc2, 0x0e, 0x23, 0x4d, 0x5b, 0x1a, 0x56, 0x9a, 0x19, 0x66, 0x5a, 0xc6, 0xe6, 0x98,
0x4a, 0x2e, 0x5b, 0x39, 0x6c, 0x55, 0x2e, 0xc9, 0x61, 0xff, 0x8e, 0xe4, 0x94, 0x53, 0xaa, 0xc2,
0x21, 0x07, 0x8e, 0x39, 0x91, 0xd4, 0xee, 0x2d, 0xb7, 0x9c, 0x72, 0x4a, 0x55, 0xaa, 0x7f, 0xcc,
0x2f, 0x49, 0x23, 0xc9, 0x59, 0x38, 0xe5, 0xd6, 0xfd, 0xe6, 0xbd, 0xa7, 0xee, 0xd7, 0xfd, 0x3e,
0xfd, 0xe9, 0xd7, 0x82, 0xa7, 0x29, 0x31, 0x75, 0xe2, 0x8c, 0x0c, 0x93, 0xee, 0x68, 0xdd, 0x9e,
0xb1, 0x43, 0x2f, 0x6d, 0xe2, 0x6e, 0xdb, 0x8e, 0x45, 0x2d, 0xb4, 0x1a, 0x7c, 0xdc, 0x66, 0x1f,
0xeb, 0xcf, 0x84, 0xb4, 0x7b, 0xce, 0xa5, 0x4d, 0xad, 0x1d, 0xdb, 0xb1, 0xac, 0x33, 0xa1, 0x5f,
0xbf, 0x11, 0xfa, 0xcc, 0xfd, 0x84, 0xbd, 0x45, 0xbe, 0x4a, 0xe3, 0xbb, 0xe4, 0xd2, 0xfb, 0xfa,
0xcc, 0x94, 0xad, 0xad, 0x39, 0xda, 0xc8, 0xfb, 0xbc, 0xd9, 0xb7, 0xac, 0xfe, 0x90, 0xec, 0xf0,
0x5e, 0x77, 0x7c, 0xb6, 0x43, 0x8d, 0x11, 0x71, 0xa9, 0x36, 0xb2, 0xa5, 0xc2, 0x7a, 0xdf, 0xea,
0x5b, 0xbc, 0xb9, 0xc3, 0x5a, 0x42, 0xaa, 0x3c, 0x28, 0x40, 0x1e, 0x93, 0xcf, 0xc6, 0xc4, 0xa5,
0x68, 0x17, 0x32, 0xa4, 0x37, 0xb0, 0x6a, 0xc9, 0xad, 0xe4, 0x8b, 0xa5, 0xdd, 0x1b, 0xdb, 0x13,
0x93, 0xdb, 0x96, 0x7a, 0xad, 0xde, 0xc0, 0x6a, 0x27, 0x30, 0xd7, 0x45, 0x6f, 0x40, 0xf6, 0x6c,
0x38, 0x76, 0x07, 0xb5, 0x14, 0x37, 0x7a, 0x26, 0xce, 0x68, 0x9f, 0x29, 0xb5, 0x13, 0x58, 0x68,
0xb3, 0x9f, 0x32, 0xcc, 0x33, 0xab, 0x96, 0x9e, 0xff, 0x53, 0x07, 0xe6, 0x19, 0xff, 0x29, 0xa6,
0x8b, 0x1a, 0x00, 0x86, 0x69, 0x50, 0xb5, 0x37, 0xd0, 0x0c, 0xb3, 0x96, 0xe1, 0x96, 0xcf, 0xc6,
0x5b, 0x1a, 0xb4, 0xc9, 0x14, 0xdb, 0x09, 0x5c, 0x34, 0xbc, 0x0e, 0x1b, 0xee, 0x67, 0x63, 0xe2,
0x5c, 0xd6, 0xb2, 0xf3, 0x87, 0xfb, 0x13, 0xa6, 0xc4, 0x86, 0xcb, 0xb5, 0x51, 0x0b, 0x4a, 0x5d,
0xd2, 0x37, 0x4c, 0xb5, 0x3b, 0xb4, 0x7a, 0x77, 0x6b, 0x39, 0x6e, 0xac, 0xc4, 0x19, 0x37, 0x98,
0x6a, 0x83, 0x69, 0xb6, 0x13, 0x18, 0xba, 0x7e, 0x0f, 0x7d, 0x0f, 0x0a, 0xbd, 0x01, 0xe9, 0xdd,
0x55, 0xe9, 0x45, 0x2d, 0xcf, 0x7d, 0x6c, 0xc6, 0xf9, 0x68, 0x32, 0xbd, 0xce, 0x45, 0x3b, 0x81,
0xf3, 0x3d, 0xd1, 0x64, 0xf3, 0xd7, 0xc9, 0xd0, 0x38, 0x27, 0x0e, 0xb3, 0x2f, 0xcc, 0x9f, 0xff,
0x7b, 0x42, 0x93, 0x7b, 0x28, 0xea, 0x5e, 0x07, 0xfd, 0x10, 0x8a, 0xc4, 0xd4, 0xe5, 0x34, 0x8a,
0xdc, 0xc5, 0x56, 0xec, 0x3a, 0x9b, 0xba, 0x37, 0x89, 0x02, 0x91, 0x6d, 0xf4, 0x16, 0xe4, 0x7a,
0xd6, 0x68, 0x64, 0xd0, 0x1a, 0x70, 0xeb, 0x8d, 0xd8, 0x09, 0x70, 0xad, 0x76, 0x02, 0x4b, 0x7d,
0x74, 0x04, 0x95, 0xa1, 0xe1, 0x52, 0xd5, 0x35, 0x35, 0xdb, 0x1d, 0x58, 0xd4, 0xad, 0x95, 0xb8,
0x87, 0xe7, 0xe3, 0x3c, 0x1c, 0x1a, 0x2e, 0x3d, 0xf5, 0x94, 0xdb, 0x09, 0x5c, 0x1e, 0x86, 0x05,
0xcc, 0x9f, 0x75, 0x76, 0x46, 0x1c, 0xdf, 0x61, 0x6d, 0x65, 0xbe, 0xbf, 0x63, 0xa6, 0xed, 0xd9,
0x33, 0x7f, 0x56, 0x58, 0x80, 0x7e, 0x06, 0xd7, 0x86, 0x96, 0xa6, 0xfb, 0xee, 0xd4, 0xde, 0x60,
0x6c, 0xde, 0xad, 0x95, 0xb9, 0xd3, 0x97, 0x62, 0x07, 0x69, 0x69, 0xba, 0xe7, 0xa2, 0xc9, 0x0c,
0xda, 0x09, 0xbc, 0x36, 0x9c, 0x14, 0xa2, 0x3b, 0xb0, 0xae, 0xd9, 0xf6, 0xf0, 0x72, 0xd2, 0x7b,
0x85, 0x7b, 0xbf, 0x19, 0xe7, 0x7d, 0x8f, 0xd9, 0x4c, 0xba, 0x47, 0xda, 0x94, 0x94, 0x05, 0xe3,
0xcc, 0x30, 0xb5, 0xa1, 0xf1, 0x05, 0x91, 0x8b, 0xbb, 0x3a, 0x3f, 0x18, 0xfb, 0x52, 0xdb, 0x5b,
0xe1, 0xf2, 0x59, 0x58, 0xd0, 0xc8, 0x43, 0xf6, 0x5c, 0x1b, 0x8e, 0x89, 0xf2, 0x7f, 0x50, 0x0a,
0xa5, 0x3d, 0xaa, 0x41, 0x7e, 0x44, 0x5c, 0x57, 0xeb, 0x13, 0x8e, 0x12, 0x45, 0xec, 0x75, 0x95,
0x0a, 0xac, 0x84, 0x53, 0x5d, 0xb9, 0x9f, 0xf4, 0x2d, 0x59, 0x16, 0x33, 0xcb, 0x73, 0xe2, 0xb8,
0x86, 0x65, 0x7a, 0x96, 0xb2, 0x8b, 0x9e, 0x83, 0x32, 0x1f, 0xb2, 0xea, 0x7d, 0x67, 0x50, 0x92,
0xc1, 0x2b, 0x5c, 0x78, 0x5b, 0x2a, 0x6d, 0x42, 0xc9, 0xde, 0xb5, 0x7d, 0x95, 0x34, 0x57, 0x01,
0x7b, 0xd7, 0xf6, 0x14, 0x9e, 0x85, 0x15, 0x36, 0x3f, 0x5f, 0x23, 0xc3, 0x7f, 0xa4, 0xc4, 0x64,
0x52, 0x45, 0xf9, 0x4b, 0x0a, 0xaa, 0x93, 0xf0, 0x80, 0xde, 0x82, 0x0c, 0x43, 0x4a, 0x09, 0x7a,
0xf5, 0x6d, 0x01, 0xa3, 0xdb, 0x1e, 0x8c, 0x6e, 0x77, 0x3c, 0x18, 0x6d, 0x14, 0xbe, 0xfc, 0x7a,
0x33, 0x71, 0xff, 0x6f, 0x9b, 0x49, 0xcc, 0x2d, 0xd0, 0x53, 0x2c, 0x9b, 0x35, 0xc3, 0x54, 0x0d,
0x9d, 0x0f, 0xb9, 0xc8, 0x52, 0x55, 0x33, 0xcc, 0x03, 0x1d, 0x1d, 0x42, 0xb5, 0x67, 0x99, 0x2e,
0x31, 0xdd, 0xb1, 0xab, 0x0a, 0x98, 0x96, 0x50, 0x17, 0x49, 0x58, 0x01, 0xfe, 0x4d, 0x4f, 0xf3,
0x84, 0x2b, 0xe2, 0xd5, 0x5e, 0x54, 0x80, 0xf6, 0x01, 0xce, 0xb5, 0xa1, 0xa1, 0x6b, 0xd4, 0x72,
0xdc, 0x5a, 0x66, 0x2b, 0x3d, 0x33, 0x6b, 0x6f, 0x7b, 0x2a, 0x1f, 0xd8, 0xba, 0x46, 0x49, 0x23,
0xc3, 0x86, 0x8b, 0x43, 0x96, 0xe8, 0x05, 0x58, 0xd5, 0x6c, 0x5b, 0x75, 0xa9, 0x46, 0x89, 0xda,
0xbd, 0xa4, 0xc4, 0xe5, 0x30, 0xb8, 0x82, 0xcb, 0x9a, 0x6d, 0x9f, 0x32, 0x69, 0x83, 0x09, 0xd1,
0xf3, 0x50, 0x61, 0x88, 0x69, 0x68, 0x43, 0x75, 0x40, 0x8c, 0xfe, 0x80, 0x72, 0xc0, 0x4b, 0xe3,
0xb2, 0x94, 0xb6, 0xb9, 0x50, 0xd1, 0xfd, 0x15, 0xe7, 0x68, 0x89, 0x10, 0x64, 0x74, 0x8d, 0x6a,
0x3c, 0x92, 0x2b, 0x98, 0xb7, 0x99, 0xcc, 0xd6, 0xe8, 0x40, 0xc6, 0x87, 0xb7, 0xd1, 0x75, 0xc8,
0x49, 0xb7, 0x69, 0xee, 0x56, 0xf6, 0xd0, 0x3a, 0x64, 0x6d, 0xc7, 0x3a, 0x27, 0x7c, 0xe9, 0x0a,
0x58, 0x74, 0x94, 0x5f, 0xa6, 0x60, 0x6d, 0x0a, 0x57, 0x99, 0xdf, 0x81, 0xe6, 0x0e, 0xbc, 0xdf,
0x62, 0x6d, 0xf4, 0x26, 0xf3, 0xab, 0xe9, 0xc4, 0x91, 0x67, 0x51, 0x6d, 0x3a, 0xd4, 0x6d, 0xfe,
0x5d, 0x86, 0x46, 0x6a, 0xa3, 0x63, 0xa8, 0x0e, 0x35, 0x97, 0xaa, 0x02, 0xa7, 0xd4, 0xd0, 0xb9,
0x34, 0x8d, 0xce, 0x87, 0x9a, 0x87, 0x6c, 0x6c, 0x53, 0x4b, 0x47, 0x95, 0x61, 0x44, 0x8a, 0x30,
0xac, 0x77, 0x2f, 0xbf, 0xd0, 0x4c, 0x6a, 0x98, 0x44, 0x9d, 0x5a, 0xb9, 0xa7, 0xa6, 0x9c, 0xb6,
0xce, 0x0d, 0x9d, 0x98, 0x3d, 0x6f, 0xc9, 0xae, 0xf9, 0xc6, 0xfe, 0x92, 0xba, 0x0a, 0x86, 0x4a,
0xf4, 0x64, 0x40, 0x15, 0x48, 0xd1, 0x0b, 0x19, 0x80, 0x14, 0xbd, 0x40, 0xff, 0x0f, 0x19, 0x36,
0x49, 0x3e, 0xf9, 0xca, 0x8c, 0x23, 0x55, 0xda, 0x75, 0x2e, 0x6d, 0x82, 0xb9, 0xa6, 0xa2, 0xf8,
0xe9, 0xe0, 0x9f, 0x16, 0x93, 0x5e, 0x95, 0x97, 0x60, 0x75, 0xe2, 0x38, 0x08, 0xad, 0x5f, 0x32,
0xbc, 0x7e, 0xca, 0x2a, 0x94, 0x23, 0xd8, 0xaf, 0x5c, 0x87, 0xf5, 0x59, 0x50, 0xae, 0x0c, 0x7c,
0x79, 0x04, 0x92, 0xd1, 0x1b, 0x50, 0xf0, 0xb1, 0x5c, 0xa4, 0xe3, 0x74, 0xac, 0x3c, 0x65, 0xec,
0xab, 0xb2, 0x3c, 0x64, 0xdb, 0x9a, 0xef, 0x87, 0x14, 0x1f, 0x78, 0x5e, 0xb3, 0xed, 0xb6, 0xe6,
0x0e, 0x94, 0x4f, 0xa0, 0x16, 0x87, 0xd3, 0x13, 0xd3, 0xc8, 0xf8, 0xdb, 0xf0, 0x3a, 0xe4, 0xce,
0x2c, 0x67, 0xa4, 0x51, 0xee, 0xac, 0x8c, 0x65, 0x8f, 0x6d, 0x4f, 0x81, 0xd9, 0x69, 0x2e, 0x16,
0x1d, 0x45, 0x85, 0xa7, 0x62, 0xb1, 0x9a, 0x99, 0x18, 0xa6, 0x4e, 0x44, 0x3c, 0xcb, 0x58, 0x74,
0x02, 0x47, 0x62, 0xb0, 0xa2, 0xc3, 0x7e, 0xd6, 0xe5, 0x73, 0xe5, 0xfe, 0x8b, 0x58, 0xf6, 0x94,
0xdf, 0xa5, 0xfc, 0x68, 0x45, 0x30, 0x1b, 0x55, 0x21, 0x4d, 0x2f, 0xdc, 0x5a, 0x72, 0x2b, 0xfd,
0xe2, 0x0a, 0x66, 0x4d, 0x3f, 0x29, 0x52, 0x33, 0x93, 0x22, 0xfd, 0xd8, 0x49, 0x91, 0xf9, 0x36,
0x92, 0x22, 0xfb, 0x18, 0x49, 0xf1, 0xcf, 0x02, 0x14, 0x30, 0x71, 0x6d, 0x86, 0x97, 0xa8, 0x01,
0x45, 0x72, 0xd1, 0x23, 0x36, 0xf5, 0x8e, 0x98, 0xd9, 0x0c, 0x4d, 0x68, 0xb7, 0x3c, 0x4d, 0x46,
0x8f, 0x7c, 0x33, 0xf4, 0xba, 0x64, 0xc0, 0xf1, 0x64, 0x56, 0x9a, 0x87, 0x29, 0xf0, 0x9b, 0x1e,
0x05, 0x4e, 0xc7, 0x32, 0x22, 0x61, 0x35, 0xc1, 0x81, 0x5f, 0x97, 0x1c, 0x38, 0xb3, 0xe0, 0xc7,
0x22, 0x24, 0xb8, 0x19, 0x21, 0xc1, 0xd9, 0x05, 0xd3, 0x8c, 0x61, 0xc1, 0x6f, 0x7a, 0x2c, 0x38,
0xb7, 0x60, 0xc4, 0x13, 0x34, 0x78, 0x3f, 0x4a, 0x83, 0x05, 0x85, 0x7d, 0x2e, 0xd6, 0x3a, 0x96,
0x07, 0x7f, 0x3f, 0xc4, 0x83, 0x0b, 0xb1, 0x24, 0x54, 0x38, 0x99, 0x41, 0x84, 0x9b, 0x11, 0x22,
0x5c, 0x5c, 0x10, 0x83, 0x18, 0x26, 0xfc, 0x6e, 0x98, 0x09, 0x43, 0x2c, 0x99, 0x96, 0xeb, 0x3d,
0x8b, 0x0a, 0xbf, 0xed, 0x53, 0xe1, 0x52, 0x2c, 0x97, 0x97, 0x73, 0x98, 0xe4, 0xc2, 0xc7, 0x53,
0x5c, 0x58, 0x70, 0xd7, 0x17, 0x62, 0x5d, 0x2c, 0x20, 0xc3, 0xc7, 0x53, 0x64, 0xb8, 0xbc, 0xc0,
0xe1, 0x02, 0x36, 0xfc, 0xf3, 0xd9, 0x6c, 0x38, 0x9e, 0xaf, 0xca, 0x61, 0x2e, 0x47, 0x87, 0xd5,
0x18, 0x3a, 0x2c, 0x48, 0xeb, 0xcb, 0xb1, 0xee, 0x97, 0xe6, 0xc3, 0xc7, 0x53, 0x7c, 0xb8, 0xba,
0x20, 0x1e, 0xcb, 0x12, 0xe2, 0x97, 0x18, 0x1d, 0x99, 0x00, 0x11, 0x06, 0xe9, 0xc4, 0x71, 0x2c,
0x47, 0x52, 0x5b, 0xd1, 0x51, 0x5e, 0x64, 0x04, 0x29, 0x00, 0x8c, 0x39, 0xe4, 0x99, 0x1f, 0x9d,
0x21, 0x90, 0x50, 0xfe, 0x90, 0x0c, 0x6c, 0x39, 0x7c, 0x86, 0xc9, 0x55, 0x51, 0x92, 0xab, 0x10,
0xa5, 0x4e, 0x45, 0x29, 0xf5, 0x26, 0x94, 0xd8, 0x91, 0x38, 0xc1, 0x96, 0x35, 0xdb, 0x67, 0xcb,
0x37, 0x61, 0x8d, 0xc3, 0xbb, 0x20, 0xde, 0xf2, 0x1c, 0xcc, 0xf0, 0xe3, 0x7c, 0x95, 0x7d, 0x10,
0x51, 0x10, 0x07, 0xe2, 0xab, 0x70, 0x2d, 0xa4, 0xeb, 0x1f, 0xb5, 0x82, 0x3a, 0x56, 0x7d, 0xed,
0x3d, 0x79, 0xe6, 0xfe, 0x29, 0x19, 0x44, 0x28, 0xa0, 0xd9, 0xb3, 0x18, 0x71, 0xf2, 0x1b, 0x62,
0xc4, 0xa9, 0xff, 0x9a, 0x11, 0x87, 0xa9, 0x43, 0x3a, 0x4a, 0x1d, 0xfe, 0x95, 0x0c, 0xd6, 0xc4,
0xe7, 0xb7, 0x3d, 0x4b, 0x27, 0xf2, 0x30, 0xe7, 0x6d, 0x76, 0x08, 0x0f, 0xad, 0xbe, 0x3c, 0xb2,
0x59, 0x93, 0x69, 0xf9, 0xa8, 0x5e, 0x94, 0xa0, 0xed, 0xf3, 0x80, 0x2c, 0x8f, 0xb0, 0xe4, 0x01,
0x55, 0x48, 0xdf, 0x25, 0x02, 0x83, 0x57, 0x30, 0x6b, 0x32, 0x3d, 0xbe, 0xc9, 0x38, 0xb2, 0xae,
0x60, 0xd1, 0x41, 0x6f, 0x41, 0x91, 0xd7, 0x90, 0x54, 0xcb, 0x76, 0x25, 0x5c, 0x3e, 0x1d, 0x9e,
0xab, 0x28, 0x15, 0x6d, 0x9f, 0x30, 0x9d, 0x63, 0xdb, 0xc5, 0x05, 0x5b, 0xb6, 0x42, 0x14, 0xa7,
0x18, 0x61, 0xda, 0x37, 0xa0, 0xc8, 0x46, 0xef, 0xda, 0x5a, 0x8f, 0x70, 0xec, 0x2b, 0xe2, 0x40,
0xa0, 0xdc, 0x01, 0x34, 0x8d, 0xe0, 0xa8, 0x0d, 0x39, 0x72, 0x4e, 0x4c, 0x2a, 0x18, 0x47, 0x69,
0xf7, 0xfa, 0x8c, 0x13, 0x9b, 0x98, 0xb4, 0x51, 0x63, 0x41, 0xfe, 0xc7, 0xd7, 0x9b, 0x55, 0xa1,
0xfd, 0x8a, 0x35, 0x32, 0x28, 0x19, 0xd9, 0xf4, 0x12, 0x4b, 0x7b, 0xe5, 0xf7, 0x29, 0xc6, 0x29,
0x23, 0xe8, 0x3e, 0x33, 0xb6, 0xde, 0x96, 0x4f, 0x85, 0xee, 0x13, 0xcb, 0xc5, 0x7b, 0x03, 0xa0,
0xaf, 0xb9, 0xea, 0xe7, 0x9a, 0x49, 0x89, 0x2e, 0x83, 0x1e, 0x92, 0xa0, 0x3a, 0x14, 0x58, 0x6f,
0xec, 0x12, 0x5d, 0x5e, 0x6d, 0xfc, 0x7e, 0x68, 0x9e, 0xf9, 0xc7, 0x9b, 0x67, 0x34, 0xca, 0x85,
0x89, 0x28, 0x87, 0xf8, 0x5e, 0x31, 0xcc, 0xf7, 0xd8, 0xd8, 0x6c, 0xc7, 0xb0, 0x1c, 0x83, 0x5e,
0xf2, 0xa5, 0x49, 0x63, 0xbf, 0xaf, 0xfc, 0x2a, 0x15, 0xa4, 0x56, 0x40, 0xd9, 0xff, 0xe7, 0x62,
0xa7, 0xfc, 0x9a, 0x5f, 0xe4, 0xa3, 0x47, 0x33, 0x3a, 0x85, 0x35, 0x3f, 0xb3, 0xd5, 0x31, 0xcf,
0x78, 0x6f, 0xaf, 0x2e, 0x0b, 0x0d, 0xd5, 0xf3, 0xa8, 0xd8, 0x45, 0x1f, 0xc1, 0x93, 0x13, 0xb0,
0xe5, 0xbb, 0x4e, 0x2d, 0x8b, 0x5e, 0x4f, 0x44, 0xd1, 0xcb, 0x73, 0x1d, 0x04, 0x2b, 0xfd, 0x98,
0x09, 0x75, 0xc0, 0xee, 0x86, 0x61, 0xa6, 0x31, 0x73, 0xf9, 0x9f, 0x83, 0xb2, 0x43, 0xa8, 0x66,
0x98, 0x6a, 0xe4, 0xf6, 0xbd, 0x22, 0x84, 0xf2, 0x4e, 0x7f, 0x02, 0x4f, 0xcc, 0x64, 0x1c, 0xe8,
0xbb, 0x50, 0x0c, 0xc8, 0x4a, 0x32, 0x86, 0xb3, 0xfb, 0x97, 0xb3, 0x40, 0x57, 0xf9, 0x63, 0x32,
0x70, 0x19, 0xbd, 0xee, 0xb5, 0x20, 0xe7, 0x10, 0x77, 0x3c, 0x14, 0x17, 0xb0, 0xca, 0xee, 0xab,
0xcb, 0x71, 0x15, 0x26, 0x1d, 0x0f, 0x29, 0x96, 0xc6, 0xca, 0x1d, 0xc8, 0x09, 0x09, 0x2a, 0x41,
0xfe, 0x83, 0xa3, 0x5b, 0x47, 0xc7, 0x1f, 0x1e, 0x55, 0x13, 0x08, 0x20, 0xb7, 0xd7, 0x6c, 0xb6,
0x4e, 0x3a, 0xd5, 0x24, 0x2a, 0x42, 0x76, 0xaf, 0x71, 0x8c, 0x3b, 0xd5, 0x14, 0x13, 0xe3, 0xd6,
0xfb, 0xad, 0x66, 0xa7, 0x9a, 0x46, 0x6b, 0x50, 0x16, 0x6d, 0x75, 0xff, 0x18, 0xff, 0x78, 0xaf,
0x53, 0xcd, 0x84, 0x44, 0xa7, 0xad, 0xa3, 0xf7, 0x5a, 0xb8, 0x9a, 0x55, 0x5e, 0x63, 0x37, 0xbc,
0x18, 0x76, 0x13, 0xdc, 0xe5, 0x92, 0xa1, 0xbb, 0x9c, 0xf2, 0xdb, 0x14, 0xd4, 0xe3, 0x29, 0x0b,
0x7a, 0x7f, 0x62, 0xe2, 0xbb, 0x57, 0xe0, 0x3b, 0x13, 0xb3, 0x47, 0xcf, 0x43, 0xc5, 0x21, 0x67,
0x84, 0xf6, 0x06, 0x82, 0x42, 0x89, 0xd3, 0xb0, 0x8c, 0xcb, 0x52, 0xca, 0x8d, 0x5c, 0xa1, 0xf6,
0x29, 0xe9, 0x51, 0x55, 0xc0, 0x8c, 0xd8, 0x74, 0x45, 0xa6, 0xc6, 0xa4, 0xa7, 0x42, 0xa8, 0x7c,
0x72, 0xa5, 0x58, 0x16, 0x21, 0x8b, 0x5b, 0x1d, 0xfc, 0x51, 0x35, 0x8d, 0x10, 0x54, 0x78, 0x53,
0x3d, 0x3d, 0xda, 0x3b, 0x39, 0x6d, 0x1f, 0xb3, 0x58, 0x5e, 0x83, 0x55, 0x2f, 0x96, 0x9e, 0x30,
0xab, 0xfc, 0x39, 0x15, 0x6c, 0x87, 0xe8, 0x7d, 0xf6, 0x3b, 0xc1, 0x7d, 0x76, 0x29, 0x3a, 0x2f,
0xee, 0xbc, 0x33, 0xb3, 0x3e, 0xf5, 0xed, 0x65, 0x7d, 0xfa, 0x1b, 0xcb, 0xfa, 0xcc, 0x63, 0x66,
0xfd, 0xc7, 0x50, 0x89, 0x5e, 0xbc, 0xd9, 0x66, 0x74, 0xac, 0xb1, 0xa9, 0xf3, 0x6d, 0x95, 0xc5,
0xa2, 0x83, 0xde, 0x80, 0xec, 0xb9, 0x15, 0x44, 0x65, 0x3a, 0x6b, 0x6f, 0x5b, 0x94, 0x84, 0x2e,
0xee, 0x42, 0x5b, 0xf9, 0x02, 0xb2, 0x7c, 0x24, 0x0c, 0x4b, 0x78, 0x5d, 0x49, 0x32, 0x4f, 0xd6,
0x46, 0x1f, 0x03, 0x68, 0x94, 0x3a, 0x46, 0x77, 0x1c, 0x38, 0xde, 0x9c, 0x3d, 0x93, 0x3d, 0x4f,
0xaf, 0x71, 0x43, 0x4e, 0x69, 0x3d, 0x30, 0x0d, 0x4d, 0x2b, 0xe4, 0x50, 0x39, 0x82, 0x4a, 0xd4,
0xd6, 0xe3, 0x4a, 0x62, 0x0c, 0x51, 0xae, 0x24, 0xa8, 0xaf, 0xe4, 0x4a, 0x3e, 0xd3, 0x4a, 0x8b,
0x1a, 0x22, 0xef, 0x28, 0xf7, 0x92, 0x50, 0xe8, 0x5c, 0xc8, 0x9d, 0x1d, 0x53, 0xbe, 0x0a, 0x4c,
0x53, 0xe1, 0x62, 0x8d, 0xa8, 0x87, 0xa5, 0xfd, 0x2a, 0xdb, 0xbb, 0x7e, 0xee, 0x66, 0x96, 0xbd,
0x77, 0x7a, 0x95, 0x15, 0x89, 0x57, 0xef, 0x40, 0xd1, 0xdf, 0x87, 0x8c, 0xc2, 0x6b, 0xba, 0xee,
0x10, 0xd7, 0x95, 0x08, 0xe2, 0x75, 0x79, 0x35, 0xd4, 0xfa, 0x5c, 0xd6, 0x6d, 0xd2, 0x58, 0x74,
0x14, 0x1d, 0x56, 0x27, 0x36, 0x31, 0x7a, 0x07, 0xf2, 0xf6, 0xb8, 0xab, 0x7a, 0xe1, 0x99, 0x78,
0x4d, 0xf3, 0xc8, 0xe1, 0xb8, 0x3b, 0x34, 0x7a, 0xb7, 0xc8, 0xa5, 0x37, 0x18, 0x7b, 0xdc, 0xbd,
0x25, 0xa2, 0x28, 0x7e, 0x25, 0x15, 0xfe, 0x95, 0x73, 0x28, 0x78, 0x9b, 0x02, 0xfd, 0x00, 0x8a,
0x7e, 0x7e, 0xf8, 0x45, 0xf2, 0xd8, 0xc4, 0x92, 0xee, 0x03, 0x13, 0x76, 0xd3, 0x70, 0x8d, 0xbe,
0x49, 0x74, 0x35, 0xb8, 0x44, 0xf0, 0x5f, 0x2b, 0xe0, 0x55, 0xf1, 0xe1, 0xd0, 0xbb, 0x41, 0x28,
0xff, 0x4e, 0x42, 0xc1, 0xab, 0xfb, 0xa0, 0xd7, 0x42, 0xfb, 0xae, 0x32, 0xa3, 0x3c, 0xe2, 0x29,
0x06, 0x05, 0xcd, 0xe8, 0x58, 0x53, 0x57, 0x1f, 0x6b, 0x5c, 0x65, 0xda, 0x7b, 0x23, 0xc8, 0x5c,
0xf9, 0x8d, 0xe0, 0x15, 0x40, 0xd4, 0xa2, 0xda, 0x50, 0x3d, 0xb7, 0xa8, 0x61, 0xf6, 0x55, 0x11,
0x6c, 0xc1, 0xaa, 0xaa, 0xfc, 0xcb, 0x6d, 0xfe, 0xe1, 0x84, 0xc7, 0xfd, 0x17, 0x49, 0x28, 0xf8,
0xc7, 0xe3, 0x55, 0xeb, 0x93, 0xd7, 0x21, 0x27, 0x4f, 0x00, 0x51, 0xa0, 0x94, 0x3d, 0xbf, 0x2a,
0x98, 0x09, 0x55, 0x05, 0xeb, 0x50, 0x18, 0x11, 0xaa, 0x71, 0x8e, 0x20, 0xee, 0x71, 0x7e, 0xff,
0xe6, 0xdb, 0x50, 0x0a, 0x95, 0x8a, 0x59, 0xe6, 0x1d, 0xb5, 0x3e, 0xac, 0x26, 0xea, 0xf9, 0x7b,
0x0f, 0xb6, 0xd2, 0x47, 0xe4, 0x73, 0xb6, 0x67, 0x71, 0xab, 0xd9, 0x6e, 0x35, 0x6f, 0x55, 0x93,
0xf5, 0xd2, 0xbd, 0x07, 0x5b, 0x79, 0x4c, 0x78, 0x69, 0xe6, 0x66, 0x1b, 0x56, 0xc2, 0xab, 0x12,
0x3d, 0x44, 0x10, 0x54, 0xde, 0xfb, 0xe0, 0xe4, 0xf0, 0xa0, 0xb9, 0xd7, 0x69, 0xa9, 0xb7, 0x8f,
0x3b, 0xad, 0x6a, 0x12, 0x3d, 0x09, 0xd7, 0x0e, 0x0f, 0x7e, 0xd4, 0xee, 0xa8, 0xcd, 0xc3, 0x83,
0xd6, 0x51, 0x47, 0xdd, 0xeb, 0x74, 0xf6, 0x9a, 0xb7, 0xaa, 0xa9, 0xdd, 0xdf, 0x14, 0x60, 0x75,
0xaf, 0xd1, 0x3c, 0x60, 0x07, 0xa0, 0xd1, 0xd3, 0xf8, 0x25, 0xbb, 0x09, 0x19, 0x7e, 0x8d, 0x9e,
0xfb, 0x30, 0x5d, 0x9f, 0x5f, 0xb4, 0x43, 0xfb, 0x90, 0xe5, 0x37, 0x6c, 0x34, 0xff, 0xa5, 0xba,
0xbe, 0xa0, 0x8a, 0xc7, 0x06, 0xc3, 0xd3, 0x63, 0xee, 0xd3, 0x75, 0x7d, 0x7e, 0x51, 0x0f, 0x1d,
0x42, 0xde, 0xbb, 0x00, 0x2d, 0x7a, 0x08, 0xae, 0x2f, 0xac, 0x90, 0xb1, 0xa9, 0x89, 0x8b, 0xea,
0xfc, 0x57, 0xed, 0xfa, 0x82, 0x72, 0x1f, 0x3a, 0x80, 0x9c, 0xa4, 0x91, 0x0b, 0x1e, 0x77, 0xeb,
0x8b, 0x2a, 0x5e, 0x08, 0x43, 0x31, 0x28, 0x01, 0x2c, 0x7e, 0xab, 0xaf, 0x2f, 0x51, 0xc9, 0x44,
0x77, 0xa0, 0x1c, 0xa5, 0xa6, 0xcb, 0x3d, 0x20, 0xd7, 0x97, 0xac, 0xad, 0x31, 0xff, 0x51, 0x9e,
0xba, 0xdc, 0x83, 0x72, 0x7d, 0xc9, 0x52, 0x1b, 0xfa, 0x14, 0xd6, 0xa6, 0x79, 0xe4, 0xf2, 0xef,
0xcb, 0xf5, 0x2b, 0x14, 0xdf, 0xd0, 0x08, 0xd0, 0x0c, 0xfe, 0x79, 0x85, 0xe7, 0xe6, 0xfa, 0x55,
0x6a, 0x71, 0x2c, 0x74, 0x51, 0x4e, 0xb7, 0xdc, 0xf3, 0x73, 0x7d, 0xc9, 0xaa, 0x5c, 0xa3, 0xf5,
0xe5, 0xc3, 0x8d, 0xe4, 0x57, 0x0f, 0x37, 0x92, 0x7f, 0x7f, 0xb8, 0x91, 0xbc, 0xff, 0x68, 0x23,
0xf1, 0xd5, 0xa3, 0x8d, 0xc4, 0x5f, 0x1f, 0x6d, 0x24, 0x7e, 0xfa, 0x72, 0xdf, 0xa0, 0x83, 0x71,
0x77, 0xbb, 0x67, 0x8d, 0x76, 0xc2, 0xff, 0x93, 0x99, 0xf5, 0xdf, 0x9d, 0x6e, 0x8e, 0x03, 0xf7,
0xeb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x32, 0xd7, 0x62, 0xdb, 0x23, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -3315,13 +3312,13 @@ type ABCIApplicationClient interface {
Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error)
Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error)
Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error)
DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error)
// rpc DeliverTx(RequestDeliverTx) returns (ResponseDeliverTx);
CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error)
Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error)
Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error)
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)
// rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock);
// rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock);
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)
@@ -3364,15 +3361,6 @@ func (c *aBCIApplicationClient) Info(ctx context.Context, in *RequestInfo, opts
return out, nil
}
func (c *aBCIApplicationClient) DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) {
out := new(ResponseDeliverTx)
err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/DeliverTx", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *aBCIApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) {
out := new(ResponseCheckTx)
err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/CheckTx", in, out, opts...)
@@ -3409,24 +3397,6 @@ func (c *aBCIApplicationClient) InitChain(ctx context.Context, in *RequestInitCh
return out, nil
}
func (c *aBCIApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) {
out := new(ResponseBeginBlock)
err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/BeginBlock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) {
out := new(ResponseEndBlock)
err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/EndBlock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *aBCIApplicationClient) ListSnapshots(ctx context.Context, in *RequestListSnapshots, opts ...grpc.CallOption) (*ResponseListSnapshots, error) {
out := new(ResponseListSnapshots)
err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/ListSnapshots", in, out, opts...)
@@ -3477,13 +3447,13 @@ type ABCIApplicationServer interface {
Echo(context.Context, *RequestEcho) (*ResponseEcho, error)
Flush(context.Context, *RequestFlush) (*ResponseFlush, error)
Info(context.Context, *RequestInfo) (*ResponseInfo, error)
DeliverTx(context.Context, *RequestDeliverTx) (*ResponseDeliverTx, error)
// rpc DeliverTx(RequestDeliverTx) returns (ResponseDeliverTx);
CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error)
Query(context.Context, *RequestQuery) (*ResponseQuery, error)
Commit(context.Context, *RequestCommit) (*ResponseCommit, error)
InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error)
BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error)
EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error)
// rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock);
// rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock);
ListSnapshots(context.Context, *RequestListSnapshots) (*ResponseListSnapshots, error)
OfferSnapshot(context.Context, *RequestOfferSnapshot) (*ResponseOfferSnapshot, error)
LoadSnapshotChunk(context.Context, *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error)
@@ -3504,9 +3474,6 @@ func (*UnimplementedABCIApplicationServer) Flush(ctx context.Context, req *Reque
func (*UnimplementedABCIApplicationServer) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) {
return nil, status.Errorf(codes.Unimplemented, "method Info not implemented")
}
func (*UnimplementedABCIApplicationServer) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeliverTx not implemented")
}
func (*UnimplementedABCIApplicationServer) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) {
return nil, status.Errorf(codes.Unimplemented, "method CheckTx not implemented")
}
@@ -3519,12 +3486,6 @@ func (*UnimplementedABCIApplicationServer) Commit(ctx context.Context, req *Requ
func (*UnimplementedABCIApplicationServer) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) {
return nil, status.Errorf(codes.Unimplemented, "method InitChain not implemented")
}
func (*UnimplementedABCIApplicationServer) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
return nil, status.Errorf(codes.Unimplemented, "method BeginBlock not implemented")
}
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")
}
@@ -3599,24 +3560,6 @@ func _ABCIApplication_Info_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _ABCIApplication_DeliverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RequestDeliverTx)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ABCIApplicationServer).DeliverTx(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/tendermint.abci.ABCIApplication/DeliverTx",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ABCIApplicationServer).DeliverTx(ctx, req.(*RequestDeliverTx))
}
return interceptor(ctx, in, info, handler)
}
func _ABCIApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RequestCheckTx)
if err := dec(in); err != nil {
@@ -3689,42 +3632,6 @@ func _ABCIApplication_InitChain_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _ABCIApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RequestBeginBlock)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ABCIApplicationServer).BeginBlock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/tendermint.abci.ABCIApplication/BeginBlock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ABCIApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock))
}
return interceptor(ctx, in, info, handler)
}
func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RequestEndBlock)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ABCIApplicationServer).EndBlock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/tendermint.abci.ABCIApplication/EndBlock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ABCIApplicationServer).EndBlock(ctx, req.(*RequestEndBlock))
}
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 {
@@ -3831,10 +3738,6 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
MethodName: "Info",
Handler: _ABCIApplication_Info_Handler,
},
{
MethodName: "DeliverTx",
Handler: _ABCIApplication_DeliverTx_Handler,
},
{
MethodName: "CheckTx",
Handler: _ABCIApplication_CheckTx_Handler,
@@ -3851,14 +3754,6 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
MethodName: "InitChain",
Handler: _ABCIApplication_InitChain_Handler,
},
{
MethodName: "BeginBlock",
Handler: _ABCIApplication_BeginBlock_Handler,
},
{
MethodName: "EndBlock",
Handler: _ABCIApplication_EndBlock_Handler,
},
{
MethodName: "ListSnapshots",
Handler: _ABCIApplication_ListSnapshots_Handler,

29
mempool/v0/clist_mempool_test.go
View File

@@ -362,24 +362,29 @@ func TestSerialReap(t *testing.T) {
commitRange := func(start, end int) {
ctx := context.Background()
// Deliver some txs.
var txs = make([][]byte, start-end)
for i := start; i < end; i++ {
txBytes := make([]byte, 8)
binary.BigEndian.PutUint64(txBytes, uint64(i))
res, err := appConnCon.DeliverTxSync(ctx, abci.RequestDeliverTx{Tx: txBytes})
if err != nil {
t.Errorf("client error committing tx: %v", err)
}
if res.IsErr() {
txs[i] = txBytes
}
res, err := appConnCon.FinalizeBlockSync(ctx, abci.RequestFinalizeBlock{Txs: txs})
if err != nil {
t.Errorf("client error committing tx: %v", err)
}
for _, tx := range res.Txs {
if tx.IsErr() {
t.Errorf("error committing tx. Code:%v result:%X log:%v",
res.Code, res.Data, res.Log)
tx.Code, tx.Data, tx.Log)
}
}
res, err := appConnCon.CommitSync(ctx)
resCommit, err := appConnCon.CommitSync(ctx)
if err != nil {
t.Errorf("client error committing: %v", err)
}
if len(res.Data) != 8 {
t.Errorf("error committing. Hash:%X", res.Data)
if len(resCommit.Data) != 8 {
t.Errorf("error committing. Hash:%X", resCommit.Data)
}
}
@@ -529,9 +534,11 @@ func TestMempoolTxsBytes(t *testing.T) {
}
})
ctx := context.Background()
res, err := appConnCon.DeliverTxSync(ctx, abci.RequestDeliverTx{Tx: txBytes})
res, err := appConnCon.FinalizeBlockSync(ctx, abci.RequestFinalizeBlock{Txs: [][]byte{txBytes}})
require.NoError(t, err)
require.EqualValues(t, 0, res.Code)
for _, tx := range res.Txs {
require.EqualValues(t, 0, tx.Code)
}
res2, err := appConnCon.CommitSync(ctx)
require.NoError(t, err)
require.NotEmpty(t, res2.Data)

6
proto/tendermint/abci/types.proto
View File

@@ -368,13 +368,13 @@ service ABCIApplication {
rpc Echo(RequestEcho) returns (ResponseEcho);
rpc Flush(RequestFlush) returns (ResponseFlush);
rpc Info(RequestInfo) returns (ResponseInfo);
rpc DeliverTx(RequestDeliverTx) returns (ResponseDeliverTx);
// rpc DeliverTx(RequestDeliverTx) returns (ResponseDeliverTx);
rpc CheckTx(RequestCheckTx) returns (ResponseCheckTx);
rpc Query(RequestQuery) returns (ResponseQuery);
rpc Commit(RequestCommit) returns (ResponseCommit);
rpc InitChain(RequestInitChain) returns (ResponseInitChain);
rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock);
rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock);
// 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);

21
proxy/app_conn.go
View File

@@ -18,9 +18,6 @@ type AppConnConsensus interface {
InitChainSync(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
BeginBlockSync(context.Context, types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
DeliverTxAsync(context.Context, types.RequestDeliverTx) (*abcicli.ReqRes, error)
EndBlockSync(context.Context, types.RequestEndBlock) (*types.ResponseEndBlock, error)
FinalizeBlockSync(context.Context, types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error)
CommitSync(context.Context) (*types.ResponseCommit, error)
}
@@ -81,24 +78,6 @@ func (app *appConnConsensus) InitChainSync(
return app.appConn.InitChainSync(ctx, req)
}
func (app *appConnConsensus) BeginBlockSync(
ctx context.Context,
req types.RequestBeginBlock,
) (*types.ResponseBeginBlock, error) {
return app.appConn.BeginBlockSync(ctx, req)
}
func (app *appConnConsensus) DeliverTxAsync(ctx context.Context, req types.RequestDeliverTx) (*abcicli.ReqRes, error) {
return app.appConn.DeliverTxAsync(ctx, req)
}
func (app *appConnConsensus) EndBlockSync(
ctx context.Context,
req types.RequestEndBlock,
) (*types.ResponseEndBlock, error) {
return app.appConn.EndBlockSync(ctx, req)
}
func (app *appConnConsensus) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
return app.appConn.CommitSync(ctx)
}