mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-07-20 06:52:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge latest changes from master and fix conflicts

Browse Source 
Signed-off-by: Thane Thomson <connect@thanethomson.com>
This commit is contained in:
Thane Thomson
2022-04-05 09:33:05 -04:00
parent a682cc89c1 97f7021712
commit 16b67fd9e6
46 changed files with 552 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/proto-lint.yml
+1 -1
View File
@@ -15,7 +15,7 @@ jobs:
timeout-minutes: 5
steps:
- uses: actions/checkout@v3
- uses: bufbuild/buf-setup-action@v1.3.0
- uses: bufbuild/buf-setup-action@v1.3.1
- uses: bufbuild/buf-lint-action@v1
with:
input: 'proto'
abci/client/mocks/client.go
+1
View File
@@ -6,6 +6,7 @@ import (
context "context"
mock "github.com/stretchr/testify/mock"
types "github.com/tendermint/tendermint/abci/types"
)
abci/example/kvstore/kvstore.go
+17 -14
View File
@@ -285,8 +285,7 @@ func (app *Application) PrepareProposal(req types.RequestPrepareProposal) types.
defer app.mu.Unlock()
return types.ResponsePrepareProposal{
ModifiedTxStatus: types.ResponsePrepareProposal_MODIFIED,
TxRecords: app.substPrepareTx(req.Txs),
TxRecords: app.substPrepareTx(req.Txs, req.MaxTxBytes),
}
}
@@ -434,28 +433,32 @@ func (app *Application) execPrepareTx(tx []byte) *types.ExecTxResult {
}
// substPrepareTx substitutes all the transactions prefixed with 'prepare' in the
// proposal for transactions with the prefix strips.
// proposal for transactions with the prefix stripped.
// It marks all of the original transactions as 'REMOVED' so that
// Tendermint will remove them from its mempool.
func (app *Application) substPrepareTx(blockData [][]byte) []*types.TxRecord {
trs := make([]*types.TxRecord, len(blockData))
func (app *Application) substPrepareTx(blockData [][]byte, maxTxBytes int64) []*types.TxRecord {
trs := make([]*types.TxRecord, 0, len(blockData))
var removed []*types.TxRecord
for i, tx := range blockData {
var totalBytes int64
for _, tx := range blockData {
txMod := tx
action := types.TxRecord_UNMODIFIED
if isPrepareTx(tx) {
removed = append(removed, &types.TxRecord{
Tx: tx,
Action: types.TxRecord_REMOVED,
})
trs[i] = &types.TxRecord{
Tx: bytes.TrimPrefix(tx, []byte(PreparePrefix)),
Action: types.TxRecord_ADDED,
}
continue
txMod = bytes.TrimPrefix(tx, []byte(PreparePrefix))
action = types.TxRecord_ADDED
}
trs[i] = &types.TxRecord{
Tx: tx,
Action: types.TxRecord_UNMODIFIED,
totalBytes += int64(len(txMod))
if totalBytes > maxTxBytes {
break
}
trs = append(trs, &types.TxRecord{
Tx: txMod,
Action: action,
})
}
return append(trs, removed...)
abci/types/application.go
+13 -1
View File
@@ -95,7 +95,19 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
}
func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
return ResponsePrepareProposal{ModifiedTxStatus: ResponsePrepareProposal_UNMODIFIED}
trs := make([]*TxRecord, 0, len(req.Txs))
var totalBytes int64
for _, tx := range req.Txs {
totalBytes += int64(len(tx))
if totalBytes > req.MaxTxBytes {
break
}
trs = append(trs, &TxRecord{
Action: TxRecord_UNMODIFIED,
Tx: tx,
})
}
return ResponsePrepareProposal{TxRecords: trs}
}
func (BaseApplication) ProcessProposal(req RequestProcessProposal) ResponseProcessProposal {
abci/types/mocks/application.go
+1
View File
@@ -4,6 +4,7 @@ package mocks
import (
mock "github.com/stretchr/testify/mock"
types "github.com/tendermint/tendermint/abci/types"
)
abci/types/types.go
-8
View File
@@ -51,14 +51,6 @@ func (r ResponseQuery) IsErr() bool {
return r.Code != CodeTypeOK
}
func (r ResponsePrepareProposal) IsTxStatusUnknown() bool {
return r.ModifiedTxStatus == ResponsePrepareProposal_UNKNOWN
}
func (r ResponsePrepareProposal) IsTxStatusModified() bool {
return r.ModifiedTxStatus == ResponsePrepareProposal_MODIFIED
}
func (r ResponseProcessProposal) IsAccepted() bool {
return r.Status == ResponseProcessProposal_ACCEPT
}
abci/types/types.pb.go
+228 -295
View File
@@ -160,34 +160,6 @@ func (ResponseApplySnapshotChunk_Result) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_252557cfdd89a31a, []int{35, 0}
}
type ResponsePrepareProposal_ModifiedTxStatus int32
const (
ResponsePrepareProposal_UNKNOWN ResponsePrepareProposal_ModifiedTxStatus = 0
ResponsePrepareProposal_UNMODIFIED ResponsePrepareProposal_ModifiedTxStatus = 1
ResponsePrepareProposal_MODIFIED ResponsePrepareProposal_ModifiedTxStatus = 2
)
var ResponsePrepareProposal_ModifiedTxStatus_name = map[int32]string{
0: "UNKNOWN",
1: "UNMODIFIED",
2: "MODIFIED",
}
var ResponsePrepareProposal_ModifiedTxStatus_value = map[string]int32{
"UNKNOWN": 0,
"UNMODIFIED": 1,
"MODIFIED": 2,
}
func (x ResponsePrepareProposal_ModifiedTxStatus) String() string {
return proto.EnumName(ResponsePrepareProposal_ModifiedTxStatus_name, int32(x))
}
func (ResponsePrepareProposal_ModifiedTxStatus) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_252557cfdd89a31a, []int{36, 0}
}
type ResponseProcessProposal_ProposalStatus int32
const (
@@ -2970,12 +2942,11 @@ func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string {
}
type ResponsePrepareProposal struct {
ModifiedTxStatus ResponsePrepareProposal_ModifiedTxStatus `protobuf:"varint,1,opt,name=modified_tx_status,json=modifiedTxStatus,proto3,enum=tendermint.abci.ResponsePrepareProposal_ModifiedTxStatus" json:"modified_tx_status,omitempty"`
TxRecords []*TxRecord `protobuf:"bytes,2,rep,name=tx_records,json=txRecords,proto3" json:"tx_records,omitempty"`
AppHash []byte `protobuf:"bytes,3,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
TxResults []*ExecTxResult `protobuf:"bytes,4,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
ValidatorUpdates []*ValidatorUpdate `protobuf:"bytes,5,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
ConsensusParamUpdates *types1.ConsensusParams `protobuf:"bytes,6,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
TxRecords []*TxRecord `protobuf:"bytes,1,rep,name=tx_records,json=txRecords,proto3" json:"tx_records,omitempty"`
AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
TxResults []*ExecTxResult `protobuf:"bytes,3,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
ValidatorUpdates []*ValidatorUpdate `protobuf:"bytes,4,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
ConsensusParamUpdates *types1.ConsensusParams `protobuf:"bytes,5,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
}
func (m *ResponsePrepareProposal) Reset() { *m = ResponsePrepareProposal{} }
@@ -3011,13 +2982,6 @@ func (m *ResponsePrepareProposal) XXX_DiscardUnknown() {
var xxx_messageInfo_ResponsePrepareProposal proto.InternalMessageInfo
func (m *ResponsePrepareProposal) GetModifiedTxStatus() ResponsePrepareProposal_ModifiedTxStatus {
if m != nil {
return m.ModifiedTxStatus
}
return ResponsePrepareProposal_UNKNOWN
}
func (m *ResponsePrepareProposal) GetTxRecords() []*TxRecord {
if m != nil {
return m.TxRecords
@@ -4140,7 +4104,6 @@ func init() {
proto.RegisterEnum("tendermint.abci.EvidenceType", EvidenceType_name, EvidenceType_value)
proto.RegisterEnum("tendermint.abci.ResponseOfferSnapshot_Result", ResponseOfferSnapshot_Result_name, ResponseOfferSnapshot_Result_value)
proto.RegisterEnum("tendermint.abci.ResponseApplySnapshotChunk_Result", ResponseApplySnapshotChunk_Result_name, ResponseApplySnapshotChunk_Result_value)
proto.RegisterEnum("tendermint.abci.ResponsePrepareProposal_ModifiedTxStatus", ResponsePrepareProposal_ModifiedTxStatus_name, ResponsePrepareProposal_ModifiedTxStatus_value)
proto.RegisterEnum("tendermint.abci.ResponseProcessProposal_ProposalStatus", ResponseProcessProposal_ProposalStatus_name, ResponseProcessProposal_ProposalStatus_value)
proto.RegisterEnum("tendermint.abci.ResponseVerifyVoteExtension_VerifyStatus", ResponseVerifyVoteExtension_VerifyStatus_name, ResponseVerifyVoteExtension_VerifyStatus_value)
proto.RegisterEnum("tendermint.abci.TxRecord_TxAction", TxRecord_TxAction_name, TxRecord_TxAction_value)
@@ -4203,223 +4166,220 @@ func init() {
func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
var fileDescriptor_252557cfdd89a31a = []byte{
// 3453 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5b, 0xcb, 0x73, 0x1b, 0xc7,
0xd1, 0xc7, 0xfb, 0xd1, 0x78, 0x2d, 0x87, 0xb4, 0x0c, 0xc1, 0x12, 0x29, 0xaf, 0xca, 0xb6, 0x2c,
0xdb, 0xd4, 0x67, 0xa9, 0x64, 0x4b, 0x9f, 0xec, 0xcf, 0x45, 0x82, 0x90, 0x41, 0x89, 0x22, 0xe9,
0x25, 0x28, 0x97, 0xbf, 0xef, 0x8b, 0xd6, 0x4b, 0xec, 0x10, 0x58, 0x0b, 0xc0, 0xae, 0x77, 0x17,
0x34, 0xe8, 0x53, 0x2a, 0x55, 0xbe, 0xb8, 0x52, 0x15, 0xdf, 0x92, 0xaa, 0xc4, 0x95, 0x4b, 0x52,
0x95, 0x3f, 0x21, 0xa7, 0x5c, 0x92, 0x83, 0x0f, 0x39, 0xf8, 0x96, 0x54, 0x0e, 0x4e, 0xca, 0xbe,
0xe5, 0x1f, 0xc8, 0x29, 0x4e, 0x6a, 0x1e, 0xfb, 0x02, 0x76, 0xf1, 0xb0, 0x24, 0x5f, 0x72, 0xdb,
0x69, 0x74, 0xf7, 0xee, 0xf4, 0xcc, 0x74, 0xf7, 0xaf, 0x7b, 0x00, 0xcf, 0xd8, 0x78, 0xa0, 0x62,
0xb3, 0xaf, 0x0d, 0xec, 0x2b, 0xca, 0x51, 0x5b, 0xbb, 0x62, 0x9f, 0x1a, 0xd8, 0x5a, 0x37, 0x4c,
0xdd, 0xd6, 0x51, 0xc5, 0xfb, 0x71, 0x9d, 0xfc, 0x58, 0x3b, 0xef, 0xe3, 0x6e, 0x9b, 0xa7, 0x86,
0xad, 0x5f, 0x31, 0x4c, 0x5d, 0x3f, 0x66, 0xfc, 0xb5, 0x73, 0xbe, 0x9f, 0xa9, 0x1e, 0xbf, 0xb6,
0xc0, 0xaf, 0x5c, 0xf8, 0x21, 0x3e, 0x75, 0x7e, 0x3d, 0x3f, 0x21, 0x6b, 0x28, 0xa6, 0xd2, 0x77,
0x7e, 0x5e, 0xeb, 0xe8, 0x7a, 0xa7, 0x87, 0xaf, 0xd0, 0xd1, 0xd1, 0xf0, 0xf8, 0x8a, 0xad, 0xf5,
0xb1, 0x65, 0x2b, 0x7d, 0x83, 0x33, 0xac, 0x74, 0xf4, 0x8e, 0x4e, 0x1f, 0xaf, 0x90, 0x27, 0x46,
0x15, 0xff, 0x05, 0x90, 0x95, 0xf0, 0x87, 0x43, 0x6c, 0xd9, 0xe8, 0x2a, 0xa4, 0x70, 0xbb, 0xab,
0x57, 0xe3, 0x17, 0xe2, 0x97, 0x0a, 0x57, 0xcf, 0xad, 0x8f, 0x4d, 0x6e, 0x9d, 0xf3, 0x35, 0xda,
0x5d, 0xbd, 0x19, 0x93, 0x28, 0x2f, 0xba, 0x0e, 0xe9, 0xe3, 0xde, 0xd0, 0xea, 0x56, 0x13, 0x54,
0xe8, 0x7c, 0x94, 0xd0, 0x6d, 0xc2, 0xd4, 0x8c, 0x49, 0x8c, 0x9b, 0xbc, 0x4a, 0x1b, 0x1c, 0xeb,
0xd5, 0xe4, 0xf4, 0x57, 0x6d, 0x0f, 0x8e, 0xe9, 0xab, 0x08, 0x2f, 0xda, 0x04, 0xd0, 0x06, 0x9a,
0x2d, 0xb7, 0xbb, 0x8a, 0x36, 0xa8, 0xa6, 0xa8, 0xe4, 0xb3, 0xd1, 0x92, 0x9a, 0x5d, 0x27, 0x8c,
0xcd, 0x98, 0x94, 0xd7, 0x9c, 0x01, 0xf9, 0xdc, 0x0f, 0x87, 0xd8, 0x3c, 0xad, 0xa6, 0xa7, 0x7f,
0xee, 0x3b, 0x84, 0x89, 0x7c, 0x2e, 0xe5, 0x46, 0xdb, 0x50, 0x38, 0xc2, 0x1d, 0x6d, 0x20, 0x1f,
0xf5, 0xf4, 0xf6, 0xc3, 0x6a, 0x86, 0x0a, 0x8b, 0x51, 0xc2, 0x9b, 0x84, 0x75, 0x93, 0x70, 0x6e,
0x26, 0xaa, 0xf1, 0x66, 0x4c, 0x82, 0x23, 0x97, 0x82, 0xde, 0x80, 0x5c, 0xbb, 0x8b, 0xdb, 0x0f,
0x65, 0x7b, 0x54, 0xcd, 0x52, 0x3d, 0x6b, 0x51, 0x7a, 0xea, 0x84, 0xaf, 0x35, 0x6a, 0xc6, 0xa4,
0x6c, 0x9b, 0x3d, 0xa2, 0xdb, 0x00, 0x2a, 0xee, 0x69, 0x27, 0xd8, 0x24, 0xf2, 0xb9, 0xe9, 0x36,
0xd8, 0x62, 0x9c, 0xad, 0x11, 0xff, 0x8c, 0xbc, 0xea, 0x10, 0x50, 0x1d, 0xf2, 0x78, 0xa0, 0xf2,
0xe9, 0xe4, 0xa9, 0x9a, 0x0b, 0x91, 0xeb, 0x3d, 0x50, 0xfd, 0x93, 0xc9, 0x61, 0x3e, 0x46, 0x37,
0x20, 0xd3, 0xd6, 0xfb, 0x7d, 0xcd, 0xae, 0x02, 0xd5, 0xb0, 0x1a, 0x39, 0x11, 0xca, 0xd5, 0x8c,
0x49, 0x9c, 0x1f, 0xed, 0x42, 0xb9, 0xa7, 0x59, 0xb6, 0x6c, 0x0d, 0x14, 0xc3, 0xea, 0xea, 0xb6,
0x55, 0x2d, 0x50, 0x0d, 0xcf, 0x45, 0x69, 0xd8, 0xd1, 0x2c, 0xfb, 0xc0, 0x61, 0x6e, 0xc6, 0xa4,
0x52, 0xcf, 0x4f, 0x20, 0xfa, 0xf4, 0xe3, 0x63, 0x6c, 0xba, 0x0a, 0xab, 0xc5, 0xe9, 0xfa, 0xf6,
0x08, 0xb7, 0x23, 0x4f, 0xf4, 0xe9, 0x7e, 0x02, 0xfa, 0x3f, 0x58, 0xee, 0xe9, 0x8a, 0xea, 0xaa,
0x93, 0xdb, 0xdd, 0xe1, 0xe0, 0x61, 0xb5, 0x44, 0x95, 0xbe, 0x18, 0xf9, 0x91, 0xba, 0xa2, 0x3a,
0x2a, 0xea, 0x44, 0xa0, 0x19, 0x93, 0x96, 0x7a, 0xe3, 0x44, 0xf4, 0x00, 0x56, 0x14, 0xc3, 0xe8,
0x9d, 0x8e, 0x6b, 0x2f, 0x53, 0xed, 0x97, 0xa3, 0xb4, 0x6f, 0x10, 0x99, 0x71, 0xf5, 0x48, 0x99,
0xa0, 0xa2, 0x16, 0x08, 0x86, 0x89, 0x0d, 0xc5, 0xc4, 0xb2, 0x61, 0xea, 0x86, 0x6e, 0x29, 0xbd,
0x6a, 0x85, 0xea, 0x7e, 0x21, 0x4a, 0xf7, 0x3e, 0xe3, 0xdf, 0xe7, 0xec, 0xcd, 0x98, 0x54, 0x31,
0x82, 0x24, 0xa6, 0x55, 0x6f, 0x63, 0xcb, 0xf2, 0xb4, 0x0a, 0xb3, 0xb4, 0x52, 0xfe, 0xa0, 0xd6,
0x00, 0x09, 0x35, 0xa0, 0x80, 0x47, 0x44, 0x5c, 0x3e, 0xd1, 0x6d, 0x5c, 0x5d, 0x9a, 0x7e, 0xb0,
0x1a, 0x94, 0xf5, 0xbe, 0x6e, 0x63, 0x72, 0xa8, 0xb0, 0x3b, 0x42, 0x0a, 0x3c, 0x75, 0x82, 0x4d,
0xed, 0xf8, 0x94, 0xaa, 0x91, 0xe9, 0x2f, 0x96, 0xa6, 0x0f, 0xaa, 0x88, 0x2a, 0x7c, 0x29, 0x4a,
0xe1, 0x7d, 0x2a, 0x44, 0x54, 0x34, 0x1c, 0x91, 0x66, 0x4c, 0x5a, 0x3e, 0x99, 0x24, 0x93, 0x2d,
0x76, 0xac, 0x0d, 0x94, 0x9e, 0xf6, 0x31, 0xe6, 0xc7, 0x66, 0x79, 0xfa, 0x16, 0xbb, 0xcd, 0xb9,
0xe9, 0x59, 0x21, 0x5b, 0xec, 0xd8, 0x4f, 0xd8, 0xcc, 0x42, 0xfa, 0x44, 0xe9, 0x0d, 0xb1, 0xf8,
0x02, 0x14, 0x7c, 0x8e, 0x15, 0x55, 0x21, 0xdb, 0xc7, 0x96, 0xa5, 0x74, 0x30, 0xf5, 0xc3, 0x79,
0xc9, 0x19, 0x8a, 0x65, 0x28, 0xfa, 0x9d, 0xa9, 0xf8, 0x59, 0xdc, 0x95, 0x24, 0x7e, 0x92, 0x48,
0x9e, 0x60, 0x93, 0x4e, 0x9b, 0x4b, 0xf2, 0x21, 0xba, 0x08, 0x25, 0xfa, 0xc9, 0xb2, 0xf3, 0x3b,
0x71, 0xd6, 0x29, 0xa9, 0x48, 0x89, 0xf7, 0x39, 0xd3, 0x1a, 0x14, 0x8c, 0xab, 0x86, 0xcb, 0x92,
0xa4, 0x2c, 0x60, 0x5c, 0x35, 0x1c, 0x86, 0x67, 0xa1, 0x48, 0xe6, 0xe7, 0x72, 0xa4, 0xe8, 0x4b,
0x0a, 0x84, 0xc6, 0x59, 0xc4, 0x3f, 0x26, 0x40, 0x18, 0x77, 0xc0, 0xe8, 0x06, 0xa4, 0x48, 0x2c,
0xe2, 0x61, 0xa5, 0xb6, 0xce, 0x02, 0xd5, 0xba, 0x13, 0xa8, 0xd6, 0x5b, 0x4e, 0xa0, 0xda, 0xcc,
0x7d, 0xf1, 0xd5, 0x5a, 0xec, 0xb3, 0xbf, 0xae, 0xc5, 0x25, 0x2a, 0x81, 0xce, 0x12, 0x5f, 0xa9,
0x68, 0x03, 0x59, 0x53, 0xe9, 0x27, 0xe7, 0x89, 0x23, 0x54, 0xb4, 0xc1, 0xb6, 0x8a, 0x76, 0x40,
0x68, 0xeb, 0x03, 0x0b, 0x0f, 0xac, 0xa1, 0x25, 0xb3, 0x40, 0xc8, 0x83, 0x49, 0xc0, 0x1d, 0xb2,
0xf0, 0x5a, 0x77, 0x38, 0xf7, 0x29, 0xa3, 0x54, 0x69, 0x07, 0x09, 0xc4, 0xad, 0x9e, 0x28, 0x3d,
0x4d, 0x55, 0x6c, 0xdd, 0xb4, 0xaa, 0xa9, 0x0b, 0xc9, 0x50, 0x7f, 0x78, 0xdf, 0x61, 0x39, 0x34,
0x54, 0xc5, 0xc6, 0x9b, 0x29, 0xf2, 0xb9, 0x92, 0x4f, 0x12, 0x3d, 0x0f, 0x15, 0xc5, 0x30, 0x64,
0xcb, 0x56, 0x6c, 0x2c, 0x1f, 0x9d, 0xda, 0xd8, 0xa2, 0x81, 0xa6, 0x28, 0x95, 0x14, 0xc3, 0x38,
0x20, 0xd4, 0x4d, 0x42, 0x44, 0xcf, 0x41, 0x99, 0xc4, 0x24, 0x4d, 0xe9, 0xc9, 0x5d, 0xac, 0x75,
0xba, 0x36, 0x0d, 0x29, 0x49, 0xa9, 0xc4, 0xa9, 0x4d, 0x4a, 0x14, 0x55, 0x77, 0xc5, 0x69, 0x3c,
0x42, 0x08, 0x52, 0xaa, 0x62, 0x2b, 0xd4, 0x92, 0x45, 0x89, 0x3e, 0x13, 0x9a, 0xa1, 0xd8, 0x5d,
0x6e, 0x1f, 0xfa, 0x8c, 0xce, 0x40, 0x86, 0xab, 0x4d, 0x52, 0xb5, 0x7c, 0x84, 0x56, 0x20, 0x6d,
0x98, 0xfa, 0x09, 0xa6, 0x4b, 0x97, 0x93, 0xd8, 0x40, 0xfc, 0x61, 0x02, 0x96, 0x26, 0x22, 0x17,
0xd1, 0xdb, 0x55, 0xac, 0xae, 0xf3, 0x2e, 0xf2, 0x8c, 0x5e, 0x23, 0x7a, 0x15, 0x15, 0x9b, 0x3c,
0xda, 0x57, 0x27, 0x4d, 0xdd, 0xa4, 0xbf, 0x73, 0xd3, 0x70, 0x6e, 0x74, 0x17, 0x84, 0x9e, 0x62,
0xd9, 0x32, 0xf3, 0xfe, 0xb2, 0x2f, 0xf2, 0x3f, 0x33, 0x61, 0x64, 0x16, 0x2b, 0xc8, 0x86, 0xe6,
0x4a, 0xca, 0x44, 0xd4, 0xa3, 0x22, 0x09, 0x56, 0x8e, 0x4e, 0x3f, 0x56, 0x06, 0xb6, 0x36, 0xc0,
0xf2, 0xc4, 0xaa, 0x9d, 0x9d, 0x50, 0xd8, 0x38, 0xd1, 0x54, 0x3c, 0x68, 0x3b, 0xcb, 0xb5, 0xec,
0x0a, 0xbb, 0xcb, 0x69, 0x89, 0x12, 0x94, 0x83, 0x31, 0x17, 0x95, 0x21, 0x61, 0x8f, 0xf8, 0xe4,
0x13, 0xf6, 0x08, 0xfd, 0x17, 0xa4, 0xc8, 0x04, 0xe9, 0xc4, 0xcb, 0x21, 0x09, 0x0b, 0x97, 0x6b,
0x9d, 0x1a, 0x58, 0xa2, 0x9c, 0xa2, 0xe8, 0x1e, 0x05, 0x37, 0x0e, 0x8f, 0x6b, 0x15, 0x5f, 0x84,
0xca, 0x58, 0x90, 0xf5, 0xad, 0x5d, 0xdc, 0xbf, 0x76, 0x62, 0x05, 0x4a, 0x81, 0x68, 0x2a, 0x9e,
0x81, 0x95, 0xb0, 0xe0, 0x28, 0x76, 0x5d, 0x7a, 0x20, 0xc8, 0xa1, 0xeb, 0x90, 0x73, 0xa3, 0x23,
0x3b, 0x8a, 0x93, 0xb6, 0x72, 0x98, 0x25, 0x97, 0x95, 0x9c, 0x41, 0xb2, 0xa5, 0xe9, 0x5e, 0x48,
0xd0, 0x0f, 0xcf, 0x2a, 0x86, 0xd1, 0x54, 0xac, 0xae, 0xf8, 0x3e, 0x54, 0xa3, 0x22, 0xdf, 0xd8,
0x34, 0x52, 0xee, 0x16, 0x3c, 0x03, 0x99, 0x63, 0xdd, 0xec, 0x2b, 0x36, 0x55, 0x56, 0x92, 0xf8,
0x88, 0x6c, 0x4d, 0x16, 0x05, 0x93, 0x94, 0xcc, 0x06, 0xa2, 0x0c, 0x67, 0x23, 0xa3, 0x1f, 0x11,
0xd1, 0x06, 0x2a, 0x66, 0xf6, 0x2c, 0x49, 0x6c, 0xe0, 0x29, 0x62, 0x1f, 0xcb, 0x06, 0xe4, 0xb5,
0x16, 0x9d, 0x2b, 0xd5, 0x9f, 0x97, 0xf8, 0x48, 0xfc, 0x7d, 0x02, 0xce, 0x84, 0xc7, 0xc0, 0xc7,
0x7a, 0x00, 0x04, 0x48, 0xda, 0x23, 0xe2, 0xa0, 0x92, 0x97, 0x8a, 0x12, 0x79, 0x44, 0x87, 0xb0,
0xd4, 0xd3, 0xdb, 0x4a, 0x4f, 0xf6, 0x1d, 0x0c, 0x9e, 0xd3, 0x5e, 0x9c, 0xdc, 0xc2, 0x34, 0xd2,
0x61, 0x75, 0xe2, 0x6c, 0x54, 0xa8, 0x8e, 0x1d, 0xf7, 0x80, 0x44, 0x1e, 0x8e, 0xf4, 0x77, 0x3f,
0x1c, 0xe8, 0x02, 0x14, 0xfb, 0xca, 0x48, 0xb6, 0x47, 0xdc, 0xa3, 0x31, 0x57, 0x05, 0x7d, 0x65,
0xd4, 0x1a, 0x51, 0x77, 0x26, 0xfe, 0xd2, 0x6f, 0xc5, 0x60, 0x80, 0x7f, 0xb2, 0x56, 0x3c, 0x80,
0x15, 0x96, 0x8c, 0x60, 0x35, 0xc4, 0x90, 0x73, 0x38, 0x17, 0xe4, 0x88, 0x3f, 0x59, 0x1b, 0x8a,
0x6f, 0xb9, 0x2e, 0xd6, 0xcb, 0x61, 0x42, 0x6d, 0xe3, 0x9d, 0x9b, 0x44, 0xe0, 0xf8, 0xff, 0x22,
0x0e, 0xb5, 0xe8, 0xa4, 0x25, 0x54, 0xd5, 0x4b, 0xb0, 0xe4, 0x7e, 0xbd, 0xac, 0xa8, 0xaa, 0x89,
0x2d, 0x8b, 0x9f, 0x0a, 0xc1, 0xfd, 0x61, 0x83, 0xd1, 0x23, 0x43, 0xc6, 0x73, 0x50, 0x1e, 0x4b,
0xa9, 0x52, 0x2c, 0xa0, 0x9d, 0xf8, 0xdf, 0x2f, 0xfe, 0x3c, 0xe1, 0x7a, 0x9d, 0x40, 0xde, 0xf3,
0x84, 0xd7, 0xff, 0x1d, 0x58, 0x56, 0x71, 0x5b, 0x53, 0xbf, 0xeb, 0xf2, 0x2f, 0x71, 0xe9, 0x27,
0xbc, 0xfa, 0x7f, 0x2a, 0x40, 0x4e, 0xc2, 0x96, 0x41, 0xb2, 0x0e, 0xb4, 0x09, 0x79, 0x3c, 0x6a,
0x63, 0xc3, 0x76, 0x12, 0xb5, 0xf0, 0x84, 0x97, 0x71, 0x37, 0x1c, 0x4e, 0x02, 0xdf, 0x5c, 0x31,
0x74, 0x8d, 0x23, 0xf5, 0x68, 0xd0, 0xcd, 0xc5, 0xfd, 0x50, 0xfd, 0x35, 0x07, 0xaa, 0x27, 0x23,
0xd1, 0x1a, 0x93, 0x1a, 0xc3, 0xea, 0xd7, 0x38, 0x56, 0x4f, 0xcd, 0x78, 0x59, 0x00, 0xac, 0xd7,
0x03, 0x60, 0x3d, 0x3d, 0x63, 0x9a, 0x11, 0x68, 0xfd, 0x35, 0x07, 0xad, 0x67, 0x66, 0x7c, 0xf1,
0x18, 0x5c, 0xbf, 0x13, 0x84, 0xeb, 0xd9, 0x08, 0xb7, 0xea, 0x48, 0x4f, 0xc5, 0xeb, 0x6f, 0xfa,
0xf0, 0x7a, 0x2e, 0x12, 0x28, 0x33, 0x45, 0x21, 0x80, 0xfd, 0xed, 0x00, 0x60, 0xcf, 0xcf, 0xb0,
0xc3, 0x14, 0xc4, 0xbe, 0xe5, 0x47, 0xec, 0x10, 0x09, 0xfc, 0xf9, 0xba, 0x47, 0x41, 0xf6, 0x9b,
0x2e, 0x64, 0x2f, 0x44, 0xd6, 0x1e, 0xf8, 0x5c, 0xc6, 0x31, 0xfb, 0xde, 0x04, 0x66, 0x67, 0x18,
0xfb, 0xf9, 0x48, 0x15, 0x33, 0x40, 0xfb, 0xde, 0x04, 0x68, 0x2f, 0xcd, 0x50, 0x38, 0x03, 0xb5,
0xff, 0x7f, 0x38, 0x6a, 0x8f, 0xc6, 0xd5, 0xfc, 0x33, 0xe7, 0x83, 0xed, 0x72, 0x04, 0x6c, 0xaf,
0x44, 0x42, 0x4c, 0xa6, 0x7e, 0x6e, 0xdc, 0x7e, 0x18, 0x82, 0xdb, 0x19, 0xc2, 0xbe, 0x14, 0xa9,
0x7c, 0x0e, 0xe0, 0x7e, 0x18, 0x02, 0xdc, 0x97, 0x66, 0xaa, 0x9d, 0x89, 0xdc, 0x6f, 0x07, 0x91,
0x3b, 0x9a, 0x71, 0xc6, 0x22, 0xa1, 0xfb, 0x51, 0x14, 0x74, 0x67, 0xf0, 0xfa, 0xe5, 0x48, 0x8d,
0x0b, 0x60, 0xf7, 0xbd, 0x09, 0xec, 0xbe, 0x32, 0x63, 0xa7, 0xcd, 0x0b, 0xde, 0x5f, 0x24, 0x71,
0x7d, 0xcc, 0x55, 0x93, 0x14, 0x14, 0x9b, 0xa6, 0x6e, 0x72, 0x18, 0xce, 0x06, 0xe2, 0x25, 0x02,
0xe6, 0x3c, 0xb7, 0x3c, 0x05, 0xe8, 0xd3, 0x54, 0xdf, 0xe7, 0x8a, 0xc5, 0xdf, 0xc6, 0x3d, 0x59,
0x8a, 0x81, 0xfc, 0x40, 0x30, 0xcf, 0x81, 0xa0, 0x0f, 0xfe, 0x27, 0x82, 0xf0, 0x7f, 0x0d, 0x0a,
0x24, 0x85, 0x1f, 0x43, 0xf6, 0x8a, 0xe1, 0x22, 0xfb, 0xcb, 0xb0, 0x44, 0xc3, 0x27, 0x2b, 0x12,
0xf0, 0x3c, 0x20, 0x45, 0xf3, 0x80, 0x0a, 0xf9, 0x81, 0x59, 0x81, 0x25, 0x04, 0xaf, 0xc0, 0xb2,
0x8f, 0xd7, 0x85, 0x06, 0x0c, 0xe6, 0x0a, 0x2e, 0xf7, 0x06, 0xc7, 0x08, 0x7f, 0x88, 0x7b, 0x16,
0xf2, 0x4a, 0x02, 0x61, 0xe8, 0x3d, 0xfe, 0x98, 0xd0, 0x7b, 0xe2, 0x3b, 0xa3, 0x77, 0x3f, 0xd4,
0x49, 0x06, 0xa1, 0xce, 0x3f, 0xe2, 0xde, 0x9a, 0xb8, 0x58, 0xbc, 0xad, 0xab, 0x98, 0x83, 0x0f,
0xfa, 0x4c, 0x12, 0x94, 0x9e, 0xde, 0xe1, 0x10, 0x83, 0x3c, 0x12, 0x2e, 0x37, 0x76, 0xe6, 0x79,
0x68, 0x74, 0x71, 0x4b, 0x9a, 0x5a, 0x98, 0xe3, 0x16, 0x01, 0x92, 0x0f, 0x31, 0x8b, 0x74, 0x45,
0x89, 0x3c, 0x12, 0x3e, 0xba, 0xc9, 0x68, 0xfc, 0x2a, 0x4a, 0x6c, 0x80, 0x6e, 0x40, 0x9e, 0x76,
0x14, 0x64, 0xdd, 0xb0, 0x78, 0x40, 0x0a, 0x24, 0x3a, 0xac, 0x71, 0xb0, 0xbe, 0x4f, 0x78, 0xf6,
0x0c, 0x4b, 0xca, 0x19, 0xfc, 0xc9, 0x97, 0xe2, 0xe5, 0x03, 0x29, 0xde, 0x39, 0xc8, 0x93, 0xaf,
0xb7, 0x0c, 0xa5, 0x8d, 0x69, 0x64, 0xc9, 0x4b, 0x1e, 0x41, 0x7c, 0x00, 0x68, 0x32, 0x4e, 0xa2,
0x26, 0x64, 0xf0, 0x09, 0x1e, 0xd8, 0x64, 0xd9, 0x88, 0xb9, 0xcf, 0x84, 0xe4, 0x45, 0x78, 0x60,
0x6f, 0x56, 0x89, 0x91, 0xff, 0xfe, 0xd5, 0x9a, 0xc0, 0xb8, 0x5f, 0xd6, 0xfb, 0x9a, 0x8d, 0xfb,
0x86, 0x7d, 0x2a, 0x71, 0x79, 0xf1, 0x2f, 0x09, 0x82, 0x81, 0x03, 0xf1, 0x33, 0xd4, 0xb6, 0xce,
0x96, 0x4f, 0xf8, 0x6a, 0x1f, 0xf3, 0xd9, 0xfb, 0x3c, 0x40, 0x47, 0xb1, 0xe4, 0x8f, 0x94, 0x81,
0x8d, 0x55, 0x6e, 0xf4, 0x7c, 0x47, 0xb1, 0xde, 0xa5, 0x04, 0xb2, 0xea, 0xe4, 0xe7, 0xa1, 0x85,
0x55, 0x0e, 0x6d, 0xb2, 0x1d, 0xc5, 0x3a, 0xb4, 0xb0, 0xea, 0x9b, 0x65, 0xf6, 0xd1, 0x66, 0x19,
0xb4, 0x71, 0x6e, 0xcc, 0xc6, 0x3e, 0x74, 0x9a, 0xf7, 0xa3, 0x53, 0x54, 0x83, 0x9c, 0x61, 0x6a,
0xba, 0xa9, 0xd9, 0xa7, 0x74, 0x61, 0x92, 0x92, 0x3b, 0x46, 0x17, 0xa1, 0xd4, 0xc7, 0x7d, 0x43,
0xd7, 0x7b, 0x32, 0x73, 0x36, 0x05, 0x2a, 0x5a, 0xe4, 0xc4, 0x06, 0xf5, 0x39, 0x9f, 0x24, 0xbc,
0xd3, 0xe7, 0x55, 0x21, 0x1e, 0xaf, 0x79, 0x57, 0x43, 0xcc, 0xeb, 0xa3, 0x90, 0x49, 0x8c, 0xd9,
0xd7, 0x1d, 0x7f, 0x5f, 0x06, 0x16, 0x7f, 0x4c, 0xeb, 0x92, 0xc1, 0xdc, 0x08, 0x1d, 0xf8, 0xf1,
0xd1, 0x90, 0x3a, 0x05, 0x67, 0x3b, 0xcf, 0xeb, 0x3d, 0x3c, 0x1c, 0xc5, 0xc8, 0x16, 0x7a, 0x0f,
0x9e, 0x1e, 0xf3, 0x6c, 0xae, 0xea, 0xc4, 0xbc, 0x0e, 0xee, 0xa9, 0xa0, 0x83, 0x73, 0x54, 0x7b,
0xc6, 0x4a, 0x3e, 0xe2, 0x99, 0xdb, 0x86, 0x72, 0x30, 0xcd, 0x0b, 0x5d, 0xfe, 0x8b, 0x50, 0x32,
0xb1, 0xad, 0x68, 0x03, 0x39, 0x80, 0x0c, 0x8b, 0x8c, 0xc8, 0x4b, 0x94, 0xfb, 0xf0, 0x54, 0x68,
0xba, 0x87, 0x5e, 0x87, 0xbc, 0x97, 0x29, 0xc6, 0x23, 0xc0, 0x93, 0x5b, 0x6f, 0xf2, 0x78, 0xc5,
0xdf, 0xc5, 0x3d, 0x95, 0xc1, 0x0a, 0x56, 0x03, 0x32, 0x26, 0xb6, 0x86, 0x3d, 0x56, 0x53, 0x2a,
0x5f, 0x7d, 0x65, 0xbe, 0x44, 0x91, 0x50, 0x87, 0x3d, 0x5b, 0xe2, 0xc2, 0xe2, 0x03, 0xc8, 0x30,
0x0a, 0x2a, 0x40, 0xf6, 0x70, 0xf7, 0xee, 0xee, 0xde, 0xbb, 0xbb, 0x42, 0x0c, 0x01, 0x64, 0x36,
0xea, 0xf5, 0xc6, 0x7e, 0x4b, 0x88, 0xa3, 0x3c, 0xa4, 0x37, 0x36, 0xf7, 0xa4, 0x96, 0x90, 0x20,
0x64, 0xa9, 0x71, 0xa7, 0x51, 0x6f, 0x09, 0x49, 0xb4, 0x04, 0x25, 0xf6, 0x2c, 0xdf, 0xde, 0x93,
0xee, 0x6d, 0xb4, 0x84, 0x94, 0x8f, 0x74, 0xd0, 0xd8, 0xdd, 0x6a, 0x48, 0x42, 0x5a, 0x7c, 0x15,
0xce, 0x46, 0xa6, 0x96, 0x5e, 0x79, 0x2a, 0xee, 0x2b, 0x4f, 0x89, 0x3f, 0x4b, 0x10, 0x74, 0x1f,
0x95, 0x2f, 0xa2, 0x3b, 0x63, 0x13, 0xbf, 0xba, 0x40, 0xb2, 0x39, 0x36, 0x7b, 0x02, 0xe8, 0x4d,
0x7c, 0x8c, 0xed, 0x76, 0x97, 0xe5, 0xaf, 0x2c, 0x60, 0x96, 0xa4, 0x12, 0xa7, 0x52, 0x21, 0x8b,
0xb1, 0x7d, 0x80, 0xdb, 0xb6, 0xcc, 0x7c, 0x11, 0xdb, 0x74, 0x79, 0xc2, 0x46, 0xa8, 0x07, 0x8c,
0x28, 0xbe, 0xbf, 0x90, 0x2d, 0xf3, 0x90, 0x96, 0x1a, 0x2d, 0xe9, 0x3d, 0x21, 0x89, 0x10, 0x94,
0xe9, 0xa3, 0x7c, 0xb0, 0xbb, 0xb1, 0x7f, 0xd0, 0xdc, 0x23, 0xb6, 0x5c, 0x86, 0x8a, 0x63, 0x4b,
0x87, 0x98, 0x16, 0xbf, 0x4d, 0xc2, 0xd3, 0x11, 0xd9, 0x2e, 0xea, 0x00, 0xea, 0xeb, 0xaa, 0x76,
0xac, 0x61, 0x55, 0xb6, 0x47, 0xb4, 0xec, 0x3e, 0xb4, 0xb8, 0x8d, 0x6e, 0xce, 0x9b, 0x33, 0xaf,
0xdf, 0xe3, 0x2a, 0x5a, 0xa3, 0x03, 0xaa, 0x40, 0x12, 0xfa, 0x63, 0x14, 0x74, 0x03, 0xc0, 0x1e,
0xc9, 0x26, 0x6e, 0xeb, 0xa6, 0xea, 0x64, 0x18, 0x93, 0xbb, 0xb9, 0x35, 0x92, 0x28, 0x87, 0x94,
0xb7, 0xf9, 0xd3, 0xb4, 0x9c, 0x02, 0xbd, 0xc1, 0x95, 0x12, 0xf3, 0x39, 0xe5, 0xeb, 0xf3, 0x21,
0xb5, 0x3f, 0xdc, 0x26, 0x8a, 0xe9, 0x22, 0x52, 0xc5, 0x94, 0x1f, 0xdd, 0x0b, 0xf3, 0x5e, 0xe9,
0xf9, 0xbc, 0xd7, 0x62, 0x7e, 0x2b, 0xf3, 0x68, 0x7e, 0x4b, 0x7c, 0x13, 0x84, 0x71, 0x13, 0x07,
0x77, 0x4b, 0x19, 0xe0, 0x70, 0xf7, 0xde, 0xde, 0xd6, 0xf6, 0xed, 0xed, 0xc6, 0x96, 0x10, 0x47,
0x45, 0xc8, 0xb9, 0xa3, 0x84, 0xf8, 0xab, 0xc0, 0x06, 0x08, 0x82, 0x90, 0x3d, 0xc8, 0x04, 0x16,
0xfd, 0xf5, 0x79, 0x11, 0xcd, 0xba, 0xf3, 0xc0, 0x97, 0x9c, 0xab, 0x99, 0x52, 0xed, 0x1e, 0x5b,
0xae, 0xe4, 0xe3, 0x58, 0xae, 0xd4, 0x93, 0x58, 0xae, 0xf4, 0x23, 0x2e, 0xd7, 0x75, 0x28, 0x07,
0x8d, 0x13, 0x7d, 0xb4, 0x3d, 0xdf, 0x98, 0x10, 0x6f, 0x79, 0x79, 0xa2, 0xaf, 0xc4, 0x39, 0x59,
0x3e, 0x8c, 0x87, 0x95, 0x0f, 0x7f, 0x1d, 0x87, 0x67, 0xa6, 0xe0, 0x3a, 0xf4, 0xce, 0xd8, 0x3a,
0xdf, 0x5c, 0x04, 0x15, 0xae, 0x33, 0x5a, 0x70, 0xa5, 0xc5, 0x6b, 0x50, 0xf4, 0xd3, 0xe7, 0x9b,
0xe4, 0x4f, 0x92, 0x5e, 0x6c, 0x0a, 0xd6, 0x39, 0x1f, 0x5b, 0x42, 0x3c, 0xb6, 0xcf, 0x12, 0x0b,
0xee, 0xb3, 0xd0, 0xa4, 0x26, 0xf9, 0xe4, 0x92, 0x9a, 0xd4, 0x23, 0x26, 0x35, 0xfe, 0x03, 0x97,
0x0e, 0x1e, 0xb8, 0x89, 0xfc, 0x23, 0x13, 0x92, 0x7f, 0xbc, 0x07, 0xe0, 0xeb, 0x0d, 0xae, 0x40,
0xda, 0xd4, 0x87, 0x03, 0x95, 0x6e, 0x93, 0xb4, 0xc4, 0x06, 0xe8, 0x3a, 0xa4, 0xc9, 0x76, 0x8b,
0x76, 0xdc, 0x64, 0xbb, 0xf8, 0xaa, 0xc2, 0x8c, 0x5b, 0xd4, 0x00, 0x4d, 0x36, 0x5e, 0x22, 0x5e,
0xf1, 0x66, 0xf0, 0x15, 0xcf, 0x46, 0xb6, 0x70, 0xc2, 0x5f, 0xf5, 0x31, 0xa4, 0xe9, 0xf6, 0x20,
0x79, 0x18, 0x6d, 0x33, 0x72, 0x60, 0x4f, 0x9e, 0xd1, 0x0f, 0x00, 0x14, 0xdb, 0x36, 0xb5, 0xa3,
0xa1, 0xf7, 0x82, 0xb5, 0xf0, 0xed, 0xb5, 0xe1, 0xf0, 0x6d, 0x9e, 0xe3, 0xfb, 0x6c, 0xc5, 0x13,
0xf5, 0xed, 0x35, 0x9f, 0x42, 0x71, 0x17, 0xca, 0x41, 0x59, 0x07, 0x8a, 0xb2, 0x6f, 0x08, 0x42,
0x51, 0x56, 0x59, 0xe0, 0x50, 0xd4, 0x05, 0xb2, 0x49, 0xd6, 0x4e, 0xa6, 0x03, 0xf1, 0xdb, 0x38,
0x14, 0xfd, 0xbb, 0xf3, 0x3f, 0x0d, 0xcd, 0x89, 0x9f, 0xc4, 0x21, 0xe7, 0x4e, 0x3e, 0xa2, 0x9d,
0xeb, 0xd9, 0x2e, 0xe1, 0x6f, 0x5e, 0xb2, 0xfe, 0x70, 0xd2, 0xed, 0x3a, 0xdf, 0x72, 0x13, 0xbf,
0xa8, 0xe2, 0xbb, 0xdf, 0xd2, 0x4e, 0xbb, 0x84, 0xe7, 0xb9, 0x3f, 0xe5, 0xdf, 0x41, 0x12, 0x11,
0xf4, 0xdf, 0x90, 0x51, 0xda, 0x6e, 0xcb, 0xa1, 0x1c, 0x52, 0x83, 0x76, 0x58, 0xd7, 0x5b, 0xa3,
0x0d, 0xca, 0x29, 0x71, 0x09, 0xfe, 0x55, 0x09, 0xb7, 0x6b, 0xfd, 0x16, 0xd1, 0xcb, 0x78, 0xa6,
0x07, 0x72, 0x92, 0xfa, 0x6d, 0x6d, 0x91, 0x28, 0x4e, 0xf8, 0xa4, 0xc6, 0xbd, 0xbd, 0xfb, 0x8d,
0x2d, 0x21, 0x29, 0xde, 0x82, 0xbc, 0xeb, 0x7a, 0x50, 0x15, 0xb2, 0x4e, 0x73, 0x2a, 0xce, 0x1d,
0x00, 0xef, 0x49, 0xad, 0x40, 0xda, 0xd0, 0x3f, 0xe2, 0x3d, 0xdb, 0xa4, 0xc4, 0x06, 0xa2, 0x0a,
0x95, 0x31, 0xbf, 0x85, 0x6e, 0x41, 0xd6, 0x18, 0x1e, 0xc9, 0xce, 0xa6, 0x1d, 0xbb, 0x50, 0xe8,
0x54, 0x44, 0x86, 0x47, 0x3d, 0xad, 0x7d, 0x17, 0x9f, 0x3a, 0x66, 0x32, 0x86, 0x47, 0x77, 0xd9,
0xde, 0x66, 0x6f, 0x49, 0xf8, 0xdf, 0xf2, 0xa3, 0x38, 0xe4, 0x9c, 0xb3, 0x8a, 0xfe, 0x07, 0xf2,
0xae, 0x4f, 0x74, 0xaf, 0xb1, 0x44, 0x3a, 0x53, 0xae, 0xdf, 0x13, 0x41, 0x97, 0x61, 0xc9, 0xd2,
0x3a, 0x03, 0xa7, 0x4b, 0xc5, 0x4a, 0x90, 0x09, 0x7a, 0x68, 0x2a, 0xec, 0x87, 0x1d, 0xa7, 0x6e,
0x76, 0x27, 0x95, 0x4b, 0x0a, 0xa9, 0x3b, 0xa9, 0x5c, 0x4a, 0x48, 0x93, 0xb0, 0x28, 0x8c, 0x3b,
0x8e, 0xef, 0xf3, 0x63, 0x42, 0xc2, 0x77, 0x32, 0x2c, 0x7c, 0xff, 0x33, 0x0e, 0x39, 0xa7, 0x0f,
0x86, 0x5e, 0xf5, 0xb9, 0xb0, 0x72, 0xd8, 0x8e, 0xe5, 0x8c, 0xde, 0x55, 0x89, 0xe0, 0x94, 0x12,
0x8b, 0x4f, 0x29, 0xaa, 0x79, 0xe9, 0xdc, 0x3c, 0x4a, 0x2d, 0x7c, 0xf3, 0xe8, 0x65, 0x40, 0xb6,
0x6e, 0x2b, 0x3d, 0xf9, 0x44, 0xb7, 0xb5, 0x41, 0x47, 0x66, 0x3b, 0x84, 0x79, 0x1b, 0x81, 0xfe,
0x72, 0x9f, 0xfe, 0xb0, 0xef, 0x6e, 0x16, 0x17, 0xa5, 0x2e, 0x7a, 0xf3, 0xe1, 0x0c, 0x64, 0x38,
0x10, 0x63, 0x57, 0x1f, 0xf8, 0xc8, 0xed, 0x9c, 0xa6, 0x7c, 0x9d, 0xd3, 0x1a, 0xe4, 0xfa, 0xd8,
0x56, 0xa8, 0xeb, 0x64, 0xd1, 0xd2, 0x1d, 0x5f, 0xbe, 0x09, 0x05, 0xdf, 0x25, 0x14, 0xe2, 0x4d,
0x77, 0x1b, 0xef, 0x0a, 0xb1, 0x5a, 0xf6, 0xd3, 0xcf, 0x2f, 0x24, 0x77, 0xf1, 0x47, 0xe4, 0xa0,
0x49, 0x8d, 0x7a, 0xb3, 0x51, 0xbf, 0x2b, 0xc4, 0x6b, 0x85, 0x4f, 0x3f, 0xbf, 0x90, 0x95, 0x30,
0x6d, 0x53, 0x5d, 0x6e, 0x42, 0xd1, 0xbf, 0x2a, 0xc1, 0x43, 0x8d, 0xa0, 0xbc, 0x75, 0xb8, 0xbf,
0xb3, 0x5d, 0xdf, 0x68, 0x35, 0xe4, 0xfb, 0x7b, 0xad, 0x86, 0x10, 0x47, 0x4f, 0xc3, 0xf2, 0xce,
0xf6, 0xdb, 0xcd, 0x96, 0x5c, 0xdf, 0xd9, 0x6e, 0xec, 0xb6, 0xe4, 0x8d, 0x56, 0x6b, 0xa3, 0x7e,
0x57, 0x48, 0x5c, 0xfd, 0x4d, 0x01, 0x2a, 0x1b, 0x9b, 0xf5, 0x6d, 0x82, 0x43, 0xb5, 0xb6, 0x42,
0x5d, 0x44, 0x1d, 0x52, 0xb4, 0xe0, 0x3d, 0xf5, 0x42, 0x71, 0x6d, 0x7a, 0x13, 0x13, 0xdd, 0x86,
0x34, 0xad, 0x85, 0xa3, 0xe9, 0x37, 0x8c, 0x6b, 0x33, 0xba, 0x9a, 0xe4, 0x63, 0xe8, 0x29, 0x9a,
0x7a, 0xe5, 0xb8, 0x36, 0xbd, 0xc9, 0x89, 0x76, 0x20, 0xeb, 0x94, 0x2a, 0x67, 0x5d, 0xde, 0xad,
0xcd, 0xec, 0x16, 0x92, 0xa9, 0xb1, 0x92, 0xf2, 0xf4, 0xdb, 0xc8, 0xb5, 0x19, 0xed, 0x4f, 0xb4,
0x0d, 0x19, 0x5e, 0xcd, 0x99, 0x71, 0x11, 0xb7, 0x36, 0xab, 0xeb, 0x87, 0x24, 0xc8, 0x7b, 0xc5,
0xfa, 0xd9, 0x77, 0xac, 0x6b, 0x73, 0x74, 0x76, 0xd1, 0x03, 0x28, 0x05, 0x2b, 0x44, 0xf3, 0x5d,
0xf6, 0xad, 0xcd, 0xd9, 0x5f, 0x24, 0xfa, 0x83, 0xe5, 0xa2, 0xf9, 0x2e, 0xff, 0xd6, 0xe6, 0x6c,
0x37, 0xa2, 0x0f, 0x60, 0x69, 0xb2, 0x9c, 0x33, 0xff, 0x5d, 0xe0, 0xda, 0x02, 0x0d, 0x48, 0xd4,
0x07, 0x14, 0x52, 0x06, 0x5a, 0xe0, 0x6a, 0x70, 0x6d, 0x91, 0x7e, 0x24, 0x52, 0xa1, 0x32, 0x5e,
0x5a, 0x99, 0xf7, 0xaa, 0x70, 0x6d, 0xee, 0xde, 0x24, 0x7b, 0x4b, 0x10, 0xbf, 0xcf, 0x7b, 0x75,
0xb8, 0x36, 0x77, 0xab, 0x12, 0x1d, 0x02, 0xf8, 0xf0, 0xe7, 0x1c, 0x57, 0x89, 0x6b, 0xf3, 0x34,
0x2d, 0x91, 0x01, 0xcb, 0x61, 0xc0, 0x74, 0x91, 0x9b, 0xc5, 0xb5, 0x85, 0x7a, 0x99, 0x64, 0x3f,
0x07, 0x21, 0xe6, 0x7c, 0x37, 0x8d, 0x6b, 0x73, 0x36, 0x35, 0x37, 0x1b, 0x5f, 0x7c, 0xbd, 0x1a,
0xff, 0xf2, 0xeb, 0xd5, 0xf8, 0xdf, 0xbe, 0x5e, 0x8d, 0x7f, 0xf6, 0xcd, 0x6a, 0xec, 0xcb, 0x6f,
0x56, 0x63, 0x7f, 0xfe, 0x66, 0x35, 0xf6, 0xbf, 0x2f, 0x75, 0x34, 0xbb, 0x3b, 0x3c, 0x5a, 0x6f,
0xeb, 0xfd, 0x2b, 0xfe, 0x3f, 0x9d, 0x84, 0xfd, 0x11, 0xe6, 0x28, 0x43, 0xa3, 0xe9, 0xb5, 0x7f,
0x07, 0x00, 0x00, 0xff, 0xff, 0x0b, 0xa0, 0x3a, 0x89, 0x28, 0x33, 0x00, 0x00,
// 3397 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcb, 0x73, 0x1b, 0xc7,
0xd1, 0xc7, 0xfb, 0xd1, 0x78, 0x72, 0x48, 0xcb, 0x10, 0x2c, 0x91, 0xf2, 0xaa, 0x6c, 0xcb, 0xb2,
0x4d, 0x7d, 0x96, 0x4a, 0xb6, 0xfc, 0xc9, 0xfe, 0x5c, 0x24, 0x08, 0x19, 0x94, 0x28, 0x92, 0x5e,
0x82, 0x72, 0xf9, 0x4b, 0xa2, 0xf5, 0x72, 0x77, 0x48, 0xac, 0x05, 0xec, 0xae, 0x77, 0x17, 0x34,
0xe8, 0x53, 0x2a, 0x55, 0xbe, 0xb8, 0x52, 0x15, 0xdf, 0x92, 0xaa, 0xc4, 0x95, 0x4b, 0x52, 0x95,
0x3f, 0x21, 0xa7, 0x5c, 0x92, 0x83, 0x0f, 0x39, 0xf8, 0x94, 0xa4, 0x72, 0x70, 0x52, 0xf6, 0x2d,
0xff, 0x40, 0x4e, 0x79, 0xd4, 0x3c, 0xf6, 0x05, 0xec, 0x02, 0xa0, 0x25, 0xf9, 0x92, 0xdc, 0x76,
0x1a, 0xdd, 0xbd, 0x3b, 0x3d, 0x33, 0xdd, 0xfd, 0xeb, 0x1e, 0xc0, 0x53, 0x0e, 0xd6, 0x55, 0x6c,
0x0d, 0x34, 0xdd, 0xb9, 0x22, 0x1f, 0x28, 0xda, 0x15, 0xe7, 0xc4, 0xc4, 0xf6, 0xaa, 0x69, 0x19,
0x8e, 0x81, 0x6a, 0xfe, 0x8f, 0xab, 0xe4, 0xc7, 0xe6, 0xf9, 0x00, 0xb7, 0x62, 0x9d, 0x98, 0x8e,
0x71, 0xc5, 0xb4, 0x0c, 0xe3, 0x90, 0xf1, 0x37, 0xcf, 0x05, 0x7e, 0xa6, 0x7a, 0x82, 0xda, 0x42,
0xbf, 0x72, 0xe1, 0x07, 0xf8, 0xc4, 0xfd, 0xf5, 0xfc, 0x84, 0xac, 0x29, 0x5b, 0xf2, 0xc0, 0xfd,
0x79, 0xe5, 0xc8, 0x30, 0x8e, 0xfa, 0xf8, 0x0a, 0x1d, 0x1d, 0x0c, 0x0f, 0xaf, 0x38, 0xda, 0x00,
0xdb, 0x8e, 0x3c, 0x30, 0x39, 0xc3, 0xd2, 0x91, 0x71, 0x64, 0xd0, 0xc7, 0x2b, 0xe4, 0x89, 0x51,
0x85, 0x7f, 0x01, 0xe4, 0x45, 0xfc, 0xc1, 0x10, 0xdb, 0x0e, 0xba, 0x0a, 0x19, 0xac, 0xf4, 0x8c,
0x46, 0xf2, 0x42, 0xf2, 0x52, 0xe9, 0xea, 0xb9, 0xd5, 0xb1, 0xc9, 0xad, 0x72, 0xbe, 0xb6, 0xd2,
0x33, 0x3a, 0x09, 0x91, 0xf2, 0xa2, 0xeb, 0x90, 0x3d, 0xec, 0x0f, 0xed, 0x5e, 0x23, 0x45, 0x85,
0xce, 0xc7, 0x09, 0xdd, 0x22, 0x4c, 0x9d, 0x84, 0xc8, 0xb8, 0xc9, 0xab, 0x34, 0xfd, 0xd0, 0x68,
0xa4, 0xa7, 0xbf, 0x6a, 0x53, 0x3f, 0xa4, 0xaf, 0x22, 0xbc, 0x68, 0x1d, 0x40, 0xd3, 0x35, 0x47,
0x52, 0x7a, 0xb2, 0xa6, 0x37, 0x32, 0x54, 0xf2, 0xe9, 0x78, 0x49, 0xcd, 0x69, 0x11, 0xc6, 0x4e,
0x42, 0x2c, 0x6a, 0xee, 0x80, 0x7c, 0xee, 0x07, 0x43, 0x6c, 0x9d, 0x34, 0xb2, 0xd3, 0x3f, 0xf7,
0x6d, 0xc2, 0x44, 0x3e, 0x97, 0x72, 0xa3, 0x4d, 0x28, 0x1d, 0xe0, 0x23, 0x4d, 0x97, 0x0e, 0xfa,
0x86, 0xf2, 0xa0, 0x91, 0xa3, 0xc2, 0x42, 0x9c, 0xf0, 0x3a, 0x61, 0x5d, 0x27, 0x9c, 0xeb, 0xa9,
0x46, 0xb2, 0x93, 0x10, 0xe1, 0xc0, 0xa3, 0xa0, 0xd7, 0xa1, 0xa0, 0xf4, 0xb0, 0xf2, 0x40, 0x72,
0x46, 0x8d, 0x3c, 0xd5, 0xb3, 0x12, 0xa7, 0xa7, 0x45, 0xf8, 0xba, 0xa3, 0x4e, 0x42, 0xcc, 0x2b,
0xec, 0x11, 0xdd, 0x02, 0x50, 0x71, 0x5f, 0x3b, 0xc6, 0x16, 0x91, 0x2f, 0x4c, 0xb7, 0xc1, 0x06,
0xe3, 0xec, 0x8e, 0xf8, 0x67, 0x14, 0x55, 0x97, 0x80, 0x5a, 0x50, 0xc4, 0xba, 0xca, 0xa7, 0x53,
0xa4, 0x6a, 0x2e, 0xc4, 0xae, 0xb7, 0xae, 0x06, 0x27, 0x53, 0xc0, 0x7c, 0x8c, 0x6e, 0x40, 0x4e,
0x31, 0x06, 0x03, 0xcd, 0x69, 0x00, 0xd5, 0xb0, 0x1c, 0x3b, 0x11, 0xca, 0xd5, 0x49, 0x88, 0x9c,
0x1f, 0x6d, 0x43, 0xb5, 0xaf, 0xd9, 0x8e, 0x64, 0xeb, 0xb2, 0x69, 0xf7, 0x0c, 0xc7, 0x6e, 0x94,
0xa8, 0x86, 0x67, 0xe2, 0x34, 0x6c, 0x69, 0xb6, 0xb3, 0xe7, 0x32, 0x77, 0x12, 0x62, 0xa5, 0x1f,
0x24, 0x10, 0x7d, 0xc6, 0xe1, 0x21, 0xb6, 0x3c, 0x85, 0x8d, 0xf2, 0x74, 0x7d, 0x3b, 0x84, 0xdb,
0x95, 0x27, 0xfa, 0x8c, 0x20, 0x01, 0x7d, 0x07, 0x16, 0xfb, 0x86, 0xac, 0x7a, 0xea, 0x24, 0xa5,
0x37, 0xd4, 0x1f, 0x34, 0x2a, 0x54, 0xe9, 0xf3, 0xb1, 0x1f, 0x69, 0xc8, 0xaa, 0xab, 0xa2, 0x45,
0x04, 0x3a, 0x09, 0x71, 0xa1, 0x3f, 0x4e, 0x44, 0xf7, 0x61, 0x49, 0x36, 0xcd, 0xfe, 0xc9, 0xb8,
0xf6, 0x2a, 0xd5, 0x7e, 0x39, 0x4e, 0xfb, 0x1a, 0x91, 0x19, 0x57, 0x8f, 0xe4, 0x09, 0x2a, 0xea,
0x42, 0xdd, 0xb4, 0xb0, 0x29, 0x5b, 0x58, 0x32, 0x2d, 0xc3, 0x34, 0x6c, 0xb9, 0xdf, 0xa8, 0x51,
0xdd, 0xcf, 0xc5, 0xe9, 0xde, 0x65, 0xfc, 0xbb, 0x9c, 0xbd, 0x93, 0x10, 0x6b, 0x66, 0x98, 0xc4,
0xb4, 0x1a, 0x0a, 0xb6, 0x6d, 0x5f, 0x6b, 0x7d, 0x96, 0x56, 0xca, 0x1f, 0xd6, 0x1a, 0x22, 0xa1,
0x36, 0x94, 0xf0, 0x88, 0x88, 0x4b, 0xc7, 0x86, 0x83, 0x1b, 0x0b, 0xd3, 0x0f, 0x56, 0x9b, 0xb2,
0xde, 0x33, 0x1c, 0x4c, 0x0e, 0x15, 0xf6, 0x46, 0x48, 0x86, 0x27, 0x8e, 0xb1, 0xa5, 0x1d, 0x9e,
0x50, 0x35, 0x12, 0xfd, 0xc5, 0xd6, 0x0c, 0xbd, 0x81, 0xa8, 0xc2, 0x17, 0xe2, 0x14, 0xde, 0xa3,
0x42, 0x44, 0x45, 0xdb, 0x15, 0xe9, 0x24, 0xc4, 0xc5, 0xe3, 0x49, 0x32, 0xd9, 0x62, 0x87, 0x9a,
0x2e, 0xf7, 0xb5, 0x8f, 0x30, 0x3f, 0x36, 0x8b, 0xd3, 0xb7, 0xd8, 0x2d, 0xce, 0x4d, 0xcf, 0x0a,
0xd9, 0x62, 0x87, 0x41, 0xc2, 0x7a, 0x1e, 0xb2, 0xc7, 0x72, 0x7f, 0x88, 0x85, 0xe7, 0xa0, 0x14,
0x70, 0xac, 0xa8, 0x01, 0xf9, 0x01, 0xb6, 0x6d, 0xf9, 0x08, 0x53, 0x3f, 0x5c, 0x14, 0xdd, 0xa1,
0x50, 0x85, 0x72, 0xd0, 0x99, 0x0a, 0x9f, 0x26, 0x3d, 0x49, 0xe2, 0x27, 0x89, 0xe4, 0x31, 0xb6,
0xe8, 0xb4, 0xb9, 0x24, 0x1f, 0xa2, 0x8b, 0x50, 0xa1, 0x9f, 0x2c, 0xb9, 0xbf, 0x13, 0x67, 0x9d,
0x11, 0xcb, 0x94, 0x78, 0x8f, 0x33, 0xad, 0x40, 0xc9, 0xbc, 0x6a, 0x7a, 0x2c, 0x69, 0xca, 0x02,
0xe6, 0x55, 0xd3, 0x65, 0x78, 0x1a, 0xca, 0x64, 0x7e, 0x1e, 0x47, 0x86, 0xbe, 0xa4, 0x44, 0x68,
0x9c, 0x45, 0xf8, 0x7d, 0x0a, 0xea, 0xe3, 0x0e, 0x18, 0xdd, 0x80, 0x0c, 0x89, 0x45, 0x3c, 0xac,
0x34, 0x57, 0x59, 0xa0, 0x5a, 0x75, 0x03, 0xd5, 0x6a, 0xd7, 0x0d, 0x54, 0xeb, 0x85, 0xcf, 0xbf,
0x5c, 0x49, 0x7c, 0xfa, 0x97, 0x95, 0xa4, 0x48, 0x25, 0xd0, 0x59, 0xe2, 0x2b, 0x65, 0x4d, 0x97,
0x34, 0x95, 0x7e, 0x72, 0x91, 0x38, 0x42, 0x59, 0xd3, 0x37, 0x55, 0xb4, 0x05, 0x75, 0xc5, 0xd0,
0x6d, 0xac, 0xdb, 0x43, 0x5b, 0x62, 0x81, 0x90, 0x07, 0x93, 0x90, 0x3b, 0x64, 0xe1, 0xb5, 0xe5,
0x72, 0xee, 0x52, 0x46, 0xb1, 0xa6, 0x84, 0x09, 0xc4, 0xad, 0x1e, 0xcb, 0x7d, 0x4d, 0x95, 0x1d,
0xc3, 0xb2, 0x1b, 0x99, 0x0b, 0xe9, 0x48, 0x7f, 0x78, 0xcf, 0x65, 0xd9, 0x37, 0x55, 0xd9, 0xc1,
0xeb, 0x19, 0xf2, 0xb9, 0x62, 0x40, 0x12, 0x3d, 0x0b, 0x35, 0xd9, 0x34, 0x25, 0xdb, 0x91, 0x1d,
0x2c, 0x1d, 0x9c, 0x38, 0xd8, 0xa6, 0x81, 0xa6, 0x2c, 0x56, 0x64, 0xd3, 0xdc, 0x23, 0xd4, 0x75,
0x42, 0x44, 0xcf, 0x40, 0x95, 0xc4, 0x24, 0x4d, 0xee, 0x4b, 0x3d, 0xac, 0x1d, 0xf5, 0x1c, 0x1a,
0x52, 0xd2, 0x62, 0x85, 0x53, 0x3b, 0x94, 0x28, 0xa8, 0xde, 0x8a, 0xd3, 0x78, 0x84, 0x10, 0x64,
0x54, 0xd9, 0x91, 0xa9, 0x25, 0xcb, 0x22, 0x7d, 0x26, 0x34, 0x53, 0x76, 0x7a, 0xdc, 0x3e, 0xf4,
0x19, 0x9d, 0x81, 0x1c, 0x57, 0x9b, 0xa6, 0x6a, 0xf9, 0x08, 0x2d, 0x41, 0xd6, 0xb4, 0x8c, 0x63,
0x4c, 0x97, 0xae, 0x20, 0xb2, 0x81, 0xf0, 0xfd, 0x14, 0x2c, 0x4c, 0x44, 0x2e, 0xa2, 0xb7, 0x27,
0xdb, 0x3d, 0xf7, 0x5d, 0xe4, 0x19, 0xbd, 0x42, 0xf4, 0xca, 0x2a, 0xb6, 0x78, 0xb4, 0x6f, 0x4c,
0x9a, 0xba, 0x43, 0x7f, 0xe7, 0xa6, 0xe1, 0xdc, 0xe8, 0x0e, 0xd4, 0xfb, 0xb2, 0xed, 0x48, 0xcc,
0xfb, 0x4b, 0x81, 0xc8, 0xff, 0xd4, 0x84, 0x91, 0x59, 0xac, 0x20, 0x1b, 0x9a, 0x2b, 0xa9, 0x12,
0x51, 0x9f, 0x8a, 0x44, 0x58, 0x3a, 0x38, 0xf9, 0x48, 0xd6, 0x1d, 0x4d, 0xc7, 0xd2, 0xc4, 0xaa,
0x9d, 0x9d, 0x50, 0xd8, 0x3e, 0xd6, 0x54, 0xac, 0x2b, 0xee, 0x72, 0x2d, 0x7a, 0xc2, 0xde, 0x72,
0xda, 0x82, 0x08, 0xd5, 0x70, 0xcc, 0x45, 0x55, 0x48, 0x39, 0x23, 0x3e, 0xf9, 0x94, 0x33, 0x42,
0xff, 0x03, 0x19, 0x32, 0x41, 0x3a, 0xf1, 0x6a, 0x44, 0xc2, 0xc2, 0xe5, 0xba, 0x27, 0x26, 0x16,
0x29, 0xa7, 0x20, 0x78, 0x47, 0xc1, 0x8b, 0xc3, 0xe3, 0x5a, 0x85, 0xe7, 0xa1, 0x36, 0x16, 0x64,
0x03, 0x6b, 0x97, 0x0c, 0xae, 0x9d, 0x50, 0x83, 0x4a, 0x28, 0x9a, 0x0a, 0x67, 0x60, 0x29, 0x2a,
0x38, 0x0a, 0x3d, 0x8f, 0x1e, 0x0a, 0x72, 0xe8, 0x3a, 0x14, 0xbc, 0xe8, 0xc8, 0x8e, 0xe2, 0xa4,
0xad, 0x5c, 0x66, 0xd1, 0x63, 0x25, 0x67, 0x90, 0x6c, 0x69, 0xba, 0x17, 0x52, 0xf4, 0xc3, 0xf3,
0xb2, 0x69, 0x76, 0x64, 0xbb, 0x27, 0xbc, 0x07, 0x8d, 0xb8, 0xc8, 0x37, 0x36, 0x8d, 0x8c, 0xb7,
0x05, 0xcf, 0x40, 0xee, 0xd0, 0xb0, 0x06, 0xb2, 0x43, 0x95, 0x55, 0x44, 0x3e, 0x22, 0x5b, 0x93,
0x45, 0xc1, 0x34, 0x25, 0xb3, 0x81, 0x20, 0xc1, 0xd9, 0xd8, 0xe8, 0x47, 0x44, 0x34, 0x5d, 0xc5,
0xcc, 0x9e, 0x15, 0x91, 0x0d, 0x7c, 0x45, 0xec, 0x63, 0xd9, 0x80, 0xbc, 0xd6, 0xa6, 0x73, 0xa5,
0xfa, 0x8b, 0x22, 0x1f, 0x09, 0xbf, 0x4d, 0xc1, 0x99, 0xe8, 0x18, 0xf8, 0x48, 0x0f, 0x40, 0x1d,
0xd2, 0xce, 0x88, 0x38, 0xa8, 0xf4, 0xa5, 0xb2, 0x48, 0x1e, 0xd1, 0x3e, 0x2c, 0xf4, 0x0d, 0x45,
0xee, 0x4b, 0x81, 0x83, 0xc1, 0x73, 0xda, 0x8b, 0x93, 0x5b, 0x98, 0x46, 0x3a, 0xac, 0x4e, 0x9c,
0x8d, 0x1a, 0xd5, 0xb1, 0xe5, 0x1d, 0x90, 0xd8, 0xc3, 0x91, 0xfd, 0xe6, 0x87, 0x03, 0x5d, 0x80,
0xf2, 0x40, 0x1e, 0x49, 0xce, 0x88, 0x7b, 0x34, 0xe6, 0xaa, 0x60, 0x20, 0x8f, 0xba, 0x23, 0xea,
0xce, 0x84, 0x9f, 0x07, 0xad, 0x18, 0x0e, 0xf0, 0x8f, 0xd7, 0x8a, 0x7b, 0xb0, 0xc4, 0x92, 0x11,
0xac, 0x46, 0x18, 0x72, 0x0e, 0xe7, 0x82, 0x5c, 0xf1, 0xc7, 0x6b, 0x43, 0xe1, 0x4d, 0xcf, 0xc5,
0xfa, 0x39, 0x4c, 0xa4, 0x6d, 0xfc, 0x73, 0x93, 0x0a, 0x1d, 0xff, 0x9f, 0x25, 0xa1, 0x19, 0x9f,
0xb4, 0x44, 0xaa, 0x7a, 0x01, 0x16, 0xbc, 0xaf, 0x97, 0x64, 0x55, 0xb5, 0xb0, 0x6d, 0xf3, 0x53,
0x51, 0xf7, 0x7e, 0x58, 0x63, 0xf4, 0xd8, 0x90, 0xf1, 0x0c, 0x54, 0xc7, 0x52, 0xaa, 0x0c, 0x0b,
0x68, 0xc7, 0xc1, 0xf7, 0x0b, 0x3f, 0x4d, 0x79, 0x5e, 0x27, 0x94, 0xf7, 0x3c, 0xe6, 0xf5, 0x7f,
0x1b, 0x16, 0x55, 0xac, 0x68, 0xea, 0x37, 0x5d, 0xfe, 0x05, 0x2e, 0xfd, 0x98, 0x57, 0xff, 0x8f,
0x25, 0x28, 0x88, 0xd8, 0x36, 0x49, 0xd6, 0x81, 0xd6, 0xa1, 0x88, 0x47, 0x0a, 0x36, 0x1d, 0x37,
0x51, 0x8b, 0x4e, 0x78, 0x19, 0x77, 0xdb, 0xe5, 0x24, 0xf0, 0xcd, 0x13, 0x43, 0xd7, 0x38, 0x52,
0x8f, 0x07, 0xdd, 0x5c, 0x3c, 0x08, 0xd5, 0x5f, 0x71, 0xa1, 0x7a, 0x3a, 0x16, 0xad, 0x31, 0xa9,
0x31, 0xac, 0x7e, 0x8d, 0x63, 0xf5, 0xcc, 0x8c, 0x97, 0x85, 0xc0, 0x7a, 0x2b, 0x04, 0xd6, 0xb3,
0x33, 0xa6, 0x19, 0x83, 0xd6, 0x5f, 0x71, 0xd1, 0x7a, 0x6e, 0xc6, 0x17, 0x8f, 0xc1, 0xf5, 0xdb,
0x61, 0xb8, 0x9e, 0x8f, 0x71, 0xab, 0xae, 0xf4, 0x54, 0xbc, 0xfe, 0x46, 0x00, 0xaf, 0x17, 0x62,
0x81, 0x32, 0x53, 0x14, 0x01, 0xd8, 0xdf, 0x0a, 0x01, 0xf6, 0xe2, 0x0c, 0x3b, 0x4c, 0x41, 0xec,
0x1b, 0x41, 0xc4, 0x0e, 0xb1, 0xc0, 0x9f, 0xaf, 0x7b, 0x1c, 0x64, 0x7f, 0xcd, 0x83, 0xec, 0xa5,
0xd8, 0xda, 0x03, 0x9f, 0xcb, 0x38, 0x66, 0xdf, 0x99, 0xc0, 0xec, 0x0c, 0x63, 0x3f, 0x1b, 0xab,
0x62, 0x06, 0x68, 0xdf, 0x99, 0x00, 0xed, 0x95, 0x19, 0x0a, 0x67, 0xa0, 0xf6, 0xef, 0x46, 0xa3,
0xf6, 0x78, 0x5c, 0xcd, 0x3f, 0x73, 0x3e, 0xd8, 0x2e, 0xc5, 0xc0, 0xf6, 0x5a, 0x2c, 0xc4, 0x64,
0xea, 0xe7, 0xc6, 0xed, 0xfb, 0x11, 0xb8, 0x9d, 0x21, 0xec, 0x4b, 0xb1, 0xca, 0xe7, 0x00, 0xee,
0xfb, 0x11, 0xc0, 0x7d, 0x61, 0xa6, 0xda, 0x99, 0xc8, 0xfd, 0x56, 0x18, 0xb9, 0xa3, 0x19, 0x67,
0x2c, 0x16, 0xba, 0x1f, 0xc4, 0x41, 0x77, 0x06, 0xaf, 0x5f, 0x8c, 0xd5, 0x78, 0x0a, 0xec, 0xbe,
0x33, 0x81, 0xdd, 0x97, 0x66, 0xec, 0xb4, 0x79, 0xc1, 0xfb, 0xf3, 0x24, 0xae, 0x8f, 0xb9, 0x6a,
0x92, 0x82, 0x62, 0xcb, 0x32, 0x2c, 0x0e, 0xc3, 0xd9, 0x40, 0xb8, 0x44, 0xc0, 0x9c, 0xef, 0x96,
0xa7, 0x00, 0x7d, 0x9a, 0xea, 0x07, 0x5c, 0xb1, 0xf0, 0xeb, 0xa4, 0x2f, 0x4b, 0x31, 0x50, 0x10,
0x08, 0x16, 0x39, 0x10, 0x0c, 0xc0, 0xff, 0x54, 0x18, 0xfe, 0xaf, 0x40, 0x89, 0xa4, 0xf0, 0x63,
0xc8, 0x5e, 0x36, 0x3d, 0x64, 0x7f, 0x19, 0x16, 0x68, 0xf8, 0x64, 0x45, 0x02, 0x9e, 0x07, 0x64,
0x68, 0x1e, 0x50, 0x23, 0x3f, 0x30, 0x2b, 0xb0, 0x84, 0xe0, 0x25, 0x58, 0x0c, 0xf0, 0x7a, 0xd0,
0x80, 0xc1, 0xdc, 0xba, 0xc7, 0xbd, 0xc6, 0x31, 0xc2, 0xef, 0x92, 0xbe, 0x85, 0xfc, 0x92, 0x40,
0x14, 0x7a, 0x4f, 0x3e, 0x22, 0xf4, 0x9e, 0xfa, 0xc6, 0xe8, 0x3d, 0x08, 0x75, 0xd2, 0x61, 0xa8,
0xf3, 0xf7, 0xa4, 0xbf, 0x26, 0x1e, 0x16, 0x57, 0x0c, 0x15, 0x73, 0xf0, 0x41, 0x9f, 0x49, 0x82,
0xd2, 0x37, 0x8e, 0x38, 0xc4, 0x20, 0x8f, 0x84, 0xcb, 0x8b, 0x9d, 0x45, 0x1e, 0x1a, 0x3d, 0xdc,
0x92, 0xa5, 0x16, 0xe6, 0xb8, 0xa5, 0x0e, 0xe9, 0x07, 0x98, 0x45, 0xba, 0xb2, 0x48, 0x1e, 0x09,
0x1f, 0xdd, 0x64, 0x34, 0x7e, 0x95, 0x45, 0x36, 0x40, 0x37, 0xa0, 0x48, 0x3b, 0x0a, 0x92, 0x61,
0xda, 0x3c, 0x20, 0x85, 0x12, 0x1d, 0xd6, 0x38, 0x58, 0xdd, 0x25, 0x3c, 0x3b, 0xa6, 0x2d, 0x16,
0x4c, 0xfe, 0x14, 0x48, 0xf1, 0x8a, 0xa1, 0x14, 0xef, 0x1c, 0x14, 0xc9, 0xd7, 0xdb, 0xa6, 0xac,
0x60, 0x1a, 0x59, 0x8a, 0xa2, 0x4f, 0x10, 0xee, 0x03, 0x9a, 0x8c, 0x93, 0xa8, 0x03, 0x39, 0x7c,
0x8c, 0x75, 0x87, 0x2c, 0x1b, 0x31, 0xf7, 0x99, 0x88, 0xbc, 0x08, 0xeb, 0xce, 0x7a, 0x83, 0x18,
0xf9, 0x6f, 0x5f, 0xae, 0xd4, 0x19, 0xf7, 0x8b, 0xc6, 0x40, 0x73, 0xf0, 0xc0, 0x74, 0x4e, 0x44,
0x2e, 0x2f, 0xfc, 0x39, 0x45, 0x30, 0x70, 0x28, 0x7e, 0x46, 0xda, 0xd6, 0xdd, 0xf2, 0xa9, 0x40,
0xed, 0x63, 0x3e, 0x7b, 0x9f, 0x07, 0x38, 0x92, 0x6d, 0xe9, 0x43, 0x59, 0x77, 0xb0, 0xca, 0x8d,
0x5e, 0x3c, 0x92, 0xed, 0x77, 0x28, 0x81, 0xac, 0x3a, 0xf9, 0x79, 0x68, 0x63, 0x95, 0x43, 0x9b,
0xfc, 0x91, 0x6c, 0xef, 0xdb, 0x58, 0x0d, 0xcc, 0x32, 0xff, 0x70, 0xb3, 0x0c, 0xdb, 0xb8, 0x30,
0x66, 0xe3, 0x00, 0x3a, 0x2d, 0x06, 0xd1, 0x29, 0x6a, 0x42, 0xc1, 0xb4, 0x34, 0xc3, 0xd2, 0x9c,
0x13, 0xba, 0x30, 0x69, 0xd1, 0x1b, 0xa3, 0x8b, 0x50, 0x19, 0xe0, 0x81, 0x69, 0x18, 0x7d, 0x89,
0x39, 0x9b, 0x12, 0x15, 0x2d, 0x73, 0x62, 0x9b, 0xfa, 0x9c, 0x8f, 0x53, 0xfe, 0xe9, 0xf3, 0xab,
0x10, 0x8f, 0xd6, 0xbc, 0xcb, 0x11, 0xe6, 0x0d, 0x50, 0xc8, 0x24, 0xc6, 0xec, 0xeb, 0x8d, 0xbf,
0x2d, 0x03, 0x0b, 0x3f, 0xa4, 0x75, 0xc9, 0x70, 0x6e, 0x84, 0xf6, 0x82, 0xf8, 0x68, 0x48, 0x9d,
0x82, 0xbb, 0x9d, 0xe7, 0xf5, 0x1e, 0x3e, 0x8e, 0x62, 0x64, 0x1b, 0xbd, 0x0b, 0x4f, 0x8e, 0x79,
0x36, 0x4f, 0x75, 0x6a, 0x5e, 0x07, 0xf7, 0x44, 0xd8, 0xc1, 0xb9, 0xaa, 0x7d, 0x63, 0xa5, 0x1f,
0xf2, 0xcc, 0x6d, 0x42, 0x35, 0x9c, 0xe6, 0x45, 0x2e, 0xff, 0x45, 0xa8, 0x58, 0xd8, 0x91, 0x35,
0x5d, 0x0a, 0x21, 0xc3, 0x32, 0x23, 0xf2, 0x12, 0xe5, 0x2e, 0x3c, 0x11, 0x99, 0xee, 0xa1, 0x57,
0xa1, 0xe8, 0x67, 0x8a, 0xc9, 0x18, 0xf0, 0xe4, 0xd5, 0x9b, 0x7c, 0x5e, 0xe1, 0x37, 0x49, 0x5f,
0x65, 0xb8, 0x82, 0xd5, 0x86, 0x9c, 0x85, 0xed, 0x61, 0x9f, 0xd5, 0x94, 0xaa, 0x57, 0x5f, 0x9a,
0x2f, 0x51, 0x24, 0xd4, 0x61, 0xdf, 0x11, 0xb9, 0xb0, 0x70, 0x1f, 0x72, 0x8c, 0x82, 0x4a, 0x90,
0xdf, 0xdf, 0xbe, 0xb3, 0xbd, 0xf3, 0xce, 0x76, 0x3d, 0x81, 0x00, 0x72, 0x6b, 0xad, 0x56, 0x7b,
0xb7, 0x5b, 0x4f, 0xa2, 0x22, 0x64, 0xd7, 0xd6, 0x77, 0xc4, 0x6e, 0x3d, 0x45, 0xc8, 0x62, 0xfb,
0x76, 0xbb, 0xd5, 0xad, 0xa7, 0xd1, 0x02, 0x54, 0xd8, 0xb3, 0x74, 0x6b, 0x47, 0xbc, 0xbb, 0xd6,
0xad, 0x67, 0x02, 0xa4, 0xbd, 0xf6, 0xf6, 0x46, 0x5b, 0xac, 0x67, 0x85, 0x97, 0xe1, 0x6c, 0x6c,
0x6a, 0xe9, 0x97, 0xa7, 0x92, 0x81, 0xf2, 0x94, 0xf0, 0x93, 0x14, 0x41, 0xf7, 0x71, 0xf9, 0x22,
0xba, 0x3d, 0x36, 0xf1, 0xab, 0xa7, 0x48, 0x36, 0xc7, 0x66, 0x4f, 0x00, 0xbd, 0x85, 0x0f, 0xb1,
0xa3, 0xf4, 0x58, 0xfe, 0xca, 0x02, 0x66, 0x45, 0xac, 0x70, 0x2a, 0x15, 0xb2, 0x19, 0xdb, 0xfb,
0x58, 0x71, 0x24, 0xe6, 0x8b, 0xd8, 0xa6, 0x2b, 0x12, 0x36, 0x42, 0xdd, 0x63, 0x44, 0xe1, 0xbd,
0x53, 0xd9, 0xb2, 0x08, 0x59, 0xb1, 0xdd, 0x15, 0xdf, 0xad, 0xa7, 0x11, 0x82, 0x2a, 0x7d, 0x94,
0xf6, 0xb6, 0xd7, 0x76, 0xf7, 0x3a, 0x3b, 0xc4, 0x96, 0x8b, 0x50, 0x73, 0x6d, 0xe9, 0x12, 0xb3,
0xc2, 0x1f, 0x52, 0xf0, 0x64, 0x4c, 0xb6, 0x8b, 0x6e, 0x00, 0x38, 0x23, 0xc9, 0xc2, 0x8a, 0x61,
0xa9, 0xf1, 0x9b, 0xac, 0x3b, 0x12, 0x29, 0x87, 0x58, 0x74, 0xf8, 0x93, 0x3d, 0xa5, 0xaa, 0x89,
0x5e, 0xe7, 0x4a, 0xc9, 0xac, 0xdc, 0xa3, 0x76, 0x3e, 0xa2, 0x24, 0x87, 0x15, 0xa2, 0x98, 0xda,
0x96, 0x2a, 0xa6, 0xfc, 0xe8, 0x6e, 0x94, 0x53, 0x99, 0xb3, 0xa1, 0x70, 0x3a, 0x77, 0x92, 0x7d,
0x38, 0x77, 0x22, 0xfc, 0x22, 0x1d, 0x34, 0x6c, 0x38, 0xb9, 0xdf, 0x81, 0x9c, 0xed, 0xc8, 0xce,
0xd0, 0xe6, 0x1b, 0xee, 0xd5, 0x79, 0x91, 0xc2, 0xaa, 0xfb, 0xb0, 0x47, 0xc5, 0x45, 0xae, 0xe6,
0xbf, 0xf6, 0xb6, 0x85, 0xeb, 0x50, 0x0d, 0x1b, 0x27, 0xfe, 0xc8, 0xf8, 0x3e, 0x27, 0x25, 0xdc,
0xf4, 0xf3, 0xaf, 0x40, 0xe9, 0x70, 0xb2, 0x2c, 0x97, 0x8c, 0x2a, 0xcb, 0xfd, 0x32, 0x09, 0x4f,
0x4d, 0xc1, 0x4b, 0xe8, 0xed, 0xb1, 0x75, 0x7e, 0xed, 0x34, 0x68, 0x6b, 0x95, 0xd1, 0xc2, 0x2b,
0x2d, 0x5c, 0x83, 0x72, 0x90, 0x3e, 0xdf, 0x24, 0x7f, 0x94, 0xf6, 0x7d, 0x7e, 0xb8, 0x7e, 0xf8,
0xc8, 0x12, 0xcd, 0xb1, 0x7d, 0x96, 0x3a, 0xe5, 0x3e, 0x8b, 0x4c, 0x16, 0xd2, 0x8f, 0x2f, 0x59,
0xc8, 0x3c, 0x64, 0xb2, 0x10, 0x3c, 0x70, 0xd9, 0xf0, 0x81, 0x9b, 0x88, 0xeb, 0xb9, 0x88, 0xb8,
0xfe, 0x2e, 0x40, 0xa0, 0xe7, 0xb6, 0x04, 0x59, 0xcb, 0x18, 0xea, 0x2a, 0xdd, 0x26, 0x59, 0x91,
0x0d, 0xd0, 0x75, 0xc8, 0x92, 0xed, 0xe6, 0x1a, 0x73, 0xd2, 0xf3, 0x92, 0xed, 0x12, 0xa8, 0xb6,
0x32, 0x6e, 0x41, 0x03, 0x34, 0xd9, 0xd0, 0x88, 0x79, 0xc5, 0x1b, 0xe1, 0x57, 0x3c, 0x1d, 0xdb,
0x1a, 0x89, 0x7e, 0xd5, 0x47, 0x90, 0xa5, 0xdb, 0x83, 0xe4, 0x37, 0xb4, 0x7d, 0xc7, 0x01, 0x33,
0x79, 0x46, 0xdf, 0x03, 0x90, 0x1d, 0xc7, 0xd2, 0x0e, 0x86, 0xfe, 0x0b, 0x56, 0xa2, 0xb7, 0xd7,
0x9a, 0xcb, 0xb7, 0x7e, 0x8e, 0xef, 0xb3, 0x25, 0x5f, 0x34, 0xb0, 0xd7, 0x02, 0x0a, 0x85, 0x6d,
0xa8, 0x86, 0x65, 0x5d, 0x88, 0xc7, 0xbe, 0x21, 0x0c, 0xf1, 0x18, 0x62, 0xe7, 0x10, 0xcf, 0x03,
0x88, 0x69, 0xd6, 0xa6, 0xa5, 0x03, 0xe1, 0x9f, 0x49, 0x28, 0x07, 0x77, 0xe7, 0x7f, 0x1a, 0x4a,
0x12, 0x3e, 0x4e, 0x42, 0xc1, 0x9b, 0x7c, 0x4c, 0x9b, 0xd4, 0xb7, 0x5d, 0x2a, 0xd8, 0x14, 0x64,
0x7d, 0xd7, 0xb4, 0xd7, 0xcd, 0xbd, 0xe9, 0x25, 0x54, 0x71, 0x45, 0xed, 0xa0, 0xa5, 0xdd, 0x36,
0x04, 0xcf, 0x1f, 0x7f, 0xcc, 0xbf, 0x83, 0x64, 0x12, 0xe8, 0x7f, 0x21, 0x27, 0x2b, 0x5e, 0x29,
0xbf, 0x1a, 0x51, 0xdb, 0x75, 0x59, 0x57, 0xbb, 0xa3, 0x35, 0xca, 0x29, 0x72, 0x09, 0xfe, 0x55,
0x29, 0xaf, 0x1b, 0xfc, 0x26, 0xd1, 0xcb, 0x78, 0xc2, 0x6e, 0xb3, 0x0a, 0xb0, 0xbf, 0x7d, 0x77,
0x67, 0x63, 0xf3, 0xd6, 0x66, 0x7b, 0x83, 0xa7, 0x54, 0x1b, 0x1b, 0xed, 0x8d, 0x7a, 0x8a, 0xf0,
0x89, 0xed, 0xbb, 0x3b, 0xf7, 0xda, 0x1b, 0xf5, 0xb4, 0x70, 0x13, 0x8a, 0x9e, 0xeb, 0x41, 0x0d,
0xc8, 0xbb, 0x4d, 0x9f, 0x24, 0x77, 0x00, 0xbc, 0xd7, 0xb3, 0x04, 0x59, 0xd3, 0xf8, 0x90, 0xf7,
0x42, 0xd3, 0x22, 0x1b, 0x08, 0x2a, 0xd4, 0xc6, 0xfc, 0x16, 0xba, 0x09, 0x79, 0x73, 0x78, 0x20,
0xb9, 0x9b, 0x76, 0xec, 0xa2, 0x9e, 0x5b, 0x69, 0x18, 0x1e, 0xf4, 0x35, 0xe5, 0x0e, 0x3e, 0x71,
0xcd, 0x64, 0x0e, 0x0f, 0xee, 0xb0, 0xbd, 0xcd, 0xde, 0x92, 0x0a, 0xbe, 0xe5, 0x07, 0x49, 0x28,
0xb8, 0x67, 0x15, 0xfd, 0x1f, 0x14, 0x3d, 0x9f, 0xe8, 0x5d, 0x0f, 0x89, 0x75, 0xa6, 0x5c, 0xbf,
0x2f, 0x82, 0x2e, 0xc3, 0x82, 0xad, 0x1d, 0xe9, 0x6e, 0xf7, 0x87, 0x95, 0xf6, 0x52, 0xf4, 0xd0,
0xd4, 0xd8, 0x0f, 0x5b, 0x6e, 0x3d, 0xea, 0x76, 0xa6, 0x90, 0xae, 0x67, 0x6e, 0x67, 0x0a, 0x99,
0x7a, 0x96, 0x84, 0xc5, 0xfa, 0xb8, 0xe3, 0xf8, 0x36, 0x3f, 0x26, 0x22, 0x7c, 0xa7, 0xa3, 0xc2,
0xf7, 0x3f, 0x92, 0x50, 0x70, 0xfb, 0x4b, 0xe8, 0xe5, 0x80, 0x0b, 0xab, 0x46, 0xed, 0x58, 0xce,
0xe8, 0x5f, 0x41, 0x08, 0x4f, 0x29, 0x75, 0xfa, 0x29, 0xc5, 0x35, 0x05, 0xdd, 0x1b, 0x3d, 0x99,
0x53, 0xdf, 0xe8, 0x79, 0x11, 0x90, 0x63, 0x38, 0x72, 0x5f, 0x3a, 0x36, 0x1c, 0x4d, 0x3f, 0x92,
0xd8, 0x0e, 0x61, 0xde, 0xa6, 0x4e, 0x7f, 0xb9, 0x47, 0x7f, 0xd8, 0xf5, 0x36, 0x8b, 0x87, 0xfe,
0x4e, 0x7b, 0xa3, 0xe0, 0x0c, 0xe4, 0x38, 0xc0, 0x61, 0x57, 0x0a, 0xf8, 0xc8, 0xeb, 0x48, 0x66,
0x02, 0x1d, 0xc9, 0x26, 0x14, 0x06, 0xd8, 0x91, 0xa9, 0xeb, 0x64, 0xd1, 0xd2, 0x1b, 0x5f, 0x7e,
0x0d, 0x4a, 0x81, 0xcb, 0x1d, 0xc4, 0x9b, 0x6e, 0xb7, 0xdf, 0xa9, 0x27, 0x9a, 0xf9, 0x4f, 0x3e,
0xbb, 0x90, 0xde, 0xc6, 0x1f, 0x92, 0x83, 0x26, 0xb6, 0x5b, 0x9d, 0x76, 0xeb, 0x4e, 0x3d, 0xd9,
0x2c, 0x7d, 0xf2, 0xd9, 0x85, 0xbc, 0x88, 0x69, 0xfb, 0xe7, 0x72, 0x07, 0xca, 0xc1, 0x55, 0x09,
0x1f, 0x6a, 0x04, 0xd5, 0x8d, 0xfd, 0xdd, 0xad, 0xcd, 0xd6, 0x5a, 0xb7, 0x2d, 0xdd, 0xdb, 0xe9,
0xb6, 0xeb, 0x49, 0xf4, 0x24, 0x2c, 0x6e, 0x6d, 0xbe, 0xd5, 0xe9, 0x4a, 0xad, 0xad, 0xcd, 0xf6,
0x76, 0x57, 0x5a, 0xeb, 0x76, 0xd7, 0x5a, 0x77, 0xea, 0xa9, 0xab, 0xbf, 0x2a, 0x41, 0x6d, 0x6d,
0xbd, 0xb5, 0x49, 0xf0, 0x9d, 0xa6, 0xc8, 0xd4, 0x45, 0xb4, 0x20, 0x43, 0x0b, 0xc9, 0x53, 0x2f,
0xea, 0x36, 0xa7, 0x37, 0x07, 0xd1, 0x2d, 0xc8, 0xd2, 0x1a, 0x33, 0x9a, 0x7e, 0x73, 0xb7, 0x39,
0xa3, 0x5b, 0x48, 0x3e, 0x86, 0x9e, 0xa2, 0xa9, 0x57, 0x79, 0x9b, 0xd3, 0x9b, 0x87, 0x68, 0x0b,
0xf2, 0x6e, 0x09, 0x70, 0xd6, 0xa5, 0xd8, 0xe6, 0xcc, 0x2e, 0x1c, 0x99, 0x1a, 0x2b, 0xd5, 0x4e,
0xbf, 0xe5, 0xdb, 0x9c, 0xd1, 0x56, 0x44, 0x9b, 0x90, 0xe3, 0x55, 0x92, 0x19, 0x17, 0x5c, 0x9b,
0xb3, 0xba, 0x69, 0x48, 0x84, 0xa2, 0x5f, 0x04, 0x9f, 0x7d, 0x77, 0xb9, 0x39, 0x47, 0xc7, 0x14,
0xdd, 0x87, 0x4a, 0xb8, 0xf2, 0x32, 0xdf, 0x25, 0xda, 0xe6, 0x9c, 0x7d, 0x3b, 0xa2, 0x3f, 0x5c,
0x86, 0x99, 0xef, 0x52, 0x6d, 0x73, 0xce, 0x36, 0x1e, 0x7a, 0x1f, 0x16, 0x26, 0xcb, 0x24, 0xf3,
0xdf, 0xb1, 0x6d, 0x9e, 0xa2, 0xb1, 0x87, 0x06, 0x80, 0x22, 0xca, 0x2b, 0xa7, 0xb8, 0x72, 0xdb,
0x3c, 0x4d, 0x9f, 0x0f, 0xa9, 0x50, 0x1b, 0x2f, 0x59, 0xcc, 0x7b, 0x05, 0xb7, 0x39, 0x77, 0xcf,
0x8f, 0xbd, 0x25, 0x8c, 0xdf, 0xe7, 0xbd, 0x92, 0xdb, 0x9c, 0xbb, 0x05, 0x88, 0xf6, 0x01, 0x02,
0xf8, 0x73, 0x8e, 0x2b, 0xba, 0xcd, 0x79, 0x9a, 0x81, 0xc8, 0x84, 0xc5, 0x28, 0x60, 0x7a, 0x9a,
0x1b, 0xbb, 0xcd, 0x53, 0xf5, 0x08, 0xc9, 0x7e, 0x0e, 0x43, 0xcc, 0xf9, 0x6e, 0xf0, 0x36, 0xe7,
0x6c, 0x16, 0xae, 0xb7, 0x3f, 0xff, 0x6a, 0x39, 0xf9, 0xc5, 0x57, 0xcb, 0xc9, 0xbf, 0x7e, 0xb5,
0x9c, 0xfc, 0xf4, 0xeb, 0xe5, 0xc4, 0x17, 0x5f, 0x2f, 0x27, 0xfe, 0xf4, 0xf5, 0x72, 0xe2, 0xff,
0x5f, 0x38, 0xd2, 0x9c, 0xde, 0xf0, 0x60, 0x55, 0x31, 0x06, 0x57, 0x82, 0x7f, 0xe6, 0x88, 0xfa,
0x83, 0xc9, 0x41, 0x8e, 0x46, 0xd3, 0x6b, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x34, 0x15, 0xb7,
0x61, 0x80, 0x32, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -7576,7 +7536,7 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
dAtA[i] = 0x2a
}
if len(m.ValidatorUpdates) > 0 {
for iNdEx := len(m.ValidatorUpdates) - 1; iNdEx >= 0; iNdEx-- {
@@ -7589,7 +7549,7 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
dAtA[i] = 0x22
}
}
if len(m.TxResults) > 0 {
@@ -7603,7 +7563,7 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
dAtA[i] = 0x1a
}
}
if len(m.AppHash) > 0 {
@@ -7611,7 +7571,7 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
copy(dAtA[i:], m.AppHash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash)))
i--
dAtA[i] = 0x1a
dAtA[i] = 0x12
}
if len(m.TxRecords) > 0 {
for iNdEx := len(m.TxRecords) - 1; iNdEx >= 0; iNdEx-- {
@@ -7624,14 +7584,9 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
dAtA[i] = 0xa
}
}
if m.ModifiedTxStatus != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.ModifiedTxStatus))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
@@ -9686,9 +9641,6 @@ func (m *ResponsePrepareProposal) Size() (n int) {
}
var l int
_ = l
if m.ModifiedTxStatus != 0 {
n += 1 + sovTypes(uint64(m.ModifiedTxStatus))
}
if len(m.TxRecords) > 0 {
for _, e := range m.TxRecords {
l = e.Size()
@@ -16337,25 +16289,6 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ModifiedTxStatus", wireType)
}
m.ModifiedTxStatus = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ModifiedTxStatus |= ResponsePrepareProposal_ModifiedTxStatus(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TxRecords", wireType)
}
@@ -16389,7 +16322,7 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 3:
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType)
}
@@ -16423,7 +16356,7 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
m.AppHash = []byte{}
}
iNdEx = postIndex
case 4:
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TxResults", wireType)
}
@@ -16457,7 +16390,7 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 5:
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidatorUpdates", wireType)
}
@@ -16491,7 +16424,7 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 6:
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParamUpdates", wireType)
}
cmd/tendermint/commands/debug/debug.go
+1
View File
@@ -2,6 +2,7 @@ package debug
import (
"github.com/spf13/cobra"
"github.com/tendermint/tendermint/libs/log"
)
go.mod
+1 -1
View File
@@ -41,7 +41,7 @@ require (
github.com/creachadair/atomicfile v0.2.4
github.com/golangci/golangci-lint v1.45.2
github.com/google/go-cmp v0.5.7
github.com/vektra/mockery/v2 v2.10.1
github.com/vektra/mockery/v2 v2.10.2
gotest.tools v2.2.0+incompatible
)
go.sum
+2 -2
View File
@@ -1035,8 +1035,8 @@ github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyC
github.com/valyala/fasthttp v1.30.0/go.mod h1:2rsYD01CKFrjjsvFxx75KlEUNpWNBY9JWD3K/7o2Cus=
github.com/valyala/quicktemplate v1.7.0/go.mod h1:sqKJnoaOF88V07vkO+9FL8fb9uZg/VPSJnLYn+LmLk8=
github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
github.com/vektra/mockery/v2 v2.10.1 h1:EOsWLFVlkUJlNurdO/w1NBFbFE1vbemJJtaG3Bo6H/M=
github.com/vektra/mockery/v2 v2.10.1/go.mod h1:m/WO2UzWzqgVX3nvqpRQq70I4Z7jbSCRhdmkgtp+Ab4=
github.com/vektra/mockery/v2 v2.10.2 h1:ISAFkB3rQS6Y3aDZzAKtDwgeyDknwNa1aBE3Zgx0h+I=
github.com/vektra/mockery/v2 v2.10.2/go.mod h1:m/WO2UzWzqgVX3nvqpRQq70I4Z7jbSCRhdmkgtp+Ab4=
github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE=
github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
internal/blocksync/reactor.go
+1
View File
@@ -45,6 +45,7 @@ func GetChannelDescriptor() *p2p.ChannelDescriptor {
SendQueueCapacity: 1000,
RecvBufferCapacity: 1024,
RecvMessageCapacity: MaxMsgSize,
Name: "blockSync",
}
}
internal/consensus/mempool_test.go
+13 -2
View File
@@ -317,9 +317,20 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {
func (app *CounterApplication) PrepareProposal(
req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
return abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
trs := make([]*abci.TxRecord, 0, len(req.Txs))
var totalBytes int64
for _, tx := range req.Txs {
totalBytes += int64(len(tx))
if totalBytes > req.MaxTxBytes {
break
}
trs = append(trs, &abci.TxRecord{
Action: abci.TxRecord_UNMODIFIED,
Tx: tx,
})
}
return abci.ResponsePrepareProposal{TxRecords: trs}
}
func (app *CounterApplication) ProcessProposal(
internal/consensus/mocks/cons_sync_reactor.go
+1
View File
@@ -4,6 +4,7 @@ package mocks
import (
mock "github.com/stretchr/testify/mock"
state "github.com/tendermint/tendermint/internal/state"
)
internal/consensus/peer_state_test.go
+1
View File
@@ -4,6 +4,7 @@ import (
"testing"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/libs/log"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/tendermint/tendermint/types"
internal/consensus/reactor.go
+4
View File
@@ -38,6 +38,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 64,
RecvMessageCapacity: maxMsgSize,
RecvBufferCapacity: 128,
Name: "state",
},
DataChannel: {
// TODO: Consider a split between gossiping current block and catchup
@@ -49,6 +50,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 64,
RecvBufferCapacity: 512,
RecvMessageCapacity: maxMsgSize,
Name: "data",
},
VoteChannel: {
ID: VoteChannel,
@@ -57,6 +59,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 64,
RecvBufferCapacity: 128,
RecvMessageCapacity: maxMsgSize,
Name: "vote",
},
VoteSetBitsChannel: {
ID: VoteSetBitsChannel,
@@ -65,6 +68,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 8,
RecvBufferCapacity: 128,
RecvMessageCapacity: maxMsgSize,
Name: "voteSet",
},
}
}
internal/consensus/state.go
+5 -3
View File
@@ -1390,7 +1390,6 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
}
var commit *types.Commit
var votes []*types.Vote
switch {
case cs.Height == cs.state.InitialHeight:
// We're creating a proposal for the first block.
@@ -1400,7 +1399,6 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
case cs.LastCommit.HasTwoThirdsMajority():
// Make the commit from LastCommit
commit = cs.LastCommit.MakeCommit()
votes = cs.LastCommit.GetVotes()
default: // This shouldn't happen.
cs.logger.Error("propose step; cannot propose anything without commit for the previous block")
@@ -1416,7 +1414,11 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
proposerAddr := cs.privValidatorPubKey.Address()
return cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, commit, proposerAddr, votes)
ret, err := cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, commit, proposerAddr, cs.LastCommit.GetVotes())
if err != nil {
panic(err)
}
return ret, nil
}
// Enter: `timeoutPropose` after entering Propose.
internal/consensus/state_test.go
+2 -4
View File
@@ -2184,9 +2184,7 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
m.On("ExtendVote", mock.Anything).Return(abci.ResponseExtendVote{
VoteExtension: voteExtensions[0],
})
m.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
}).Once()
m.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{}).Once()
cs1, vss := makeState(ctx, t, makeStateArgs{config: config, application: m})
height, round := cs1.Height, cs1.Round
@@ -2233,7 +2231,7 @@ func TestPrepareProposalReceivesVoteExtensions(t *testing.T) {
m.On("PrepareProposal", mock.MatchedBy(func(r abci.RequestPrepareProposal) bool {
rpp = r
return true
})).Return(abci.ResponsePrepareProposal{ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED})
})).Return(abci.ResponsePrepareProposal{})
signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vss[1:]...)
ensureNewRound(t, newRoundCh, height, round)
internal/evidence/mocks/block_store.go
+1
View File
@@ -4,6 +4,7 @@ package mocks
import (
mock "github.com/stretchr/testify/mock"
types "github.com/tendermint/tendermint/types"
)
internal/evidence/reactor.go
+1
View File
@@ -38,6 +38,7 @@ func GetChannelDescriptor() *p2p.ChannelDescriptor {
Priority: 6,
RecvMessageCapacity: maxMsgSize,
RecvBufferCapacity: 32,
Name: "evidence",
}
}
internal/mempool/mempool_bench_test.go
+1
View File
@@ -8,6 +8,7 @@ import (
"time"
"github.com/stretchr/testify/require"
abciclient "github.com/tendermint/tendermint/abci/client"
"github.com/tendermint/tendermint/abci/example/kvstore"
"github.com/tendermint/tendermint/libs/log"
internal/mempool/reactor.go
+1
View File
@@ -106,6 +106,7 @@ func getChannelDescriptor(cfg *config.MempoolConfig) *p2p.ChannelDescriptor {
Priority: 5,
RecvMessageCapacity: batchMsg.Size(),
RecvBufferCapacity: 128,
Name: "mempool",
}
}
internal/p2p/channel.go
+3
View File
@@ -60,6 +60,7 @@ type Channel struct {
errCh chan<- PeerError // peer error reporting
messageType proto.Message // the channel's message type, used for unmarshaling
name string
}
// NewChannel creates a new channel. It is primarily for internal and test
@@ -102,6 +103,8 @@ func (ch *Channel) SendError(ctx context.Context, pe PeerError) error {
}
}
func (ch *Channel) String() string { return fmt.Sprintf("p2p.Channel<%d:%s>", ch.ID, ch.name) }
// Receive returns a new unbuffered iterator to receive messages from ch.
// The iterator runs until ctx ends.
func (ch *Channel) Receive(ctx context.Context) *ChannelIterator {
internal/p2p/conn/connection.go
+4
View File
@@ -616,6 +616,10 @@ type ChannelDescriptor struct {
// RecvBufferCapacity defines the max buffer size of inbound messages for a
// given p2p Channel queue.
RecvBufferCapacity int
// Human readable name of the channel, used in logging and
// diagnostics.
Name string
}
func (chDesc ChannelDescriptor) FillDefaults() (filled ChannelDescriptor) {
internal/p2p/pex/reactor.go
+1
View File
@@ -63,6 +63,7 @@ func ChannelDescriptor() *conn.ChannelDescriptor {
SendQueueCapacity: 10,
RecvMessageCapacity: maxMsgSize,
RecvBufferCapacity: 128,
Name: "pex",
}
}
internal/p2p/router.go
+1
View File
@@ -281,6 +281,7 @@ func (r *Router) OpenChannel(ctx context.Context, chDesc *ChannelDescriptor) (*C
outCh := make(chan Envelope, chDesc.RecvBufferCapacity)
errCh := make(chan PeerError, chDesc.RecvBufferCapacity)
channel := NewChannel(id, messageType, queue.dequeue(), outCh, errCh)
channel.name = chDesc.Name
var wrapper Wrapper
if w, ok := messageType.(Wrapper); ok {
internal/proxy/client.go
+1
View File
@@ -8,6 +8,7 @@ import (
"time"
"github.com/go-kit/kit/metrics"
abciclient "github.com/tendermint/tendermint/abci/client"
"github.com/tendermint/tendermint/abci/example/kvstore"
"github.com/tendermint/tendermint/abci/types"
internal/proxy/client_test.go
+2 -1
View File
@@ -14,6 +14,8 @@ import (
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"gotest.tools/assert"
abciclient "github.com/tendermint/tendermint/abci/client"
abcimocks "github.com/tendermint/tendermint/abci/client/mocks"
"github.com/tendermint/tendermint/abci/example/kvstore"
@@ -21,7 +23,6 @@ import (
"github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/log"
tmrand "github.com/tendermint/tendermint/libs/rand"
"gotest.tools/assert"
)
//----------------------------------------
internal/state/execution.go
+5 -12
View File
@@ -122,22 +122,15 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
// transaction causing an error.
//
// Also, the App can simply skip any transaction that could cause any kind of trouble.
// Either way, we can not recover in a meaningful way, unless we skip proposing
// this block, repair what caused the error and try again. Hence, we panic on
// purpose for now.
panic(err)
}
if rpp.IsTxStatusUnknown() {
panic(fmt.Sprintf("PrepareProposal responded with ModifiedTxStatus %s", rpp.ModifiedTxStatus.String()))
}
if !rpp.IsTxStatusModified() {
return block, nil
// Either way, we cannot recover in a meaningful way, unless we skip proposing
// this block, repair what caused the error and try again. Hence, we return an
// error for now (the production code calling this function is expected to panic).
return nil, err
}
txrSet := types.NewTxRecordSet(rpp.TxRecords)
if err := txrSet.Validate(maxDataBytes, block.Txs); err != nil {
panic(fmt.Errorf("ResponsePrepareProposal validation: %w", err))
return nil, err
}
for _, rtx := range txrSet.RemovedTxs() {
internal/state/execution_test.go
+86 -43
View File
@@ -2,6 +2,7 @@ package state_test
import (
"context"
"errors"
"testing"
"time"
@@ -11,6 +12,7 @@ import (
dbm "github.com/tendermint/tm-db"
abciclient "github.com/tendermint/tendermint/abci/client"
abciclientmocks "github.com/tendermint/tendermint/abci/client/mocks"
abci "github.com/tendermint/tendermint/abci/types"
abcimocks "github.com/tendermint/tendermint/abci/types/mocks"
"github.com/tendermint/tendermint/crypto"
@@ -271,7 +273,7 @@ func TestFinalizeBlockByzantineValidators(t *testing.T) {
func TestProcessProposal(t *testing.T) {
const height = 2
txs := factory.MakeTenTxs(height)
txs := factory.MakeNTxs(height, 10)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -617,9 +619,7 @@ func TestEmptyPrepareProposal(t *testing.T) {
require.NoError(t, eventBus.Start(ctx))
app := abcimocks.NewBaseMock()
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
}, nil)
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{})
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
err := proxyApp.Start(ctx)
@@ -656,9 +656,10 @@ func TestEmptyPrepareProposal(t *testing.T) {
require.NoError(t, err)
}
// TestPrepareProposalPanicOnInvalid tests that the block creation logic panics
// if the ResponsePrepareProposal returned from the application is invalid.
func TestPrepareProposalPanicOnInvalid(t *testing.T) {
// TestPrepareProposalErrorOnNonExistingRemoved tests that the block creation logic returns
// an error if the ResponsePrepareProposal returned from the application marks
// a transaction as REMOVED that was not present in the original proposal.
func TestPrepareProposalErrorOnNonExistingRemoved(t *testing.T) {
const height = 2
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -680,7 +681,6 @@ func TestPrepareProposalPanicOnInvalid(t *testing.T) {
// create an invalid ResponsePrepareProposal
rpp := abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
TxRecords: []*abci.TxRecord{
{
Action: abci.TxRecord_REMOVED,
@@ -688,7 +688,7 @@ func TestPrepareProposalPanicOnInvalid(t *testing.T) {
},
},
}
app.On("PrepareProposal", mock.Anything).Return(rpp, nil)
app.On("PrepareProposal", mock.Anything).Return(rpp)
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
@@ -707,10 +707,9 @@ func TestPrepareProposalPanicOnInvalid(t *testing.T) {
)
pa, _ := state.Validators.GetByIndex(0)
commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
require.Panics(t,
func() {
blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes) //nolint:errcheck
})
block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
require.Nil(t, block)
require.ErrorContains(t, err, "new transaction incorrectly marked as removed")
mp.AssertExpectations(t)
}
@@ -733,7 +732,7 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
evpool := &mocks.EvidencePool{}
evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
txs := factory.MakeTenTxs(height)
txs := factory.MakeNTxs(height, 10)
mp := &mpmocks.Mempool{}
mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs))
@@ -744,9 +743,8 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
app := abcimocks.NewBaseMock()
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
TxRecords: trs,
}, nil)
TxRecords: trs,
})
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
@@ -794,7 +792,7 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
evpool := &mocks.EvidencePool{}
evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
txs := factory.MakeTenTxs(height)
txs := factory.MakeNTxs(height, 10)
mp := &mpmocks.Mempool{}
mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs[2:]))
@@ -804,9 +802,8 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
app := abcimocks.NewBaseMock()
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
TxRecords: trs,
}, nil)
TxRecords: trs,
})
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
@@ -851,7 +848,7 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
evpool := &mocks.EvidencePool{}
evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
txs := factory.MakeTenTxs(height)
txs := factory.MakeNTxs(height, 10)
mp := &mpmocks.Mempool{}
mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs))
@@ -861,9 +858,8 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
app := abcimocks.NewBaseMock()
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
TxRecords: trs,
}, nil)
TxRecords: trs,
})
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
@@ -892,10 +888,9 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
}
// TestPrepareProposalModifiedTxStatusFalse tests that CreateBlock correctly ignores
// the ResponsePrepareProposal TxRecords if ResponsePrepareProposal does not
// set ModifiedTxStatus to true.
func TestPrepareProposalModifiedTxStatusFalse(t *testing.T) {
// TestPrepareProposalErrorOnTooManyTxs tests that the block creation logic returns
// an error if the ResponsePrepareProposal returned from the application is invalid.
func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) {
const height = 2
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -905,29 +900,26 @@ func TestPrepareProposalModifiedTxStatusFalse(t *testing.T) {
require.NoError(t, eventBus.Start(ctx))
state, stateDB, privVals := makeState(t, 1, height)
// limit max block size
state.ConsensusParams.Block.MaxBytes = 60 * 1024
stateStore := sm.NewStore(stateDB)
evpool := &mocks.EvidencePool{}
evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
txs := factory.MakeTenTxs(height)
const nValidators = 1
var bytesPerTx int64 = 3
maxDataBytes := types.MaxDataBytes(state.ConsensusParams.Block.MaxBytes, 0, nValidators)
txs := factory.MakeNTxs(height, maxDataBytes/bytesPerTx+2) // +2 so that tx don't fit
mp := &mpmocks.Mempool{}
mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs))
trs := txsToTxRecords(types.Txs(txs))
trs = append(trs[len(trs)/2:], trs[:len(trs)/2]...)
trs = trs[1:]
trs[0].Action = abci.TxRecord_REMOVED
trs[1] = &abci.TxRecord{
Tx: []byte("new"),
Action: abci.TxRecord_ADDED,
}
app := abcimocks.NewBaseMock()
app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
TxRecords: trs,
}, nil)
TxRecords: trs,
})
cc := abciclient.NewLocalClient(logger, app)
proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
@@ -946,11 +938,62 @@ func TestPrepareProposalModifiedTxStatusFalse(t *testing.T) {
)
pa, _ := state.Validators.GetByIndex(0)
commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
require.Nil(t, block)
require.ErrorContains(t, err, "transaction data size exceeds maximum")
mp.AssertExpectations(t)
}
// TestPrepareProposalErrorOnPrepareProposalError tests when the client returns an error
// upon calling PrepareProposal on it.
func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) {
const height = 2
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
logger := log.NewNopLogger()
eventBus := eventbus.NewDefault(logger)
require.NoError(t, eventBus.Start(ctx))
state, stateDB, privVals := makeState(t, 1, height)
stateStore := sm.NewStore(stateDB)
evpool := &mocks.EvidencePool{}
evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
txs := factory.MakeNTxs(height, 10)
mp := &mpmocks.Mempool{}
mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs))
cm := &abciclientmocks.Client{}
cm.On("IsRunning").Return(true)
cm.On("Error").Return(nil)
cm.On("Start", mock.Anything).Return(nil).Once()
cm.On("Wait").Return(nil).Once()
cm.On("PrepareProposal", mock.Anything, mock.Anything).Return(nil, errors.New("an injected error")).Once()
proxyApp := proxy.New(cm, logger, proxy.NopMetrics())
err := proxyApp.Start(ctx)
require.NoError(t, err)
for i, tx := range block.Data.Txs {
require.Equal(t, txs[i], tx)
}
blockExec := sm.NewBlockExecutor(
stateStore,
logger,
proxyApp,
mp,
evpool,
nil,
eventBus,
sm.NopMetrics(),
)
pa, _ := state.Validators.GetByIndex(0)
commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
require.Nil(t, block)
require.ErrorContains(t, err, "an injected error")
mp.AssertExpectations(t)
}
internal/state/helpers_test.go
+1 -1
View File
@@ -62,7 +62,7 @@ func makeAndApplyGoodBlock(
evidence []types.Evidence,
) (sm.State, types.BlockID) {
t.Helper()
block := state.MakeBlock(height, factory.MakeTenTxs(height), lastCommit, evidence, proposerAddr)
block := state.MakeBlock(height, factory.MakeNTxs(height, 10), lastCommit, evidence, proposerAddr)
partSet, err := block.MakePartSet(types.BlockPartSizeBytes)
require.NoError(t, err)
internal/state/indexer/mocks/event_sink.go
+1
View File
@@ -6,6 +6,7 @@ import (
context "context"
mock "github.com/stretchr/testify/mock"
indexer "github.com/tendermint/tendermint/internal/state/indexer"
query "github.com/tendermint/tendermint/internal/pubsub/query"
internal/state/mocks/evidence_pool.go
+1
View File
@@ -6,6 +6,7 @@ import (
context "context"
mock "github.com/stretchr/testify/mock"
state "github.com/tendermint/tendermint/internal/state"
types "github.com/tendermint/tendermint/types"
internal/state/mocks/store.go
+1
View File
@@ -4,6 +4,7 @@ package mocks
import (
mock "github.com/stretchr/testify/mock"
state "github.com/tendermint/tendermint/internal/state"
tendermintstate "github.com/tendermint/tendermint/proto/tendermint/state"
internal/state/test/factory/block.go
+1 -1
View File
@@ -45,7 +45,7 @@ func MakeBlocks(ctx context.Context, t *testing.T, n int, state *sm.State, privV
func MakeBlock(state sm.State, height int64, c *types.Commit) *types.Block {
return state.MakeBlock(
height,
factory.MakeTenTxs(state.LastBlockHeight),
factory.MakeNTxs(state.LastBlockHeight, 10),
c,
nil,
state.Validators.GetProposer().Address,
internal/state/validation_test.go
+1 -1
View File
@@ -338,7 +338,7 @@ func TestValidateBlockEvidence(t *testing.T) {
evidence = append(evidence, newEv)
currentBytes += int64(len(newEv.Bytes()))
}
block := state.MakeBlock(height, testfactory.MakeTenTxs(height), lastCommit, evidence, proposerAddr)
block := state.MakeBlock(height, testfactory.MakeNTxs(height, 10), lastCommit, evidence, proposerAddr)
err := blockExec.ValidateBlock(ctx, state, block)
if assert.Error(t, err) {
internal/statesync/mocks/state_provider.go
+1
View File
@@ -6,6 +6,7 @@ import (
context "context"
mock "github.com/stretchr/testify/mock"
state "github.com/tendermint/tendermint/internal/state"
types "github.com/tendermint/tendermint/types"
internal/statesync/reactor.go
+39 -14
View File
@@ -16,6 +16,7 @@ import (
"github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/internal/eventbus"
"github.com/tendermint/tendermint/internal/p2p"
"github.com/tendermint/tendermint/internal/p2p/conn"
sm "github.com/tendermint/tendermint/internal/state"
"github.com/tendermint/tendermint/internal/store"
"github.com/tendermint/tendermint/libs/log"
@@ -75,13 +76,13 @@ const (
func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
return map[p2p.ChannelID]*p2p.ChannelDescriptor{
SnapshotChannel: {
ID: SnapshotChannel,
MessageType: new(ssproto.Message),
Priority: 6,
SendQueueCapacity: 10,
RecvMessageCapacity: snapshotMsgSize,
RecvBufferCapacity: 128,
Name: "snapshot",
},
ChunkChannel: {
ID: ChunkChannel,
@@ -90,6 +91,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 4,
RecvMessageCapacity: chunkMsgSize,
RecvBufferCapacity: 128,
Name: "chunk",
},
LightBlockChannel: {
ID: LightBlockChannel,
@@ -98,6 +100,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 10,
RecvMessageCapacity: lightBlockMsgSize,
RecvBufferCapacity: 128,
Name: "light-block",
},
ParamsChannel: {
ID: ParamsChannel,
@@ -106,6 +109,7 @@ func getChannelDescriptors() map[p2p.ChannelID]*p2p.ChannelDescriptor {
SendQueueCapacity: 10,
RecvMessageCapacity: paramMsgSize,
RecvBufferCapacity: 128,
Name: "params",
},
}
@@ -233,10 +237,7 @@ func NewReactor(
// The caller must be sure to execute OnStop to ensure the outbound p2p Channels are
// closed. No error is returned.
func (r *Reactor) OnStart(ctx context.Context) error {
go r.processCh(ctx, r.snapshotCh, "snapshot")
go r.processCh(ctx, r.chunkCh, "chunk")
go r.processCh(ctx, r.blockCh, "light block")
go r.processCh(ctx, r.paramsCh, "consensus params")
go r.processChannels(ctx, r.snapshotCh, r.chunkCh, r.blockCh, r.paramsCh)
go r.processPeerUpdates(ctx)
return nil
@@ -291,6 +292,7 @@ func (r *Reactor) Sync(ctx context.Context) (sm.State, error) {
r.metrics,
)
r.mtx.Unlock()
defer func() {
r.mtx.Lock()
// reset syncing objects at the close of Sync
@@ -780,6 +782,8 @@ func (r *Reactor) handleParamsMessage(ctx context.Context, envelope *p2p.Envelop
if sp, ok := r.stateProvider.(*stateProviderP2P); ok {
select {
case sp.paramsRecvCh <- cp:
case <-ctx.Done():
return ctx.Err()
case <-time.After(time.Second):
return errors.New("failed to send consensus params, stateprovider not ready for response")
}
@@ -797,7 +801,7 @@ func (r *Reactor) handleParamsMessage(ctx context.Context, envelope *p2p.Envelop
// handleMessage handles an Envelope sent from a peer on a specific p2p Channel.
// It will handle errors and any possible panics gracefully. A caller can handle
// any error returned by sending a PeerError on the respective channel.
func (r *Reactor) handleMessage(ctx context.Context, chID p2p.ChannelID, envelope *p2p.Envelope) (err error) {
func (r *Reactor) handleMessage(ctx context.Context, envelope *p2p.Envelope) (err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("panic in processing message: %v", e)
@@ -811,7 +815,7 @@ func (r *Reactor) handleMessage(ctx context.Context, chID p2p.ChannelID, envelop
r.logger.Debug("received message", "message", reflect.TypeOf(envelope.Message), "peer", envelope.From)
switch chID {
switch envelope.ChannelID {
case SnapshotChannel:
err = r.handleSnapshotMessage(ctx, envelope)
case ChunkChannel:
@@ -821,7 +825,7 @@ func (r *Reactor) handleMessage(ctx context.Context, chID p2p.ChannelID, envelop
case ParamsChannel:
err = r.handleParamsMessage(ctx, envelope)
default:
err = fmt.Errorf("unknown channel ID (%d) for envelope (%v)", chID, envelope)
err = fmt.Errorf("unknown channel ID (%d) for envelope (%v)", envelope.ChannelID, envelope)
}
return err
@@ -831,15 +835,35 @@ func (r *Reactor) handleMessage(ctx context.Context, chID p2p.ChannelID, envelop
// encountered during message execution will result in a PeerError being sent on
// the respective channel. When the reactor is stopped, we will catch the signal
// and close the p2p Channel gracefully.
func (r *Reactor) processCh(ctx context.Context, ch *p2p.Channel, chName string) {
iter := ch.Receive(ctx)
func (r *Reactor) processChannels(ctx context.Context, chs ...*p2p.Channel) {
// make sure that the iterator gets cleaned up in case of error
ctx, cancel := context.WithCancel(ctx)
defer cancel()
chanTable := make(map[conn.ChannelID]*p2p.Channel, len(chs))
for idx := range chs {
ch := chs[idx]
chanTable[ch.ID] = ch
}
iter := p2p.MergedChannelIterator(ctx, chs...)
for iter.Next(ctx) {
envelope := iter.Envelope()
if err := r.handleMessage(ctx, ch.ID, envelope); err != nil {
if err := r.handleMessage(ctx, envelope); err != nil {
ch, ok := chanTable[envelope.ChannelID]
if !ok {
r.logger.Error("received impossible message",
"envelope_from", envelope.From,
"envelope_ch", envelope.ChannelID,
"num_chs", len(chanTable),
"err", err,
)
return
}
r.logger.Error("failed to process message",
"err", err,
"channel", chName,
"ch_id", ch.ID,
"channel", ch.String(),
"ch_id", envelope.ChannelID,
"envelope", envelope)
if serr := ch.SendError(ctx, p2p.PeerError{
NodeID: envelope.From,
@@ -875,14 +899,15 @@ func (r *Reactor) processPeerUpdate(ctx context.Context, peerUpdate p2p.PeerUpda
r.mtx.Lock()
defer r.mtx.Unlock()
if r.syncer == nil {
return
}
switch peerUpdate.Status {
case p2p.PeerStatusUp:
newProvider := NewBlockProvider(peerUpdate.NodeID, r.chainID, r.dispatcher)
r.providers[peerUpdate.NodeID] = newProvider
err := r.syncer.AddPeer(ctx, peerUpdate.NodeID)
if err != nil {
internal/statesync/reactor_test.go
+26 -15
View File
@@ -257,8 +257,9 @@ func TestReactor_ChunkRequest_InvalidRequest(t *testing.T) {
rts := setup(ctx, t, nil, nil, 2)
rts.chunkInCh <- p2p.Envelope{
From: types.NodeID("aa"),
Message: &ssproto.SnapshotsRequest{},
From: types.NodeID("aa"),
ChannelID: ChunkChannel,
Message: &ssproto.SnapshotsRequest{},
}
response := <-rts.chunkPeerErrCh
@@ -315,8 +316,9 @@ func TestReactor_ChunkRequest(t *testing.T) {
rts := setup(ctx, t, conn, nil, 2)
rts.chunkInCh <- p2p.Envelope{
From: types.NodeID("aa"),
Message: tc.request,
From: types.NodeID("aa"),
ChannelID: ChunkChannel,
Message: tc.request,
}
response := <-rts.chunkOutCh
@@ -335,8 +337,9 @@ func TestReactor_SnapshotsRequest_InvalidRequest(t *testing.T) {
rts := setup(ctx, t, nil, nil, 2)
rts.snapshotInCh <- p2p.Envelope{
From: types.NodeID("aa"),
Message: &ssproto.ChunkRequest{},
From: types.NodeID("aa"),
ChannelID: SnapshotChannel,
Message: &ssproto.ChunkRequest{},
}
response := <-rts.snapshotPeerErrCh
@@ -400,8 +403,9 @@ func TestReactor_SnapshotsRequest(t *testing.T) {
rts := setup(ctx, t, conn, nil, 100)
rts.snapshotInCh <- p2p.Envelope{
From: types.NodeID("aa"),
Message: &ssproto.SnapshotsRequest{},
From: types.NodeID("aa"),
ChannelID: SnapshotChannel,
Message: &ssproto.SnapshotsRequest{},
}
if len(tc.expectResponses) > 0 {
@@ -457,7 +461,8 @@ func TestReactor_LightBlockResponse(t *testing.T) {
rts.stateStore.On("LoadValidators", height).Return(vals, nil)
rts.blockInCh <- p2p.Envelope{
From: types.NodeID("aa"),
From: types.NodeID("aa"),
ChannelID: LightBlockChannel,
Message: &ssproto.LightBlockRequest{
Height: 10,
},
@@ -733,7 +738,8 @@ func handleLightBlockRequests(
require.NoError(t, err)
select {
case sending <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: LightBlockChannel,
Message: &ssproto.LightBlockResponse{
LightBlock: lb,
},
@@ -750,7 +756,8 @@ func handleLightBlockRequests(
require.NoError(t, err)
select {
case sending <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: LightBlockChannel,
Message: &ssproto.LightBlockResponse{
LightBlock: differntLB,
},
@@ -761,7 +768,8 @@ func handleLightBlockRequests(
case 1: // send nil block i.e. pretend we don't have it
select {
case sending <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: LightBlockChannel,
Message: &ssproto.LightBlockResponse{
LightBlock: nil,
},
@@ -802,7 +810,8 @@ func handleConsensusParamsRequest(
}
select {
case sending <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: ParamsChannel,
Message: &ssproto.ParamsResponse{
Height: msg.Height,
ConsensusParams: paramsProto,
@@ -913,7 +922,8 @@ func handleSnapshotRequests(
require.True(t, ok)
for _, snapshot := range snapshots {
sendingCh <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: SnapshotChannel,
Message: &ssproto.SnapshotsResponse{
Height: snapshot.Height,
Format: snapshot.Format,
@@ -946,7 +956,8 @@ func handleChunkRequests(
msg, ok := envelope.Message.(*ssproto.ChunkRequest)
require.True(t, ok)
sendingCh <- p2p.Envelope{
From: envelope.To,
From: envelope.To,
ChannelID: ChunkChannel,
Message: &ssproto.ChunkResponse{
Height: msg.Height,
Format: msg.Format,
internal/test/factory/tx.go
+3 -3
View File
@@ -2,10 +2,10 @@ package factory
import "github.com/tendermint/tendermint/types"
func MakeTenTxs(height int64) []types.Tx {
txs := make([]types.Tx, 10)
func MakeNTxs(height, n int64) []types.Tx {
txs := make([]types.Tx, n)
for i := range txs {
txs[i] = types.Tx([]byte{byte(height), byte(i)})
txs[i] = types.Tx([]byte{byte(height), byte(i / 256), byte(i % 256)})
}
return txs
}
proto/tendermint/abci/types.proto
+5 -12
View File
@@ -316,18 +316,11 @@ message ResponseApplySnapshotChunk {
}
message ResponsePrepareProposal {
ModifiedTxStatus modified_tx_status = 1;
repeated TxRecord tx_records = 2;
bytes app_hash = 3;
repeated ExecTxResult tx_results = 4;
repeated ValidatorUpdate validator_updates = 5;
tendermint.types.ConsensusParams consensus_param_updates = 6;
enum ModifiedTxStatus {
UNKNOWN = 0;
UNMODIFIED = 1;
MODIFIED = 2;
}
repeated TxRecord tx_records = 1;
bytes app_hash = 2;
repeated ExecTxResult tx_results = 3;
repeated ValidatorUpdate validator_updates = 4;
tendermint.types.ConsensusParams consensus_param_updates = 5;
}
message ResponseProcessProposal {
proto/tendermint/abci/types.proto.intermediate
+5 -12
View File
@@ -317,18 +317,11 @@ message ResponseApplySnapshotChunk {
}
message ResponsePrepareProposal {
ModifiedTxStatus modified_tx_status = 1;
repeated TxRecord tx_records = 2;
bytes app_hash = 3;
repeated ExecTxResult tx_results = 4;
repeated ValidatorUpdate validator_updates = 5;
tendermint.types.ConsensusParams consensus_param_updates = 6;
enum ModifiedTxStatus {
UNKNOWN = 0;
UNMODIFIED = 1;
MODIFIED = 2;
}
repeated TxRecord tx_records = 1;
bytes app_hash = 2;
repeated ExecTxResult tx_results = 3;
repeated ValidatorUpdate validator_updates = 4;
tendermint.types.ConsensusParams consensus_param_updates = 5;
}
message ResponseProcessProposal {
spec/abci++/abci++_methods_002_draft.md
+14 -34
View File
@@ -298,7 +298,6 @@ title: Methods
| Name | Type | Description | Field Number |
|-------------------------|--------------------------------------------------|---------------------------------------------------------------------------------------------|--------------|
| modified_tx_status | [TxModifiedStatus](#TxModifiedStatus) | `enum` signaling if the application has made changes to the list of transactions. | 1 |
| tx_records | repeated [TxRecord](#txrecord) | Possibly modified list of transactions that have been picked as part of the proposed block. | 2 |
| app_hash | bytes | The Merkle root hash of the application state. | 3 |
| tx_results | repeated [ExecTxResult](#txresult) | List of structures containing the data resulting from executing the transactions | 4 |
@@ -311,19 +310,15 @@ title: Methods
* The header contains the height, timestamp, and more - it exactly matches the
Tendermint block header.
* `RequestPrepareProposal` contains a preliminary set of transactions `txs` that Tendermint considers to be a good block proposal, called _raw proposal_. The Application can modify this set via `ResponsePrepareProposal.tx_records` (see [TxRecord](#txrecord)).
* In this case, the Application should set `ResponsePrepareProposal.modified_tx_status` to `MODIFIED`.
* The Application _can_ reorder, remove or add transactions to the raw proposal. Let `tx` be a transaction in `txs`:
* If the Application considers that `tx` should not be proposed in this block, e.g., there are other transactions with higher priority, then it should not include it in `tx_records`. In this case, Tendermint won't remove `tx` from the mempool. The Application should be extra-careful, as abusing this feature may cause transactions to stay forever in the mempool.
* If the Application considers that a `tx` should not be included in the proposal and removed from the mempool, then the Application should include it in `tx_records` and _mark_ it as `REMOVED`. In this case, Tendermint will remove `tx` from the mempool.
* If the Application wants to add a new transaction, then the Application should include it in `tx_records` and _mark_ it as `ADD`. In this case, Tendermint will add it to the mempool.
* The Application should be aware that removing and adding transactions may compromise _traceability_.
> Consider the following example: the Application transforms a client-submitted transaction `t1` into a second transaction `t2`, i.e., the Application asks Tendermint to remove `t1` and add `t2` to the mempool. If a client wants to eventually check what happened to `t1`, it will discover that `t_1` is not in the mempool or in a committed block, getting the wrong idea that `t_1` did not make it into a block. Note that `t_2` _will be_ in a committed block, but unless the Application tracks this information, no component will be aware of it. Thus, if the Application wants traceability, it is its responsability to support it. For instance, the Application could attach to a transformed transaction a list with the hashes of the transactions it derives from.
* If the Application does not modify the preliminary set of transactions `txs`, then it sets `ResponsePrepareProposal.modified_tx_status` to `UNMODIFIED`. In this case, Tendermint will ignore the contents of `ResponsePrepareProposal.tx_records`.
* Tendermint MAY include a list of transactions in `RequestPrepareProposal.txs` whose total size in bytes exceeds `RequestPrepareProposal.max_tx_bytes`.
Therefore, if the size of `RequestPrepareProposal.txs` is greater than `RequestPrepareProposal.max_tx_bytes`:
* the Application MUST make sure that the `RequestPrepareProposal.max_tx_bytes` limit is respected by those
transaction records returned in `ResponsePrepareProposal.tx_records` that are marked as `UNMODIFIED` or `ADDED`.
* the Application MUST set `ResponsePrepareProposal.modified_tx_status` to `MODIFIED`. Tendermint will panic otherwise.
Therefore, if the size of `RequestPrepareProposal.txs` is greater than `RequestPrepareProposal.max_tx_bytes`, the Application MUST make sure that the
`RequestPrepareProposal.max_tx_bytes` limit is respected by those transaction records returned in `ResponsePrepareProposal.tx_records` that are marked as `UNMODIFIED` or `ADDED`.
* In same-block execution mode, the Application must provide values for `ResponsePrepareProposal.app_hash`,
`ResponsePrepareProposal.tx_results`, `ResponsePrepareProposal.validator_updates`, and
`ResponsePrepareProposal.consensus_param_updates`, as a result of fully executing the block.
@@ -413,7 +408,7 @@ Note that, if _p_ has a non-`nil` _validValue_, Tendermint will use it as propos
| Name | Type | Description | Field Number |
|-------------------------|--------------------------------------------------|-----------------------------------------------------------------------------------|--------------|
| status | [ProposalStatus](#ProposalStatus) | `enum` that signals if the application finds the proposal valid. | 1 |
| status | [ProposalStatus](#proposalstatus) | `enum` that signals if the application finds the proposal valid. | 1 |
| app_hash | bytes | The Merkle root hash of the application state. | 2 |
| tx_results | repeated [ExecTxResult](#txresult) | List of structures containing the data resulting from executing the transactions. | 3 |
| validator_updates | repeated [ValidatorUpdate](#validatorupdate) | Changes to validator set (set voting power to 0 to remove). | 4 |
@@ -539,7 +534,7 @@ a [CanonicalVoteExtension](#canonicalvoteextension) field in the `precommit nil`
| Name | Type | Description | Field Number |
|--------|-------------------------------|----------------------------------------------------------------|--------------|
| status | [VerifyStatus](#VerifyStatus) | `enum` signaling if the application accepts the vote extension | 1 |
| status | [VerifyStatus](#verifystatus) | `enum` signaling if the application accepts the vote extension | 1 |
* **Usage**:
* `RequestVerifyVoteExtension.vote_extension` can be an empty byte array. The Application's interpretation of it should be
@@ -832,7 +827,7 @@ Most of the data structures used in ABCI are shared [common data structures](../
| info | string | Additional information. **May be non-deterministic.** | 4 |
| gas_wanted | int64 | Amount of gas requested for transaction. | 5 |
| gas_used | int64 | Amount of gas consumed by transaction. | 6 |
| events | repeated [Event](abci++_basic_concepts_002_draft.md#events) | Type & Key-Value events for indexing transactions (e.g. by account). | 7 |
| events | repeated [Event](abci++_basic_concepts_002_draft.md#events) | Type & Key-Value events for indexing transactions (e.g. by account). | 7 |
| codespace | string | Namespace for the `code`. | 8 |
### TxAction
@@ -852,6 +847,7 @@ enum TxAction {
* If `Action` is `ADDED`, Tendermint includes the transaction in the proposal. The transaction is _not_ added to the mempool.
* If `Action` is `REMOVED`, Tendermint excludes the transaction from the proposal. The transaction is also removed from the mempool if it exists,
similar to `CheckTx` returning _false_.
### TxRecord
* **Fields**:
@@ -872,26 +868,10 @@ enum ProposalStatus {
```
* **Usage**:
* Used within the [ProcessProposal](#ProcessProposal) response.
* If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
* If `Status` is `ACCEPT`, Tendermint accepts the proposal and will issue a Prevote message for it.
* If `Status` is `REJECT`, Tendermint rejects the proposal and will issue a Prevote for `nil` instead.
### TxModifiedStatus
```proto
enum ModifiedTxStatus {
UNKNOWN = 0; // Unknown status. Returning this from the application is always an error.
UNMODIFIED = 1; // Status that signals the application has modified the returned list of transactions.
MODIFIED = 2; // Status that signals that the application has not modified the list of transactions.
}
```
* **Usage**:
* Used within the [PrepareProposal](#PrepareProposal) response.
* If `TxModifiedStatus` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
* If `TxModifiedStatus` is `UNMODIFIED`, Tendermint will ignore the contents of the `PrepareProposal` response and use the transactions originally passed to the application during `PrepareProposal`.
* If `TxModifiedStatus` is `MODIFIED`, Tendermint will update the block proposal using the contents of the `PrepareProposal` response returned by the application.
* Used within the [ProcessProposal](#processproposal) response.
* If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
* If `Status` is `ACCEPT`, Tendermint accepts the proposal and will issue a Prevote message for it.
* If `Status` is `REJECT`, Tendermint rejects the proposal and will issue a Prevote for `nil` instead.
### VerifyStatus
@@ -904,10 +884,10 @@ enum VerifyStatus {
```
* **Usage**:
* Used within the [VerifyVoteExtension](#VerifyVoteExtension) response.
* If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
* If `Status` is `ACCEPT`, Tendermint will accept the vote as valid.
* If `Status` is `REJECT`, Tendermint will reject the vote as invalid.
* Used within the [VerifyVoteExtension](#verifyvoteextension) response.
* If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
* If `Status` is `ACCEPT`, Tendermint will accept the vote as valid.
* If `Status` is `REJECT`, Tendermint will reject the vote as invalid.
### CanonicalVoteExtension
spec/abci++/abci++_tmint_expected_behavior_002_draft.md
+13 -10
View File
@@ -202,14 +202,17 @@ to undergo any changes in their implementation.
As for the new methods:
* `PrepareProposal` should check whether the size of transactions exceeds the byte limit.
* If it does: remove transactions at the end of the list until the total byte size conforms to the limit,
then set `ResponsePrepareProposal.modified_tx_status` to `MODIFIED` and return.
* Else, set `ResponsePrepareProposal.modified_tx_status` to `UNMODIFIED` and return.
* `ProcessProposal` should set `ResponseProcessProposal.accept` to _true_ and return.
* `ExtendVote` should set `ResponseExtendVote.extension` to an empty byte array and return.
* `VerifyVoteExtension` should set `ResponseVerifyVoteExtension.accept` to _true_ if the extension is an empty byte array
* `PrepareProposal` must create a list of [TxRecord](./abci++_methods_002_draft.md#txrecord) each containing a
transaction passed in `RequestPrepareProposal.txs`, in the same other. The field `action` must be set to `UNMODIFIED`
for all [TxRecord](./abci++_methods_002_draft.md#txrecord) elements in the list.
The Application must check whether the size of all transactions exceeds the byte limit
(`RequestPrepareProposal.max_tx_bytes`). If so, the Application must remove transactions at the end of the list
until the total byte size is at or below the limit.
* `ProcessProposal` must set `ResponseProcessProposal.accept` to _true_ and return.
* `ExtendVote` is to set `ResponseExtendVote.extension` to an empty byte array and return.
* `VerifyVoteExtension` must set `ResponseVerifyVoteExtension.accept` to _true_ if the extension is an empty byte array
and _false_ otherwise, then return.
* `FinalizeBlock` should coalesce the implementation of methods `BeginBlock`, `DeliverTx`, `EndBlock`, and `Commit`.
The logic extracted from `DeliverTx` should be wrappped by a loop that will execute as many times as
transactions exist in `RequestFinalizeBlock.tx`.
* `FinalizeBlock` is to coalesce the implementation of methods `BeginBlock`, `DeliverTx`, `EndBlock`, and `Commit`.
Legacy applications looking to reuse old code that implemented `DeliverTx` should wrap the legacy
`DeliverTx` logic in a loop that executes one transaction iteration per
transaction in `RequestFinalizeBlock.tx`.
test/e2e/app/app.go
+14 -3
View File
@@ -356,12 +356,23 @@ func (app *Application) PrepareProposal(req abci.RequestPrepareProposal) abci.Re
Tx: extTx,
}
return abci.ResponsePrepareProposal{
ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
TxRecords: txRecords,
TxRecords: txRecords,
}
}
// None of the transactions are modified by this application.
return abci.ResponsePrepareProposal{ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED}
trs := make([]*abci.TxRecord, 0, len(req.Txs))
var totalBytes int64
for _, tx := range req.Txs {
totalBytes += int64(len(tx))
if totalBytes > req.MaxTxBytes {
break
}
trs = append(trs, &abci.TxRecord{
Action: abci.TxRecord_UNMODIFIED,
Tx: tx,
})
}
return abci.ResponsePrepareProposal{TxRecords: trs}
}
// ProcessProposal implements part of the Application interface.
types/tx.go
+8 -6
View File
@@ -188,13 +188,7 @@ func (t TxRecordSet) Validate(maxSizeBytes int64, otxs Txs) error {
// Only the slices are copied, the transaction contents are shared.
allCopy := sortedCopy(t.all)
var size int64
for i, cur := range allCopy {
size += int64(len(cur))
if size > maxSizeBytes {
return fmt.Errorf("transaction data size %d exceeds maximum %d", size, maxSizeBytes)
}
// allCopy is sorted, so any duplicated data will be adjacent.
if i+1 < len(allCopy) && bytes.Equal(cur, allCopy[i+1]) {
return fmt.Errorf("found duplicate transaction with hash: %x", cur.Hash())
@@ -207,6 +201,14 @@ func (t TxRecordSet) Validate(maxSizeBytes int64, otxs Txs) error {
removedCopy := sortedCopy(t.removed)
unmodifiedCopy := sortedCopy(t.unmodified)
var size int64
for _, cur := range append(unmodifiedCopy, addedCopy...) {
size += int64(len(cur))
if size > maxSizeBytes {
return fmt.Errorf("transaction data size exceeds maximum %d", maxSizeBytes)
}
}
// make a defensive copy of otxs so that the order of
// the caller's data is not altered.
otxsCopy := sortedCopy(otxs)
types/tx_test.go
+19
View File
@@ -64,6 +64,25 @@ func TestValidateTxRecordSet(t *testing.T) {
err := txrSet.Validate(9, []Tx{})
require.Error(t, err)
})
t.Run("should not error on removed transaction size exceeding max data size", func(t *testing.T) {
trs := []*abci.TxRecord{
{
Action: abci.TxRecord_ADDED,
Tx: Tx([]byte{1, 2, 3, 4, 5}),
},
{
Action: abci.TxRecord_ADDED,
Tx: Tx([]byte{6, 7, 8, 9}),
},
{
Action: abci.TxRecord_REMOVED,
Tx: Tx([]byte{10}),
},
}
txrSet := NewTxRecordSet(trs)
err := txrSet.Validate(9, []Tx{[]byte{10}})
require.NoError(t, err)
})
t.Run("should error on duplicate transactions with the same action", func(t *testing.T) {
trs := []*abci.TxRecord{
{