diff --git a/abci/example/kvstore/kvstore.go b/abci/example/kvstore/kvstore.go index ab04ac3c71..c97e0a9cc6 100644 --- a/abci/example/kvstore/kvstore.go +++ b/abci/example/kvstore/kvstore.go @@ -373,12 +373,14 @@ func (app *Application) ProcessProposal(_ context.Context, req *abci.RequestProc Status: abci.ResponseProcessProposal_REJECT, }, err } + resp := &abci.ResponseProcessProposal{ Status: abci.ResponseProcessProposal_ACCEPT, AppHash: roundState.GetAppHash(), TxResults: txResults, ConsensusParamUpdates: app.getConsensusParamsUpdate(req.Height), ValidatorSetUpdate: app.getValidatorSetUpdate(req.Height), + Events: []abci.Event{app.eventValUpdate(req.Height)}, } if app.cfg.ProcessProposalDelayMS != 0 { @@ -425,10 +427,7 @@ func (app *Application) FinalizeBlock(_ context.Context, req *abci.RequestFinali return nil, err } } - events := []abci.Event{app.eventValUpdate(req.Height)} - resp := &abci.ResponseFinalizeBlock{ - Events: events, - } + resp := &abci.ResponseFinalizeBlock{} if app.RetainBlocks > 0 && app.LastCommittedState.GetHeight() >= app.RetainBlocks { resp.RetainHeight = app.LastCommittedState.GetHeight() - app.RetainBlocks + 1 } diff --git a/abci/example/kvstore/kvstore_test.go b/abci/example/kvstore/kvstore_test.go index 66274fe414..95281a3914 100644 --- a/abci/example/kvstore/kvstore_test.go +++ b/abci/example/kvstore/kvstore_test.go @@ -55,6 +55,7 @@ func testKVStore(ctx context.Context, t *testing.T, app types.Application, tx [] require.NoError(t, err) require.Len(t, respProcess.TxResults, 1) require.False(t, respProcess.TxResults[0].IsErr(), respProcess.TxResults[0].Log) + require.Len(t, respProcess.Events, 1) // Duplicate ProcessProposal calls should return error _, err = app.ProcessProposal(ctx, reqProcess) @@ -62,9 +63,8 @@ func testKVStore(ctx context.Context, t *testing.T, app types.Application, tx [] reqFin := &types.RequestFinalizeBlock{Height: height} reqFin.Block, reqFin.BlockID = makeBlock(t, height, [][]byte{tx}, respPrep.AppHash) - respFin, err := app.FinalizeBlock(ctx, reqFin) + _, err = app.FinalizeBlock(ctx, reqFin) require.NoError(t, err) - require.Equal(t, 1, len(respFin.Events)) // repeating tx raises an error _, err = app.FinalizeBlock(ctx, reqFin) @@ -290,12 +290,12 @@ func makeApplyBlock( require.NoError(t, err) require.NotZero(t, respProcessProposal) require.Equal(t, types.ResponseProcessProposal_ACCEPT, respProcessProposal.Status) + require.Len(t, respProcessProposal.Events, 1) rfb := &types.RequestFinalizeBlock{Hash: hash, Height: height} rfb.Block, rfb.BlockID = makeBlock(t, height, txs, respProcessProposal.AppHash) resFinalizeBlock, err := kvstore.FinalizeBlock(ctx, rfb) require.NoError(t, err) - require.Len(t, resFinalizeBlock.Events, 1) return respProcessProposal, resFinalizeBlock } @@ -413,13 +413,13 @@ func testClient(ctx context.Context, t *testing.T, app abciclient.Client, height require.NotZero(t, rpp) require.Equal(t, 1, len(rpp.TxResults)) require.False(t, rpp.TxResults[0].IsErr()) + require.Len(t, rpp.Events, 1) rfb := &types.RequestFinalizeBlock{Height: height} rfb.Block, rfb.BlockID = makeBlock(t, height, [][]byte{tx}, rpp.AppHash) ar, err := app.FinalizeBlock(ctx, rfb) require.NoError(t, err) require.Zero(t, ar.RetainHeight) - require.Len(t, ar.Events, 1) info, err := app.Info(ctx, &types.RequestInfo{}) require.NoError(t, err) diff --git a/abci/example/kvstore/verify_test.go b/abci/example/kvstore/verify_test.go index cb381a9fc9..29c8a8207c 100644 --- a/abci/example/kvstore/verify_test.go +++ b/abci/example/kvstore/verify_test.go @@ -60,6 +60,7 @@ func TestVerifyBlockCommit(t *testing.T) { assert.Len(t, respPrep.TxRecords, 1) require.Equal(t, 1, len(respPrep.TxResults)) require.False(t, respPrep.TxResults[0].IsErr(), respPrep.TxResults[0].Log) + pbBlock, err := block.ToProto() require.NoError(t, err) blockID := block.BlockID(nil) @@ -70,9 +71,8 @@ func TestVerifyBlockCommit(t *testing.T) { Block: pbBlock, BlockID: &pbBlockID, } - respFb, err := kvstore.FinalizeBlock(ctx, reqFb) + _, err = kvstore.FinalizeBlock(ctx, reqFb) require.NoError(t, err) - require.Equal(t, 1, len(respFb.Events)) } type blockExecutor struct { diff --git a/abci/tests/test_cli/ex1.abci.out b/abci/tests/test_cli/ex1.abci.out index bf0d354630..08f6069752 100644 --- a/abci/tests/test_cli/ex1.abci.out +++ b/abci/tests/test_cli/ex1.abci.out @@ -23,7 +23,6 @@ > finalize_block 1 0000000000000000000000000000000000000000000000000000000000000000 "abc" -> code: OK --> data.hex: 0x6576656E74733A3C747970653A2276616C5F757064617465732220617474726962757465733A3C6B65793A2273697A65222076616C75653A223022203E20617474726962757465733A3C6B65793A22686569676874222076616C75653A223122203E203E20 > info -> code: OK @@ -56,7 +55,6 @@ > finalize_block 2 3C868EF29ED961094EE2C48BDD78CDC83C7AA426E763024985AF9F0F569EEFBE "def=xyz" "ghi=123" -> code: OK --> data.hex: 0x6576656E74733A3C747970653A2276616C5F757064617465732220617474726962757465733A3C6B65793A2273697A65222076616C75653A223022203E20617474726962757465733A3C6B65793A22686569676874222076616C75653A223222203E203E20 > query "def" -> code: OK @@ -101,5 +99,4 @@ > finalize_block 3 243BA0AC2622E2E7ACFEF366E85E503ACEBA1C950357436B554CA253492420AB -> code: OK --> data.hex: 0x6576656E74733A3C747970653A2276616C5F757064617465732220617474726962757465733A3C6B65793A2273697A65222076616C75653A223022203E20617474726962757465733A3C6B65793A22686569676874222076616C75653A223322203E203E20 diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index affea0bb3b..9ea388dac6 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -1198,7 +1198,7 @@ func (m *RequestApplySnapshotChunk) GetSender() string { // their propose timeout goes off. // - As a result of executing the prepared proposal, the Application may produce header events or transaction events. // The Application must keep those events until a block is decided and then pass them on to Tenderdash via -// `ResponseFinalizeBlock`. +// `ResponsePrepareProposal`. // - As a sanity check, Tenderdash will check the returned parameters for validity if the Application modified them. // In particular, `ResponsePrepareProposal.tx_records` will be deemed invalid if // - There is a duplicate transaction in the list. @@ -1820,8 +1820,8 @@ func (m *RequestVerifyVoteExtension) GetVoteExtensions() []*ExtendVoteExtension // - The application must execute the transactions in full, in the order they appear in `RequestFinalizeBlock.txs`, // before returning control to Tenderdash. Alternatively, it can commit the candidate state corresponding to the same block // previously executed via `PrepareProposal` or `ProcessProposal`. -// - `ResponseFinalizeBlock.tx_results[i].Code == 0` only if the _i_-th transaction is fully valid. -// - Application is expected to persist its state at the end of this call, before calling `ResponseFinalizeBlock`. +// - If ProcessProposal for the same arguments have succeeded, FinalizeBlock MUST always succeed. +// - Application is expected to persist its state at the end of this call, before returning `ResponseFinalizeBlock`. // - Later calls to `Query` can return proofs about the application state anchored // in this Merkle root hash. // - Use `ResponseFinalizeBlock.retain_height` with caution! If all nodes in the network remove historical @@ -2997,6 +2997,8 @@ type ResponseProcessProposal struct { ConsensusParamUpdates *types1.ConsensusParams `protobuf:"bytes,4,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"` // Changes to validator set (set voting power to 0 to remove). ValidatorSetUpdate *ValidatorSetUpdate `protobuf:"bytes,5,opt,name=validator_set_update,json=validatorSetUpdate,proto3" json:"validator_set_update,omitempty"` + // Type & Key-Value events for indexing + Events []Event `protobuf:"bytes,6,rep,name=events,proto3" json:"events,omitempty"` } func (m *ResponseProcessProposal) Reset() { *m = ResponseProcessProposal{} } @@ -3067,6 +3069,13 @@ func (m *ResponseProcessProposal) GetValidatorSetUpdate() *ValidatorSetUpdate { return nil } +func (m *ResponseProcessProposal) GetEvents() []Event { + if m != nil { + return m.Events + } + return nil +} + // Provides a vote extension for signing. `type` and `extension` fields are mandatory for filling type ExtendVoteExtension struct { // Vote extension type can be either DEFAULT, THRESHOLD_RECOVER or THRESHOLD_RECOVER_RAW. @@ -3251,8 +3260,6 @@ func (m *ResponseVerifyVoteExtension) GetStatus() ResponseVerifyVoteExtension_Ve } type ResponseFinalizeBlock struct { - // Type & Key-Value events for indexing - Events []Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` // Blocks below this height may be removed. Defaults to `0` (retain all). RetainHeight int64 `protobuf:"varint,2,opt,name=retain_height,json=retainHeight,proto3" json:"retain_height,omitempty"` } @@ -3290,13 +3297,6 @@ func (m *ResponseFinalizeBlock) XXX_DiscardUnknown() { var xxx_messageInfo_ResponseFinalizeBlock proto.InternalMessageInfo -func (m *ResponseFinalizeBlock) GetEvents() []Event { - if m != nil { - return m.Events - } - return nil -} - func (m *ResponseFinalizeBlock) GetRetainHeight() int64 { if m != nil { return m.RetainHeight @@ -4309,236 +4309,237 @@ func init() { func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) } var fileDescriptor_252557cfdd89a31a = []byte{ - // 3664 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5b, 0xcb, 0x73, 0x1b, 0xc7, - 0xd1, 0xc7, 0xe2, 0x8d, 0xc6, 0x6b, 0x39, 0xa4, 0x24, 0x08, 0x92, 0x48, 0x7a, 0xf5, 0xd9, 0x92, - 0x65, 0x9b, 0xb4, 0xa5, 0xcf, 0x96, 0xfd, 0xd9, 0x5f, 0xaa, 0x00, 0x10, 0x0a, 0x28, 0x51, 0x24, - 0xbd, 0x04, 0xe9, 0x72, 0x1c, 0x7b, 0x6b, 0x09, 0x0c, 0x89, 0xb5, 0x00, 0xec, 0x7a, 0x77, 0x41, - 0x81, 0xbe, 0x26, 0x4e, 0xa5, 0x7c, 0xf2, 0x3f, 0xe0, 0x5b, 0x72, 0xcc, 0x25, 0xa7, 0x54, 0x0e, - 0x49, 0xe5, 0xe6, 0x54, 0x2e, 0x3e, 0xe6, 0x12, 0xc5, 0x25, 0x5f, 0x52, 0xb9, 0xf9, 0x94, 0x6b, - 0x6a, 0x1e, 0xfb, 0x02, 0xb0, 0x78, 0x58, 0xae, 0x4a, 0xe5, 0x86, 0xe9, 0xe9, 0xee, 0x9d, 0x47, - 0x4f, 0x77, 0xcf, 0xaf, 0x07, 0x70, 0xc5, 0xc6, 0xfd, 0x36, 0x36, 0x7b, 0x5a, 0xdf, 0xde, 0x54, - 0x8f, 0x5b, 0xda, 0xa6, 0x7d, 0x6e, 0x60, 0x6b, 0xc3, 0x30, 0x75, 0x5b, 0x47, 0x45, 0xaf, 0x73, - 0x83, 0x74, 0x96, 0xaf, 0xf9, 0xb8, 0x5b, 0xe6, 0xb9, 0x61, 0xeb, 0x9b, 0x86, 0xa9, 0xeb, 0x27, - 0x8c, 0xbf, 0xec, 0x57, 0x46, 0xf5, 0x6c, 0xb6, 0x55, 0xab, 0xc3, 0x3b, 0xaf, 0x8e, 0x75, 0x1e, - 0x77, 0xf5, 0xd6, 0xa3, 0xd0, 0x5e, 0xdf, 0x40, 0x02, 0xbd, 0xfc, 0xbb, 0x8f, 0xf0, 0xb9, 0xd3, - 0x7b, 0x6d, 0x4c, 0xd6, 0x50, 0x4d, 0xb5, 0xe7, 0x74, 0xaf, 0xfa, 0xba, 0xcf, 0xb0, 0x69, 0x69, - 0x7a, 0x3f, 0xa0, 0x7c, 0xed, 0x54, 0xd7, 0x4f, 0xbb, 0x78, 0x93, 0xb6, 0x8e, 0x07, 0x27, 0x9b, - 0xb6, 0xd6, 0xc3, 0x96, 0xad, 0xf6, 0x0c, 0xce, 0xb0, 0x72, 0xaa, 0x9f, 0xea, 0xf4, 0xe7, 0x26, - 0xf9, 0xc5, 0xa8, 0xd2, 0x67, 0x19, 0x48, 0xc9, 0xf8, 0x93, 0x01, 0xb6, 0x6c, 0x74, 0x1b, 0xe2, - 0xb8, 0xd5, 0xd1, 0x4b, 0xc2, 0xba, 0x70, 0x33, 0x7b, 0xfb, 0xea, 0xc6, 0xc8, 0xba, 0x6d, 0x70, - 0xbe, 0x7a, 0xab, 0xa3, 0x37, 0x22, 0x32, 0xe5, 0x45, 0xaf, 0x43, 0xe2, 0xa4, 0x3b, 0xb0, 0x3a, - 0xa5, 0x28, 0x15, 0xba, 0x16, 0x26, 0x74, 0x8f, 0x30, 0x35, 0x22, 0x32, 0xe3, 0x26, 0x9f, 0xd2, - 0xfa, 0x27, 0x7a, 0x29, 0x36, 0xfd, 0x53, 0xdb, 0xfd, 0x13, 0xfa, 0x29, 0xc2, 0x8b, 0xaa, 0x00, - 0x5a, 0x5f, 0xb3, 0x95, 0x56, 0x47, 0xd5, 0xfa, 0xa5, 0x38, 0x95, 0x7c, 0x2e, 0x5c, 0x52, 0xb3, - 0x6b, 0x84, 0xb1, 0x11, 0x91, 0x33, 0x9a, 0xd3, 0x20, 0xc3, 0xfd, 0x64, 0x80, 0xcd, 0xf3, 0x52, - 0x62, 0xfa, 0x70, 0xdf, 0x25, 0x4c, 0x64, 0xb8, 0x94, 0x1b, 0xbd, 0x03, 0xe9, 0x56, 0x07, 0xb7, - 0x1e, 0x29, 0xf6, 0xb0, 0x94, 0xa2, 0x92, 0x6b, 0x61, 0x92, 0x35, 0xc2, 0xd7, 0x1c, 0x36, 0x22, - 0x72, 0xaa, 0xc5, 0x7e, 0xa2, 0x5d, 0x28, 0x74, 0x35, 0xcb, 0x56, 0xac, 0xbe, 0x6a, 0x58, 0x1d, - 0xdd, 0xb6, 0x4a, 0x59, 0xaa, 0xe3, 0xf9, 0x30, 0x1d, 0x3b, 0x9a, 0x65, 0x1f, 0x38, 0xcc, 0x8d, - 0x88, 0x9c, 0xef, 0xfa, 0x09, 0x44, 0x9f, 0x7e, 0x72, 0x82, 0x4d, 0x57, 0x61, 0x29, 0x37, 0x5d, - 0xdf, 0x1e, 0xe1, 0x76, 0xe4, 0x89, 0x3e, 0xdd, 0x4f, 0x40, 0x1f, 0xc0, 0x72, 0x57, 0x57, 0xdb, - 0xae, 0x3a, 0xa5, 0xd5, 0x19, 0xf4, 0x1f, 0x95, 0xf2, 0x54, 0xe9, 0x8b, 0xa1, 0x83, 0xd4, 0xd5, - 0xb6, 0xa3, 0xa2, 0x46, 0x04, 0x1a, 0x11, 0x79, 0xa9, 0x3b, 0x4a, 0x44, 0x1f, 0xc1, 0x8a, 0x6a, - 0x18, 0xdd, 0xf3, 0x51, 0xed, 0x05, 0xaa, 0xfd, 0x56, 0x98, 0xf6, 0x0a, 0x91, 0x19, 0x55, 0x8f, - 0xd4, 0x31, 0x2a, 0x6a, 0x82, 0x68, 0x98, 0xd8, 0x50, 0x4d, 0xac, 0x18, 0xa6, 0x6e, 0xe8, 0x96, - 0xda, 0x2d, 0x15, 0xa9, 0xee, 0x1b, 0x61, 0xba, 0xf7, 0x19, 0xff, 0x3e, 0x67, 0x6f, 0x44, 0xe4, - 0xa2, 0x11, 0x24, 0x31, 0xad, 0x7a, 0x0b, 0x5b, 0x96, 0xa7, 0x55, 0x9c, 0xa5, 0x95, 0xf2, 0x07, - 0xb5, 0x06, 0x48, 0xa8, 0x0e, 0x59, 0x3c, 0x24, 0xe2, 0xca, 0x99, 0x6e, 0xe3, 0xd2, 0x12, 0x55, - 0x28, 0x85, 0x9e, 0x33, 0xca, 0x7a, 0xa4, 0xdb, 0xb8, 0x11, 0x91, 0x01, 0xbb, 0x2d, 0xa4, 0xc2, - 0x85, 0x33, 0x6c, 0x6a, 0x27, 0xe7, 0x54, 0x8d, 0x42, 0x7b, 0x88, 0x3f, 0x28, 0x21, 0xaa, 0xf0, - 0xa5, 0x30, 0x85, 0x47, 0x54, 0x88, 0xa8, 0xa8, 0x3b, 0x22, 0x8d, 0x88, 0xbc, 0x7c, 0x36, 0x4e, - 0x26, 0x26, 0x76, 0xa2, 0xf5, 0xd5, 0xae, 0xf6, 0x29, 0x56, 0xa8, 0x83, 0x2b, 0x2d, 0x4f, 0x37, - 0xb1, 0x7b, 0x9c, 0xbb, 0x4a, 0x98, 0x89, 0x89, 0x9d, 0xf8, 0x09, 0xd5, 0x14, 0x24, 0xce, 0xd4, - 0xee, 0x00, 0xdf, 0x8f, 0xa7, 0x93, 0x62, 0xea, 0x7e, 0x3c, 0x9d, 0x16, 0x33, 0xf7, 0xe3, 0xe9, - 0x8c, 0x08, 0xf7, 0xe3, 0x69, 0x10, 0xb3, 0xd2, 0x0d, 0xc8, 0xfa, 0xdc, 0x0b, 0x2a, 0x41, 0xaa, - 0x87, 0x2d, 0x4b, 0x3d, 0xc5, 0xd4, 0x1b, 0x65, 0x64, 0xa7, 0x29, 0x15, 0x20, 0xe7, 0x77, 0x29, - 0xd2, 0x17, 0x82, 0x2b, 0x49, 0xbc, 0x05, 0x91, 0xe4, 0xee, 0xd1, 0x91, 0xe4, 0x4d, 0x74, 0x1d, - 0xf2, 0x74, 0x2a, 0x8a, 0xd3, 0x4f, 0x5c, 0x56, 0x5c, 0xce, 0x51, 0xe2, 0x11, 0x67, 0x5a, 0x83, - 0xac, 0x71, 0xdb, 0x70, 0x59, 0x62, 0x94, 0x05, 0x8c, 0xdb, 0x86, 0xc3, 0xf0, 0x1c, 0xe4, 0xc8, - 0xbc, 0x5d, 0x8e, 0x38, 0xfd, 0x48, 0x96, 0xd0, 0x38, 0x8b, 0xf4, 0xf3, 0x18, 0x88, 0xa3, 0x6e, - 0x08, 0xbd, 0x09, 0x71, 0xe2, 0x91, 0xb9, 0x73, 0x2d, 0x6f, 0x30, 0x77, 0xbd, 0xe1, 0xb8, 0xeb, - 0x8d, 0xa6, 0xe3, 0xae, 0xab, 0xe9, 0xaf, 0x9e, 0xac, 0x45, 0xbe, 0xf8, 0xfb, 0x9a, 0x20, 0x53, - 0x09, 0x74, 0x99, 0x38, 0x1f, 0x55, 0xeb, 0x2b, 0x5a, 0x9b, 0x0e, 0x39, 0x43, 0x3c, 0x8b, 0xaa, - 0xf5, 0xb7, 0xdb, 0x68, 0x07, 0xc4, 0x96, 0xde, 0xb7, 0x70, 0xdf, 0x1a, 0x58, 0x0a, 0x0b, 0x17, - 0xdc, 0xa5, 0x06, 0x1c, 0x23, 0x8b, 0x13, 0x35, 0x87, 0x73, 0x9f, 0x32, 0xca, 0xc5, 0x56, 0x90, - 0x80, 0x76, 0x21, 0x7f, 0xa6, 0x76, 0xb5, 0xb6, 0x6a, 0xeb, 0xa6, 0x62, 0x61, 0x9b, 0xfb, 0xd8, - 0xeb, 0x63, 0x7b, 0x7e, 0xe4, 0x70, 0x1d, 0x60, 0xfb, 0xd0, 0x68, 0xab, 0x36, 0xae, 0xc6, 0xbf, - 0x7a, 0xb2, 0x26, 0xc8, 0xb9, 0x33, 0x5f, 0x0f, 0x7a, 0x01, 0x8a, 0xaa, 0x61, 0x28, 0x96, 0xad, - 0xda, 0x58, 0x39, 0x3e, 0xb7, 0xb1, 0x45, 0xdd, 0x6e, 0x4e, 0xce, 0xab, 0x86, 0x71, 0x40, 0xa8, - 0x55, 0x42, 0x44, 0xcf, 0x43, 0x81, 0x78, 0x68, 0x4d, 0xed, 0x2a, 0x1d, 0xac, 0x9d, 0x76, 0xec, - 0x52, 0x72, 0x5d, 0xb8, 0x19, 0x93, 0xf3, 0x9c, 0xda, 0xa0, 0x44, 0xb4, 0x01, 0xcb, 0x0e, 0x5b, - 0x4b, 0x37, 0xb1, 0xc3, 0x4b, 0xfc, 0x71, 0x5e, 0x5e, 0xe2, 0x5d, 0x35, 0xdd, 0xc4, 0x8c, 0x5f, - 0x6a, 0xbb, 0x96, 0x42, 0xbd, 0x39, 0x42, 0x10, 0x6f, 0xab, 0xb6, 0x4a, 0x77, 0x20, 0x27, 0xd3, - 0xdf, 0x84, 0x66, 0xa8, 0x76, 0x87, 0xaf, 0x2b, 0xfd, 0x8d, 0x2e, 0x42, 0x92, 0xab, 0x8e, 0xd1, - 0x61, 0xf0, 0x16, 0x5a, 0x81, 0x84, 0x61, 0xea, 0x67, 0x98, 0x2e, 0x4b, 0x5a, 0x66, 0x0d, 0x49, - 0x86, 0x42, 0xd0, 0xf3, 0xa3, 0x02, 0x44, 0xed, 0x21, 0xff, 0x4a, 0xd4, 0x1e, 0xa2, 0x57, 0x21, - 0x4e, 0x36, 0x80, 0x7e, 0xa3, 0x30, 0x21, 0xd6, 0x71, 0xb9, 0xe6, 0xb9, 0x81, 0x65, 0xca, 0x29, - 0x5d, 0x84, 0x95, 0x49, 0x91, 0x40, 0xea, 0xb8, 0xf4, 0x80, 0x47, 0x47, 0xaf, 0x43, 0xda, 0x0d, - 0x05, 0xcc, 0xbe, 0x2e, 0x8f, 0x7d, 0xc5, 0x61, 0x96, 0x5d, 0x56, 0x62, 0x58, 0x64, 0x7f, 0x3a, - 0x2a, 0x0f, 0xdf, 0x39, 0x39, 0xa5, 0x1a, 0x46, 0x43, 0xb5, 0x3a, 0xd2, 0x29, 0x94, 0xc2, 0xdc, - 0xbc, 0x6f, 0x7d, 0x04, 0x7a, 0x3a, 0x9c, 0xf5, 0xf1, 0x9d, 0xbc, 0x28, 0xdd, 0x13, 0xf7, 0xe4, - 0x51, 0x0b, 0x1e, 0xf4, 0x1f, 0x11, 0x0b, 0x8e, 0xb1, 0x0f, 0xd1, 0xf6, 0x76, 0x5b, 0x6a, 0xc3, - 0xe5, 0x50, 0x8f, 0x1f, 0x90, 0x13, 0x02, 0x72, 0x64, 0x33, 0x58, 0x1c, 0x61, 0x03, 0x67, 0x0d, - 0x32, 0x34, 0x8b, 0xce, 0x9b, 0x7e, 0x26, 0x23, 0xf3, 0x96, 0xf4, 0x5d, 0x1c, 0x2e, 0x4e, 0x76, - 0xfe, 0x68, 0x1d, 0x72, 0x3d, 0x75, 0xa8, 0xd8, 0x43, 0x6e, 0xa1, 0x02, 0xdd, 0x73, 0xe8, 0xa9, - 0xc3, 0xe6, 0x90, 0x99, 0xa7, 0x08, 0x31, 0x7b, 0x68, 0x95, 0xa2, 0xeb, 0xb1, 0x9b, 0x39, 0x99, - 0xfc, 0x44, 0x0f, 0x61, 0xa9, 0xab, 0xb7, 0xd4, 0xae, 0xd2, 0x55, 0x2d, 0x5b, 0x69, 0xe9, 0xbd, - 0x9e, 0x66, 0xf3, 0x73, 0x77, 0x65, 0x7c, 0x7b, 0x69, 0x37, 0xf1, 0x4d, 0xf4, 0x90, 0x44, 0xe4, - 0x22, 0x95, 0xdd, 0x51, 0x2d, 0x9b, 0x75, 0xa1, 0x2d, 0xc8, 0xf6, 0x34, 0xeb, 0x18, 0x77, 0xd4, - 0x33, 0x4d, 0x37, 0x4b, 0xf1, 0xf5, 0xd8, 0xc4, 0x9c, 0xe8, 0xa1, 0xc7, 0xc3, 0x35, 0xf9, 0xc5, - 0x7c, 0xdb, 0x92, 0x08, 0x98, 0xad, 0xe3, 0x78, 0x92, 0x0b, 0x3b, 0x9e, 0x57, 0x61, 0xa5, 0x8f, - 0x87, 0xb6, 0xe2, 0x1e, 0x6a, 0x8b, 0xd9, 0x4a, 0x8a, 0x2e, 0x39, 0x22, 0x7d, 0xae, 0x27, 0xb0, - 0x88, 0xd9, 0x90, 0x5d, 0x31, 0xf5, 0x41, 0xbf, 0x5d, 0x4a, 0xaf, 0x0b, 0x37, 0x13, 0x32, 0x6b, - 0xa0, 0xbb, 0x50, 0xa2, 0x07, 0x96, 0x79, 0x31, 0xe2, 0x6d, 0x71, 0xdb, 0x39, 0xbd, 0x19, 0x6a, - 0x29, 0x17, 0x48, 0x3f, 0xf5, 0x93, 0x3b, 0xb4, 0x97, 0x9f, 0xf8, 0x4d, 0x58, 0x61, 0xd1, 0x17, - 0x9b, 0x24, 0x0c, 0x93, 0x4d, 0xa2, 0x03, 0x00, 0x3a, 0x80, 0x25, 0xa7, 0x6f, 0xdf, 0xd4, 0x9b, - 0x43, 0xfa, 0xfd, 0x57, 0x5d, 0x81, 0xb6, 0x42, 0x4c, 0xdb, 0xb1, 0xc7, 0x2c, 0x35, 0x54, 0xe4, - 0xf4, 0x55, 0x0c, 0xd7, 0x9d, 0xdf, 0xf5, 0x8c, 0x36, 0x37, 0x9e, 0x12, 0xf2, 0x2e, 0xcf, 0x75, - 0x7a, 0x36, 0xbd, 0x06, 0xd9, 0x4f, 0x06, 0xba, 0x39, 0xe8, 0xb1, 0x21, 0xe5, 0xe9, 0x90, 0x80, - 0x91, 0xe8, 0x11, 0xfa, 0x63, 0xc2, 0x67, 0x73, 0xc1, 0x3c, 0x80, 0x5b, 0x94, 0xe0, 0x59, 0xd4, - 0x81, 0x6f, 0xe0, 0x7e, 0xa3, 0x8a, 0xce, 0x6b, 0x54, 0xee, 0xdc, 0xc2, 0xed, 0x2a, 0xf6, 0xfd, - 0xec, 0x0a, 0x41, 0x9c, 0xce, 0x30, 0xce, 0xdc, 0x26, 0xf9, 0x1d, 0x6a, 0x6b, 0xee, 0xfe, 0x27, - 0xfd, 0xfb, 0xef, 0x58, 0x60, 0xea, 0x07, 0xb3, 0xc0, 0x74, 0xa8, 0x05, 0x7e, 0x6f, 0x5b, 0x6b, - 0xc2, 0xc5, 0x11, 0x41, 0x65, 0x40, 0x43, 0x1b, 0xb5, 0xb6, 0x91, 0x84, 0xdf, 0x09, 0xa8, 0x3e, - 0x45, 0xf2, 0x72, 0x40, 0x2f, 0x0b, 0x8b, 0xa1, 0x16, 0x9c, 0x5d, 0xd4, 0x82, 0x73, 0xf3, 0x58, - 0x70, 0xfe, 0x59, 0x2c, 0xb8, 0x30, 0x66, 0xc1, 0x87, 0xb0, 0x34, 0x96, 0x8a, 0xba, 0xe6, 0x20, - 0x4c, 0x34, 0x87, 0xe8, 0x64, 0x73, 0x88, 0xf9, 0xcc, 0x41, 0xfa, 0x46, 0x80, 0x72, 0x78, 0x46, - 0x3a, 0xf1, 0x03, 0xaf, 0xc1, 0x05, 0x2f, 0x33, 0xf1, 0xaf, 0x23, 0xf3, 0xfe, 0xc8, 0xed, 0xf4, - 0x16, 0x72, 0x4a, 0x14, 0x67, 0x63, 0x8a, 0xfb, 0x4d, 0xf4, 0x21, 0x14, 0x83, 0xb9, 0x34, 0x49, - 0x55, 0xc8, 0x71, 0xf9, 0x9f, 0xb1, 0xe3, 0xe2, 0xad, 0x85, 0x3b, 0x66, 0xb9, 0x70, 0xe6, 0x6f, - 0x5a, 0xd2, 0x5f, 0xa2, 0x6e, 0xa4, 0x0e, 0x24, 0xc6, 0xe8, 0x2d, 0x48, 0xf2, 0x93, 0x2d, 0xcc, - 0x7b, 0xb2, 0xb9, 0xc0, 0xe8, 0x69, 0x8e, 0x3e, 0xdb, 0x69, 0x8e, 0x4d, 0xdc, 0xbe, 0xf8, 0xe4, - 0xa5, 0x4a, 0xf8, 0x97, 0xea, 0x15, 0x48, 0xb0, 0x1b, 0x01, 0x0b, 0x28, 0x97, 0xc6, 0xcf, 0x05, - 0x9d, 0xaa, 0xcc, 0xb8, 0x50, 0x05, 0xd2, 0x2c, 0xeb, 0xd6, 0xda, 0xdc, 0x01, 0x5c, 0x0e, 0x91, - 0xd8, 0xde, 0xaa, 0x66, 0x9f, 0x3e, 0x59, 0x4b, 0xf1, 0x86, 0x9c, 0xa2, 0x72, 0xdb, 0x6d, 0xe9, - 0x4f, 0x19, 0x48, 0xcb, 0xd8, 0x32, 0x88, 0x09, 0xa3, 0x2a, 0x64, 0xf0, 0xb0, 0x85, 0x0d, 0xdb, - 0xc9, 0xf0, 0x27, 0xdf, 0xa0, 0x18, 0x77, 0xdd, 0xe1, 0x6c, 0x44, 0x64, 0x4f, 0x0c, 0xdd, 0xe1, - 0x40, 0x47, 0x38, 0x66, 0xc1, 0xc5, 0xfd, 0x48, 0xc7, 0x1b, 0x0e, 0xd2, 0xc1, 0x02, 0xfd, 0x6a, - 0xa8, 0xd4, 0x08, 0xd4, 0x71, 0x87, 0x43, 0x1d, 0xf1, 0x19, 0x1f, 0x0b, 0x60, 0x1d, 0xb5, 0x00, - 0xd6, 0x91, 0x98, 0x31, 0xcd, 0x10, 0xb0, 0xe3, 0x0d, 0x07, 0xec, 0x48, 0xce, 0x18, 0xf1, 0x08, - 0xda, 0xf1, 0xff, 0x63, 0x68, 0xc7, 0x7a, 0xa8, 0xe8, 0x04, 0xb8, 0x63, 0x6f, 0x0c, 0xee, 0x48, - 0x53, 0x25, 0x2f, 0x84, 0x2a, 0x99, 0x81, 0x77, 0xec, 0x8d, 0xe1, 0x1d, 0x99, 0x19, 0x0a, 0x67, - 0x00, 0x1e, 0x3f, 0x9d, 0x0c, 0x78, 0x40, 0x28, 0x24, 0xc1, 0x87, 0x39, 0x1f, 0xe2, 0xa1, 0x84, - 0x20, 0x1e, 0xd9, 0xd0, 0xdb, 0x39, 0x53, 0x3f, 0x37, 0xe4, 0x71, 0x38, 0x01, 0xf2, 0x60, 0xc9, - 0xcb, 0xcd, 0x50, 0xe5, 0x73, 0x60, 0x1e, 0x87, 0x13, 0x30, 0x8f, 0xfc, 0x4c, 0xb5, 0x33, 0x41, - 0x8f, 0x7b, 0x41, 0xd0, 0xa3, 0x10, 0x72, 0xa7, 0xf4, 0x8e, 0x6c, 0x08, 0xea, 0x71, 0x1c, 0x86, - 0x7a, 0x30, 0xb4, 0xe7, 0xe5, 0x50, 0x8d, 0x0b, 0xc0, 0x1e, 0x7b, 0x63, 0xb0, 0x87, 0x38, 0xc3, - 0xd2, 0xe6, 0xc4, 0x3d, 0xa4, 0x17, 0x49, 0x2c, 0x1d, 0x71, 0x4a, 0xc4, 0xc1, 0x62, 0xd3, 0xd4, - 0x4d, 0x8e, 0x54, 0xb0, 0x86, 0x74, 0x93, 0xdc, 0x5b, 0x3d, 0x07, 0x34, 0x05, 0x0b, 0x29, 0x42, - 0x3e, 0xe0, 0x74, 0xa4, 0xdf, 0x09, 0x9e, 0x2c, 0x45, 0x43, 0xfc, 0x77, 0xde, 0x0c, 0xbf, 0xf3, - 0x8e, 0xdc, 0xd3, 0x32, 0x81, 0x8c, 0xc0, 0x9f, 0x73, 0x70, 0xf0, 0x43, 0xf5, 0x72, 0x8d, 0x5b, - 0xb0, 0x44, 0xb3, 0x53, 0xe6, 0xd1, 0x03, 0x41, 0xa3, 0x48, 0x3a, 0xd8, 0x2a, 0xb0, 0xe8, 0xf1, - 0x0a, 0x2c, 0xfb, 0x78, 0xdd, 0x8b, 0x26, 0x43, 0x00, 0x44, 0x97, 0xbb, 0xc2, 0x6f, 0x9c, 0xff, - 0x88, 0x7a, 0x2b, 0xe4, 0xa1, 0x26, 0x93, 0x00, 0x0e, 0xe1, 0x7b, 0x03, 0x1c, 0xe1, 0x17, 0x5e, - 0xf4, 0x01, 0xac, 0x04, 0xb0, 0x0f, 0x27, 0xf9, 0x8b, 0x2d, 0x06, 0x81, 0x44, 0x7c, 0xb9, 0x88, - 0xdb, 0x83, 0x3e, 0x84, 0x2b, 0x34, 0x8d, 0x0d, 0x49, 0x30, 0xe3, 0xf3, 0x25, 0x98, 0x97, 0x88, - 0x8e, 0xda, 0x84, 0x24, 0x33, 0x04, 0x18, 0x49, 0x84, 0x01, 0x23, 0xff, 0x12, 0x3c, 0xbb, 0x71, - 0xa1, 0x91, 0x96, 0xde, 0x66, 0xf6, 0x95, 0x97, 0xe9, 0x6f, 0x72, 0x49, 0xe9, 0xea, 0xa7, 0xdc, - 0x44, 0xc8, 0x4f, 0xc2, 0xe5, 0x82, 0xf6, 0x19, 0x1e, 0xa8, 0x56, 0x20, 0xa1, 0xf5, 0xdb, 0x78, - 0xc8, 0xad, 0x80, 0x35, 0x88, 0xec, 0x23, 0x7c, 0xce, 0xf7, 0x9a, 0xfc, 0x24, 0x7c, 0xf4, 0x20, - 0xd0, 0x58, 0x94, 0x93, 0x59, 0x03, 0xbd, 0x09, 0x19, 0x5a, 0x79, 0x51, 0x74, 0xc3, 0xe2, 0xa1, - 0x26, 0x90, 0x11, 0xb1, 0x2a, 0xc9, 0xc6, 0x3e, 0xe1, 0xd9, 0x33, 0x2c, 0x39, 0x6d, 0xf0, 0x5f, - 0xbe, 0x9c, 0x25, 0x1d, 0xc8, 0x59, 0xae, 0x42, 0x86, 0x8c, 0xde, 0x32, 0xd4, 0x16, 0xa6, 0x61, - 0x22, 0x23, 0x7b, 0x04, 0xe9, 0x0f, 0x02, 0x14, 0x47, 0x22, 0xd7, 0xc4, 0xb9, 0x3b, 0xc7, 0x26, - 0x1a, 0x84, 0x8a, 0xc6, 0x66, 0x7f, 0x0d, 0xe0, 0x54, 0xb5, 0x94, 0xc7, 0x6a, 0xdf, 0xc6, 0x6d, - 0xbe, 0x04, 0x99, 0x53, 0xd5, 0x7a, 0x8f, 0x12, 0x82, 0x83, 0x49, 0x8c, 0x0c, 0xc6, 0x07, 0x56, - 0x24, 0xfd, 0x60, 0x05, 0x2a, 0x43, 0xda, 0x30, 0x35, 0xdd, 0xd4, 0xec, 0x73, 0xba, 0x26, 0x31, - 0xd9, 0x6d, 0x4b, 0xfb, 0x70, 0x61, 0x62, 0xd0, 0x44, 0x77, 0x21, 0xe3, 0xc5, 0x5b, 0x81, 0xe6, - 0x86, 0x53, 0x30, 0x20, 0x8f, 0x97, 0x2c, 0xc9, 0x85, 0x89, 0x61, 0x13, 0xd5, 0x21, 0x69, 0x62, - 0x6b, 0xd0, 0x65, 0xb9, 0x6a, 0xe1, 0xf6, 0x2b, 0xf3, 0x85, 0x5b, 0x42, 0x1d, 0x74, 0x6d, 0x99, - 0x0b, 0x4b, 0x1f, 0x41, 0x92, 0x51, 0x50, 0x16, 0x52, 0x87, 0xbb, 0x0f, 0x76, 0xf7, 0xde, 0xdb, - 0x15, 0x23, 0x08, 0x20, 0x59, 0xa9, 0xd5, 0xea, 0xfb, 0x4d, 0x51, 0x40, 0x19, 0x48, 0x54, 0xaa, - 0x7b, 0x72, 0x53, 0x8c, 0x12, 0xb2, 0x5c, 0xbf, 0x5f, 0xaf, 0x35, 0xc5, 0x18, 0x5a, 0x82, 0x3c, - 0xfb, 0xad, 0xdc, 0xdb, 0x93, 0x1f, 0x56, 0x9a, 0x62, 0xdc, 0x47, 0x3a, 0xa8, 0xef, 0x6e, 0xd5, - 0x65, 0x31, 0x21, 0xbd, 0x06, 0x97, 0x43, 0x03, 0xb4, 0x07, 0x13, 0x09, 0x3e, 0x98, 0x48, 0xfa, - 0x3a, 0x4a, 0x6e, 0x20, 0x61, 0x51, 0x17, 0xdd, 0x1f, 0x99, 0xf8, 0xed, 0x05, 0x42, 0xf6, 0xc8, - 0xec, 0xd1, 0xf3, 0x50, 0x30, 0xf1, 0x09, 0xb6, 0x5b, 0x1d, 0x96, 0x05, 0x38, 0x38, 0x52, 0x9e, - 0x53, 0xa9, 0x90, 0xc5, 0xd8, 0x3e, 0xc6, 0x2d, 0x5b, 0x61, 0x46, 0x60, 0xd1, 0xdb, 0x7a, 0x86, - 0xb0, 0x11, 0xea, 0x01, 0x23, 0x12, 0x07, 0xcd, 0x1c, 0x09, 0x53, 0x15, 0xa7, 0xaa, 0x80, 0xfa, - 0x05, 0x4a, 0x91, 0x1e, 0x2f, 0xb4, 0xd8, 0x19, 0x48, 0xc8, 0xf5, 0xa6, 0xfc, 0xbe, 0x18, 0x43, - 0x08, 0x0a, 0xf4, 0xa7, 0x72, 0xb0, 0x5b, 0xd9, 0x3f, 0x68, 0xec, 0x91, 0xc5, 0x5e, 0x86, 0xa2, - 0xb3, 0xd8, 0x0e, 0x31, 0x81, 0x2e, 0xc0, 0x52, 0x6d, 0xef, 0xe1, 0xfe, 0x4e, 0xbd, 0x59, 0xf7, - 0xc8, 0x49, 0xe9, 0xf7, 0x31, 0xb8, 0x14, 0x92, 0x6b, 0xa0, 0x37, 0x01, 0xec, 0xa1, 0x62, 0xe2, - 0x96, 0x6e, 0xb6, 0xc3, 0x8d, 0xb3, 0x39, 0x94, 0x29, 0x87, 0x9c, 0xb1, 0xf9, 0xaf, 0xa9, 0x0e, - 0xfb, 0x1d, 0xae, 0x94, 0x4c, 0xd6, 0xe2, 0xd8, 0xc6, 0xb5, 0x09, 0x97, 0x35, 0xdc, 0x22, 0x8a, - 0xe9, 0x9e, 0x50, 0xc5, 0x94, 0x1f, 0xbd, 0x0f, 0x97, 0x46, 0xe2, 0x0a, 0x77, 0xc6, 0xd6, 0xa4, - 0xc2, 0xe2, 0xe4, 0xf0, 0x72, 0x21, 0x18, 0x5e, 0x98, 0x33, 0xb6, 0xa6, 0x00, 0x09, 0x89, 0x67, - 0x00, 0x12, 0xc2, 0xe2, 0x53, 0x72, 0x51, 0x88, 0x7e, 0x42, 0x7c, 0x92, 0x7e, 0x1b, 0xd8, 0xbc, - 0x60, 0xfa, 0xb6, 0x07, 0x49, 0xcb, 0x56, 0xed, 0x81, 0xc5, 0x0f, 0xc3, 0xdd, 0x79, 0x73, 0xc1, - 0x0d, 0xe7, 0xc7, 0x01, 0x15, 0x97, 0xb9, 0x9a, 0xff, 0xca, 0x3d, 0x0d, 0x5b, 0xfd, 0xc4, 0x0f, - 0xb1, 0xfa, 0xaf, 0x43, 0x21, 0xb8, 0x54, 0xe1, 0x67, 0xd7, 0xf3, 0x8e, 0x51, 0xe9, 0x37, 0x02, - 0x2c, 0x4f, 0xc0, 0x22, 0xd0, 0x5d, 0x5e, 0x6e, 0x60, 0xdb, 0x75, 0x7d, 0x7c, 0xce, 0x01, 0x76, - 0xaf, 0xea, 0x40, 0xa2, 0x95, 0x97, 0x54, 0xb3, 0x9d, 0xf1, 0x08, 0xe8, 0x25, 0x28, 0x5a, 0xda, - 0x69, 0x5f, 0x31, 0x19, 0xac, 0xe1, 0x42, 0xf9, 0x24, 0xe7, 0x25, 0x1d, 0x4e, 0xc1, 0xab, 0xfd, - 0x4b, 0x41, 0xa8, 0x22, 0x10, 0x95, 0x11, 0x6e, 0xa9, 0x05, 0x68, 0x3c, 0xc7, 0x9f, 0x04, 0xbc, - 0x08, 0xcf, 0x00, 0xbc, 0xfc, 0x5a, 0x80, 0x2b, 0x53, 0xf2, 0x7e, 0xf4, 0xee, 0x88, 0x35, 0xbf, - 0xb5, 0xc8, 0xad, 0x61, 0x83, 0xd1, 0x82, 0xf6, 0x2c, 0xdd, 0x81, 0x9c, 0x9f, 0x3e, 0xdf, 0xe6, - 0xfd, 0xc2, 0x17, 0x75, 0x83, 0x08, 0x51, 0x03, 0x92, 0xf8, 0x0c, 0xf7, 0xdd, 0x28, 0x7e, 0x71, - 0x7c, 0x1d, 0x48, 0x77, 0xb5, 0x44, 0xb2, 0xcd, 0x7f, 0x3e, 0x59, 0x13, 0x19, 0xf7, 0xcb, 0x7a, - 0x4f, 0xb3, 0x71, 0xcf, 0xb0, 0xcf, 0x65, 0x2e, 0x8f, 0xae, 0x43, 0xde, 0xc4, 0x36, 0x71, 0x42, - 0x01, 0x70, 0x2e, 0xc7, 0x88, 0x3c, 0x17, 0xfc, 0xb3, 0x00, 0xe0, 0x41, 0x4e, 0x1e, 0xe4, 0x23, - 0xf8, 0x21, 0x9f, 0x11, 0xa4, 0x30, 0x3a, 0x8a, 0x14, 0xa2, 0x1b, 0x50, 0x64, 0x69, 0x3e, 0xd9, - 0x74, 0xd5, 0x1e, 0x98, 0x98, 0x03, 0x4c, 0x05, 0x4a, 0x3e, 0x70, 0xa8, 0xe8, 0x03, 0xb8, 0x6c, - 0x77, 0x4c, 0x6c, 0x75, 0xf4, 0x6e, 0x5b, 0x19, 0xdd, 0x78, 0x56, 0xf8, 0x58, 0x9b, 0x61, 0xb1, - 0xf2, 0x25, 0x57, 0xc3, 0x51, 0x70, 0xf3, 0x3f, 0x85, 0x04, 0x5d, 0x1b, 0x92, 0xaa, 0xb9, 0x47, - 0x20, 0xc3, 0xad, 0xfb, 0x43, 0x00, 0xd5, 0xb6, 0x4d, 0xed, 0x78, 0x40, 0x1c, 0x42, 0x74, 0xfc, - 0x53, 0xde, 0xda, 0x56, 0x1c, 0xbe, 0xea, 0x55, 0xbe, 0xc8, 0x2b, 0x9e, 0xa8, 0x6f, 0xa1, 0x7d, - 0x0a, 0xa5, 0x5d, 0x28, 0x04, 0x65, 0x9d, 0x1c, 0x98, 0x8d, 0x21, 0x98, 0x03, 0xb3, 0x9c, 0x9a, - 0xe7, 0xc0, 0x6e, 0x06, 0x1d, 0x63, 0x65, 0x45, 0xda, 0x90, 0xbe, 0x13, 0x20, 0xe7, 0x77, 0x74, - 0x73, 0xa7, 0xa9, 0x3c, 0x6d, 0x8f, 0x8d, 0xa7, 0xed, 0x71, 0x5f, 0xe2, 0x7a, 0x19, 0xd2, 0x24, - 0x71, 0x1d, 0x58, 0xb8, 0xcd, 0x8b, 0xad, 0xa9, 0x53, 0xd5, 0x3a, 0xb4, 0x70, 0xdb, 0x67, 0x80, - 0xa9, 0x67, 0x34, 0xc0, 0x40, 0xfa, 0x9b, 0x1e, 0x49, 0x7f, 0xef, 0xc7, 0xd3, 0x09, 0x31, 0x29, - 0xfb, 0xf2, 0x67, 0xe9, 0x33, 0x01, 0xd2, 0xee, 0x7c, 0x83, 0x55, 0xc6, 0x00, 0x28, 0xc9, 0x96, - 0x8b, 0xd5, 0x18, 0xf9, 0x85, 0x83, 0xd5, 0x5c, 0x63, 0x6e, 0xcd, 0xf5, 0x6d, 0x37, 0x85, 0x0b, - 0x83, 0xdd, 0xfc, 0x8b, 0xeb, 0x20, 0xad, 0x3c, 0x63, 0xfd, 0x15, 0x1f, 0x07, 0xc9, 0x41, 0xd0, - 0xff, 0x41, 0x52, 0x6d, 0xb9, 0x60, 0x63, 0x61, 0x02, 0x0a, 0xe7, 0xb0, 0x6e, 0x34, 0x87, 0x15, - 0xca, 0x29, 0x73, 0x09, 0x3e, 0xaa, 0xa8, 0x33, 0x2a, 0x69, 0x87, 0xe8, 0x65, 0x3c, 0x41, 0x37, - 0x51, 0x00, 0x38, 0xdc, 0x7d, 0xb8, 0xb7, 0xb5, 0x7d, 0x6f, 0xbb, 0xbe, 0xc5, 0x73, 0xb4, 0xad, - 0xad, 0xfa, 0x96, 0x18, 0x25, 0x7c, 0x72, 0xfd, 0xe1, 0xde, 0x51, 0x7d, 0x4b, 0x8c, 0x91, 0xc6, - 0x56, 0x7d, 0xa7, 0xf2, 0x7e, 0x7d, 0x4b, 0x8c, 0x4b, 0x15, 0xc8, 0xb8, 0x71, 0x86, 0x16, 0xa7, - 0xf5, 0xc7, 0xd8, 0xe4, 0xab, 0xc5, 0x1a, 0x68, 0x15, 0xb2, 0xe3, 0x68, 0x39, 0xb9, 0x72, 0x31, - 0x90, 0x9c, 0xc4, 0x90, 0xa2, 0xab, 0x83, 0x67, 0x1a, 0x6f, 0x43, 0xca, 0x18, 0x1c, 0x2b, 0x8e, - 0xed, 0x8e, 0x60, 0xcc, 0xce, 0x8d, 0x6c, 0x70, 0xdc, 0xd5, 0x5a, 0x0f, 0xf0, 0x39, 0x8f, 0x6b, - 0x49, 0x63, 0x70, 0xfc, 0x80, 0x99, 0x38, 0x1b, 0x46, 0x74, 0xca, 0x30, 0x62, 0x23, 0xc3, 0x40, - 0x37, 0x20, 0xd7, 0xd7, 0xdb, 0x58, 0x51, 0xdb, 0x6d, 0x13, 0x5b, 0x2c, 0x5c, 0x67, 0xb8, 0xe6, - 0x2c, 0xe9, 0xa9, 0xb0, 0x0e, 0xe9, 0x1b, 0x01, 0xd0, 0x78, 0x6c, 0x45, 0x07, 0xb0, 0xe4, 0x85, - 0x67, 0x27, 0xe6, 0x33, 0xf7, 0xb9, 0x1e, 0x1e, 0x9b, 0x03, 0xd7, 0x76, 0xf1, 0x2c, 0x48, 0x26, - 0x79, 0xdc, 0x8a, 0xe7, 0xaa, 0x0c, 0x3a, 0x5f, 0xba, 0x28, 0xd1, 0x39, 0x17, 0x25, 0x22, 0x23, - 0x57, 0xde, 0xed, 0x19, 0x75, 0xa5, 0xb1, 0xb1, 0xa2, 0x8b, 0x01, 0xa5, 0xe6, 0x98, 0x18, 0x9f, - 0x67, 0xd8, 0x90, 0x84, 0x67, 0x19, 0x92, 0x74, 0x07, 0xc4, 0x77, 0xdd, 0xef, 0xf3, 0x2f, 0x8d, - 0x0c, 0x53, 0x18, 0x1b, 0xe6, 0x19, 0xa4, 0x89, 0xf7, 0xa5, 0x41, 0xe3, 0x47, 0x90, 0x71, 0x57, - 0xcf, 0x7d, 0xdf, 0x12, 0xba, 0xec, 0x7c, 0x24, 0x9e, 0x08, 0xba, 0x05, 0x4b, 0x24, 0x6e, 0x38, - 0xa5, 0x4f, 0x06, 0xbc, 0x45, 0xa9, 0x37, 0x2c, 0xb2, 0x8e, 0x1d, 0x07, 0x2d, 0x22, 0x01, 0x5e, - 0x64, 0x89, 0x00, 0x6e, 0xff, 0x27, 0x06, 0x40, 0x6e, 0x6a, 0x23, 0xf8, 0x23, 0xdb, 0xc3, 0x7c, - 0x20, 0x13, 0x91, 0x7e, 0x16, 0x85, 0xac, 0xaf, 0x14, 0x83, 0xfe, 0x37, 0x90, 0x95, 0xad, 0x4f, - 0x2b, 0xdb, 0xf8, 0x52, 0xb2, 0xc0, 0xc4, 0xa2, 0x8b, 0x4f, 0x2c, 0xac, 0x08, 0xe6, 0x54, 0x64, - 0xe3, 0x0b, 0x57, 0x64, 0x5f, 0x06, 0x64, 0xeb, 0xb6, 0xda, 0x25, 0xc1, 0x5b, 0xeb, 0x9f, 0x2a, - 0xec, 0xb4, 0xb3, 0x2a, 0xb0, 0x48, 0x7b, 0x8e, 0x68, 0xc7, 0x3e, 0xa1, 0x4b, 0x5d, 0x48, 0xbb, - 0x70, 0xc2, 0xe2, 0xcf, 0x46, 0x26, 0x55, 0x9e, 0xcb, 0x90, 0xee, 0x61, 0x5b, 0xa5, 0x61, 0x8f, - 0xc1, 0x4b, 0x6e, 0xfb, 0xd6, 0x5b, 0x90, 0xf5, 0xbd, 0xa5, 0x21, 0x91, 0x70, 0xb7, 0xfe, 0x9e, - 0x18, 0x29, 0xa7, 0x3e, 0xff, 0x72, 0x3d, 0xb6, 0x8b, 0x1f, 0x93, 0x4f, 0xc9, 0xf5, 0x5a, 0xa3, - 0x5e, 0x7b, 0x20, 0x0a, 0xe5, 0xec, 0xe7, 0x5f, 0xae, 0xa7, 0x64, 0x4c, 0xab, 0x16, 0xb7, 0x1e, - 0x40, 0x71, 0x64, 0x07, 0x82, 0x0e, 0x1a, 0x41, 0x61, 0xeb, 0x70, 0x7f, 0x67, 0xbb, 0x56, 0x69, - 0xd6, 0x95, 0xa3, 0xbd, 0x66, 0x5d, 0x14, 0xd0, 0x25, 0x58, 0xde, 0xd9, 0xfe, 0x71, 0xa3, 0xa9, - 0xd4, 0x76, 0xb6, 0xeb, 0xbb, 0x4d, 0xa5, 0xd2, 0x6c, 0x56, 0x6a, 0x0f, 0xc4, 0xe8, 0xed, 0xbf, - 0x01, 0x14, 0x2b, 0xd5, 0xda, 0x76, 0xc5, 0x30, 0xba, 0x5a, 0x4b, 0xa5, 0xee, 0xbe, 0x06, 0x71, - 0x0a, 0xe6, 0x4e, 0x7d, 0x55, 0x5b, 0x9e, 0x5e, 0x8a, 0x42, 0xf7, 0x20, 0x41, 0x71, 0x5e, 0x34, - 0xfd, 0x99, 0x6d, 0x79, 0x46, 0x6d, 0x8a, 0x0c, 0x86, 0x9e, 0x9b, 0xa9, 0xef, 0x6e, 0xcb, 0xd3, - 0x4b, 0x55, 0x68, 0x07, 0x52, 0x0e, 0x84, 0x36, 0xeb, 0x31, 0x6c, 0x79, 0x66, 0xfd, 0x88, 0x4c, - 0x8d, 0x41, 0x91, 0xd3, 0x9f, 0xe4, 0x96, 0x67, 0x14, 0xb1, 0x90, 0x0c, 0x19, 0x0f, 0x3d, 0x9e, - 0xfd, 0x3a, 0xb8, 0x3c, 0x47, 0x51, 0x0d, 0x7d, 0x04, 0xf9, 0x20, 0xd8, 0x36, 0xdf, 0xc3, 0xdd, - 0xf2, 0x9c, 0x05, 0x2f, 0xa2, 0x3f, 0x88, 0xbc, 0xcd, 0xf7, 0x90, 0xb7, 0x3c, 0x67, 0xfd, 0x0b, - 0x7d, 0x0c, 0x4b, 0xe3, 0xc8, 0xd8, 0xfc, 0xef, 0x7a, 0xcb, 0x0b, 0x54, 0xc4, 0x50, 0x0f, 0xd0, - 0x04, 0x44, 0x6d, 0x81, 0x67, 0xbe, 0xe5, 0x45, 0x0a, 0x64, 0xa8, 0x0d, 0xc5, 0x51, 0xb4, 0x69, - 0xde, 0x67, 0xbf, 0xe5, 0xb9, 0x8b, 0x65, 0xec, 0x2b, 0x41, 0x58, 0x64, 0xde, 0x67, 0xc0, 0xe5, - 0xb9, 0x6b, 0x67, 0xe8, 0x10, 0xc0, 0x77, 0x31, 0x9e, 0xe3, 0x59, 0x70, 0x79, 0x9e, 0x2a, 0x1a, - 0x32, 0x60, 0x79, 0xd2, 0x4d, 0x78, 0x91, 0x57, 0xc2, 0xe5, 0x85, 0x8a, 0x6b, 0xc4, 0x9e, 0x83, - 0x77, 0xda, 0xf9, 0x5e, 0x0d, 0x97, 0xe7, 0xac, 0xb2, 0x55, 0xab, 0x5f, 0x3d, 0x5d, 0x15, 0xbe, - 0x7e, 0xba, 0x2a, 0x7c, 0xf3, 0x74, 0x55, 0xf8, 0xe2, 0xdb, 0xd5, 0xc8, 0xd7, 0xdf, 0xae, 0x46, - 0xfe, 0xfa, 0xed, 0x6a, 0xe4, 0x27, 0x37, 0x4f, 0x35, 0xbb, 0x33, 0x38, 0xde, 0x68, 0xe9, 0x3d, - 0xfa, 0xa7, 0x0d, 0x43, 0x3d, 0xdf, 0x64, 0x3a, 0x49, 0xcb, 0xf7, 0xd7, 0x90, 0xe3, 0x24, 0x8d, - 0x75, 0x77, 0xfe, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x01, 0x57, 0x30, 0x3e, 0x3a, 0x32, 0x00, 0x00, + // 3678 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5b, 0xcd, 0x73, 0x1b, 0xd7, + 0x91, 0xc7, 0xe0, 0x1b, 0x8d, 0xaf, 0xe1, 0x23, 0x25, 0x41, 0x90, 0x44, 0xd2, 0xa3, 0xb5, 0x25, + 0xcb, 0x36, 0x69, 0x4b, 0x6b, 0xcb, 0x5e, 0x7b, 0xb7, 0x0a, 0x00, 0xa1, 0x05, 0x29, 0x8a, 0xa4, + 0x87, 0x20, 0x5d, 0x5e, 0xaf, 0x3d, 0x35, 0x04, 0x1e, 0x89, 0xb1, 0x00, 0xcc, 0x78, 0x66, 0x40, + 0x81, 0xbe, 0xee, 0xba, 0x2a, 0xe5, 0x93, 0xff, 0x01, 0xdf, 0x92, 0x63, 0xee, 0xa9, 0x1c, 0x92, + 0xca, 0xcd, 0xa9, 0x5c, 0x7c, 0xcc, 0x25, 0x8a, 0x4b, 0xbe, 0xa4, 0x72, 0xf3, 0x29, 0x97, 0x1c, + 0x52, 0xef, 0x63, 0xbe, 0x00, 0x0c, 0x3e, 0x2c, 0x57, 0xa5, 0x72, 0xc3, 0xeb, 0xd7, 0xdd, 0xf3, + 0x3e, 0xfa, 0x75, 0xf7, 0xfb, 0xf5, 0x03, 0x5c, 0xb3, 0x71, 0xbf, 0x8d, 0xcd, 0x9e, 0xd6, 0xb7, + 0x37, 0xd5, 0x93, 0x96, 0xb6, 0x69, 0x5f, 0x18, 0xd8, 0xda, 0x30, 0x4c, 0xdd, 0xd6, 0x51, 0xd1, + 0xeb, 0xdc, 0x20, 0x9d, 0xe5, 0x1b, 0x3e, 0xee, 0x96, 0x79, 0x61, 0xd8, 0xfa, 0xa6, 0x61, 0xea, + 0xfa, 0x29, 0xe3, 0x2f, 0xfb, 0x95, 0x51, 0x3d, 0x9b, 0x6d, 0xd5, 0xea, 0xf0, 0xce, 0xeb, 0x63, + 0x9d, 0x27, 0x5d, 0xbd, 0xf5, 0x38, 0xb4, 0xd7, 0x37, 0x90, 0x40, 0x2f, 0xff, 0xee, 0x63, 0x7c, + 0xe1, 0xf4, 0xde, 0x18, 0x93, 0x35, 0x54, 0x53, 0xed, 0x39, 0xdd, 0xab, 0xbe, 0xee, 0x73, 0x6c, + 0x5a, 0x9a, 0xde, 0x0f, 0x28, 0x5f, 0x3b, 0xd3, 0xf5, 0xb3, 0x2e, 0xde, 0xa4, 0xad, 0x93, 0xc1, + 0xe9, 0xa6, 0xad, 0xf5, 0xb0, 0x65, 0xab, 0x3d, 0x83, 0x33, 0xac, 0x9c, 0xe9, 0x67, 0x3a, 0xfd, + 0xb9, 0x49, 0x7e, 0x31, 0xaa, 0xf4, 0x45, 0x06, 0x52, 0x32, 0xfe, 0x6c, 0x80, 0x2d, 0x1b, 0xdd, + 0x85, 0x38, 0x6e, 0x75, 0xf4, 0x92, 0xb0, 0x2e, 0xdc, 0xce, 0xde, 0xbd, 0xbe, 0x31, 0xb2, 0x6e, + 0x1b, 0x9c, 0xaf, 0xde, 0xea, 0xe8, 0x8d, 0x88, 0x4c, 0x79, 0xd1, 0x9b, 0x90, 0x38, 0xed, 0x0e, + 0xac, 0x4e, 0x29, 0x4a, 0x85, 0x6e, 0x84, 0x09, 0x3d, 0x20, 0x4c, 0x8d, 0x88, 0xcc, 0xb8, 0xc9, + 0xa7, 0xb4, 0xfe, 0xa9, 0x5e, 0x8a, 0x4d, 0xff, 0xd4, 0x76, 0xff, 0x94, 0x7e, 0x8a, 0xf0, 0xa2, + 0x2a, 0x80, 0xd6, 0xd7, 0x6c, 0xa5, 0xd5, 0x51, 0xb5, 0x7e, 0x29, 0x4e, 0x25, 0x5f, 0x08, 0x97, + 0xd4, 0xec, 0x1a, 0x61, 0x6c, 0x44, 0xe4, 0x8c, 0xe6, 0x34, 0xc8, 0x70, 0x3f, 0x1b, 0x60, 0xf3, + 0xa2, 0x94, 0x98, 0x3e, 0xdc, 0xf7, 0x09, 0x13, 0x19, 0x2e, 0xe5, 0x46, 0xef, 0x41, 0xba, 0xd5, + 0xc1, 0xad, 0xc7, 0x8a, 0x3d, 0x2c, 0xa5, 0xa8, 0xe4, 0x5a, 0x98, 0x64, 0x8d, 0xf0, 0x35, 0x87, + 0x8d, 0x88, 0x9c, 0x6a, 0xb1, 0x9f, 0x68, 0x0f, 0x0a, 0x5d, 0xcd, 0xb2, 0x15, 0xab, 0xaf, 0x1a, + 0x56, 0x47, 0xb7, 0xad, 0x52, 0x96, 0xea, 0x78, 0x31, 0x4c, 0xc7, 0xae, 0x66, 0xd9, 0x87, 0x0e, + 0x73, 0x23, 0x22, 0xe7, 0xbb, 0x7e, 0x02, 0xd1, 0xa7, 0x9f, 0x9e, 0x62, 0xd3, 0x55, 0x58, 0xca, + 0x4d, 0xd7, 0xb7, 0x4f, 0xb8, 0x1d, 0x79, 0xa2, 0x4f, 0xf7, 0x13, 0xd0, 0x47, 0xb0, 0xdc, 0xd5, + 0xd5, 0xb6, 0xab, 0x4e, 0x69, 0x75, 0x06, 0xfd, 0xc7, 0xa5, 0x3c, 0x55, 0xfa, 0x72, 0xe8, 0x20, + 0x75, 0xb5, 0xed, 0xa8, 0xa8, 0x11, 0x81, 0x46, 0x44, 0x5e, 0xea, 0x8e, 0x12, 0xd1, 0x27, 0xb0, + 0xa2, 0x1a, 0x46, 0xf7, 0x62, 0x54, 0x7b, 0x81, 0x6a, 0xbf, 0x13, 0xa6, 0xbd, 0x42, 0x64, 0x46, + 0xd5, 0x23, 0x75, 0x8c, 0x8a, 0x9a, 0x20, 0x1a, 0x26, 0x36, 0x54, 0x13, 0x2b, 0x86, 0xa9, 0x1b, + 0xba, 0xa5, 0x76, 0x4b, 0x45, 0xaa, 0xfb, 0x56, 0x98, 0xee, 0x03, 0xc6, 0x7f, 0xc0, 0xd9, 0x1b, + 0x11, 0xb9, 0x68, 0x04, 0x49, 0x4c, 0xab, 0xde, 0xc2, 0x96, 0xe5, 0x69, 0x15, 0x67, 0x69, 0xa5, + 0xfc, 0x41, 0xad, 0x01, 0x12, 0xaa, 0x43, 0x16, 0x0f, 0x89, 0xb8, 0x72, 0xae, 0xdb, 0xb8, 0xb4, + 0x44, 0x15, 0x4a, 0xa1, 0xe7, 0x8c, 0xb2, 0x1e, 0xeb, 0x36, 0x6e, 0x44, 0x64, 0xc0, 0x6e, 0x0b, + 0xa9, 0x70, 0xe9, 0x1c, 0x9b, 0xda, 0xe9, 0x05, 0x55, 0xa3, 0xd0, 0x1e, 0xe2, 0x0f, 0x4a, 0x88, + 0x2a, 0x7c, 0x25, 0x4c, 0xe1, 0x31, 0x15, 0x22, 0x2a, 0xea, 0x8e, 0x48, 0x23, 0x22, 0x2f, 0x9f, + 0x8f, 0x93, 0x89, 0x89, 0x9d, 0x6a, 0x7d, 0xb5, 0xab, 0x7d, 0x8e, 0x15, 0xea, 0xe0, 0x4a, 0xcb, + 0xd3, 0x4d, 0xec, 0x01, 0xe7, 0xae, 0x12, 0x66, 0x62, 0x62, 0xa7, 0x7e, 0x42, 0x35, 0x05, 0x89, + 0x73, 0xb5, 0x3b, 0xc0, 0x3b, 0xf1, 0x74, 0x52, 0x4c, 0xed, 0xc4, 0xd3, 0x69, 0x31, 0xb3, 0x13, + 0x4f, 0x67, 0x44, 0xd8, 0x89, 0xa7, 0x41, 0xcc, 0x4a, 0xb7, 0x20, 0xeb, 0x73, 0x2f, 0xa8, 0x04, + 0xa9, 0x1e, 0xb6, 0x2c, 0xf5, 0x0c, 0x53, 0x6f, 0x94, 0x91, 0x9d, 0xa6, 0x54, 0x80, 0x9c, 0xdf, + 0xa5, 0x48, 0x5f, 0x09, 0xae, 0x24, 0xf1, 0x16, 0x44, 0x92, 0xbb, 0x47, 0x47, 0x92, 0x37, 0xd1, + 0x4d, 0xc8, 0xd3, 0xa9, 0x28, 0x4e, 0x3f, 0x71, 0x59, 0x71, 0x39, 0x47, 0x89, 0xc7, 0x9c, 0x69, + 0x0d, 0xb2, 0xc6, 0x5d, 0xc3, 0x65, 0x89, 0x51, 0x16, 0x30, 0xee, 0x1a, 0x0e, 0xc3, 0x0b, 0x90, + 0x23, 0xf3, 0x76, 0x39, 0xe2, 0xf4, 0x23, 0x59, 0x42, 0xe3, 0x2c, 0xd2, 0xff, 0xc7, 0x40, 0x1c, + 0x75, 0x43, 0xe8, 0x6d, 0x88, 0x13, 0x8f, 0xcc, 0x9d, 0x6b, 0x79, 0x83, 0xb9, 0xeb, 0x0d, 0xc7, + 0x5d, 0x6f, 0x34, 0x1d, 0x77, 0x5d, 0x4d, 0x7f, 0xf3, 0x74, 0x2d, 0xf2, 0xd5, 0x9f, 0xd7, 0x04, + 0x99, 0x4a, 0xa0, 0xab, 0xc4, 0xf9, 0xa8, 0x5a, 0x5f, 0xd1, 0xda, 0x74, 0xc8, 0x19, 0xe2, 0x59, + 0x54, 0xad, 0xbf, 0xdd, 0x46, 0xbb, 0x20, 0xb6, 0xf4, 0xbe, 0x85, 0xfb, 0xd6, 0xc0, 0x52, 0x58, + 0xb8, 0xe0, 0x2e, 0x35, 0xe0, 0x18, 0x59, 0x9c, 0xa8, 0x39, 0x9c, 0x07, 0x94, 0x51, 0x2e, 0xb6, + 0x82, 0x04, 0xb4, 0x07, 0xf9, 0x73, 0xb5, 0xab, 0xb5, 0x55, 0x5b, 0x37, 0x15, 0x0b, 0xdb, 0xdc, + 0xc7, 0xde, 0x1c, 0xdb, 0xf3, 0x63, 0x87, 0xeb, 0x10, 0xdb, 0x47, 0x46, 0x5b, 0xb5, 0x71, 0x35, + 0xfe, 0xcd, 0xd3, 0x35, 0x41, 0xce, 0x9d, 0xfb, 0x7a, 0xd0, 0x4b, 0x50, 0x54, 0x0d, 0x43, 0xb1, + 0x6c, 0xd5, 0xc6, 0xca, 0xc9, 0x85, 0x8d, 0x2d, 0xea, 0x76, 0x73, 0x72, 0x5e, 0x35, 0x8c, 0x43, + 0x42, 0xad, 0x12, 0x22, 0x7a, 0x11, 0x0a, 0xc4, 0x43, 0x6b, 0x6a, 0x57, 0xe9, 0x60, 0xed, 0xac, + 0x63, 0x97, 0x92, 0xeb, 0xc2, 0xed, 0x98, 0x9c, 0xe7, 0xd4, 0x06, 0x25, 0xa2, 0x0d, 0x58, 0x76, + 0xd8, 0x5a, 0xba, 0x89, 0x1d, 0x5e, 0xe2, 0x8f, 0xf3, 0xf2, 0x12, 0xef, 0xaa, 0xe9, 0x26, 0x66, + 0xfc, 0x52, 0xdb, 0xb5, 0x14, 0xea, 0xcd, 0x11, 0x82, 0x78, 0x5b, 0xb5, 0x55, 0xba, 0x03, 0x39, + 0x99, 0xfe, 0x26, 0x34, 0x43, 0xb5, 0x3b, 0x7c, 0x5d, 0xe9, 0x6f, 0x74, 0x19, 0x92, 0x5c, 0x75, + 0x8c, 0x0e, 0x83, 0xb7, 0xd0, 0x0a, 0x24, 0x0c, 0x53, 0x3f, 0xc7, 0x74, 0x59, 0xd2, 0x32, 0x6b, + 0x48, 0x32, 0x14, 0x82, 0x9e, 0x1f, 0x15, 0x20, 0x6a, 0x0f, 0xf9, 0x57, 0xa2, 0xf6, 0x10, 0xbd, + 0x0e, 0x71, 0xb2, 0x01, 0xf4, 0x1b, 0x85, 0x09, 0xb1, 0x8e, 0xcb, 0x35, 0x2f, 0x0c, 0x2c, 0x53, + 0x4e, 0xe9, 0x32, 0xac, 0x4c, 0x8a, 0x04, 0x52, 0xc7, 0xa5, 0x07, 0x3c, 0x3a, 0x7a, 0x13, 0xd2, + 0x6e, 0x28, 0x60, 0xf6, 0x75, 0x75, 0xec, 0x2b, 0x0e, 0xb3, 0xec, 0xb2, 0x12, 0xc3, 0x22, 0xfb, + 0xd3, 0x51, 0x79, 0xf8, 0xce, 0xc9, 0x29, 0xd5, 0x30, 0x1a, 0xaa, 0xd5, 0x91, 0xce, 0xa0, 0x14, + 0xe6, 0xe6, 0x7d, 0xeb, 0x23, 0xd0, 0xd3, 0xe1, 0xac, 0x8f, 0xef, 0xe4, 0x45, 0xe9, 0x9e, 0xb8, + 0x27, 0x8f, 0x5a, 0xf0, 0xa0, 0xff, 0x98, 0x58, 0x70, 0x8c, 0x7d, 0x88, 0xb6, 0xb7, 0xdb, 0x52, + 0x1b, 0xae, 0x86, 0x7a, 0xfc, 0x80, 0x9c, 0x10, 0x90, 0x23, 0x9b, 0xc1, 0xe2, 0x08, 0x1b, 0x38, + 0x6b, 0x90, 0xa1, 0x59, 0x74, 0xde, 0xf4, 0x33, 0x19, 0x99, 0xb7, 0xa4, 0x1f, 0xe2, 0x70, 0x79, + 0xb2, 0xf3, 0x47, 0xeb, 0x90, 0xeb, 0xa9, 0x43, 0xc5, 0x1e, 0x72, 0x0b, 0x15, 0xe8, 0x9e, 0x43, + 0x4f, 0x1d, 0x36, 0x87, 0xcc, 0x3c, 0x45, 0x88, 0xd9, 0x43, 0xab, 0x14, 0x5d, 0x8f, 0xdd, 0xce, + 0xc9, 0xe4, 0x27, 0x7a, 0x04, 0x4b, 0x5d, 0xbd, 0xa5, 0x76, 0x95, 0xae, 0x6a, 0xd9, 0x4a, 0x4b, + 0xef, 0xf5, 0x34, 0x9b, 0x9f, 0xbb, 0x6b, 0xe3, 0xdb, 0x4b, 0xbb, 0x89, 0x6f, 0xa2, 0x87, 0x24, + 0x22, 0x17, 0xa9, 0xec, 0xae, 0x6a, 0xd9, 0xac, 0x0b, 0x6d, 0x41, 0xb6, 0xa7, 0x59, 0x27, 0xb8, + 0xa3, 0x9e, 0x6b, 0xba, 0x59, 0x8a, 0xaf, 0xc7, 0x26, 0xe6, 0x44, 0x8f, 0x3c, 0x1e, 0xae, 0xc9, + 0x2f, 0xe6, 0xdb, 0x96, 0x44, 0xc0, 0x6c, 0x1d, 0xc7, 0x93, 0x5c, 0xd8, 0xf1, 0xbc, 0x0e, 0x2b, + 0x7d, 0x3c, 0xb4, 0x15, 0xf7, 0x50, 0x5b, 0xcc, 0x56, 0x52, 0x74, 0xc9, 0x11, 0xe9, 0x73, 0x3d, + 0x81, 0x45, 0xcc, 0x86, 0xec, 0x8a, 0xa9, 0x0f, 0xfa, 0xed, 0x52, 0x7a, 0x5d, 0xb8, 0x9d, 0x90, + 0x59, 0x03, 0xdd, 0x87, 0x12, 0x3d, 0xb0, 0xcc, 0x8b, 0x11, 0x6f, 0x8b, 0xdb, 0xce, 0xe9, 0xcd, + 0x50, 0x4b, 0xb9, 0x44, 0xfa, 0xa9, 0x9f, 0xdc, 0xa5, 0xbd, 0xfc, 0xc4, 0x6f, 0xc2, 0x0a, 0x8b, + 0xbe, 0xd8, 0x24, 0x61, 0x98, 0x6c, 0x12, 0x1d, 0x00, 0xd0, 0x01, 0x2c, 0x39, 0x7d, 0x07, 0xa6, + 0xde, 0x1c, 0xd2, 0xef, 0xbf, 0xee, 0x0a, 0xb4, 0x15, 0x62, 0xda, 0x8e, 0x3d, 0x66, 0xa9, 0xa1, + 0x22, 0xa7, 0xaf, 0x62, 0xb8, 0xee, 0xfc, 0xbe, 0x67, 0xb4, 0xb9, 0xf1, 0x94, 0x90, 0x77, 0x79, + 0xae, 0xd3, 0xb3, 0xe9, 0x35, 0xc8, 0x7e, 0x36, 0xd0, 0xcd, 0x41, 0x8f, 0x0d, 0x29, 0x4f, 0x87, + 0x04, 0x8c, 0x44, 0x8f, 0xd0, 0x6f, 0x13, 0x3e, 0x9b, 0x0b, 0xe6, 0x01, 0xdc, 0xa2, 0x04, 0xcf, + 0xa2, 0x0e, 0x7d, 0x03, 0xf7, 0x1b, 0x55, 0x74, 0x5e, 0xa3, 0x72, 0xe7, 0x16, 0x6e, 0x57, 0xb1, + 0x1f, 0x67, 0x57, 0x08, 0xe2, 0x74, 0x86, 0x71, 0xe6, 0x36, 0xc9, 0xef, 0x50, 0x5b, 0x73, 0xf7, + 0x3f, 0xe9, 0xdf, 0x7f, 0xc7, 0x02, 0x53, 0x3f, 0x99, 0x05, 0xa6, 0x43, 0x2d, 0xf0, 0x47, 0xdb, + 0x5a, 0x13, 0x2e, 0x8f, 0x08, 0x2a, 0x03, 0x1a, 0xda, 0xa8, 0xb5, 0x8d, 0x24, 0xfc, 0x4e, 0x40, + 0xf5, 0x29, 0x92, 0x97, 0x03, 0x7a, 0x59, 0x58, 0x0c, 0xb5, 0xe0, 0xec, 0xa2, 0x16, 0x9c, 0x9b, + 0xc7, 0x82, 0xf3, 0xcf, 0x63, 0xc1, 0x85, 0x31, 0x0b, 0x3e, 0x82, 0xa5, 0xb1, 0x54, 0xd4, 0x35, + 0x07, 0x61, 0xa2, 0x39, 0x44, 0x27, 0x9b, 0x43, 0xcc, 0x67, 0x0e, 0xd2, 0x77, 0x02, 0x94, 0xc3, + 0x33, 0xd2, 0x89, 0x1f, 0x78, 0x03, 0x2e, 0x79, 0x99, 0x89, 0x7f, 0x1d, 0x99, 0xf7, 0x47, 0x6e, + 0xa7, 0xb7, 0x90, 0x53, 0xa2, 0x38, 0x1b, 0x53, 0xdc, 0x6f, 0xa2, 0x8f, 0xa0, 0x18, 0xcc, 0xa5, + 0x49, 0xaa, 0x42, 0x8e, 0xcb, 0xbf, 0x8d, 0x1d, 0x17, 0x6f, 0x2d, 0xdc, 0x31, 0xcb, 0x85, 0x73, + 0x7f, 0xd3, 0x92, 0xfe, 0x10, 0x75, 0x23, 0x75, 0x20, 0x31, 0x46, 0xef, 0x40, 0x92, 0x9f, 0x6c, + 0x61, 0xde, 0x93, 0xcd, 0x05, 0x46, 0x4f, 0x73, 0xf4, 0xf9, 0x4e, 0x73, 0x6c, 0xe2, 0xf6, 0xc5, + 0x27, 0x2f, 0x55, 0xc2, 0xbf, 0x54, 0xaf, 0x41, 0x82, 0xdd, 0x08, 0x58, 0x40, 0xb9, 0x32, 0x7e, + 0x2e, 0xe8, 0x54, 0x65, 0xc6, 0x85, 0x2a, 0x90, 0x66, 0x59, 0xb7, 0xd6, 0xe6, 0x0e, 0xe0, 0x6a, + 0x88, 0xc4, 0xf6, 0x56, 0x35, 0xfb, 0xec, 0xe9, 0x5a, 0x8a, 0x37, 0xe4, 0x14, 0x95, 0xdb, 0x6e, + 0x4b, 0xbf, 0xcb, 0x40, 0x5a, 0xc6, 0x96, 0x41, 0x4c, 0x18, 0x55, 0x21, 0x83, 0x87, 0x2d, 0x6c, + 0xd8, 0x4e, 0x86, 0x3f, 0xf9, 0x06, 0xc5, 0xb8, 0xeb, 0x0e, 0x67, 0x23, 0x22, 0x7b, 0x62, 0xe8, + 0x1e, 0x07, 0x3a, 0xc2, 0x31, 0x0b, 0x2e, 0xee, 0x47, 0x3a, 0xde, 0x72, 0x90, 0x0e, 0x16, 0xe8, + 0x57, 0x43, 0xa5, 0x46, 0xa0, 0x8e, 0x7b, 0x1c, 0xea, 0x88, 0xcf, 0xf8, 0x58, 0x00, 0xeb, 0xa8, + 0x05, 0xb0, 0x8e, 0xc4, 0x8c, 0x69, 0x86, 0x80, 0x1d, 0x6f, 0x39, 0x60, 0x47, 0x72, 0xc6, 0x88, + 0x47, 0xd0, 0x8e, 0xff, 0x1c, 0x43, 0x3b, 0xd6, 0x43, 0x45, 0x27, 0xc0, 0x1d, 0xfb, 0x63, 0x70, + 0x47, 0x9a, 0x2a, 0x79, 0x29, 0x54, 0xc9, 0x0c, 0xbc, 0x63, 0x7f, 0x0c, 0xef, 0xc8, 0xcc, 0x50, + 0x38, 0x03, 0xf0, 0xf8, 0xdf, 0xc9, 0x80, 0x07, 0x84, 0x42, 0x12, 0x7c, 0x98, 0xf3, 0x21, 0x1e, + 0x4a, 0x08, 0xe2, 0x91, 0x0d, 0xbd, 0x9d, 0x33, 0xf5, 0x73, 0x43, 0x1e, 0x47, 0x13, 0x20, 0x0f, + 0x96, 0xbc, 0xdc, 0x0e, 0x55, 0x3e, 0x07, 0xe6, 0x71, 0x34, 0x01, 0xf3, 0xc8, 0xcf, 0x54, 0x3b, + 0x13, 0xf4, 0x78, 0x10, 0x04, 0x3d, 0x0a, 0x21, 0x77, 0x4a, 0xef, 0xc8, 0x86, 0xa0, 0x1e, 0x27, + 0x61, 0xa8, 0x07, 0x43, 0x7b, 0x5e, 0x0d, 0xd5, 0xb8, 0x00, 0xec, 0xb1, 0x3f, 0x06, 0x7b, 0x88, + 0x33, 0x2c, 0x6d, 0x4e, 0xdc, 0x43, 0x7a, 0x99, 0xc4, 0xd2, 0x11, 0xa7, 0x44, 0x1c, 0x2c, 0x36, + 0x4d, 0xdd, 0xe4, 0x48, 0x05, 0x6b, 0x48, 0xb7, 0xc9, 0xbd, 0xd5, 0x73, 0x40, 0x53, 0xb0, 0x90, + 0x22, 0xe4, 0x03, 0x4e, 0x47, 0xfa, 0x95, 0xe0, 0xc9, 0x52, 0x34, 0xc4, 0x7f, 0xe7, 0xcd, 0xf0, + 0x3b, 0xef, 0xc8, 0x3d, 0x2d, 0x13, 0xc8, 0x08, 0xfc, 0x39, 0x07, 0x07, 0x3f, 0x54, 0x2f, 0xd7, + 0xb8, 0x03, 0x4b, 0x34, 0x3b, 0x65, 0x1e, 0x3d, 0x10, 0x34, 0x8a, 0xa4, 0x83, 0xad, 0x02, 0x8b, + 0x1e, 0xaf, 0xc1, 0xb2, 0x8f, 0xd7, 0xbd, 0x68, 0x32, 0x04, 0x40, 0x74, 0xb9, 0x2b, 0xfc, 0xc6, + 0xf9, 0x97, 0xa8, 0xb7, 0x42, 0x1e, 0x6a, 0x32, 0x09, 0xe0, 0x10, 0x7e, 0x34, 0xc0, 0x11, 0x7e, + 0xe1, 0x45, 0x1f, 0xc1, 0x4a, 0x00, 0xfb, 0x70, 0x92, 0xbf, 0xd8, 0x62, 0x10, 0x48, 0xc4, 0x97, + 0x8b, 0xb8, 0x3d, 0xe8, 0x63, 0xb8, 0x46, 0xd3, 0xd8, 0x90, 0x04, 0x33, 0x3e, 0x5f, 0x82, 0x79, + 0x85, 0xe8, 0xa8, 0x4d, 0x48, 0x32, 0x43, 0x80, 0x91, 0x44, 0x18, 0x30, 0xf2, 0x37, 0xc1, 0xb3, + 0x1b, 0x17, 0x1a, 0x69, 0xe9, 0x6d, 0x66, 0x5f, 0x79, 0x99, 0xfe, 0x26, 0x97, 0x94, 0xae, 0x7e, + 0xc6, 0x4d, 0x84, 0xfc, 0x24, 0x5c, 0x2e, 0x68, 0x9f, 0xe1, 0x81, 0x6a, 0x05, 0x12, 0x5a, 0xbf, + 0x8d, 0x87, 0xdc, 0x0a, 0x58, 0x83, 0xc8, 0x3e, 0xc6, 0x17, 0x7c, 0xaf, 0xc9, 0x4f, 0xc2, 0x47, + 0x0f, 0x02, 0x8d, 0x45, 0x39, 0x99, 0x35, 0xd0, 0xdb, 0x90, 0xa1, 0x95, 0x17, 0x45, 0x37, 0x2c, + 0x1e, 0x6a, 0x02, 0x19, 0x11, 0xab, 0x92, 0x6c, 0x1c, 0x10, 0x9e, 0x7d, 0xc3, 0x92, 0xd3, 0x06, + 0xff, 0xe5, 0xcb, 0x59, 0xd2, 0x81, 0x9c, 0xe5, 0x3a, 0x64, 0xc8, 0xe8, 0x2d, 0x43, 0x6d, 0x61, + 0x1a, 0x26, 0x32, 0xb2, 0x47, 0x90, 0x7e, 0x23, 0x40, 0x71, 0x24, 0x72, 0x4d, 0x9c, 0xbb, 0x73, + 0x6c, 0xa2, 0x41, 0xa8, 0x68, 0x6c, 0xf6, 0x37, 0x00, 0xce, 0x54, 0x4b, 0x79, 0xa2, 0xf6, 0x6d, + 0xdc, 0xe6, 0x4b, 0x90, 0x39, 0x53, 0xad, 0x0f, 0x28, 0x21, 0x38, 0x98, 0xc4, 0xc8, 0x60, 0x7c, + 0x60, 0x45, 0xd2, 0x0f, 0x56, 0xa0, 0x32, 0xa4, 0x0d, 0x53, 0xd3, 0x4d, 0xcd, 0xbe, 0xa0, 0x6b, + 0x12, 0x93, 0xdd, 0xb6, 0x74, 0x00, 0x97, 0x26, 0x06, 0x4d, 0x74, 0x1f, 0x32, 0x5e, 0xbc, 0x15, + 0x68, 0x6e, 0x38, 0x05, 0x03, 0xf2, 0x78, 0xc9, 0x92, 0x5c, 0x9a, 0x18, 0x36, 0x51, 0x1d, 0x92, + 0x26, 0xb6, 0x06, 0x5d, 0x96, 0xab, 0x16, 0xee, 0xbe, 0x36, 0x5f, 0xb8, 0x25, 0xd4, 0x41, 0xd7, + 0x96, 0xb9, 0xb0, 0xf4, 0x09, 0x24, 0x19, 0x05, 0x65, 0x21, 0x75, 0xb4, 0xf7, 0x70, 0x6f, 0xff, + 0x83, 0x3d, 0x31, 0x82, 0x00, 0x92, 0x95, 0x5a, 0xad, 0x7e, 0xd0, 0x14, 0x05, 0x94, 0x81, 0x44, + 0xa5, 0xba, 0x2f, 0x37, 0xc5, 0x28, 0x21, 0xcb, 0xf5, 0x9d, 0x7a, 0xad, 0x29, 0xc6, 0xd0, 0x12, + 0xe4, 0xd9, 0x6f, 0xe5, 0xc1, 0xbe, 0xfc, 0xa8, 0xd2, 0x14, 0xe3, 0x3e, 0xd2, 0x61, 0x7d, 0x6f, + 0xab, 0x2e, 0x8b, 0x09, 0xe9, 0x0d, 0xb8, 0x1a, 0x1a, 0xa0, 0x3d, 0x98, 0x48, 0xf0, 0xc1, 0x44, + 0xd2, 0xb7, 0x51, 0x72, 0x03, 0x09, 0x8b, 0xba, 0x68, 0x67, 0x64, 0xe2, 0x77, 0x17, 0x08, 0xd9, + 0x23, 0xb3, 0x47, 0x2f, 0x42, 0xc1, 0xc4, 0xa7, 0xd8, 0x6e, 0x75, 0x58, 0x16, 0xe0, 0xe0, 0x48, + 0x79, 0x4e, 0xa5, 0x42, 0x16, 0x63, 0xfb, 0x14, 0xb7, 0x6c, 0x85, 0x19, 0x81, 0x45, 0x6f, 0xeb, + 0x19, 0xc2, 0x46, 0xa8, 0x87, 0x8c, 0x48, 0x1c, 0x34, 0x73, 0x24, 0x4c, 0x55, 0x9c, 0xaa, 0x02, + 0xea, 0x17, 0x28, 0x45, 0x7a, 0xb2, 0xd0, 0x62, 0x67, 0x20, 0x21, 0xd7, 0x9b, 0xf2, 0x87, 0x62, + 0x0c, 0x21, 0x28, 0xd0, 0x9f, 0xca, 0xe1, 0x5e, 0xe5, 0xe0, 0xb0, 0xb1, 0x4f, 0x16, 0x7b, 0x19, + 0x8a, 0xce, 0x62, 0x3b, 0xc4, 0x04, 0xba, 0x04, 0x4b, 0xb5, 0xfd, 0x47, 0x07, 0xbb, 0xf5, 0x66, + 0xdd, 0x23, 0x27, 0xa5, 0x5f, 0xc7, 0xe0, 0x4a, 0x48, 0xae, 0x81, 0xde, 0x06, 0xb0, 0x87, 0x8a, + 0x89, 0x5b, 0xba, 0xd9, 0x0e, 0x37, 0xce, 0xe6, 0x50, 0xa6, 0x1c, 0x72, 0xc6, 0xe6, 0xbf, 0xa6, + 0x3a, 0xec, 0xf7, 0xb8, 0x52, 0x32, 0x59, 0x8b, 0x63, 0x1b, 0x37, 0x26, 0x5c, 0xd6, 0x70, 0x8b, + 0x28, 0xa6, 0x7b, 0x42, 0x15, 0x53, 0x7e, 0xf4, 0x21, 0x5c, 0x19, 0x89, 0x2b, 0xdc, 0x19, 0x5b, + 0x93, 0x0a, 0x8b, 0x93, 0xc3, 0xcb, 0xa5, 0x60, 0x78, 0x61, 0xce, 0xd8, 0x9a, 0x02, 0x24, 0x24, + 0x9e, 0x03, 0x48, 0x08, 0x8b, 0x4f, 0xc9, 0x45, 0x21, 0xfa, 0x09, 0xf1, 0x49, 0xfa, 0x7b, 0x60, + 0xf3, 0x82, 0xe9, 0xdb, 0x3e, 0x24, 0x2d, 0x5b, 0xb5, 0x07, 0x16, 0x3f, 0x0c, 0xf7, 0xe7, 0xcd, + 0x05, 0x37, 0x9c, 0x1f, 0x87, 0x54, 0x5c, 0xe6, 0x6a, 0xfe, 0x25, 0xf7, 0x34, 0x6c, 0xf5, 0x13, + 0x3f, 0xc1, 0xea, 0xa3, 0x06, 0x24, 0xf1, 0x39, 0xee, 0xdb, 0x56, 0x29, 0x49, 0x67, 0x7c, 0x79, + 0x7c, 0xc6, 0xa4, 0xbb, 0x5a, 0x22, 0xf9, 0xc5, 0x5f, 0x9f, 0xae, 0x89, 0x8c, 0xfb, 0x55, 0xbd, + 0xa7, 0xd9, 0xb8, 0x67, 0xd8, 0x17, 0x32, 0x97, 0x97, 0xde, 0x84, 0x42, 0x70, 0xd1, 0xc3, 0xbd, + 0x80, 0xe7, 0x67, 0xa3, 0xd2, 0x2f, 0x05, 0x58, 0x9e, 0x80, 0x6a, 0xa0, 0xfb, 0xbc, 0x70, 0xc1, + 0x36, 0xfe, 0xe6, 0xf8, 0xea, 0x05, 0xd8, 0xbd, 0xfa, 0x05, 0x89, 0x7b, 0x5e, 0x7a, 0xce, 0xf6, + 0xd8, 0x23, 0xa0, 0x57, 0xa0, 0x68, 0x69, 0x67, 0x7d, 0xc5, 0x64, 0x00, 0x89, 0x5b, 0x14, 0x20, + 0xd9, 0x33, 0xe9, 0x70, 0x4a, 0x67, 0xed, 0x9f, 0x09, 0x42, 0x15, 0x81, 0xa8, 0x8c, 0x70, 0x4b, + 0x2d, 0x40, 0xe3, 0xb7, 0x85, 0x49, 0x10, 0x8e, 0xf0, 0x1c, 0x10, 0xce, 0x2f, 0x04, 0xb8, 0x36, + 0xe5, 0x06, 0x81, 0xde, 0x1f, 0x39, 0x17, 0xef, 0x2c, 0x72, 0xff, 0xd8, 0x60, 0xb4, 0xe0, 0xc9, + 0x90, 0xee, 0x41, 0xce, 0x4f, 0x9f, 0x6f, 0xf3, 0x76, 0xbc, 0xf0, 0x1d, 0x84, 0x9a, 0x6e, 0x42, + 0xde, 0xc4, 0x36, 0xf1, 0x41, 0x01, 0x6c, 0x2e, 0xc7, 0x88, 0x2c, 0x15, 0xdc, 0x89, 0xa7, 0x05, + 0x31, 0xea, 0xda, 0xcf, 0xef, 0x05, 0x00, 0x0f, 0x7f, 0xf2, 0xf0, 0x1f, 0xc1, 0x8f, 0xff, 0x8c, + 0xc0, 0x86, 0xd1, 0x51, 0xd8, 0x10, 0xdd, 0x82, 0x22, 0xcb, 0xf9, 0xc9, 0xbe, 0xa9, 0xf6, 0xc0, + 0xc4, 0x1c, 0x6d, 0x2a, 0x50, 0xf2, 0xa1, 0x43, 0x45, 0x1f, 0xc1, 0x55, 0xbb, 0x63, 0x62, 0xab, + 0xa3, 0x77, 0xdb, 0xca, 0xe8, 0xde, 0xb1, 0x2a, 0xc8, 0xda, 0x0c, 0xa3, 0x93, 0xaf, 0xb8, 0x1a, + 0x8e, 0x83, 0xfb, 0xf7, 0x39, 0x24, 0xe8, 0xb1, 0x21, 0x79, 0x9b, 0x6b, 0xc5, 0x19, 0x6e, 0xa0, + 0x1f, 0x03, 0xa8, 0xb6, 0x6d, 0x6a, 0x27, 0x03, 0xe2, 0x1d, 0xa2, 0xe3, 0x9f, 0xf2, 0x8e, 0x5d, + 0xc5, 0xe1, 0xab, 0x5e, 0xe7, 0xe7, 0x6f, 0xc5, 0x13, 0xf5, 0x9d, 0x41, 0x9f, 0x42, 0x69, 0x0f, + 0x0a, 0x41, 0x59, 0x27, 0x21, 0x66, 0x63, 0x08, 0x26, 0xc4, 0x2c, 0xc1, 0xe6, 0x09, 0xb1, 0x9b, + 0x4e, 0xc7, 0x58, 0x8d, 0x91, 0x36, 0xa4, 0x1f, 0x04, 0xc8, 0xf9, 0xbd, 0xde, 0xdc, 0x39, 0x2b, + 0xcf, 0xe1, 0x63, 0xe3, 0x39, 0x7c, 0xdc, 0x97, 0xc5, 0x5e, 0x85, 0x34, 0xc9, 0x62, 0x07, 0x16, + 0x6e, 0xf3, 0xca, 0x6b, 0xea, 0x4c, 0xb5, 0x8e, 0x2c, 0xdc, 0xf6, 0xf9, 0xa6, 0xd4, 0xf3, 0xf9, + 0xa6, 0x60, 0x2e, 0x9c, 0x1e, 0xc9, 0x85, 0x77, 0xe2, 0xe9, 0x84, 0x98, 0x94, 0x7d, 0xc9, 0xb4, + 0xf4, 0x85, 0x00, 0x69, 0x77, 0xbe, 0xc1, 0x92, 0x63, 0x00, 0xa1, 0x64, 0xcb, 0xc5, 0x0a, 0x8e, + 0xfc, 0xf6, 0xc1, 0x0a, 0xb0, 0x31, 0xb7, 0x00, 0xfb, 0xae, 0x9b, 0xcf, 0x85, 0x61, 0x70, 0xfe, + 0xc5, 0x75, 0x60, 0x57, 0x9e, 0xbe, 0xfe, 0x9c, 0x8f, 0x83, 0x24, 0x24, 0xe8, 0x3f, 0x20, 0xa9, + 0xb6, 0x5c, 0xe4, 0xb1, 0x30, 0x01, 0x92, 0x73, 0x58, 0x37, 0x9a, 0xc3, 0x0a, 0xe5, 0x94, 0xb9, + 0x04, 0x1f, 0x55, 0xd4, 0x19, 0x95, 0xb4, 0x4b, 0xf4, 0x32, 0x9e, 0xe0, 0x49, 0x2f, 0x00, 0x1c, + 0xed, 0x3d, 0xda, 0xdf, 0xda, 0x7e, 0xb0, 0x5d, 0xdf, 0xe2, 0x09, 0xdb, 0xd6, 0x56, 0x7d, 0x4b, + 0x8c, 0x12, 0x3e, 0xb9, 0xfe, 0x68, 0xff, 0xb8, 0xbe, 0x25, 0xc6, 0x48, 0x63, 0xab, 0xbe, 0x5b, + 0xf9, 0xb0, 0xbe, 0x25, 0xc6, 0xa5, 0x0a, 0x64, 0xdc, 0xa0, 0x43, 0x2b, 0xd5, 0xfa, 0x13, 0x6c, + 0xf2, 0xd5, 0x62, 0x0d, 0xb4, 0x0a, 0xd9, 0x71, 0xe8, 0x9c, 0xdc, 0xbf, 0x18, 0x62, 0x4e, 0xc2, + 0x40, 0xd1, 0xd5, 0xc1, 0x63, 0xd3, 0xbb, 0x90, 0x32, 0x06, 0x27, 0x8a, 0x63, 0xbb, 0x23, 0x80, + 0xb3, 0x73, 0x3d, 0x1b, 0x9c, 0x74, 0xb5, 0xd6, 0x43, 0x7c, 0xc1, 0x83, 0x5c, 0xd2, 0x18, 0x9c, + 0x3c, 0x64, 0x26, 0xce, 0x86, 0x11, 0x9d, 0x32, 0x8c, 0xd8, 0xc8, 0x30, 0xd0, 0x2d, 0xc8, 0xf5, + 0xf5, 0x36, 0x56, 0xd4, 0x76, 0xdb, 0xc4, 0x16, 0x8b, 0xdd, 0x19, 0xae, 0x39, 0x4b, 0x7a, 0x2a, + 0xac, 0x43, 0xfa, 0x4e, 0x00, 0x34, 0x1e, 0x68, 0xd1, 0x21, 0x2c, 0x79, 0xb1, 0xda, 0x49, 0x00, + 0x58, 0x24, 0x58, 0x0f, 0x0f, 0xd4, 0x81, 0x3b, 0xbc, 0x78, 0x1e, 0x24, 0x93, 0xa4, 0x6e, 0xc5, + 0x73, 0x55, 0x06, 0x9d, 0x2f, 0x5d, 0x94, 0xe8, 0x9c, 0x8b, 0x12, 0x91, 0x91, 0x2b, 0xef, 0xf6, + 0x8c, 0xba, 0xd2, 0xd8, 0x58, 0x05, 0xc6, 0x80, 0x52, 0x73, 0x4c, 0x8c, 0xcf, 0x33, 0x6c, 0x48, + 0xc2, 0xf3, 0x0c, 0x49, 0xba, 0x07, 0xe2, 0xfb, 0xee, 0xf7, 0xf9, 0x97, 0x46, 0x86, 0x29, 0x8c, + 0x0d, 0xf3, 0x1c, 0xd2, 0xc4, 0xfb, 0xd2, 0xa0, 0xf1, 0x5f, 0x90, 0x71, 0x57, 0xcf, 0x7d, 0xec, + 0x12, 0xba, 0xec, 0x7c, 0x24, 0x9e, 0x08, 0xba, 0x03, 0x4b, 0x24, 0x6e, 0x38, 0x75, 0x50, 0x86, + 0xc2, 0x45, 0xa9, 0x37, 0x2c, 0xb2, 0x8e, 0x5d, 0x07, 0x3a, 0x22, 0x31, 0x5a, 0x64, 0xb1, 0x1c, + 0xb7, 0xff, 0x19, 0x03, 0x20, 0xd7, 0xb6, 0x11, 0x30, 0x92, 0xed, 0x61, 0x3e, 0x90, 0x4c, 0x48, + 0xff, 0x17, 0x85, 0xac, 0xaf, 0x2e, 0x83, 0xfe, 0x3d, 0x90, 0x58, 0xad, 0x4f, 0xab, 0xe1, 0xf8, + 0xb2, 0xaa, 0xc0, 0xc4, 0xa2, 0x8b, 0x4f, 0x2c, 0xac, 0x22, 0xe6, 0x94, 0x67, 0xe3, 0x0b, 0x97, + 0x67, 0x5f, 0x05, 0x64, 0xeb, 0xb6, 0xda, 0x25, 0xc1, 0x5b, 0xeb, 0x9f, 0x29, 0xec, 0xb4, 0xb3, + 0x92, 0xb0, 0x48, 0x7b, 0x8e, 0x69, 0xc7, 0x01, 0xa1, 0x4b, 0x5d, 0x48, 0xbb, 0xd8, 0xc2, 0xe2, + 0x6f, 0x48, 0x26, 0x95, 0xa1, 0xcb, 0x90, 0xee, 0x61, 0x5b, 0xa5, 0x61, 0x8f, 0x61, 0x4d, 0x6e, + 0xfb, 0xce, 0x3b, 0x90, 0xf5, 0x3d, 0xac, 0x21, 0x91, 0x70, 0xaf, 0xfe, 0x81, 0x18, 0x29, 0xa7, + 0xbe, 0xfc, 0x7a, 0x3d, 0xb6, 0x87, 0x9f, 0x90, 0x4f, 0xc9, 0xf5, 0x5a, 0xa3, 0x5e, 0x7b, 0x28, + 0x0a, 0xe5, 0xec, 0x97, 0x5f, 0xaf, 0xa7, 0x64, 0x4c, 0x4b, 0x18, 0x77, 0x1e, 0x42, 0x71, 0x64, + 0x07, 0x82, 0x0e, 0x1a, 0x41, 0x61, 0xeb, 0xe8, 0x60, 0x77, 0xbb, 0x56, 0x69, 0xd6, 0x95, 0xe3, + 0xfd, 0x66, 0x5d, 0x14, 0xd0, 0x15, 0x58, 0xde, 0xdd, 0xfe, 0xef, 0x46, 0x53, 0xa9, 0xed, 0x6e, + 0xd7, 0xf7, 0x9a, 0x4a, 0xa5, 0xd9, 0xac, 0xd4, 0x1e, 0x8a, 0xd1, 0xbb, 0x7f, 0x02, 0x28, 0x56, + 0xaa, 0xb5, 0xed, 0x8a, 0x61, 0x74, 0xb5, 0x96, 0x4a, 0xdd, 0x7d, 0x0d, 0xe2, 0x14, 0xd9, 0x9d, + 0xfa, 0xc4, 0xb6, 0x3c, 0xbd, 0x2e, 0x85, 0x1e, 0x40, 0x82, 0x82, 0xbe, 0x68, 0xfa, 0x9b, 0xdb, + 0xf2, 0x8c, 0x42, 0x15, 0x19, 0x0c, 0x3d, 0x37, 0x53, 0x1f, 0xe1, 0x96, 0xa7, 0xd7, 0xad, 0xd0, + 0x2e, 0xa4, 0x1c, 0x3c, 0x6d, 0xd6, 0xcb, 0xd8, 0xf2, 0xcc, 0x62, 0x12, 0x99, 0x1a, 0xc3, 0x25, + 0xa7, 0xbf, 0xcf, 0x2d, 0xcf, 0xa8, 0x68, 0x21, 0x19, 0x32, 0x1e, 0x94, 0x3c, 0xfb, 0xa9, 0x70, + 0x79, 0x8e, 0x0a, 0x1b, 0xfa, 0x04, 0xf2, 0x41, 0xe4, 0x6d, 0xbe, 0x57, 0xbc, 0xe5, 0x39, 0xab, + 0x5f, 0x44, 0x7f, 0x10, 0x86, 0x9b, 0xef, 0x55, 0x6f, 0x79, 0xce, 0x62, 0x18, 0xfa, 0x14, 0x96, + 0xc6, 0x61, 0xb2, 0xf9, 0x1f, 0xf9, 0x96, 0x17, 0x28, 0x8f, 0xa1, 0x1e, 0xa0, 0x09, 0xf0, 0xda, + 0x02, 0x6f, 0x7e, 0xcb, 0x8b, 0x54, 0xcb, 0x50, 0x1b, 0x8a, 0xa3, 0xd0, 0xd3, 0xbc, 0x6f, 0x80, + 0xcb, 0x73, 0x57, 0xce, 0xd8, 0x57, 0x82, 0x18, 0xc9, 0xbc, 0x6f, 0x82, 0xcb, 0x73, 0x17, 0xd2, + 0xd0, 0x11, 0x80, 0xef, 0x6e, 0x3b, 0xc7, 0x1b, 0xe1, 0xf2, 0x3c, 0x25, 0x35, 0x64, 0xc0, 0xf2, + 0xa4, 0xcb, 0xec, 0x22, 0x4f, 0x86, 0xcb, 0x0b, 0x55, 0xda, 0x88, 0x3d, 0x07, 0xef, 0xa5, 0xf3, + 0x3d, 0x21, 0x2e, 0xcf, 0x59, 0x72, 0xab, 0x56, 0xbf, 0x79, 0xb6, 0x2a, 0x7c, 0xfb, 0x6c, 0x55, + 0xf8, 0xee, 0xd9, 0xaa, 0xf0, 0xd5, 0xf7, 0xab, 0x91, 0x6f, 0xbf, 0x5f, 0x8d, 0xfc, 0xf1, 0xfb, + 0xd5, 0xc8, 0xff, 0xdc, 0x3e, 0xd3, 0xec, 0xce, 0xe0, 0x64, 0xa3, 0xa5, 0xf7, 0xe8, 0x3f, 0x38, + 0x0c, 0xf5, 0x62, 0x93, 0xe9, 0x24, 0x2d, 0xdf, 0xff, 0x44, 0x4e, 0x92, 0x34, 0xd6, 0xdd, 0xfb, + 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0x62, 0x2f, 0xa1, 0x47, 0x32, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7335,6 +7336,20 @@ func (m *ResponseProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if len(m.Events) > 0 { + for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } if m.ValidatorSetUpdate != nil { { size, err := m.ValidatorSetUpdate.MarshalToSizedBuffer(dAtA[:i]) @@ -7538,20 +7553,6 @@ func (m *ResponseFinalizeBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x10 } - if len(m.Events) > 0 { - for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Events[iNdEx].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 } @@ -9352,6 +9353,12 @@ func (m *ResponseProcessProposal) Size() (n int) { l = m.ValidatorSetUpdate.Size() n += 1 + l + sovTypes(uint64(l)) } + if len(m.Events) > 0 { + for _, e := range m.Events { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } return n } @@ -9419,12 +9426,6 @@ func (m *ResponseFinalizeBlock) Size() (n int) { } var l int _ = l - if len(m.Events) > 0 { - for _, e := range m.Events { - l = e.Size() - n += 1 + l + sovTypes(uint64(l)) - } - } if m.RetainHeight != 0 { n += 1 + sovTypes(uint64(m.RetainHeight)) } @@ -15622,6 +15623,40 @@ func (m *ResponseProcessProposal) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 6: + 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 + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + 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 + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -15961,40 +15996,6 @@ func (m *ResponseFinalizeBlock) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: ResponseFinalizeBlock: 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) - } - 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.Events = append(m.Events, Event{}) - if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RetainHeight", wireType) diff --git a/cmd/tenderdash/commands/reindex_event.go b/cmd/tenderdash/commands/reindex_event.go index 961a60e635..43250430b8 100644 --- a/cmd/tenderdash/commands/reindex_event.go +++ b/cmd/tenderdash/commands/reindex_event.go @@ -202,9 +202,7 @@ func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error { NumTxs: int64(len(b.Txs)), ResultProcessProposal: *r.ProcessProposal, } - if r.FinalizeBlock != nil { - e.ResultFinalizeBlock = *r.FinalizeBlock - } + var batch *indexer.Batch if e.NumTxs > 0 { batch = indexer.NewBatch(e.NumTxs) diff --git a/internal/consensus/replay_stubs.go b/internal/consensus/replay_stubs.go index c0b52b6c2e..9fce5090a2 100644 --- a/internal/consensus/replay_stubs.go +++ b/internal/consensus/replay_stubs.go @@ -113,10 +113,7 @@ func (mock *mockProxyApp) ProcessProposal(_ context.Context, _req *abci.RequestP } func (mock *mockProxyApp) FinalizeBlock(_ context.Context, _req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) { - r := mock.abciResponses.FinalizeBlock mock.txCount++ - if r == nil { - return &abci.ResponseFinalizeBlock{}, nil - } - return r, nil + + return &abci.ResponseFinalizeBlock{}, nil } diff --git a/internal/consensus/replayer.go b/internal/consensus/replayer.go index 6cb6e3c646..5c45c5cbb1 100644 --- a/internal/consensus/replayer.go +++ b/internal/consensus/replayer.go @@ -170,7 +170,8 @@ func (r *BlockReplayer) syncStateIfItIsOneAheadOfStore(ctx context.Context, rs r return r.replayBlocks(ctx, rs, state, true) } if rs.appHeight == rs.stateHeight { - // We haven't run Commit (both the state and app are one block behind), + // Store is ahead of both App and State + // We haven't run FinalizeBlock (both the state and app are one block behind), // so replay with the real app. // NOTE: We could instead use the cs.WAL on cs.Start, // but we'd have to allow the WAL to block a block that wrote its #ENDHEIGHT @@ -182,6 +183,7 @@ func (r *BlockReplayer) syncStateIfItIsOneAheadOfStore(ctx context.Context, rs r return state.LastAppHash, nil } if rs.appHeight == rs.storeHeight { + // Store and App are ahead of State // We ran Commit, but didn't save the state, so replay with mock app. abciResponses, err := r.stateStore.LoadABCIResponses(rs.storeHeight) if err != nil { @@ -232,19 +234,18 @@ func (r *BlockReplayer) replayBlocks( var ( block *types.Block commit *types.Commit - fbResp *abci.ResponseFinalizeBlock ucState sm.CurrentRoundState ) for i := firstBlock; i <= finalBlock; i++ { block = r.store.LoadBlock(i) commit = r.store.LoadSeenCommitAt(i) - ucState, fbResp, err = r.replayBlock(ctx, block, commit, state, i) + ucState, err = r.replayBlock(ctx, block, commit, state, i) if err != nil { return nil, err } } if !mutateState { - err = r.publishEvents(block, ucState, fbResp) + err = r.publishEvents(block, ucState) if err != nil { return nil, err } @@ -271,27 +272,26 @@ func (r *BlockReplayer) replayBlock( commit *types.Commit, state sm.State, height int64, -) (sm.CurrentRoundState, *abci.ResponseFinalizeBlock, error) { +) (sm.CurrentRoundState, error) { r.logger.Info("Replay: applying block", "height", height) // Extra check to ensure the app was not changed in a way it shouldn't have. ucState, err := r.blockExec.ProcessProposal(ctx, block, commit.Round, state, false) if err != nil { - return sm.CurrentRoundState{}, nil, fmt.Errorf("blockReplayer process proposal: %w", err) + return sm.CurrentRoundState{}, fmt.Errorf("blockReplayer process proposal: %w", err) } - // We emit events for the index services at the final block due to the sync issue when // the node shutdown during the block committing status. // For all other cases, we disable emitting events by providing blockExec=nil in ExecReplayedCommitBlock - fbResp, err := sm.ExecReplayedCommitBlock(ctx, r.appClient, block, commit, r.logger) + _, err = sm.ExecReplayedCommitBlock(ctx, r.appClient, block, commit, r.logger) if err != nil { - return sm.CurrentRoundState{}, nil, err + return sm.CurrentRoundState{}, err } // Extra check to ensure the app was not changed in a way it shouldn't have. if err := checkAppHashEqualsOneFromBlock(ucState.AppHash, block); err != nil { - return sm.CurrentRoundState{}, nil, err + return sm.CurrentRoundState{}, err } r.nBlocks++ - return ucState, fbResp, nil + return ucState, nil } // syncStateAt loads block's data for a height H to sync it with the application. @@ -372,10 +372,9 @@ func (r *BlockReplayer) execInitChain(ctx context.Context, rs *replayState, stat func (r *BlockReplayer) publishEvents( block *types.Block, ucState sm.CurrentRoundState, - fbResp *abci.ResponseFinalizeBlock, ) error { blockID := block.BlockID(nil) - es := sm.NewFullEventSet(block, blockID, ucState, fbResp, ucState.NextValidators) + es := sm.NewFullEventSet(block, blockID, ucState, ucState.NextValidators) err := es.Publish(r.publisher) if err != nil { r.logger.Error("failed publishing event", "err", err) diff --git a/internal/eventbus/event_bus.go b/internal/eventbus/event_bus.go index 05dbdcbc82..9cffd1475a 100644 --- a/internal/eventbus/event_bus.go +++ b/internal/eventbus/event_bus.go @@ -82,7 +82,7 @@ func (b *EventBus) Publish(eventValue string, eventData types.EventData) error { } func (b *EventBus) PublishEventNewBlock(data types.EventDataNewBlock) error { - events := data.ResultFinalizeBlock.Events + events := data.ResultProcessProposal.Events // add Tendermint-reserved new block event events = append(events, types.EventNewBlock) @@ -93,7 +93,7 @@ func (b *EventBus) PublishEventNewBlock(data types.EventDataNewBlock) error { func (b *EventBus) PublishEventNewBlockHeader(data types.EventDataNewBlockHeader) error { // no explicit deadline for publishing events - events := data.ResultFinalizeBlock.Events + events := data.ResultProcessProposal.Events // add Tendermint-reserved new block header event events = append(events, types.EventNewBlockHeader) diff --git a/internal/eventbus/event_bus_test.go b/internal/eventbus/event_bus_test.go index 8e28b9b288..d993a25a0e 100644 --- a/internal/eventbus/event_bus_test.go +++ b/internal/eventbus/event_bus_test.go @@ -86,7 +86,7 @@ func TestEventBusPublishEventNewBlock(t *testing.T) { bps, err := block.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} - resultFinalizeBlock := abci.ResponseFinalizeBlock{ + respProcessProposal := abci.ResponseProcessProposal{ Events: []abci.Event{ {Type: "testType", Attributes: []abci.EventAttribute{ {Key: "baz", Value: "1"}, @@ -112,13 +112,13 @@ func TestEventBusPublishEventNewBlock(t *testing.T) { edt := msg.Data().(types.EventDataNewBlock) assert.Equal(t, block, edt.Block) assert.Equal(t, blockID, edt.BlockID) - assert.Equal(t, resultFinalizeBlock, edt.ResultFinalizeBlock) + assert.Equal(t, respProcessProposal, edt.ResultProcessProposal) }() err = eventBus.PublishEventNewBlock(types.EventDataNewBlock{ - Block: block, - BlockID: blockID, - ResultFinalizeBlock: resultFinalizeBlock, + Block: block, + BlockID: blockID, + ResultProcessProposal: respProcessProposal, }) assert.NoError(t, err) @@ -256,14 +256,7 @@ func TestEventBusPublishEventNewBlockHeader(t *testing.T) { block := types.MakeBlock(0, []types.Tx{}, nil, []types.Evidence{}) block.SetDashParams(0, nil, 1, nil) - resultFinalizeBlock := abci.ResponseFinalizeBlock{ - Events: []abci.Event{ - {Type: "testType", Attributes: []abci.EventAttribute{ - {Key: "baz", Value: "1"}, - {Key: "foz", Value: "2"}, - }}, - }, - } + resultProcessProposal := abci.ResponseProcessProposal{ Status: abci.ResponseProcessProposal_ACCEPT, AppHash: make([]byte, crypto.DefaultAppHashSize), @@ -271,6 +264,12 @@ func TestEventBusPublishEventNewBlockHeader(t *testing.T) { {Code: abci.CodeTypeOK, Data: []byte("baz=1")}, {Code: abci.CodeTypeOK, Data: []byte("foz=2")}, }, + Events: []abci.Event{ + {Type: "testType", Attributes: []abci.EventAttribute{ + {Key: "baz", Value: "1"}, + {Key: "foz", Value: "2"}, + }}, + }, } // PublishEventNewBlockHeader adds the tm.event compositeKey, so the query below should work @@ -289,13 +288,11 @@ func TestEventBusPublishEventNewBlockHeader(t *testing.T) { edt := msg.Data().(types.EventDataNewBlockHeader) assert.Equal(t, block.Header, edt.Header) - assert.Equal(t, resultFinalizeBlock, edt.ResultFinalizeBlock) }() err = eventBus.PublishEventNewBlockHeader(types.EventDataNewBlockHeader{ Header: block.Header, ResultProcessProposal: resultProcessProposal, - ResultFinalizeBlock: resultFinalizeBlock, }) assert.NoError(t, err) diff --git a/internal/inspect/inspect_test.go b/internal/inspect/inspect_test.go index f5e7fcdb1b..bbbb4f9107 100644 --- a/internal/inspect/inspect_test.go +++ b/internal/inspect/inspect_test.go @@ -264,7 +264,6 @@ func TestBlockResults(t *testing.T) { testGasUsed := int64(100) stateStoreMock := &statemocks.Store{} stateStoreMock.On("LoadABCIResponses", testHeight).Return(&state.ABCIResponses{ - FinalizeBlock: &abcitypes.ResponseFinalizeBlock{}, ProcessProposal: &abcitypes.ResponseProcessProposal{ TxResults: []*abcitypes.ExecTxResult{ { diff --git a/internal/rpc/core/blocks.go b/internal/rpc/core/blocks.go index bb97effe63..434410c77e 100644 --- a/internal/rpc/core/blocks.go +++ b/internal/rpc/core/blocks.go @@ -202,7 +202,7 @@ func (env *Environment) BlockResults(_ctx context.Context, req *coretypes.Reques Height: height, TxsResults: results.ProcessProposal.TxResults, TotalGasUsed: totalGasUsed, - FinalizeBlockEvents: results.FinalizeBlock.Events, + FinalizeBlockEvents: results.ProcessProposal.Events, ValidatorSetUpdate: results.ProcessProposal.ValidatorSetUpdate, ConsensusParamUpdates: consensusParamsPtrFromProtoPtr(results.ProcessProposal.ConsensusParamUpdates), }, nil diff --git a/internal/rpc/core/blocks_test.go b/internal/rpc/core/blocks_test.go index 3138210e28..2b761c3bf3 100644 --- a/internal/rpc/core/blocks_test.go +++ b/internal/rpc/core/blocks_test.go @@ -71,7 +71,6 @@ func TestBlockchainInfo(t *testing.T) { func TestBlockResults(t *testing.T) { results := state.ABCIResponses{ - FinalizeBlock: &abci.ResponseFinalizeBlock{}, ProcessProposal: &abci.ResponseProcessProposal{ TxResults: []*abci.ExecTxResult{ {Code: 0, Data: []byte{0x01}, Log: "ok", GasUsed: 10}, @@ -102,7 +101,7 @@ func TestBlockResults(t *testing.T) { Height: 100, TxsResults: results.ProcessProposal.TxResults, TotalGasUsed: 15, - FinalizeBlockEvents: results.FinalizeBlock.Events, + FinalizeBlockEvents: results.ProcessProposal.Events, ValidatorSetUpdate: results.ProcessProposal.ValidatorSetUpdate, ConsensusParamUpdates: consensusParamsPtrFromProtoPtr(results.ProcessProposal.ConsensusParamUpdates), }}, diff --git a/internal/state/events.go b/internal/state/events.go index 50c55e1ee6..104ca2e5aa 100644 --- a/internal/state/events.go +++ b/internal/state/events.go @@ -23,14 +23,13 @@ func NewFullEventSet( block *types.Block, blockID types.BlockID, uncommittedState CurrentRoundState, - fbResp *abci.ResponseFinalizeBlock, validatorsSet *types.ValidatorSet, ) EventSet { - rpp := uncommittedState.Params.ToProcessProposal() + responseProcessProposal := uncommittedState.Params.ToProcessProposal() es := EventSet{} es. - WithNewBlock(block, blockID, *fbResp). - WthNewBlockHeader(block, *rpp, *fbResp). + WithNewBlock(block, blockID, *responseProcessProposal). + WthNewBlockHeader(block, *responseProcessProposal). WithNewEvidences(block). WithTxs(block, uncommittedState.TxResults). WithValidatorSetUpdate(validatorsSet) @@ -41,12 +40,12 @@ func NewFullEventSet( func (e *EventSet) WithNewBlock( block *types.Block, blockID types.BlockID, - fbResp abci.ResponseFinalizeBlock, + responseProcessProposal abci.ResponseProcessProposal, ) *EventSet { e.NewBlock = &types.EventDataNewBlock{ - Block: block, - BlockID: blockID, - ResultFinalizeBlock: fbResp, + Block: block, + BlockID: blockID, + ResultProcessProposal: responseProcessProposal, } return e } @@ -55,13 +54,11 @@ func (e *EventSet) WithNewBlock( func (e *EventSet) WthNewBlockHeader( block *types.Block, ppResp abci.ResponseProcessProposal, - fbResp abci.ResponseFinalizeBlock, ) *EventSet { e.NewBlockHeader = &types.EventDataNewBlockHeader{ Header: block.Header, NumTxs: int64(len(block.Txs)), ResultProcessProposal: ppResp, - ResultFinalizeBlock: fbResp, } return e } diff --git a/internal/state/events_test.go b/internal/state/events_test.go index 14e9486b95..2b4492898d 100644 --- a/internal/state/events_test.go +++ b/internal/state/events_test.go @@ -32,9 +32,8 @@ func TestEventSetError(t *testing.T) { Params: RoundParams{}, TxResults: []*abci.ExecTxResult{{}}, } - fbResp := abci.ResponseFinalizeBlock{} validatorSet := &types.ValidatorSet{} - es := NewFullEventSet(block, blockID, ucs, &fbResp, validatorSet) + es := NewFullEventSet(block, blockID, ucs, validatorSet) publisher := &mocks.BlockEventPublisher{} publisher. On("PublishEventNewBlock", mock.Anything). @@ -75,15 +74,14 @@ func TestEventSet(t *testing.T) { } blockID := types.BlockID{} ppResp := abci.ResponseProcessProposal{} - fbResp := abci.ResponseFinalizeBlock{} validatorSet := &types.ValidatorSet{} txResults := []*abci.ExecTxResult{{}, {}} publisher := &mocks.BlockEventPublisher{} publisher. On("PublishEventNewBlock", types.EventDataNewBlock{ - Block: block, - BlockID: blockID, - ResultFinalizeBlock: fbResp, + Block: block, + BlockID: blockID, + ResultProcessProposal: ppResp, }). Once(). Return(nil) @@ -92,7 +90,6 @@ func TestEventSet(t *testing.T) { Header: block.Header, NumTxs: 2, ResultProcessProposal: ppResp, - ResultFinalizeBlock: fbResp, }). Once(). Return(nil) @@ -142,8 +139,8 @@ func TestEventSet(t *testing.T) { Return(nil) es := EventSet{} es. - WithNewBlock(block, blockID, fbResp). - WthNewBlockHeader(block, ppResp, fbResp). + WithNewBlock(block, blockID, ppResp). + WthNewBlockHeader(block, ppResp). WithValidatorSetUpdate(validatorSet). WithNewEvidences(block). WithTxs(block, txResults) diff --git a/internal/state/execution.go b/internal/state/execution.go index a12599613f..1e03339454 100644 --- a/internal/state/execution.go +++ b/internal/state/execution.go @@ -488,25 +488,24 @@ func (blockExec *BlockExecutor) FinalizeBlock( if err := blockExec.ValidateBlockWithRoundState(ctx, state, uncommittedState, block); err != nil { return state, ErrInvalidBlock{err} } - startTime := time.Now().UnixNano() - fbResp, err := execBlockWithoutState(ctx, blockExec.appClient, block, commit, blockExec.logger) - if err != nil { - return state, ErrInvalidBlock{err} - } - endTime := time.Now().UnixNano() - blockExec.metrics.BlockProcessingTime.Observe(float64(endTime-startTime) / 1000000) - // Save the results before we commit. - // We need to save Prepare/ProcessProposal AND FinalizeBlock responses, as we don't have details like validators - // in FinalizeResponse. + // Save ResponseProcessProposal before FinalizeBlock to be able to recover when app state is ahead of tenderdash state + // (eg. when tenderdash fails just after receiving ResponseFinalizeBlock). abciResponses := tmstate.ABCIResponses{ ProcessProposal: uncommittedState.Params.ToProcessProposal(), - FinalizeBlock: fbResp, } if err := blockExec.store.SaveABCIResponses(block.Height, abciResponses); err != nil { return state, err } + startTime := time.Now().UnixNano() + fbResp, err := execBlockWithoutState(ctx, blockExec.appClient, block, commit, blockExec.logger) + if err != nil { + return state, ErrInvalidBlock{err} + } + endTime := time.Now().UnixNano() + blockExec.metrics.BlockProcessingTime.Observe(float64(endTime-startTime) / 1000000) + if state, err = state.Update(blockID, &block.Header, &uncommittedState); err != nil { return state, fmt.Errorf("commit failed for application: %w", err) } @@ -532,7 +531,7 @@ func (blockExec *BlockExecutor) FinalizeBlock( // Events are fired after everything else. // NOTE: if we crash between Commit and Save, events wont be fired during replay - es := NewFullEventSet(block, blockID, uncommittedState, fbResp, state.Validators) + es := NewFullEventSet(block, blockID, uncommittedState, state.Validators) if err = es.Publish(blockExec.eventPublisher); err != nil { blockExec.logger.Error("failed publishing event", "err", err) } diff --git a/internal/state/helpers_test.go b/internal/state/helpers_test.go index 3c5593a478..ae4b33e599 100644 --- a/internal/state/helpers_test.go +++ b/internal/state/helpers_test.go @@ -234,9 +234,7 @@ func (app *testApp) Info(_ context.Context, _req *abci.RequestInfo) (*abci.Respo func (app *testApp) FinalizeBlock(_ context.Context, req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) { app.Misbehavior = req.Misbehavior - return &abci.ResponseFinalizeBlock{ - Events: []abci.Event{}, - }, nil + return &abci.ResponseFinalizeBlock{}, nil } func (app *testApp) CheckTx(_ context.Context, _req *abci.RequestCheckTx) (*abci.ResponseCheckTx, error) { @@ -279,5 +277,6 @@ func (app *testApp) ProcessProposal(_ context.Context, req *abci.RequestProcessP }, TxResults: resTxs, Status: abci.ResponseProcessProposal_ACCEPT, + Events: []abci.Event{}, }, nil } diff --git a/internal/state/indexer/block/kv/kv.go b/internal/state/indexer/block/kv/kv.go index ccba695093..dd9f62764c 100644 --- a/internal/state/indexer/block/kv/kv.go +++ b/internal/state/indexer/block/kv/kv.go @@ -65,7 +65,7 @@ func (idx *BlockerIndexer) Index(bh types.EventDataNewBlockHeader) error { } // 2. index FinalizeBlock events - if err := idx.indexEvents(batch, bh.ResultFinalizeBlock.Events, "finalize_block", height); err != nil { + if err := idx.indexEvents(batch, bh.ResultProcessProposal.Events, "finalize_block", height); err != nil { return fmt.Errorf("failed to index FinalizeBlock events: %w", err) } diff --git a/internal/state/indexer/block/kv/kv_test.go b/internal/state/indexer/block/kv/kv_test.go index 20cda5a82c..4d5552745b 100644 --- a/internal/state/indexer/block/kv/kv_test.go +++ b/internal/state/indexer/block/kv/kv_test.go @@ -20,7 +20,7 @@ func TestBlockIndexer(t *testing.T) { require.NoError(t, indexer.Index(types.EventDataNewBlockHeader{ Header: types.Header{Height: 1}, - ResultFinalizeBlock: abci.ResponseFinalizeBlock{ + ResultProcessProposal: abci.ResponseProcessProposal{ Events: []abci.Event{ { Type: "finalize_event1", @@ -53,7 +53,7 @@ func TestBlockIndexer(t *testing.T) { } require.NoError(t, indexer.Index(types.EventDataNewBlockHeader{ Header: types.Header{Height: int64(i)}, - ResultFinalizeBlock: abci.ResponseFinalizeBlock{ + ResultProcessProposal: abci.ResponseProcessProposal{ Events: []abci.Event{ { Type: "finalize_event1", diff --git a/internal/state/indexer/sink/kv/kv_test.go b/internal/state/indexer/sink/kv/kv_test.go index 690e9d5be0..5ec843672d 100644 --- a/internal/state/indexer/sink/kv/kv_test.go +++ b/internal/state/indexer/sink/kv/kv_test.go @@ -34,7 +34,7 @@ func TestBlockFuncs(t *testing.T) { require.NoError(t, indexer.IndexBlockEvents(types.EventDataNewBlockHeader{ Header: types.Header{Height: 1}, - ResultFinalizeBlock: abci.ResponseFinalizeBlock{ + ResultProcessProposal: abci.ResponseProcessProposal{ Events: []abci.Event{ { Type: "finalize_eventA", @@ -72,7 +72,7 @@ func TestBlockFuncs(t *testing.T) { require.NoError(t, indexer.IndexBlockEvents(types.EventDataNewBlockHeader{ Header: types.Header{Height: int64(i)}, - ResultFinalizeBlock: abci.ResponseFinalizeBlock{ + ResultProcessProposal: abci.ResponseProcessProposal{ Events: []abci.Event{ { Type: "finalize_eventA", diff --git a/internal/state/indexer/sink/psql/psql.go b/internal/state/indexer/sink/psql/psql.go index b3f751880d..dd1c46a206 100644 --- a/internal/state/indexer/sink/psql/psql.go +++ b/internal/state/indexer/sink/psql/psql.go @@ -170,7 +170,7 @@ INSERT INTO `+tableBlocks+` (height, chain_id, created_at) return fmt.Errorf("block meta-events: %w", err) } // Insert all the block events. Order is important here, - if err := insertEvents(dbtx, blockID, 0, h.ResultFinalizeBlock.Events); err != nil { + if err := insertEvents(dbtx, blockID, 0, h.ResultProcessProposal.Events); err != nil { return fmt.Errorf("finalize-block events: %w", err) } return nil diff --git a/internal/state/indexer/sink/psql/psql_test.go b/internal/state/indexer/sink/psql/psql_test.go index 17c457530e..92549c2e77 100644 --- a/internal/state/indexer/sink/psql/psql_test.go +++ b/internal/state/indexer/sink/psql/psql_test.go @@ -227,8 +227,6 @@ func newTestBlockHeader() types.EventDataNewBlockHeader { ResultProcessProposal: abci.ResponseProcessProposal{ Status: abci.ResponseProcessProposal_ACCEPT, AppHash: make([]byte, crypto.DefaultAppHashSize), - }, - ResultFinalizeBlock: abci.ResponseFinalizeBlock{ Events: []abci.Event{ makeIndexedEvent("finalize_event.proposer", "FCAA001"), makeIndexedEvent("thingy.whatzit", "O.O"), diff --git a/internal/state/store_test.go b/internal/state/store_test.go index 153fa4bd7b..174f63ce9f 100644 --- a/internal/state/store_test.go +++ b/internal/state/store_test.go @@ -233,7 +233,6 @@ func TestPruneStates(t *testing.T) { {Data: []byte{3}}, }, }, - FinalizeBlock: &abci.ResponseFinalizeBlock{}, }) require.NoError(t, err) } diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto index 60046c011a..85c0b2fc7c 100644 --- a/proto/tendermint/abci/types.proto +++ b/proto/tendermint/abci/types.proto @@ -219,7 +219,7 @@ message RequestApplySnapshotChunk { // their propose timeout goes off. // - As a result of executing the prepared proposal, the Application may produce header events or transaction events. // The Application must keep those events until a block is decided and then pass them on to Tenderdash via -// `ResponseFinalizeBlock`. +// `ResponsePrepareProposal`. // - As a sanity check, Tenderdash will check the returned parameters for validity if the Application modified them. // In particular, `ResponsePrepareProposal.tx_records` will be deemed invalid if // - There is a duplicate transaction in the list. @@ -463,8 +463,8 @@ message RequestVerifyVoteExtension { // - The application must execute the transactions in full, in the order they appear in `RequestFinalizeBlock.txs`, // before returning control to Tenderdash. Alternatively, it can commit the candidate state corresponding to the same block // previously executed via `PrepareProposal` or `ProcessProposal`. -// - `ResponseFinalizeBlock.tx_results[i].Code == 0` only if the _i_-th transaction is fully valid. -// - Application is expected to persist its state at the end of this call, before calling `ResponseFinalizeBlock`. +// - If ProcessProposal for the same arguments have succeeded, FinalizeBlock MUST always succeed. +// - Application is expected to persist its state at the end of this call, before returning `ResponseFinalizeBlock`. // - Later calls to `Query` can return proofs about the application state anchored // in this Merkle root hash. // - Use `ResponseFinalizeBlock.retain_height` with caution! If all nodes in the network remove historical @@ -658,6 +658,9 @@ message ResponseProcessProposal { // Changes to validator set (set voting power to 0 to remove). ValidatorSetUpdate validator_set_update = 5 [(gogoproto.nullable) = true]; + + // Type & Key-Value events for indexing + repeated Event events = 6 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; } // Provides a vote extension for signing. `type` and `extension` fields are mandatory for filling @@ -698,8 +701,10 @@ message ResponseVerifyVoteExtension { } message ResponseFinalizeBlock { - // Type & Key-Value events for indexing - repeated Event events = 1 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; + // Events are moved to ProcessProposal + reserved "events"; + reserved 1; + // Blocks below this height may be removed. Defaults to `0` (retain all). int64 retain_height = 2; } diff --git a/proto/tendermint/state/types.pb.go b/proto/tendermint/state/types.pb.go index 69ed892f8c..1a53d15db6 100644 --- a/proto/tendermint/state/types.pb.go +++ b/proto/tendermint/state/types.pb.go @@ -35,7 +35,6 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // It is persisted to disk for each height before calling Commit. type ABCIResponses struct { ProcessProposal *types.ResponseProcessProposal `protobuf:"bytes,1,opt,name=process_proposal,json=processProposal,proto3" json:"process_proposal,omitempty"` - FinalizeBlock *types.ResponseFinalizeBlock `protobuf:"bytes,2,opt,name=finalize_block,json=finalizeBlock,proto3" json:"finalize_block,omitempty"` } func (m *ABCIResponses) Reset() { *m = ABCIResponses{} } @@ -78,13 +77,6 @@ func (m *ABCIResponses) GetProcessProposal() *types.ResponseProcessProposal { return nil } -func (m *ABCIResponses) GetFinalizeBlock() *types.ResponseFinalizeBlock { - if m != nil { - return m.FinalizeBlock - } - return nil -} - // ValidatorsInfo represents the latest validator set, or the last height it changed type ValidatorsInfo struct { ValidatorSet *types1.ValidatorSet `protobuf:"bytes,1,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` @@ -421,57 +413,56 @@ func init() { func init() { proto.RegisterFile("tendermint/state/types.proto", fileDescriptor_ccfacf933f22bf93) } var fileDescriptor_ccfacf933f22bf93 = []byte{ - // 799 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x3f, 0x6f, 0xfb, 0x44, - 0x18, 0x8e, 0xf9, 0xb5, 0x4d, 0x72, 0xa9, 0x93, 0xf6, 0xda, 0xc1, 0x4d, 0xa9, 0x13, 0x02, 0x54, - 0x11, 0x83, 0x23, 0x01, 0x0b, 0x0b, 0x52, 0x93, 0x0a, 0x1a, 0x51, 0xaa, 0xca, 0x45, 0x1d, 0x58, - 0xac, 0x8b, 0x7d, 0x89, 0x2d, 0x1c, 0x9f, 0xe5, 0xbb, 0x14, 0xca, 0xce, 0xde, 0x95, 0xcf, 0xc1, - 0xcc, 0xde, 0xb1, 0x23, 0x53, 0x41, 0xe9, 0x17, 0x41, 0xf7, 0xc7, 0xce, 0x39, 0x29, 0x52, 0xd1, - 0x6f, 0xcb, 0xbd, 0xcf, 0xf3, 0x3e, 0xf7, 0xe4, 0xbd, 0xe7, 0x95, 0xc1, 0x87, 0x0c, 0x27, 0x01, - 0xce, 0xe6, 0x51, 0xc2, 0x06, 0x94, 0x21, 0x86, 0x07, 0xec, 0x3e, 0xc5, 0xd4, 0x49, 0x33, 0xc2, - 0x08, 0xdc, 0x5b, 0xa1, 0x8e, 0x40, 0xdb, 0x87, 0x33, 0x32, 0x23, 0x02, 0x1c, 0xf0, 0x5f, 0x92, - 0xd7, 0x3e, 0xd6, 0x54, 0xd0, 0xc4, 0x8f, 0x74, 0x91, 0xb6, 0x7e, 0x85, 0xa8, 0x97, 0xd0, 0xe3, - 0x0d, 0x34, 0x40, 0x34, 0x54, 0x60, 0x77, 0x03, 0xbc, 0x43, 0x71, 0x14, 0x20, 0x46, 0x32, 0xc5, - 0x38, 0xd9, 0x60, 0xa4, 0x28, 0x43, 0xf3, 0x5c, 0xdd, 0xd6, 0xe0, 0x3b, 0x9c, 0xd1, 0x88, 0x24, - 0xa5, 0xdb, 0x3b, 0x33, 0x42, 0x66, 0x31, 0x1e, 0x88, 0xd3, 0x64, 0x31, 0x1d, 0xb0, 0x68, 0x8e, - 0x29, 0x43, 0xf3, 0x54, 0x12, 0x7a, 0x7f, 0x18, 0xc0, 0x3c, 0x1b, 0x8e, 0xc6, 0x2e, 0xa6, 0x29, - 0x49, 0x28, 0xa6, 0xf0, 0x06, 0xec, 0xa5, 0x19, 0xf1, 0x31, 0xa5, 0x5e, 0x9a, 0x91, 0x94, 0x50, - 0x14, 0x5b, 0x46, 0xd7, 0xe8, 0x37, 0x3e, 0xef, 0x3b, 0xda, 0xb8, 0xf8, 0x18, 0x9c, 0xbc, 0xeb, - 0x5a, 0x36, 0x5c, 0x2b, 0xbe, 0xdb, 0x4a, 0xcb, 0x05, 0xf8, 0x3d, 0x68, 0x4e, 0xa3, 0x04, 0xc5, - 0xd1, 0xaf, 0xd8, 0x9b, 0xc4, 0xc4, 0xff, 0xc9, 0xfa, 0x40, 0x48, 0x9e, 0xfe, 0xa7, 0xe4, 0x37, - 0x8a, 0x3e, 0xe4, 0x6c, 0xd7, 0x9c, 0xea, 0xc7, 0xde, 0x6f, 0x06, 0x68, 0xde, 0xe6, 0x93, 0xa2, - 0xe3, 0x64, 0x4a, 0xe0, 0x08, 0x98, 0xc5, 0xec, 0x3c, 0x8a, 0x99, 0xf2, 0x6c, 0xeb, 0x17, 0xc8, - 0xc9, 0x14, 0x8d, 0x37, 0x98, 0xb9, 0xbb, 0x77, 0xda, 0x09, 0x3a, 0xe0, 0x20, 0x46, 0x94, 0x79, - 0x21, 0x8e, 0x66, 0x21, 0xf3, 0xfc, 0x10, 0x25, 0x33, 0x1c, 0x08, 0xaf, 0xef, 0xdc, 0x7d, 0x0e, - 0x5d, 0x08, 0x64, 0x24, 0x81, 0xde, 0xef, 0x06, 0x38, 0x18, 0x71, 0xb7, 0x09, 0x5d, 0xd0, 0x6b, - 0xf1, 0x30, 0xc2, 0x8c, 0x0b, 0xf6, 0xfc, 0xbc, 0xec, 0xc9, 0x07, 0x53, 0x7e, 0x3e, 0xda, 0xf4, - 0xb3, 0x26, 0x30, 0xdc, 0x7a, 0x7c, 0xee, 0x54, 0xdc, 0x96, 0x5f, 0x2e, 0xff, 0x6f, 0x6f, 0x21, - 0xa8, 0xde, 0xca, 0x44, 0xc0, 0x33, 0x50, 0x2f, 0xd4, 0x94, 0x8f, 0x13, 0xdd, 0x87, 0x4a, 0xce, - 0xca, 0x89, 0xf2, 0xb0, 0xea, 0x82, 0x6d, 0x50, 0xa3, 0x64, 0xca, 0x7e, 0x46, 0x19, 0x16, 0x57, - 0xd6, 0xdd, 0xe2, 0xdc, 0xfb, 0xb3, 0x0a, 0xb6, 0x6f, 0xf8, 0xf6, 0xc0, 0xaf, 0x40, 0x55, 0x69, - 0xa9, 0x6b, 0x8e, 0x9c, 0xf5, 0x0d, 0x73, 0x94, 0x29, 0x75, 0x45, 0xce, 0x87, 0xa7, 0xa0, 0xe6, - 0x87, 0x28, 0x4a, 0xbc, 0x48, 0xfe, 0xa7, 0xfa, 0xb0, 0xb1, 0x7c, 0xee, 0x54, 0x47, 0xbc, 0x36, - 0x3e, 0x77, 0xab, 0x02, 0x1c, 0x07, 0xf0, 0x53, 0xd0, 0x8c, 0x92, 0x88, 0x45, 0x28, 0x56, 0x93, - 0xb0, 0xde, 0x89, 0x09, 0x98, 0xaa, 0x2a, 0x87, 0x00, 0x3f, 0x03, 0x62, 0x24, 0x32, 0x6c, 0x39, - 0x73, 0x4b, 0x30, 0x5b, 0x1c, 0x10, 0x39, 0x52, 0x5c, 0x17, 0x98, 0x1a, 0x37, 0x0a, 0xac, 0xed, - 0x4d, 0xef, 0xf2, 0xa9, 0x44, 0xd7, 0xf8, 0x7c, 0x78, 0xc0, 0xbd, 0x2f, 0x9f, 0x3b, 0x8d, 0xcb, - 0x5c, 0x6a, 0x7c, 0xee, 0x36, 0x0a, 0xdd, 0x71, 0x00, 0x2f, 0x41, 0x4b, 0xd3, 0xe4, 0x5b, 0x67, - 0xed, 0x08, 0xd5, 0xb6, 0x23, 0x57, 0xd2, 0xc9, 0x57, 0xd2, 0xf9, 0x21, 0x5f, 0xc9, 0x61, 0x8d, - 0xcb, 0x3e, 0xfc, 0xdd, 0x31, 0x5c, 0xb3, 0xd0, 0xe2, 0x28, 0xfc, 0x1a, 0x80, 0x22, 0xa7, 0xd4, - 0xaa, 0xbe, 0x29, 0xd9, 0x5a, 0x07, 0xfc, 0x56, 0xb9, 0xd1, 0x44, 0x6a, 0x6f, 0x12, 0x69, 0xf2, - 0xb6, 0xd5, 0xa6, 0xc1, 0x11, 0xb0, 0xf5, 0x10, 0xae, 0xf4, 0x8a, 0x3c, 0xd6, 0xc5, 0x8c, 0x8f, - 0x57, 0x79, 0x5c, 0x75, 0xab, 0x64, 0xbe, 0xba, 0x1d, 0xe0, 0x3d, 0xb7, 0xe3, 0x0a, 0x7c, 0x52, - 0xda, 0x8e, 0x35, 0xfd, 0xc2, 0x5e, 0x43, 0xd8, 0xeb, 0x6a, 0xeb, 0x52, 0x16, 0xca, 0x3d, 0xe6, - 0xf9, 0xc9, 0x30, 0x5d, 0xc4, 0x8c, 0x7a, 0x21, 0xa2, 0xa1, 0xb5, 0xdb, 0x35, 0xfa, 0xbb, 0x32, - 0x3f, 0xae, 0xac, 0x5f, 0x20, 0x1a, 0xc2, 0x23, 0x50, 0x43, 0x69, 0x2a, 0x29, 0xa6, 0xa0, 0x54, - 0x51, 0x9a, 0x0a, 0xe8, 0x3b, 0xf0, 0xb1, 0x90, 0xf1, 0x49, 0x86, 0x3d, 0x99, 0x6f, 0xfe, 0xa8, - 0x38, 0x28, 0x07, 0xb3, 0xd9, 0x35, 0xfa, 0xa6, 0x2b, 0x46, 0x3b, 0x22, 0x19, 0x16, 0xa1, 0xbf, - 0x14, 0x3c, 0x3d, 0xa7, 0xb7, 0xe0, 0x30, 0xc1, 0xbf, 0x6c, 0x88, 0x59, 0x2d, 0x31, 0xbb, 0xce, - 0x6b, 0xb3, 0xd3, 0xb4, 0xc4, 0xe4, 0x0c, 0x77, 0x9f, 0x4b, 0x94, 0x81, 0xab, 0xc7, 0xa5, 0x6d, - 0x3c, 0x2d, 0x6d, 0xe3, 0x9f, 0xa5, 0x6d, 0x3c, 0xbc, 0xd8, 0x95, 0xa7, 0x17, 0xbb, 0xf2, 0xd7, - 0x8b, 0x5d, 0xf9, 0xf1, 0xcb, 0x59, 0xc4, 0xc2, 0xc5, 0xc4, 0xf1, 0xc9, 0x5c, 0x7c, 0xb6, 0x52, - 0x74, 0x3f, 0x90, 0xb7, 0xf0, 0x93, 0xfc, 0xaa, 0x0c, 0xd6, 0xbf, 0xb0, 0x93, 0x1d, 0x51, 0xff, - 0xe2, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x72, 0x4b, 0x4a, 0xb6, 0x7c, 0x07, 0x00, 0x00, + // 771 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xcd, 0x4e, 0xdb, 0x4c, + 0x14, 0x8d, 0x3f, 0x7e, 0x92, 0x4c, 0x48, 0x02, 0x03, 0x0b, 0x13, 0x3e, 0x9c, 0x34, 0xfd, 0x51, + 0xd4, 0x85, 0x23, 0xb5, 0xdd, 0x74, 0x53, 0x89, 0x04, 0xa9, 0x44, 0x45, 0x08, 0x99, 0x8a, 0x45, + 0x37, 0xd6, 0xc4, 0x1e, 0x62, 0xab, 0x89, 0xc7, 0xf2, 0x4c, 0x68, 0x79, 0x80, 0xee, 0xd9, 0xf6, + 0x61, 0xba, 0x67, 0xc9, 0xb2, 0x2b, 0x5a, 0x85, 0x17, 0xa9, 0xe6, 0xc7, 0xce, 0x38, 0x61, 0x41, + 0xd5, 0x9d, 0xe7, 0x9e, 0x7b, 0xcf, 0x3d, 0x73, 0xe7, 0x5c, 0x19, 0xfc, 0xcf, 0x70, 0xe4, 0xe3, + 0x64, 0x12, 0x46, 0xac, 0x4b, 0x19, 0x62, 0xb8, 0xcb, 0xae, 0x62, 0x4c, 0xed, 0x38, 0x21, 0x8c, + 0xc0, 0xcd, 0x39, 0x6a, 0x0b, 0xb4, 0xb1, 0x33, 0x22, 0x23, 0x22, 0xc0, 0x2e, 0xff, 0x92, 0x79, + 0x8d, 0x3d, 0x8d, 0x05, 0x0d, 0xbd, 0x50, 0x27, 0x69, 0xe8, 0x2d, 0x44, 0x3c, 0x87, 0xee, 0x2d, + 0xa1, 0x3e, 0xa2, 0x81, 0x02, 0x5b, 0x4b, 0xe0, 0x25, 0x1a, 0x87, 0x3e, 0x62, 0x24, 0x51, 0x19, + 0xfb, 0x4b, 0x19, 0x31, 0x4a, 0xd0, 0x24, 0x65, 0xb7, 0x34, 0xf8, 0x12, 0x27, 0x34, 0x24, 0x51, + 0xae, 0x7b, 0x73, 0x44, 0xc8, 0x68, 0x8c, 0xbb, 0xe2, 0x34, 0x9c, 0x5e, 0x74, 0x59, 0x38, 0xc1, + 0x94, 0xa1, 0x49, 0x2c, 0x13, 0xda, 0x3e, 0xa8, 0x1e, 0xf4, 0xfa, 0x03, 0x07, 0xd3, 0x98, 0x44, + 0x14, 0x53, 0x78, 0x06, 0x36, 0xe3, 0x84, 0x78, 0x98, 0x52, 0x37, 0x4e, 0x48, 0x4c, 0x28, 0x1a, + 0x9b, 0x46, 0xcb, 0xe8, 0x54, 0x5e, 0x75, 0x6c, 0x6d, 0x5a, 0x7c, 0x0a, 0x76, 0x5a, 0x75, 0x2a, + 0x0b, 0x4e, 0x55, 0xbe, 0x53, 0x8f, 0xf3, 0x81, 0xf6, 0x37, 0x03, 0xd4, 0xce, 0xd3, 0x9b, 0xd1, + 0x41, 0x74, 0x41, 0x60, 0x1f, 0x54, 0xb3, 0xbb, 0xba, 0x14, 0x33, 0xd5, 0xc4, 0xd2, 0x9b, 0xc8, + 0x9b, 0x64, 0x85, 0x67, 0x98, 0x39, 0x1b, 0x97, 0xda, 0x09, 0xda, 0x60, 0x7b, 0x8c, 0x28, 0x73, + 0x03, 0x1c, 0x8e, 0x02, 0xe6, 0x7a, 0x01, 0x8a, 0x46, 0xd8, 0x37, 0xff, 0x6b, 0x19, 0x9d, 0x15, + 0x67, 0x8b, 0x43, 0x47, 0x02, 0xe9, 0x4b, 0xa0, 0xfd, 0xdd, 0x00, 0xdb, 0x7d, 0xae, 0x38, 0xa2, + 0x53, 0x7a, 0x2a, 0x06, 0x29, 0xc4, 0x38, 0x60, 0xd3, 0x4b, 0xc3, 0xae, 0x1c, 0xb0, 0xd2, 0xf3, + 0x64, 0x59, 0xcf, 0x02, 0x41, 0x6f, 0xf5, 0xe6, 0xae, 0x59, 0x70, 0xea, 0x5e, 0x3e, 0xfc, 0xd7, + 0xda, 0x02, 0x50, 0x3c, 0x97, 0x2f, 0x08, 0x0f, 0x40, 0x39, 0x63, 0x53, 0x3a, 0xf6, 0x75, 0x1d, + 0xea, 0xa5, 0xe7, 0x4a, 0x94, 0x86, 0x79, 0x15, 0x6c, 0x80, 0x12, 0x25, 0x17, 0xec, 0x0b, 0x4a, + 0xb0, 0x68, 0x59, 0x76, 0xb2, 0x73, 0xfb, 0x47, 0x11, 0xac, 0x9d, 0x71, 0xb7, 0xc3, 0xb7, 0xa0, + 0xa8, 0xb8, 0x54, 0x9b, 0x5d, 0x7b, 0x71, 0x23, 0x6c, 0x25, 0x4a, 0xb5, 0x48, 0xf3, 0xe1, 0x0b, + 0x50, 0xf2, 0x02, 0x14, 0x46, 0x6e, 0x28, 0xef, 0x54, 0xee, 0x55, 0x66, 0x77, 0xcd, 0x62, 0x9f, + 0xc7, 0x06, 0x87, 0x4e, 0x51, 0x80, 0x03, 0x1f, 0x3e, 0x07, 0xb5, 0x30, 0x0a, 0x59, 0x88, 0xc6, + 0x6a, 0x12, 0xe6, 0x8a, 0x98, 0x40, 0x55, 0x45, 0xe5, 0x10, 0xe0, 0x4b, 0x20, 0x46, 0xe2, 0x0e, + 0xc7, 0xc4, 0xfb, 0x9c, 0x66, 0xae, 0x8a, 0xcc, 0x3a, 0x07, 0x7a, 0x3c, 0xae, 0x72, 0x1d, 0x50, + 0xd5, 0x72, 0x43, 0xdf, 0x5c, 0x5b, 0xd6, 0x2e, 0x9f, 0x4a, 0x54, 0x0d, 0x0e, 0x7b, 0xdb, 0x5c, + 0xfb, 0xec, 0xae, 0x59, 0x39, 0x4e, 0xa9, 0x06, 0x87, 0x4e, 0x25, 0xe3, 0x1d, 0xf8, 0xf0, 0x18, + 0xd4, 0x35, 0x4e, 0xbe, 0x25, 0xe6, 0xba, 0x60, 0x6d, 0xd8, 0x72, 0x85, 0xec, 0x74, 0x85, 0xec, + 0x8f, 0xe9, 0x0a, 0xf5, 0x4a, 0x9c, 0xf6, 0xfa, 0x57, 0xd3, 0x70, 0xaa, 0x19, 0x17, 0x47, 0xe1, + 0x3b, 0x00, 0x32, 0x9f, 0x52, 0xb3, 0xf8, 0x28, 0x67, 0x6b, 0x15, 0xf0, 0xbd, 0x52, 0xa3, 0x91, + 0x94, 0x1e, 0x45, 0x52, 0xe3, 0x65, 0xf3, 0x4d, 0x83, 0x7d, 0x60, 0xe9, 0x26, 0x9c, 0xf3, 0x65, + 0x7e, 0x2c, 0x8b, 0x19, 0xef, 0xcd, 0xfd, 0x38, 0xaf, 0x56, 0xce, 0x7c, 0x70, 0x3b, 0xc0, 0x3f, + 0x6e, 0xc7, 0x09, 0x78, 0x96, 0xdb, 0x8e, 0x05, 0xfe, 0x4c, 0x5e, 0x45, 0xc8, 0x6b, 0x69, 0xeb, + 0x92, 0x27, 0x4a, 0x35, 0xa6, 0xfe, 0x49, 0x30, 0x9d, 0x8e, 0x19, 0x75, 0x03, 0x44, 0x03, 0x73, + 0xa3, 0x65, 0x74, 0x36, 0xa4, 0x7f, 0x1c, 0x19, 0x3f, 0x42, 0x34, 0x80, 0xbb, 0xa0, 0x84, 0xe2, + 0x58, 0xa6, 0x54, 0x45, 0x4a, 0x11, 0xc5, 0xb1, 0x80, 0x3e, 0x80, 0xa7, 0x82, 0xc6, 0x23, 0x09, + 0x76, 0xa5, 0xbf, 0xf9, 0xa3, 0x62, 0x3f, 0x6f, 0xcc, 0x5a, 0xcb, 0xe8, 0x54, 0x1d, 0x31, 0xda, + 0x3e, 0x49, 0xb0, 0x30, 0xfd, 0xb1, 0xc8, 0xd3, 0x7d, 0x7a, 0x0e, 0x76, 0x22, 0xfc, 0x75, 0x89, + 0xcc, 0xac, 0x8b, 0xd9, 0x35, 0x1f, 0x9a, 0x9d, 0xc6, 0x25, 0x26, 0x67, 0x38, 0x5b, 0x9c, 0x22, + 0x0f, 0x9c, 0xdc, 0xcc, 0x2c, 0xe3, 0x76, 0x66, 0x19, 0xbf, 0x67, 0x96, 0x71, 0x7d, 0x6f, 0x15, + 0x6e, 0xef, 0xad, 0xc2, 0xcf, 0x7b, 0xab, 0xf0, 0xe9, 0xcd, 0x28, 0x64, 0xc1, 0x74, 0x68, 0x7b, + 0x64, 0x22, 0x7e, 0x33, 0x31, 0xba, 0xea, 0xca, 0x2e, 0xfc, 0x24, 0xff, 0x02, 0xdd, 0xc5, 0x3f, + 0xe2, 0x70, 0x5d, 0xc4, 0x5f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x4e, 0x41, 0x27, 0x2c, + 0x07, 0x00, 0x00, } func (m *ABCIResponses) Marshal() (dAtA []byte, err error) { @@ -494,18 +485,6 @@ func (m *ABCIResponses) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.FinalizeBlock != nil { - { - size, err := m.FinalizeBlock.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } if m.ProcessProposal != nil { { size, err := m.ProcessProposal.MarshalToSizedBuffer(dAtA[:i]) @@ -734,12 +713,12 @@ func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x3a } - n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastBlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime):]) - if err10 != nil { - return 0, err10 + n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastBlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime):]) + if err9 != nil { + return 0, err9 } - i -= n10 - i = encodeVarintTypes(dAtA, i, uint64(n10)) + i -= n9 + i = encodeVarintTypes(dAtA, i, uint64(n9)) i-- dAtA[i] = 0x32 { @@ -803,10 +782,6 @@ func (m *ABCIResponses) Size() (n int) { l = m.ProcessProposal.Size() n += 1 + l + sovTypes(uint64(l)) } - if m.FinalizeBlock != nil { - l = m.FinalizeBlock.Size() - n += 1 + l + sovTypes(uint64(l)) - } return n } @@ -982,42 +957,6 @@ func (m *ABCIResponses) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FinalizeBlock", 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.FinalizeBlock == nil { - m.FinalizeBlock = &types.ResponseFinalizeBlock{} - } - if err := m.FinalizeBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/proto/tendermint/state/types.proto b/proto/tendermint/state/types.proto index 5445ac9922..7b87241a36 100644 --- a/proto/tendermint/state/types.proto +++ b/proto/tendermint/state/types.proto @@ -17,7 +17,6 @@ import "google/protobuf/timestamp.proto"; // It is persisted to disk for each height before calling Commit. message ABCIResponses { tendermint.abci.ResponseProcessProposal process_proposal = 1; - tendermint.abci.ResponseFinalizeBlock finalize_block = 2; } // ValidatorsInfo represents the latest validator set, or the last height it changed diff --git a/spec/abci++/api.md b/spec/abci++/api.md index e04abeba19..829e9e82af 100644 --- a/spec/abci++/api.md +++ b/spec/abci++/api.md @@ -391,8 +391,8 @@ Finalize newly decided block. - The application must execute the transactions in full, in the order they appear in `RequestFinalizeBlock.txs`, before returning control to Tenderdash. Alternatively, it can commit the candidate state corresponding to the same block previously executed via `PrepareProposal` or `ProcessProposal`. -- `ResponseFinalizeBlock.tx_results[i].Code == 0` only if the _i_-th transaction is fully valid. -- Application is expected to persist its state at the end of this call, before calling `ResponseFinalizeBlock`. +- If ProcessProposal for the same arguments have succeeded, FinalizeBlock MUST always succeed. +- Application is expected to persist its state at the end of this call, before returning `ResponseFinalizeBlock`. - Later calls to `Query` can return proofs about the application state anchored in this Merkle root hash. - Use `ResponseFinalizeBlock.retain_height` with caution! If all nodes in the network remove historical @@ -582,7 +582,7 @@ Prepare new block proposal, potentially altering list of transactions. their propose timeout goes off. - As a result of executing the prepared proposal, the Application may produce header events or transaction events. The Application must keep those events until a block is decided and then pass them on to Tenderdash via - `ResponseFinalizeBlock`. + `ResponsePrepareProposal`. - As a sanity check, Tenderdash will check the returned parameters for validity if the Application modified them. In particular, `ResponsePrepareProposal.tx_records` will be deemed invalid if - There is a duplicate transaction in the list. @@ -912,7 +912,6 @@ nondeterministic | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| events | [Event](#tendermint-abci-Event) | repeated | Type & Key-Value events for indexing | | retain_height | [int64](#int64) | | Blocks below this height may be removed. Defaults to `0` (retain all). | @@ -1046,6 +1045,7 @@ nondeterministic | tx_results | [ExecTxResult](#tendermint-abci-ExecTxResult) | repeated | List of structures containing the data resulting from executing the transactions. | | consensus_param_updates | [tendermint.types.ConsensusParams](#tendermint-types-ConsensusParams) | | Changes to consensus-critical gas, size, and other parameters. | | validator_set_update | [ValidatorSetUpdate](#tendermint-abci-ValidatorSetUpdate) | | Changes to validator set (set voting power to 0 to remove). | +| events | [Event](#tendermint-abci-Event) | repeated | Type & Key-Value events for indexing | diff --git a/types/events.go b/types/events.go index 90568bbc92..3be39451ef 100644 --- a/types/events.go +++ b/types/events.go @@ -126,7 +126,7 @@ type EventDataNewBlock struct { Block *Block `json:"block"` BlockID BlockID `json:"block_id"` - ResultFinalizeBlock abci.ResponseFinalizeBlock `json:"result_finalize_block"` + ResultProcessProposal abci.ResponseProcessProposal `json:"result_finalize_block"` } // TypeTag implements the required method of jsontypes.Tagged. @@ -135,7 +135,7 @@ func (EventDataNewBlock) TypeTag() string { return "tendermint/event/NewBlock" } // ABCIEvents implements the eventlog.ABCIEventer interface. func (e EventDataNewBlock) ABCIEvents() []abci.Event { base := []abci.Event{eventWithAttr(BlockHeightKey, fmt.Sprint(e.Block.Header.Height))} - return append(base, e.ResultFinalizeBlock.Events...) + return append(base, e.ResultProcessProposal.Events...) } type EventDataNewBlockHeader struct { @@ -144,7 +144,6 @@ type EventDataNewBlockHeader struct { NumTxs int64 `json:"num_txs,string"` // Number of txs in a block ResultProcessProposal abci.ResponseProcessProposal `json:"result_process_proposal"` - ResultFinalizeBlock abci.ResponseFinalizeBlock `json:"result_finalize_block"` } // TypeTag implements the required method of jsontypes.Tagged. @@ -153,7 +152,7 @@ func (EventDataNewBlockHeader) TypeTag() string { return "tendermint/event/NewBl // ABCIEvents implements the eventlog.ABCIEventer interface. func (e EventDataNewBlockHeader) ABCIEvents() []abci.Event { base := []abci.Event{eventWithAttr(BlockHeightKey, fmt.Sprint(e.Header.Height))} - return append(base, e.ResultFinalizeBlock.Events...) + return append(base, e.ResultProcessProposal.Events...) } type EventDataNewEvidence struct { diff --git a/version/version.go b/version/version.go index 38e3810150..008a74f3d4 100644 --- a/version/version.go +++ b/version/version.go @@ -11,7 +11,7 @@ const ( // when not using git describe. It is formatted with semantic versioning. TMVersionDefault = "0.14.0-dev.4" // ABCISemVer is the semantic version of the ABCI library - ABCISemVer = "0.26.1" + ABCISemVer = "0.26.2" ABCIVersion = ABCISemVer )