From 14d8569022610d84627ee09d4ad54835674ed2bc Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Thu, 6 Mar 2025 15:37:41 +0800 Subject: [PATCH 1/7] expanding mempool Tx --- mempool/v0/clist_mempool.go | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index a779f02a4..8b04d7063 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -418,6 +418,12 @@ func (mem *CListMempool) resCbFirstTime( height: mem.height, gasWanted: r.CheckTx.GasWanted, tx: tx, + + signerAddress: r.CheckTx.SignerAddress, + nonce: r.CheckTx.Nonce, + gasPrice: r.CheckTx.GasPrice, + gasLimit: r.CheckTx.GasLimit, + txType: r.CheckTx.Type, } memTx.senders.Store(peerID, true) mem.addTx(memTx) @@ -699,6 +705,13 @@ type mempoolTx struct { // ids of peers who've sent us this tx (as a map for quick lookups). // senders: PeerID -> bool senders sync.Map + + // additonal data of tx + signerAddress string + nonce uint64 + txType int32 + gasPrice uint64 + gasLimit uint64 } // Height returns the height for this transaction From 9ea4a99b3f30f3f5a285725d6dcfe5aa035bedf9 Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Thu, 6 Mar 2025 21:24:51 +0800 Subject: [PATCH 2/7] expanding response of check tx --- abci/types/types.pb.go | 439 +++++++++++++++++------------- proto/tendermint/abci/types.proto | 2 + 2 files changed, 250 insertions(+), 191 deletions(-) diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index dad667e37..3523e8172 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -2128,11 +2128,13 @@ type ResponseCheckTx struct { // ABCI applictions creating a ResponseCheckTX should not set mempool_error. MempoolError string `protobuf:"bytes,11,opt,name=mempool_error,json=mempoolError,proto3" json:"mempool_error,omitempty"` // tx info - SignerAddress string `protobuf:"bytes,20,opt,name=signer_address,proto3" json:"signer_address,omitempty"` + SignerAddress string `protobuf:"bytes,20,opt,name=signer_address,json=signerAddress,proto3" json:"signer_address,omitempty"` Nonce uint64 `protobuf:"varint,21,opt,name=nonce,proto3" json:"nonce,omitempty"` GasLimit uint64 `protobuf:"varint,22,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"` GasPrice uint64 `protobuf:"varint,23,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"` Type int32 `protobuf:"varint,24,opt,name=type,proto3" json:"type,omitempty"` + // replaceable tx + ReplaceableTx []byte `protobuf:"bytes,25,opt,name=replaceable_tx,json=replaceableTx,proto3" json:"replaceable_tx,omitempty"` } func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } @@ -2280,6 +2282,13 @@ func (m *ResponseCheckTx) GetType() int32 { return 0 } +func (m *ResponseCheckTx) GetReplaceableTx() []byte { + if m != nil { + return m.ReplaceableTx + } + return nil +} + type ResponseDeliverTx struct { Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` @@ -3502,200 +3511,201 @@ func init() { func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) } var fileDescriptor_252557cfdd89a31a = []byte{ - // 3075 bytes of a gzipped FileDescriptorProto + // 3095 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xbb, 0x73, 0x23, 0xc7, 0xd1, 0xc7, 0xfb, 0xd1, 0x78, 0x72, 0x8e, 0xe2, 0xe1, 0xa0, 0x13, 0x49, 0xed, 0x95, 0xa4, 0xbb, 0x93, 0x44, 0xea, 0xa3, 0xbe, 0xd3, 0xa3, 0xf4, 0xe9, 0xfb, 0x04, 0xe0, 0x70, 0x1f, 0x28, 0x52, 0x24, 0xbd, 0x04, 0x4f, 0x25, 0x3f, 0x6e, 0xb5, 0x58, 0x0c, 0x89, 0xd5, 0x01, 0xbb, 0xab, 0xdd, - 0x01, 0x05, 0x2a, 0xb4, 0xca, 0x55, 0x2e, 0x95, 0x03, 0x85, 0x4a, 0x14, 0x38, 0xf0, 0xff, 0xe0, - 0xc8, 0x91, 0x03, 0x05, 0x0e, 0x14, 0x38, 0x70, 0x24, 0xbb, 0xa4, 0xc0, 0x55, 0xfe, 0x07, 0x1c, - 0x38, 0xb0, 0x6b, 0x1e, 0xfb, 0x02, 0xb0, 0x04, 0x28, 0xb9, 0x5c, 0xe5, 0x72, 0x36, 0xd3, 0xd3, - 0xdd, 0x33, 0xd3, 0x33, 0xdb, 0xdd, 0xbf, 0xde, 0x81, 0x27, 0x09, 0x36, 0xfa, 0xd8, 0x1e, 0xe9, - 0x06, 0xd9, 0x56, 0x7b, 0x9a, 0xbe, 0x4d, 0x2e, 0x2c, 0xec, 0x6c, 0x59, 0xb6, 0x49, 0x4c, 0x54, - 0xf1, 0x07, 0xb7, 0xe8, 0x60, 0xfd, 0xa9, 0x00, 0xb7, 0x66, 0x5f, 0x58, 0xc4, 0xdc, 0xb6, 0x6c, - 0xd3, 0x3c, 0xe5, 0xfc, 0xf5, 0x9b, 0x81, 0x61, 0xa6, 0x27, 0xa8, 0x2d, 0x34, 0x2a, 0x84, 0x1f, - 0xe3, 0x0b, 0x77, 0xf4, 0xa9, 0x19, 0x59, 0x4b, 0xb5, 0xd5, 0x91, 0x3b, 0xbc, 0x71, 0x66, 0x9a, - 0x67, 0x43, 0xbc, 0xcd, 0x7a, 0xbd, 0xf1, 0xe9, 0x36, 0xd1, 0x47, 0xd8, 0x21, 0xea, 0xc8, 0x12, - 0x0c, 0xab, 0x67, 0xe6, 0x99, 0xc9, 0x9a, 0xdb, 0xb4, 0xc5, 0xa9, 0xd2, 0xdf, 0x73, 0x90, 0x95, - 0xf1, 0x87, 0x63, 0xec, 0x10, 0xb4, 0x03, 0x29, 0xac, 0x0d, 0xcc, 0x5a, 0x7c, 0x33, 0x7e, 0xbb, - 0xb0, 0x73, 0x73, 0x6b, 0x6a, 0x73, 0x5b, 0x82, 0xaf, 0xad, 0x0d, 0xcc, 0x4e, 0x4c, 0x66, 0xbc, - 0xe8, 0x1e, 0xa4, 0x4f, 0x87, 0x63, 0x67, 0x50, 0x4b, 0x30, 0xa1, 0xa7, 0xa2, 0x84, 0x1e, 0x50, - 0xa6, 0x4e, 0x4c, 0xe6, 0xdc, 0x74, 0x2a, 0xdd, 0x38, 0x35, 0x6b, 0xc9, 0xcb, 0xa7, 0xda, 0x35, - 0x4e, 0xd9, 0x54, 0x94, 0x17, 0x35, 0x01, 0x74, 0x43, 0x27, 0x8a, 0x36, 0x50, 0x75, 0xa3, 0x96, - 0x66, 0x92, 0x4f, 0x47, 0x4b, 0xea, 0xa4, 0x45, 0x19, 0x3b, 0x31, 0x39, 0xaf, 0xbb, 0x1d, 0xba, - 0xdc, 0x0f, 0xc7, 0xd8, 0xbe, 0xa8, 0x65, 0x2e, 0x5f, 0xee, 0x0f, 0x28, 0x13, 0x5d, 0x2e, 0xe3, - 0x46, 0x6d, 0x28, 0xf4, 0xf0, 0x99, 0x6e, 0x28, 0xbd, 0xa1, 0xa9, 0x3d, 0xae, 0x65, 0x99, 0xb0, - 0x14, 0x25, 0xdc, 0xa4, 0xac, 0x4d, 0xca, 0xd9, 0x89, 0xc9, 0xd0, 0xf3, 0x7a, 0xe8, 0x7f, 0x20, - 0xa7, 0x0d, 0xb0, 0xf6, 0x58, 0x21, 0x93, 0x5a, 0x8e, 0xe9, 0xd8, 0x88, 0xd2, 0xd1, 0xa2, 0x7c, - 0xdd, 0x49, 0x27, 0x26, 0x67, 0x35, 0xde, 0xa4, 0xfb, 0xef, 0xe3, 0xa1, 0x7e, 0x8e, 0x6d, 0x2a, - 0x9f, 0xbf, 0x7c, 0xff, 0xf7, 0x39, 0x27, 0xd3, 0x90, 0xef, 0xbb, 0x1d, 0xf4, 0x7f, 0x90, 0xc7, - 0x46, 0x5f, 0x6c, 0x03, 0x98, 0x8a, 0xcd, 0xc8, 0x73, 0x36, 0xfa, 0xee, 0x26, 0x72, 0x58, 0xb4, - 0xd1, 0x6b, 0x90, 0xd1, 0xcc, 0xd1, 0x48, 0x27, 0xb5, 0x02, 0x93, 0x5e, 0x8f, 0xdc, 0x00, 0xe3, - 0xea, 0xc4, 0x64, 0xc1, 0x8f, 0x0e, 0xa0, 0x3c, 0xd4, 0x1d, 0xa2, 0x38, 0x86, 0x6a, 0x39, 0x03, - 0x93, 0x38, 0xb5, 0x22, 0xd3, 0xf0, 0x4c, 0x94, 0x86, 0x7d, 0xdd, 0x21, 0xc7, 0x2e, 0x73, 0x27, - 0x26, 0x97, 0x86, 0x41, 0x02, 0xd5, 0x67, 0x9e, 0x9e, 0x62, 0xdb, 0x53, 0x58, 0x2b, 0x5d, 0xae, - 0xef, 0x90, 0x72, 0xbb, 0xf2, 0x54, 0x9f, 0x19, 0x24, 0xa0, 0x1f, 0xc1, 0xb5, 0xa1, 0xa9, 0xf6, - 0x3d, 0x75, 0x8a, 0x36, 0x18, 0x1b, 0x8f, 0x6b, 0x65, 0xa6, 0xf4, 0x4e, 0xe4, 0x22, 0x4d, 0xb5, - 0xef, 0xaa, 0x68, 0x51, 0x81, 0x4e, 0x4c, 0x5e, 0x19, 0x4e, 0x13, 0xd1, 0x23, 0x58, 0x55, 0x2d, - 0x6b, 0x78, 0x31, 0xad, 0xbd, 0xc2, 0xb4, 0xdf, 0x8d, 0xd2, 0xde, 0xa0, 0x32, 0xd3, 0xea, 0x91, - 0x3a, 0x43, 0x45, 0x5d, 0xa8, 0x5a, 0x36, 0xb6, 0x54, 0x1b, 0x2b, 0x96, 0x6d, 0x5a, 0xa6, 0xa3, - 0x0e, 0x6b, 0x55, 0xa6, 0xfb, 0xb9, 0x28, 0xdd, 0x47, 0x9c, 0xff, 0x48, 0xb0, 0x77, 0x62, 0x72, - 0xc5, 0x0a, 0x93, 0xb8, 0x56, 0x53, 0xc3, 0x8e, 0xe3, 0x6b, 0x5d, 0x59, 0xa4, 0x95, 0xf1, 0x87, - 0xb5, 0x86, 0x48, 0xcd, 0x2c, 0xa4, 0xcf, 0xd5, 0xe1, 0x18, 0xbf, 0x9d, 0xca, 0xa5, 0xaa, 0x69, - 0xe9, 0x39, 0x28, 0x04, 0x1c, 0x0b, 0xaa, 0x41, 0x76, 0x84, 0x1d, 0x47, 0x3d, 0xc3, 0xcc, 0x0f, - 0xe5, 0x65, 0xb7, 0x2b, 0x95, 0xa1, 0x18, 0x74, 0x26, 0xd2, 0x67, 0x71, 0x4f, 0x92, 0xfa, 0x09, - 0x2a, 0x79, 0x8e, 0x6d, 0x47, 0x37, 0x0d, 0x57, 0x52, 0x74, 0xd1, 0x2d, 0x28, 0xb1, 0x1b, 0xaf, - 0xb8, 0xe3, 0xd4, 0x59, 0xa5, 0xe4, 0x22, 0x23, 0x3e, 0x14, 0x4c, 0x1b, 0x50, 0xb0, 0x76, 0x2c, - 0x8f, 0x25, 0xc9, 0x58, 0xc0, 0xda, 0xb1, 0x5c, 0x86, 0xa7, 0xa1, 0x48, 0x77, 0xea, 0x71, 0xa4, - 0xd8, 0x24, 0x05, 0x4a, 0x13, 0x2c, 0xd2, 0xef, 0x12, 0x50, 0x9d, 0x76, 0x40, 0xe8, 0x35, 0x48, - 0x51, 0x5f, 0x2c, 0xdc, 0x6a, 0x7d, 0x8b, 0x3b, 0xea, 0x2d, 0xd7, 0x51, 0x6f, 0x75, 0x5d, 0x47, - 0xdd, 0xcc, 0x7d, 0xf9, 0xf5, 0x46, 0xec, 0xb3, 0x3f, 0x6e, 0xc4, 0x65, 0x26, 0x81, 0x6e, 0x50, - 0x7f, 0xa1, 0xea, 0x86, 0xa2, 0xf7, 0xd9, 0x92, 0xf3, 0xd4, 0x19, 0xa8, 0xba, 0xb1, 0xdb, 0x47, - 0xfb, 0x50, 0xd5, 0x4c, 0xc3, 0xc1, 0x86, 0x33, 0x76, 0x14, 0x1e, 0x08, 0x84, 0x33, 0x0d, 0xb9, - 0x04, 0x1e, 0x5e, 0x5a, 0x2e, 0xe7, 0x11, 0x63, 0x94, 0x2b, 0x5a, 0x98, 0x80, 0x1e, 0x00, 0x9c, - 0xab, 0x43, 0xbd, 0xaf, 0x12, 0xd3, 0x76, 0x6a, 0xa9, 0xcd, 0xe4, 0x5c, 0xbf, 0xf0, 0xd0, 0x65, - 0x39, 0xb1, 0xfa, 0x2a, 0xc1, 0xcd, 0x14, 0x5d, 0xae, 0x1c, 0x90, 0x44, 0xcf, 0x42, 0x45, 0xb5, - 0x2c, 0xc5, 0x21, 0x2a, 0xc1, 0x4a, 0xef, 0x82, 0x60, 0x87, 0xf9, 0xe9, 0xa2, 0x5c, 0x52, 0x2d, - 0xeb, 0x98, 0x52, 0x9b, 0x94, 0x88, 0x9e, 0x81, 0x32, 0xf5, 0xc9, 0xba, 0x3a, 0x54, 0x06, 0x58, - 0x3f, 0x1b, 0x10, 0xe6, 0x8f, 0x93, 0x72, 0x49, 0x50, 0x3b, 0x8c, 0x28, 0xf5, 0xbd, 0x13, 0x67, - 0xfe, 0x18, 0x21, 0x48, 0xf5, 0x55, 0xa2, 0x32, 0x4b, 0x16, 0x65, 0xd6, 0xa6, 0x34, 0x4b, 0x25, - 0x03, 0x61, 0x1f, 0xd6, 0x46, 0x6b, 0x90, 0x11, 0x6a, 0x93, 0x4c, 0xad, 0xe8, 0xa1, 0x55, 0x48, - 0x5b, 0xb6, 0x79, 0x8e, 0xd9, 0xd1, 0xe5, 0x64, 0xde, 0x91, 0x3e, 0x49, 0xc0, 0xca, 0x8c, 0xe7, - 0xa6, 0x7a, 0x07, 0xaa, 0x33, 0x70, 0xe7, 0xa2, 0x6d, 0xf4, 0x0a, 0xd5, 0xab, 0xf6, 0xb1, 0x2d, - 0xa2, 0x5d, 0x6d, 0xd6, 0xd4, 0x1d, 0x36, 0x2e, 0x4c, 0x23, 0xb8, 0xd1, 0x1e, 0x54, 0x87, 0xaa, - 0x43, 0x14, 0xee, 0x09, 0x95, 0x40, 0xe4, 0x7b, 0x72, 0xc6, 0xc8, 0xdc, 0x6f, 0xd2, 0x0b, 0x2d, - 0x94, 0x94, 0xa9, 0xa8, 0x4f, 0x45, 0x27, 0xb0, 0xda, 0xbb, 0xf8, 0x58, 0x35, 0x88, 0x6e, 0x60, - 0x65, 0xe6, 0xd4, 0x66, 0x43, 0xe9, 0x3b, 0xba, 0xd3, 0xc3, 0x03, 0xf5, 0x5c, 0x37, 0xdd, 0x65, - 0x5d, 0xf3, 0xe4, 0xbd, 0x13, 0x75, 0x24, 0x19, 0xca, 0xe1, 0xd0, 0x83, 0xca, 0x90, 0x20, 0x13, - 0xb1, 0xff, 0x04, 0x99, 0xa0, 0x97, 0x20, 0x45, 0xf7, 0xc8, 0xf6, 0x5e, 0x9e, 0x33, 0x91, 0x90, - 0xeb, 0x5e, 0x58, 0x58, 0x66, 0x9c, 0x92, 0xe4, 0x7d, 0x0d, 0x5e, 0x38, 0x9a, 0xd6, 0x2a, 0xdd, - 0x81, 0xca, 0x54, 0xbc, 0x09, 0x1c, 0x5f, 0x3c, 0x78, 0x7c, 0x52, 0x05, 0x4a, 0xa1, 0xe0, 0x22, - 0xad, 0xc1, 0xea, 0xbc, 0x58, 0x21, 0x0d, 0x3c, 0x7a, 0xc8, 0xe7, 0xa3, 0x7b, 0x90, 0xf3, 0x82, - 0x05, 0xff, 0x1a, 0x6f, 0xcc, 0xec, 0xc2, 0x65, 0x96, 0x3d, 0x56, 0xfa, 0x19, 0xd2, 0x5b, 0xcd, - 0xae, 0x43, 0x82, 0x2d, 0x3c, 0xab, 0x5a, 0x56, 0x47, 0x75, 0x06, 0xd2, 0xfb, 0x50, 0x8b, 0x0a, - 0x04, 0x53, 0xdb, 0x48, 0x79, 0xb7, 0x70, 0x0d, 0x32, 0xa7, 0xa6, 0x3d, 0x52, 0x09, 0x53, 0x56, - 0x92, 0x45, 0x8f, 0xde, 0x4e, 0x1e, 0x14, 0x92, 0x8c, 0xcc, 0x3b, 0x92, 0x02, 0x37, 0x22, 0x83, - 0x01, 0x15, 0xd1, 0x8d, 0x3e, 0xe6, 0xf6, 0x2c, 0xc9, 0xbc, 0xe3, 0x2b, 0xe2, 0x8b, 0xe5, 0x1d, - 0x3a, 0xad, 0xc3, 0xf6, 0xca, 0xf4, 0xe7, 0x65, 0xd1, 0x93, 0x3e, 0x4f, 0xc2, 0xda, 0xfc, 0x90, - 0x80, 0x36, 0xa1, 0x38, 0x52, 0x27, 0x0a, 0x99, 0x88, 0x6f, 0x99, 0x1f, 0x07, 0x8c, 0xd4, 0x49, - 0x77, 0xc2, 0x3f, 0xe4, 0x2a, 0x24, 0xc9, 0xc4, 0xa9, 0x25, 0x36, 0x93, 0xb7, 0x8b, 0x32, 0x6d, - 0xa2, 0x13, 0x58, 0x19, 0x9a, 0x9a, 0x3a, 0x54, 0x02, 0x37, 0x5e, 0x5c, 0xf6, 0x5b, 0x33, 0xc6, - 0x6e, 0x4f, 0x18, 0xa5, 0x3f, 0x73, 0xe9, 0x2b, 0x4c, 0xc7, 0xbe, 0x77, 0xf3, 0xd1, 0x7d, 0x28, - 0x8c, 0xfc, 0x8b, 0x7c, 0x85, 0xcb, 0x1e, 0x14, 0x0b, 0x1c, 0x49, 0x3a, 0xe4, 0x18, 0x5c, 0x17, - 0x9d, 0xb9, 0xb2, 0x8b, 0x7e, 0x09, 0x56, 0x0d, 0x3c, 0x21, 0x81, 0x0f, 0x91, 0xdf, 0x93, 0x2c, - 0x33, 0x3d, 0xa2, 0x63, 0xfe, 0x47, 0x46, 0xaf, 0x0c, 0xba, 0xc3, 0x82, 0xaa, 0x65, 0x3a, 0xd8, - 0x56, 0xd4, 0x7e, 0xdf, 0xc6, 0x8e, 0xc3, 0x92, 0xc1, 0x22, 0x8b, 0x94, 0x8c, 0xde, 0xe0, 0x64, - 0xe9, 0xe7, 0xc1, 0xa3, 0x09, 0x05, 0x51, 0xd7, 0xf0, 0x71, 0xdf, 0xf0, 0xc7, 0xb0, 0x2a, 0xe4, - 0xfb, 0x21, 0xdb, 0x27, 0x96, 0x75, 0x34, 0xc8, 0x15, 0x8f, 0x36, 0x7b, 0xf2, 0xbb, 0x99, 0xdd, - 0xf5, 0xa5, 0xa9, 0x80, 0x2f, 0xfd, 0x37, 0x3b, 0x8a, 0xdf, 0xe7, 0x21, 0x27, 0x63, 0xc7, 0xa2, - 0x81, 0x13, 0x35, 0x21, 0x8f, 0x27, 0x1a, 0xb6, 0x88, 0x9b, 0x6b, 0xcc, 0x07, 0x03, 0x9c, 0xbb, - 0xed, 0x72, 0xd2, 0x4c, 0xdc, 0x13, 0x43, 0x2f, 0x0b, 0xb0, 0x15, 0x8d, 0x9b, 0x84, 0x78, 0x10, - 0x6d, 0xbd, 0xe2, 0xa2, 0xad, 0x64, 0x64, 0xf2, 0xcd, 0xa5, 0xa6, 0xe0, 0xd6, 0xcb, 0x02, 0x6e, - 0xa5, 0x16, 0x4c, 0x16, 0xc2, 0x5b, 0xad, 0x10, 0xde, 0xca, 0x2c, 0xd8, 0x66, 0x04, 0xe0, 0x7a, - 0xc5, 0x05, 0x5c, 0xd9, 0x05, 0x2b, 0x9e, 0x42, 0x5c, 0x0f, 0xc2, 0x88, 0x2b, 0x17, 0xe1, 0x40, - 0x5c, 0xe9, 0x48, 0xc8, 0xf5, 0x66, 0x00, 0x72, 0xe5, 0x23, 0xf1, 0x0e, 0x57, 0x32, 0x07, 0x73, - 0xb5, 0x42, 0x98, 0x0b, 0x16, 0xd8, 0x20, 0x02, 0x74, 0xbd, 0x15, 0x04, 0x5d, 0x85, 0x48, 0xdc, - 0x26, 0xce, 0x7b, 0x1e, 0xea, 0x7a, 0xdd, 0x43, 0x5d, 0xc5, 0x48, 0xd8, 0x28, 0xf6, 0x30, 0x0d, - 0xbb, 0x0e, 0x67, 0x60, 0x17, 0x87, 0x49, 0xcf, 0x46, 0xaa, 0x58, 0x80, 0xbb, 0x0e, 0x67, 0x70, - 0x57, 0x79, 0x81, 0xc2, 0x05, 0xc0, 0xeb, 0xc7, 0xf3, 0x81, 0x57, 0x34, 0x34, 0x12, 0xcb, 0x5c, - 0x0e, 0x79, 0x29, 0x11, 0xc8, 0x8b, 0xa3, 0xa3, 0xe7, 0x23, 0xd5, 0x2f, 0x0d, 0xbd, 0x4e, 0xe6, - 0x40, 0x2f, 0x0e, 0x92, 0x6e, 0x47, 0x2a, 0x5f, 0x02, 0x7b, 0x9d, 0xcc, 0xc1, 0x5e, 0x68, 0xa1, - 0xda, 0xab, 0x80, 0xaf, 0x74, 0x35, 0x23, 0xdd, 0xa1, 0xa9, 0xef, 0x94, 0x9f, 0xa2, 0xf9, 0x03, - 0xb6, 0x6d, 0xd3, 0x16, 0x30, 0x8a, 0x77, 0xa4, 0xdb, 0x34, 0x19, 0xf7, 0x7d, 0xd2, 0x25, 0x40, - 0x8d, 0xe5, 0x69, 0x01, 0x3f, 0x24, 0xfd, 0x3a, 0xee, 0xcb, 0xb2, 0x1c, 0x36, 0x98, 0xc8, 0xe7, - 0x45, 0x22, 0x1f, 0x80, 0x6f, 0x89, 0x30, 0x7c, 0xdb, 0x80, 0x02, 0xcd, 0xbf, 0xa6, 0x90, 0x99, - 0x6a, 0x79, 0xc8, 0xec, 0x2e, 0xac, 0xb0, 0x88, 0xc7, 0x41, 0x9e, 0x08, 0x2b, 0x29, 0x16, 0x56, - 0x2a, 0x74, 0x80, 0x7f, 0x50, 0x3c, 0xbe, 0xbc, 0x08, 0xd7, 0x02, 0xbc, 0x5e, 0x5e, 0xc7, 0x61, - 0x4a, 0xd5, 0xe3, 0x6e, 0x88, 0x04, 0xef, 0xb7, 0x71, 0xdf, 0x42, 0x3e, 0xa4, 0x9b, 0x87, 0xbe, - 0xe2, 0xff, 0x24, 0xf4, 0x95, 0xf8, 0xce, 0xe8, 0x2b, 0x98, 0xa7, 0x26, 0xc3, 0x79, 0xea, 0x5f, - 0xe3, 0xfe, 0x99, 0x78, 0x58, 0x4a, 0x33, 0xfb, 0x58, 0x64, 0x8e, 0xac, 0x4d, 0x93, 0x8a, 0xa1, - 0x79, 0x26, 0xf2, 0x43, 0xda, 0xa4, 0x5c, 0x5e, 0xe0, 0xc8, 0x8b, 0xb8, 0xe0, 0x25, 0x9d, 0x3c, - 0x70, 0x8b, 0xa4, 0xb3, 0x0a, 0xc9, 0xc7, 0x98, 0xd7, 0xd5, 0x8a, 0x32, 0x6d, 0x52, 0x3e, 0x76, - 0xd5, 0x44, 0x00, 0xe6, 0x1d, 0xf4, 0x1a, 0xe4, 0x59, 0x45, 0x54, 0x31, 0x2d, 0x47, 0xb8, 0xf5, - 0x50, 0x6e, 0xc2, 0x0b, 0x9f, 0x5b, 0x47, 0x94, 0xe7, 0xd0, 0x72, 0xe4, 0x9c, 0x25, 0x5a, 0x81, - 0x8c, 0x21, 0x1f, 0xca, 0x18, 0x6e, 0x42, 0x9e, 0xae, 0xde, 0xb1, 0x54, 0x0d, 0x33, 0x17, 0x9d, - 0x97, 0x7d, 0x82, 0xf4, 0x08, 0xd0, 0x6c, 0x90, 0x40, 0x1d, 0xc8, 0xe0, 0x73, 0x6c, 0x10, 0x9e, - 0x41, 0x15, 0x76, 0xd6, 0x66, 0x53, 0x53, 0x3a, 0xdc, 0xac, 0x51, 0x23, 0xff, 0xe5, 0xeb, 0x8d, - 0x2a, 0xe7, 0x7e, 0xc1, 0x1c, 0xe9, 0x04, 0x8f, 0x2c, 0x72, 0x21, 0x0b, 0x79, 0xe9, 0xcf, 0x49, - 0x0a, 0x60, 0x42, 0x01, 0x64, 0xae, 0x6d, 0xdd, 0x2b, 0x9f, 0x08, 0x60, 0xd7, 0xe5, 0xec, 0xbd, - 0x0e, 0x70, 0xa6, 0x3a, 0xca, 0x47, 0xaa, 0x41, 0x70, 0x5f, 0x18, 0x3d, 0x40, 0x41, 0x75, 0xc8, - 0xd1, 0xde, 0xd8, 0xc1, 0x7d, 0x01, 0xa3, 0xbd, 0x7e, 0x60, 0x9f, 0xd9, 0xef, 0xb7, 0xcf, 0xb0, - 0x95, 0x73, 0x53, 0x56, 0x0e, 0x80, 0x8b, 0x7c, 0x10, 0x5c, 0xd0, 0xb5, 0x59, 0xb6, 0x6e, 0xda, - 0x3a, 0xb9, 0x60, 0x47, 0x93, 0x94, 0xbd, 0x3e, 0xba, 0x05, 0xa5, 0x11, 0x1e, 0x59, 0xa6, 0x39, - 0x54, 0xb8, 0xbb, 0x29, 0x30, 0xd1, 0xa2, 0x20, 0xb6, 0x29, 0x0d, 0x3d, 0x03, 0x65, 0x47, 0x3f, - 0x33, 0x02, 0x09, 0xda, 0x2a, 0xe3, 0x2a, 0x71, 0xaa, 0x48, 0xcf, 0xe8, 0x5d, 0x33, 0x4c, 0x43, - 0xc3, 0xb5, 0x27, 0x98, 0x73, 0xe0, 0x1d, 0xf4, 0x24, 0xe4, 0xa9, 0x25, 0x86, 0x3a, 0x8d, 0x9c, - 0x6b, 0x6c, 0x84, 0x9a, 0x66, 0x9f, 0xf6, 0xdd, 0x41, 0xcb, 0xd6, 0x35, 0x5c, 0xbb, 0xee, 0x0d, - 0x1e, 0xd1, 0x3e, 0x3d, 0x07, 0x86, 0x75, 0x6b, 0x9b, 0xf1, 0xdb, 0x69, 0x81, 0x66, 0x7f, 0x96, - 0xf0, 0x5d, 0x81, 0x8f, 0x67, 0xff, 0xe3, 0xce, 0x5a, 0xfa, 0x05, 0x2b, 0x72, 0x85, 0xb3, 0x15, - 0x74, 0x0c, 0x2b, 0x9e, 0x27, 0x52, 0xc6, 0xcc, 0x43, 0xb9, 0xdf, 0xd6, 0xb2, 0xae, 0xac, 0x7a, - 0x1e, 0x26, 0x3b, 0xe8, 0x3d, 0xb8, 0x3e, 0xe5, 0x66, 0x3d, 0xd5, 0x89, 0x65, 0xbd, 0xed, 0x13, - 0x61, 0x6f, 0xeb, 0xaa, 0xf6, 0x8d, 0x95, 0xfc, 0x9e, 0x0e, 0x60, 0x17, 0xca, 0xe1, 0xe4, 0x6b, - 0xee, 0xf1, 0xdf, 0x82, 0x92, 0x8d, 0x89, 0xaa, 0x1b, 0x4a, 0xa8, 0x32, 0x55, 0xe4, 0x44, 0x51, - 0xef, 0x3a, 0x82, 0x27, 0xe6, 0x26, 0x61, 0xe8, 0x55, 0xc8, 0xfb, 0xf9, 0x1b, 0xb7, 0xea, 0x25, - 0x95, 0x0b, 0x9f, 0x57, 0xfa, 0x4d, 0xdc, 0x57, 0x19, 0xae, 0x85, 0xb4, 0x21, 0x63, 0x63, 0x67, - 0x3c, 0xe4, 0xd5, 0x89, 0xf2, 0xce, 0x8b, 0xcb, 0xa5, 0x6f, 0x94, 0x3a, 0x1e, 0x12, 0x59, 0x08, - 0x4b, 0x8f, 0x20, 0xc3, 0x29, 0xa8, 0x00, 0xd9, 0x93, 0x83, 0xbd, 0x83, 0xc3, 0x77, 0x0f, 0xaa, - 0x31, 0x04, 0x90, 0x69, 0xb4, 0x5a, 0xed, 0xa3, 0x6e, 0x35, 0x8e, 0xf2, 0x90, 0x6e, 0x34, 0x0f, - 0xe5, 0x6e, 0x35, 0x41, 0xc9, 0x72, 0xfb, 0xed, 0x76, 0xab, 0x5b, 0x4d, 0xa2, 0x15, 0x28, 0xf1, - 0xb6, 0xf2, 0xe0, 0x50, 0x7e, 0xa7, 0xd1, 0xad, 0xa6, 0x02, 0xa4, 0xe3, 0xf6, 0xc1, 0xfd, 0xb6, - 0x5c, 0x4d, 0x4b, 0xff, 0x05, 0x37, 0x22, 0x13, 0x3e, 0xbf, 0xd0, 0x11, 0x0f, 0x14, 0x3a, 0xa4, - 0xcf, 0x13, 0x50, 0x8f, 0xce, 0xe2, 0xd0, 0xdb, 0x53, 0x1b, 0xdf, 0xb9, 0x42, 0x0a, 0x38, 0xb5, - 0x7b, 0xea, 0x9d, 0x6c, 0x7c, 0x8a, 0x89, 0x36, 0xe0, 0x59, 0x25, 0x8f, 0xde, 0x25, 0xb9, 0x24, - 0xa8, 0x4c, 0xc8, 0xe1, 0x6c, 0x1f, 0x60, 0x8d, 0x28, 0xdc, 0x2d, 0xf2, 0x4b, 0x97, 0xa7, 0x6c, - 0x94, 0x7a, 0xcc, 0x89, 0xd2, 0xfb, 0x57, 0xb2, 0x65, 0x1e, 0xd2, 0x72, 0xbb, 0x2b, 0xbf, 0x57, - 0x4d, 0x22, 0x04, 0x65, 0xd6, 0x54, 0x8e, 0x0f, 0x1a, 0x47, 0xc7, 0x9d, 0x43, 0x6a, 0xcb, 0x6b, - 0x50, 0x71, 0x6d, 0xe9, 0x12, 0xd3, 0xd2, 0xf3, 0x70, 0x3d, 0x22, 0x05, 0x9d, 0x2d, 0x28, 0x48, - 0xbf, 0x8c, 0x07, 0xb9, 0xc3, 0xe5, 0x87, 0x43, 0xc8, 0x38, 0x44, 0x25, 0x63, 0x47, 0x18, 0xf1, - 0xd5, 0x65, 0x73, 0xd2, 0x2d, 0xb7, 0x71, 0xcc, 0xc4, 0x65, 0xa1, 0x46, 0xba, 0x07, 0xe5, 0xf0, - 0x48, 0xb4, 0x0d, 0xfc, 0x4b, 0x94, 0x90, 0xde, 0x03, 0x08, 0x94, 0x46, 0x57, 0x21, 0x6d, 0x9b, - 0x63, 0xa3, 0xcf, 0x16, 0x95, 0x96, 0x79, 0x07, 0xdd, 0x83, 0xf4, 0xb9, 0xc9, 0x7d, 0xc6, 0xfc, - 0x0f, 0xe7, 0xa1, 0x49, 0x70, 0xa0, 0x0e, 0xc2, 0xb9, 0x25, 0x1d, 0xd0, 0x6c, 0x79, 0x2a, 0x62, - 0x8a, 0x37, 0xc3, 0x53, 0x3c, 0x1d, 0x59, 0xe8, 0x9a, 0x3f, 0xd5, 0xc7, 0x90, 0x66, 0xde, 0xc6, - 0x0b, 0x3b, 0x22, 0x2f, 0xa6, 0x6d, 0xf4, 0x13, 0x00, 0x95, 0x10, 0x5b, 0xef, 0x8d, 0xfd, 0x09, - 0x36, 0xe6, 0x7b, 0xab, 0x86, 0xcb, 0xd7, 0xbc, 0x29, 0xdc, 0xd6, 0xaa, 0x2f, 0x1a, 0x70, 0x5d, - 0x01, 0x85, 0xd2, 0x01, 0x94, 0xc3, 0xb2, 0x6e, 0x26, 0xc7, 0xd7, 0x10, 0xce, 0xe4, 0x78, 0x62, - 0x2e, 0x32, 0x39, 0x2f, 0x0f, 0x4c, 0xf2, 0x6a, 0x3a, 0xeb, 0x48, 0x9f, 0xc6, 0x21, 0xd7, 0x9d, - 0x88, 0x7b, 0x1c, 0x51, 0xc9, 0xf5, 0x45, 0x13, 0xc1, 0xba, 0x25, 0x2f, 0x0d, 0x27, 0xbd, 0x82, - 0xf3, 0x5b, 0xde, 0x97, 0x9a, 0x5a, 0x16, 0x78, 0xbb, 0x85, 0x77, 0xe1, 0x9d, 0xde, 0x80, 0xbc, - 0x17, 0x6b, 0x28, 0xc0, 0x70, 0x73, 0x88, 0xb8, 0xc8, 0x8e, 0xfd, 0xec, 0xc1, 0x32, 0x3f, 0x12, - 0x95, 0xd1, 0xa4, 0xcc, 0x3b, 0x52, 0x1f, 0x2a, 0x53, 0x81, 0x0a, 0xbd, 0x01, 0x59, 0x6b, 0xdc, - 0x53, 0x5c, 0xf3, 0x4c, 0x95, 0xc2, 0xdc, 0xd4, 0x75, 0xdc, 0x1b, 0xea, 0xda, 0x1e, 0xbe, 0x70, - 0x17, 0x63, 0x8d, 0x7b, 0x7b, 0xdc, 0x8a, 0x7c, 0x96, 0x44, 0x70, 0x96, 0x73, 0xc8, 0xb9, 0x97, - 0x02, 0xfd, 0x2f, 0xe4, 0xbd, 0x18, 0xe8, 0xfd, 0x2e, 0x8a, 0x0c, 0x9e, 0x42, 0xbd, 0x2f, 0x42, - 0x71, 0x10, 0x4b, 0x8b, 0x44, 0x01, 0x90, 0x17, 0x1c, 0x12, 0xec, 0x74, 0x2a, 0x7c, 0x60, 0xdf, - 0xc5, 0x37, 0xd2, 0xaf, 0xe2, 0x50, 0x9d, 0xbe, 0x95, 0xff, 0xca, 0x05, 0x50, 0xa7, 0x48, 0x6f, - 0xbf, 0x82, 0xe9, 0x22, 0x3c, 0x60, 0x57, 0x94, 0x4b, 0x94, 0xda, 0x76, 0x89, 0xd2, 0x27, 0x09, - 0x28, 0x04, 0xca, 0x8b, 0xe8, 0xbf, 0x03, 0x9f, 0x48, 0x79, 0x4e, 0x6e, 0x11, 0xe0, 0xf5, 0xff, - 0x44, 0x84, 0x37, 0x96, 0xb8, 0xfa, 0xc6, 0xa2, 0xfe, 0x28, 0xb9, 0xd5, 0xca, 0xd4, 0x95, 0xab, - 0x95, 0x2f, 0x00, 0x22, 0x26, 0x51, 0x87, 0xca, 0xb9, 0x49, 0x74, 0xe3, 0x4c, 0xe1, 0x57, 0x83, - 0x67, 0x7c, 0x55, 0x36, 0xf2, 0x90, 0x0d, 0x1c, 0xb1, 0x5b, 0xf2, 0xd3, 0x38, 0xe4, 0xbc, 0xd0, - 0x7d, 0xd5, 0x1f, 0x0b, 0x6b, 0x90, 0x11, 0xd1, 0x89, 0xff, 0x59, 0x10, 0xbd, 0xb9, 0x65, 0xd9, - 0x3a, 0xe4, 0x46, 0x98, 0xa8, 0x2c, 0x7f, 0xe1, 0x98, 0xd8, 0xeb, 0xdf, 0x7d, 0x1d, 0x0a, 0x81, - 0x7f, 0x3c, 0xd4, 0x4f, 0x1c, 0xb4, 0xdf, 0xad, 0xc6, 0xea, 0xd9, 0x4f, 0xbf, 0xd8, 0x4c, 0x1e, - 0xe0, 0x8f, 0xe8, 0x17, 0x26, 0xb7, 0x5b, 0x9d, 0x76, 0x6b, 0xaf, 0x1a, 0xaf, 0x17, 0x3e, 0xfd, - 0x62, 0x33, 0x2b, 0x63, 0x56, 0x49, 0xbb, 0xbb, 0x07, 0x95, 0xa9, 0x83, 0x09, 0xfb, 0x77, 0x04, - 0xe5, 0xfb, 0x27, 0x47, 0xfb, 0xbb, 0xad, 0x46, 0xb7, 0xad, 0x3c, 0x3c, 0xec, 0xb6, 0xab, 0x71, - 0x74, 0x1d, 0xae, 0xed, 0xef, 0xfe, 0x7f, 0xa7, 0xab, 0xb4, 0xf6, 0x77, 0xdb, 0x07, 0x5d, 0xa5, - 0xd1, 0xed, 0x36, 0x5a, 0x7b, 0xd5, 0xc4, 0xce, 0xdf, 0x00, 0x2a, 0x8d, 0x66, 0x6b, 0x97, 0xc6, - 0x67, 0x5d, 0x53, 0x59, 0xcd, 0xa2, 0x05, 0x29, 0x56, 0x95, 0xb8, 0xf4, 0xd5, 0x4a, 0xfd, 0xf2, - 0x32, 0x2b, 0x7a, 0x00, 0x69, 0x56, 0xb0, 0x40, 0x97, 0x3f, 0x63, 0xa9, 0x2f, 0xa8, 0xbb, 0xd2, - 0xc5, 0xb0, 0xcf, 0xe9, 0xd2, 0x77, 0x2d, 0xf5, 0xcb, 0xcb, 0xb0, 0x48, 0x86, 0xbc, 0x8f, 0x32, - 0x16, 0xbf, 0xf3, 0xa8, 0x2f, 0xe1, 0x1d, 0xd1, 0x3e, 0x64, 0x5d, 0x8c, 0xba, 0xe8, 0xe5, 0x49, - 0x7d, 0x61, 0x9d, 0x94, 0x9a, 0x8b, 0xd7, 0x12, 0x2e, 0x7f, 0x46, 0x53, 0x5f, 0x50, 0xf4, 0x45, - 0xbb, 0x90, 0x11, 0x99, 0xf3, 0x82, 0xd7, 0x24, 0xf5, 0x45, 0x75, 0x4f, 0x6a, 0x34, 0xbf, 0x4a, - 0xb3, 0xf8, 0x71, 0x50, 0x7d, 0x89, 0x7a, 0x36, 0x3a, 0x01, 0x08, 0x54, 0x0e, 0x96, 0x78, 0xf5, - 0x53, 0x5f, 0xa6, 0x4e, 0x8d, 0x0e, 0x21, 0xe7, 0xa1, 0xa7, 0x85, 0x6f, 0x70, 0xea, 0x8b, 0x0b, - 0xc6, 0xe8, 0x11, 0x94, 0xc2, 0xa8, 0x61, 0xb9, 0x97, 0x35, 0xf5, 0x25, 0x2b, 0xc1, 0x54, 0x7f, - 0x18, 0x42, 0x2c, 0xf7, 0xd2, 0xa6, 0xbe, 0x64, 0x61, 0x18, 0x7d, 0x00, 0x2b, 0xb3, 0x29, 0xfe, - 0xf2, 0x0f, 0x6f, 0xea, 0x57, 0x28, 0x15, 0xa3, 0x11, 0xa0, 0x39, 0xd0, 0xe0, 0x0a, 0xef, 0x70, - 0xea, 0x57, 0xa9, 0x1c, 0xa3, 0x3e, 0x54, 0xa6, 0xf3, 0xed, 0x65, 0xdf, 0xe5, 0xd4, 0x97, 0xae, - 0x22, 0xf3, 0x59, 0xc2, 0x79, 0xfa, 0xb2, 0xef, 0x74, 0xea, 0x4b, 0x17, 0x95, 0x9b, 0x8d, 0x2f, - 0xbf, 0x59, 0x8f, 0x7f, 0xf5, 0xcd, 0x7a, 0xfc, 0x4f, 0xdf, 0xac, 0xc7, 0x3f, 0xfb, 0x76, 0x3d, - 0xf6, 0xd5, 0xb7, 0xeb, 0xb1, 0x3f, 0x7c, 0xbb, 0x1e, 0xfb, 0xe1, 0x73, 0x67, 0x3a, 0x19, 0x8c, - 0x7b, 0x5b, 0x9a, 0x39, 0xda, 0xd6, 0xcc, 0x11, 0x26, 0xbd, 0x53, 0xe2, 0x37, 0xfc, 0xc7, 0x93, - 0xbd, 0x0c, 0x8b, 0x8f, 0x2f, 0xff, 0x23, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x34, 0xeb, 0xaa, 0x5c, - 0x29, 0x00, 0x00, + 0x01, 0x05, 0x2a, 0xb4, 0xca, 0x55, 0x2e, 0x95, 0xcb, 0xa5, 0x50, 0x89, 0x02, 0x07, 0xfe, 0x1f, + 0x1c, 0x39, 0x72, 0xa0, 0xc0, 0x81, 0x02, 0x07, 0x8e, 0x64, 0x97, 0x94, 0xf9, 0x1f, 0x70, 0xe0, + 0xc0, 0xae, 0x79, 0xec, 0x0b, 0xc0, 0x12, 0xa0, 0xe4, 0x72, 0x95, 0xcb, 0xd9, 0x4c, 0x4f, 0x77, + 0xcf, 0x4c, 0xcf, 0x6c, 0x77, 0xff, 0x7a, 0x07, 0x9e, 0x24, 0xd8, 0xe8, 0x63, 0x7b, 0xa4, 0x1b, + 0x64, 0x5b, 0xed, 0x69, 0xfa, 0x36, 0xb9, 0xb0, 0xb0, 0xb3, 0x65, 0xd9, 0x26, 0x31, 0x51, 0xc5, + 0x1f, 0xdc, 0xa2, 0x83, 0xf5, 0xa7, 0x02, 0xdc, 0x9a, 0x7d, 0x61, 0x11, 0x73, 0xdb, 0xb2, 0x4d, + 0xf3, 0x94, 0xf3, 0xd7, 0x6f, 0x06, 0x86, 0x99, 0x9e, 0xa0, 0xb6, 0xd0, 0xa8, 0x10, 0x7e, 0x8c, + 0x2f, 0xdc, 0xd1, 0xa7, 0x66, 0x64, 0x2d, 0xd5, 0x56, 0x47, 0xee, 0xf0, 0xc6, 0x99, 0x69, 0x9e, + 0x0d, 0xf1, 0x36, 0xeb, 0xf5, 0xc6, 0xa7, 0xdb, 0x44, 0x1f, 0x61, 0x87, 0xa8, 0x23, 0x4b, 0x30, + 0xac, 0x9e, 0x99, 0x67, 0x26, 0x6b, 0x6e, 0xd3, 0x16, 0xa7, 0x4a, 0x7f, 0xcf, 0x41, 0x56, 0xc6, + 0x1f, 0x8e, 0xb1, 0x43, 0xd0, 0x0e, 0xa4, 0xb0, 0x36, 0x30, 0x6b, 0xf1, 0xcd, 0xf8, 0xed, 0xc2, + 0xce, 0xcd, 0xad, 0xa9, 0xcd, 0x6d, 0x09, 0xbe, 0xb6, 0x36, 0x30, 0x3b, 0x31, 0x99, 0xf1, 0xa2, + 0x7b, 0x90, 0x3e, 0x1d, 0x8e, 0x9d, 0x41, 0x2d, 0xc1, 0x84, 0x9e, 0x8a, 0x12, 0x7a, 0x40, 0x99, + 0x3a, 0x31, 0x99, 0x73, 0xd3, 0xa9, 0x74, 0xe3, 0xd4, 0xac, 0x25, 0x2f, 0x9f, 0x6a, 0xd7, 0x38, + 0x65, 0x53, 0x51, 0x5e, 0xd4, 0x04, 0xd0, 0x0d, 0x9d, 0x28, 0xda, 0x40, 0xd5, 0x8d, 0x5a, 0x9a, + 0x49, 0x3e, 0x1d, 0x2d, 0xa9, 0x93, 0x16, 0x65, 0xec, 0xc4, 0xe4, 0xbc, 0xee, 0x76, 0xe8, 0x72, + 0x3f, 0x1c, 0x63, 0xfb, 0xa2, 0x96, 0xb9, 0x7c, 0xb9, 0x3f, 0xa0, 0x4c, 0x74, 0xb9, 0x8c, 0x1b, + 0xb5, 0xa1, 0xd0, 0xc3, 0x67, 0xba, 0xa1, 0xf4, 0x86, 0xa6, 0xf6, 0xb8, 0x96, 0x65, 0xc2, 0x52, + 0x94, 0x70, 0x93, 0xb2, 0x36, 0x29, 0x67, 0x27, 0x26, 0x43, 0xcf, 0xeb, 0xa1, 0xff, 0x81, 0x9c, + 0x36, 0xc0, 0xda, 0x63, 0x85, 0x4c, 0x6a, 0x39, 0xa6, 0x63, 0x23, 0x4a, 0x47, 0x8b, 0xf2, 0x75, + 0x27, 0x9d, 0x98, 0x9c, 0xd5, 0x78, 0x93, 0xee, 0xbf, 0x8f, 0x87, 0xfa, 0x39, 0xb6, 0xa9, 0x7c, + 0xfe, 0xf2, 0xfd, 0xdf, 0xe7, 0x9c, 0x4c, 0x43, 0xbe, 0xef, 0x76, 0xd0, 0xff, 0x41, 0x1e, 0x1b, + 0x7d, 0xb1, 0x0d, 0x60, 0x2a, 0x36, 0x23, 0xcf, 0xd9, 0xe8, 0xbb, 0x9b, 0xc8, 0x61, 0xd1, 0x46, + 0xaf, 0x41, 0x46, 0x33, 0x47, 0x23, 0x9d, 0xd4, 0x0a, 0x4c, 0x7a, 0x3d, 0x72, 0x03, 0x8c, 0xab, + 0x13, 0x93, 0x05, 0x3f, 0x3a, 0x80, 0xf2, 0x50, 0x77, 0x88, 0xe2, 0x18, 0xaa, 0xe5, 0x0c, 0x4c, + 0xe2, 0xd4, 0x8a, 0x4c, 0xc3, 0x33, 0x51, 0x1a, 0xf6, 0x75, 0x87, 0x1c, 0xbb, 0xcc, 0x9d, 0x98, + 0x5c, 0x1a, 0x06, 0x09, 0x54, 0x9f, 0x79, 0x7a, 0x8a, 0x6d, 0x4f, 0x61, 0xad, 0x74, 0xb9, 0xbe, + 0x43, 0xca, 0xed, 0xca, 0x53, 0x7d, 0x66, 0x90, 0x80, 0x7e, 0x04, 0xd7, 0x86, 0xa6, 0xda, 0xf7, + 0xd4, 0x29, 0xda, 0x60, 0x6c, 0x3c, 0xae, 0x95, 0x99, 0xd2, 0x3b, 0x91, 0x8b, 0x34, 0xd5, 0xbe, + 0xab, 0xa2, 0x45, 0x05, 0x3a, 0x31, 0x79, 0x65, 0x38, 0x4d, 0x44, 0x8f, 0x60, 0x55, 0xb5, 0xac, + 0xe1, 0xc5, 0xb4, 0xf6, 0x0a, 0xd3, 0x7e, 0x37, 0x4a, 0x7b, 0x83, 0xca, 0x4c, 0xab, 0x47, 0xea, + 0x0c, 0x15, 0x75, 0xa1, 0x6a, 0xd9, 0xd8, 0x52, 0x6d, 0xac, 0x58, 0xb6, 0x69, 0x99, 0x8e, 0x3a, + 0xac, 0x55, 0x99, 0xee, 0xe7, 0xa2, 0x74, 0x1f, 0x71, 0xfe, 0x23, 0xc1, 0xde, 0x89, 0xc9, 0x15, + 0x2b, 0x4c, 0xe2, 0x5a, 0x4d, 0x0d, 0x3b, 0x8e, 0xaf, 0x75, 0x65, 0x91, 0x56, 0xc6, 0x1f, 0xd6, + 0x1a, 0x22, 0x35, 0xb3, 0x90, 0x3e, 0x57, 0x87, 0x63, 0xfc, 0x76, 0x2a, 0x97, 0xaa, 0xa6, 0xa5, + 0xe7, 0xa0, 0x10, 0x70, 0x2c, 0xa8, 0x06, 0xd9, 0x11, 0x76, 0x1c, 0xf5, 0x0c, 0x33, 0x3f, 0x94, + 0x97, 0xdd, 0xae, 0x54, 0x86, 0x62, 0xd0, 0x99, 0x48, 0x9f, 0xc5, 0x3d, 0x49, 0xea, 0x27, 0xa8, + 0xe4, 0x39, 0xb6, 0x1d, 0xdd, 0x34, 0x5c, 0x49, 0xd1, 0x45, 0xb7, 0xa0, 0xc4, 0x6e, 0xbc, 0xe2, + 0x8e, 0x53, 0x67, 0x95, 0x92, 0x8b, 0x8c, 0xf8, 0x50, 0x30, 0x6d, 0x40, 0xc1, 0xda, 0xb1, 0x3c, + 0x96, 0x24, 0x63, 0x01, 0x6b, 0xc7, 0x72, 0x19, 0x9e, 0x86, 0x22, 0xdd, 0xa9, 0xc7, 0x91, 0x62, + 0x93, 0x14, 0x28, 0x4d, 0xb0, 0x48, 0xbf, 0x4f, 0x40, 0x75, 0xda, 0x01, 0xa1, 0xd7, 0x20, 0x45, + 0x7d, 0xb1, 0x70, 0xab, 0xf5, 0x2d, 0xee, 0xa8, 0xb7, 0x5c, 0x47, 0xbd, 0xd5, 0x75, 0x1d, 0x75, + 0x33, 0xf7, 0xe5, 0xd7, 0x1b, 0xb1, 0xcf, 0xfe, 0xb4, 0x11, 0x97, 0x99, 0x04, 0xba, 0x41, 0xfd, + 0x85, 0xaa, 0x1b, 0x8a, 0xde, 0x67, 0x4b, 0xce, 0x53, 0x67, 0xa0, 0xea, 0xc6, 0x6e, 0x1f, 0xed, + 0x43, 0x55, 0x33, 0x0d, 0x07, 0x1b, 0xce, 0xd8, 0x51, 0x78, 0x20, 0x10, 0xce, 0x34, 0xe4, 0x12, + 0x78, 0x78, 0x69, 0xb9, 0x9c, 0x47, 0x8c, 0x51, 0xae, 0x68, 0x61, 0x02, 0x7a, 0x00, 0x70, 0xae, + 0x0e, 0xf5, 0xbe, 0x4a, 0x4c, 0xdb, 0xa9, 0xa5, 0x36, 0x93, 0x73, 0xfd, 0xc2, 0x43, 0x97, 0xe5, + 0xc4, 0xea, 0xab, 0x04, 0x37, 0x53, 0x74, 0xb9, 0x72, 0x40, 0x12, 0x3d, 0x0b, 0x15, 0xd5, 0xb2, + 0x14, 0x87, 0xa8, 0x04, 0x2b, 0xbd, 0x0b, 0x82, 0x1d, 0xe6, 0xa7, 0x8b, 0x72, 0x49, 0xb5, 0xac, + 0x63, 0x4a, 0x6d, 0x52, 0x22, 0x7a, 0x06, 0xca, 0xd4, 0x27, 0xeb, 0xea, 0x50, 0x19, 0x60, 0xfd, + 0x6c, 0x40, 0x98, 0x3f, 0x4e, 0xca, 0x25, 0x41, 0xed, 0x30, 0xa2, 0xd4, 0xf7, 0x4e, 0x9c, 0xf9, + 0x63, 0x84, 0x20, 0xd5, 0x57, 0x89, 0xca, 0x2c, 0x59, 0x94, 0x59, 0x9b, 0xd2, 0x2c, 0x95, 0x0c, + 0x84, 0x7d, 0x58, 0x1b, 0xad, 0x41, 0x46, 0xa8, 0x4d, 0x32, 0xb5, 0xa2, 0x87, 0x56, 0x21, 0x6d, + 0xd9, 0xe6, 0x39, 0x66, 0x47, 0x97, 0x93, 0x79, 0x47, 0xfa, 0x24, 0x01, 0x2b, 0x33, 0x9e, 0x9b, + 0xea, 0x1d, 0xa8, 0xce, 0xc0, 0x9d, 0x8b, 0xb6, 0xd1, 0x2b, 0x54, 0xaf, 0xda, 0xc7, 0xb6, 0x88, + 0x76, 0xb5, 0x59, 0x53, 0x77, 0xd8, 0xb8, 0x30, 0x8d, 0xe0, 0x46, 0x7b, 0x50, 0x1d, 0xaa, 0x0e, + 0x51, 0xb8, 0x27, 0x54, 0x02, 0x91, 0xef, 0xc9, 0x19, 0x23, 0x73, 0xbf, 0x49, 0x2f, 0xb4, 0x50, + 0x52, 0xa6, 0xa2, 0x3e, 0x15, 0x9d, 0xc0, 0x6a, 0xef, 0xe2, 0x63, 0xd5, 0x20, 0xba, 0x81, 0x95, + 0x99, 0x53, 0x9b, 0x0d, 0xa5, 0xef, 0xe8, 0x4e, 0x0f, 0x0f, 0xd4, 0x73, 0xdd, 0x74, 0x97, 0x75, + 0xcd, 0x93, 0xf7, 0x4e, 0xd4, 0x91, 0x64, 0x28, 0x87, 0x43, 0x0f, 0x2a, 0x43, 0x82, 0x4c, 0xc4, + 0xfe, 0x13, 0x64, 0x82, 0x5e, 0x82, 0x14, 0xdd, 0x23, 0xdb, 0x7b, 0x79, 0xce, 0x44, 0x42, 0xae, + 0x7b, 0x61, 0x61, 0x99, 0x71, 0x4a, 0x92, 0xf7, 0x35, 0x78, 0xe1, 0x68, 0x5a, 0xab, 0x74, 0x07, + 0x2a, 0x53, 0xf1, 0x26, 0x70, 0x7c, 0xf1, 0xe0, 0xf1, 0x49, 0x15, 0x28, 0x85, 0x82, 0x8b, 0xb4, + 0x06, 0xab, 0xf3, 0x62, 0x85, 0x34, 0xf0, 0xe8, 0x21, 0x9f, 0x8f, 0xee, 0x41, 0xce, 0x0b, 0x16, + 0xfc, 0x6b, 0xbc, 0x31, 0xb3, 0x0b, 0x97, 0x59, 0xf6, 0x58, 0xe9, 0x67, 0x48, 0x6f, 0x35, 0xbb, + 0x0e, 0x09, 0xb6, 0xf0, 0xac, 0x6a, 0x59, 0x1d, 0xd5, 0x19, 0x48, 0xef, 0x43, 0x2d, 0x2a, 0x10, + 0x4c, 0x6d, 0x23, 0xe5, 0xdd, 0xc2, 0x35, 0xc8, 0x9c, 0x9a, 0xf6, 0x48, 0x25, 0x4c, 0x59, 0x49, + 0x16, 0x3d, 0x7a, 0x3b, 0x79, 0x50, 0x48, 0x32, 0x32, 0xef, 0x48, 0x0a, 0xdc, 0x88, 0x0c, 0x06, + 0x54, 0x44, 0x37, 0xfa, 0x98, 0xdb, 0xb3, 0x24, 0xf3, 0x8e, 0xaf, 0x88, 0x2f, 0x96, 0x77, 0xe8, + 0xb4, 0x0e, 0xdb, 0x2b, 0xd3, 0x9f, 0x97, 0x45, 0x4f, 0xfa, 0x3c, 0x09, 0x6b, 0xf3, 0x43, 0x02, + 0xda, 0x84, 0xe2, 0x48, 0x9d, 0x28, 0x64, 0x22, 0xbe, 0x65, 0x7e, 0x1c, 0x30, 0x52, 0x27, 0xdd, + 0x09, 0xff, 0x90, 0xab, 0x90, 0x24, 0x13, 0xa7, 0x96, 0xd8, 0x4c, 0xde, 0x2e, 0xca, 0xb4, 0x89, + 0x4e, 0x60, 0x65, 0x68, 0x6a, 0xea, 0x50, 0x09, 0xdc, 0x78, 0x71, 0xd9, 0x6f, 0xcd, 0x18, 0xbb, + 0x3d, 0x61, 0x94, 0xfe, 0xcc, 0xa5, 0xaf, 0x30, 0x1d, 0xfb, 0xde, 0xcd, 0x47, 0xf7, 0xa1, 0x30, + 0xf2, 0x2f, 0xf2, 0x15, 0x2e, 0x7b, 0x50, 0x2c, 0x70, 0x24, 0xe9, 0x90, 0x63, 0x70, 0x5d, 0x74, + 0xe6, 0xca, 0x2e, 0xfa, 0x25, 0x58, 0x35, 0xf0, 0x84, 0x04, 0x3e, 0x44, 0x7e, 0x4f, 0xb2, 0xcc, + 0xf4, 0x88, 0x8e, 0xf9, 0x1f, 0x19, 0xbd, 0x32, 0xe8, 0x0e, 0x0b, 0xaa, 0x96, 0xe9, 0x60, 0x5b, + 0x51, 0xfb, 0x7d, 0x1b, 0x3b, 0x0e, 0x4b, 0x06, 0x8b, 0x2c, 0x52, 0x32, 0x7a, 0x83, 0x93, 0xa5, + 0x9f, 0x07, 0x8f, 0x26, 0x14, 0x44, 0x5d, 0xc3, 0xc7, 0x7d, 0xc3, 0x1f, 0xc3, 0xaa, 0x90, 0xef, + 0x87, 0x6c, 0x9f, 0x58, 0xd6, 0xd1, 0x20, 0x57, 0x3c, 0xda, 0xec, 0xc9, 0xef, 0x66, 0x76, 0xd7, + 0x97, 0xa6, 0x02, 0xbe, 0xf4, 0xdf, 0xec, 0x28, 0xfe, 0x90, 0x87, 0x9c, 0x8c, 0x1d, 0x8b, 0x06, + 0x4e, 0xd4, 0x84, 0x3c, 0x9e, 0x68, 0xd8, 0x22, 0x6e, 0xae, 0x31, 0x1f, 0x0c, 0x70, 0xee, 0xb6, + 0xcb, 0x49, 0x33, 0x71, 0x4f, 0x0c, 0xbd, 0x2c, 0xc0, 0x56, 0x34, 0x6e, 0x12, 0xe2, 0x41, 0xb4, + 0xf5, 0x8a, 0x8b, 0xb6, 0x92, 0x91, 0xc9, 0x37, 0x97, 0x9a, 0x82, 0x5b, 0x2f, 0x0b, 0xb8, 0x95, + 0x5a, 0x30, 0x59, 0x08, 0x6f, 0xb5, 0x42, 0x78, 0x2b, 0xb3, 0x60, 0x9b, 0x11, 0x80, 0xeb, 0x15, + 0x17, 0x70, 0x65, 0x17, 0xac, 0x78, 0x0a, 0x71, 0x3d, 0x08, 0x23, 0xae, 0x5c, 0x84, 0x03, 0x71, + 0xa5, 0x23, 0x21, 0xd7, 0x9b, 0x01, 0xc8, 0x95, 0x8f, 0xc4, 0x3b, 0x5c, 0xc9, 0x1c, 0xcc, 0xd5, + 0x0a, 0x61, 0x2e, 0x58, 0x60, 0x83, 0x08, 0xd0, 0xf5, 0x56, 0x10, 0x74, 0x15, 0x22, 0x71, 0x9b, + 0x38, 0xef, 0x79, 0xa8, 0xeb, 0x75, 0x0f, 0x75, 0x15, 0x23, 0x61, 0xa3, 0xd8, 0xc3, 0x34, 0xec, + 0x3a, 0x9c, 0x81, 0x5d, 0x1c, 0x26, 0x3d, 0x1b, 0xa9, 0x62, 0x01, 0xee, 0x3a, 0x9c, 0xc1, 0x5d, + 0xe5, 0x05, 0x0a, 0x17, 0x00, 0xaf, 0x1f, 0xcf, 0x07, 0x5e, 0xd1, 0xd0, 0x48, 0x2c, 0x73, 0x39, + 0xe4, 0xa5, 0x44, 0x20, 0x2f, 0x8e, 0x8e, 0x9e, 0x8f, 0x54, 0xbf, 0x34, 0xf4, 0x3a, 0x99, 0x03, + 0xbd, 0x38, 0x48, 0xba, 0x1d, 0xa9, 0x7c, 0x09, 0xec, 0x75, 0x32, 0x07, 0x7b, 0xa1, 0x85, 0x6a, + 0xaf, 0x02, 0xbe, 0xd2, 0xd5, 0x8c, 0x74, 0x87, 0xa6, 0xbe, 0x53, 0x7e, 0x8a, 0xe6, 0x0f, 0xd8, + 0xb6, 0x4d, 0x5b, 0xc0, 0x28, 0xde, 0x91, 0x6e, 0xd3, 0x64, 0xdc, 0xf7, 0x49, 0x97, 0x00, 0x35, + 0x96, 0xa7, 0x05, 0xfc, 0x90, 0xf4, 0x9b, 0xb8, 0x2f, 0xcb, 0x72, 0xd8, 0x60, 0x22, 0x9f, 0x17, + 0x89, 0x7c, 0x00, 0xbe, 0x25, 0xc2, 0xf0, 0x6d, 0x03, 0x0a, 0x34, 0xff, 0x9a, 0x42, 0x66, 0xaa, + 0xe5, 0x21, 0xb3, 0xbb, 0xb0, 0xc2, 0x22, 0x1e, 0x07, 0x79, 0x22, 0xac, 0xa4, 0x58, 0x58, 0xa9, + 0xd0, 0x01, 0xfe, 0x41, 0xf1, 0xf8, 0xf2, 0x22, 0x5c, 0x0b, 0xf0, 0x7a, 0x79, 0x1d, 0x87, 0x29, + 0x55, 0x8f, 0xbb, 0x21, 0x12, 0xbc, 0xdf, 0xc5, 0x7d, 0x0b, 0xf9, 0x90, 0x6e, 0x1e, 0xfa, 0x8a, + 0xff, 0x93, 0xd0, 0x57, 0xe2, 0x3b, 0xa3, 0xaf, 0x60, 0x9e, 0x9a, 0x0c, 0xe7, 0xa9, 0x7f, 0x8d, + 0xfb, 0x67, 0xe2, 0x61, 0x29, 0xcd, 0xec, 0x63, 0x91, 0x39, 0xb2, 0x36, 0x4d, 0x2a, 0x86, 0xe6, + 0x99, 0xc8, 0x0f, 0x69, 0x93, 0x72, 0x79, 0x81, 0x23, 0x2f, 0xe2, 0x82, 0x97, 0x74, 0xf2, 0xc0, + 0x2d, 0x92, 0xce, 0x2a, 0x24, 0x1f, 0x63, 0x5e, 0x57, 0x2b, 0xca, 0xb4, 0x49, 0xf9, 0xd8, 0x55, + 0x13, 0x01, 0x98, 0x77, 0xd0, 0x6b, 0x90, 0x67, 0x15, 0x51, 0xc5, 0xb4, 0x1c, 0xe1, 0xd6, 0x43, + 0xb9, 0x09, 0x2f, 0x7c, 0x6e, 0x1d, 0x51, 0x9e, 0x43, 0xcb, 0x91, 0x73, 0x96, 0x68, 0x05, 0x32, + 0x86, 0x7c, 0x28, 0x63, 0xb8, 0x09, 0x79, 0xba, 0x7a, 0xc7, 0x52, 0x35, 0xcc, 0x5c, 0x74, 0x5e, + 0xf6, 0x09, 0xd2, 0x23, 0x40, 0xb3, 0x41, 0x02, 0x75, 0x20, 0x83, 0xcf, 0xb1, 0x41, 0x78, 0x06, + 0x55, 0xd8, 0x59, 0x9b, 0x4d, 0x4d, 0xe9, 0x70, 0xb3, 0x46, 0x8d, 0xfc, 0x97, 0xaf, 0x37, 0xaa, + 0x9c, 0xfb, 0x05, 0x73, 0xa4, 0x13, 0x3c, 0xb2, 0xc8, 0x85, 0x2c, 0xe4, 0xa5, 0x5f, 0xa6, 0x28, + 0x80, 0x09, 0x05, 0x90, 0xb9, 0xb6, 0x75, 0xaf, 0x7c, 0x22, 0x80, 0x5d, 0x97, 0xb3, 0xf7, 0x3a, + 0xc0, 0x99, 0xea, 0x28, 0x1f, 0xa9, 0x06, 0xc1, 0x7d, 0x61, 0xf4, 0x00, 0x05, 0xd5, 0x21, 0x47, + 0x7b, 0x63, 0x07, 0xf7, 0x05, 0x8c, 0xf6, 0xfa, 0x81, 0x7d, 0x66, 0xbf, 0xdf, 0x3e, 0xc3, 0x56, + 0xce, 0x4d, 0x59, 0x39, 0x00, 0x2e, 0xf2, 0x41, 0x70, 0x41, 0xd7, 0x66, 0xd9, 0xba, 0x69, 0xeb, + 0xe4, 0x82, 0x1d, 0x4d, 0x52, 0xf6, 0xfa, 0xe8, 0x16, 0x94, 0x46, 0x78, 0x64, 0x99, 0xe6, 0x50, + 0xe1, 0xee, 0xa6, 0xc0, 0x44, 0x8b, 0x82, 0xd8, 0xa6, 0x34, 0xf4, 0x0c, 0x94, 0x1d, 0xfd, 0xcc, + 0x08, 0x24, 0x68, 0xab, 0x8c, 0xab, 0xc4, 0xa9, 0x22, 0x3d, 0xa3, 0x77, 0xcd, 0x30, 0x0d, 0x0d, + 0xd7, 0x9e, 0x60, 0xce, 0x81, 0x77, 0xd0, 0x93, 0x90, 0xa7, 0x96, 0x18, 0xea, 0x34, 0x72, 0xae, + 0xb1, 0x11, 0x6a, 0x9a, 0x7d, 0xda, 0x77, 0x07, 0x2d, 0x5b, 0xd7, 0x70, 0xed, 0xba, 0x37, 0x78, + 0x44, 0xfb, 0xf4, 0x1c, 0x18, 0xd6, 0xad, 0x6d, 0xc6, 0x6f, 0xa7, 0x39, 0x9a, 0xa5, 0x4b, 0xb1, + 0xb1, 0x35, 0x54, 0x35, 0xac, 0xf6, 0x86, 0x98, 0xe6, 0x03, 0x37, 0x78, 0x6d, 0x23, 0x40, 0xed, + 0x4e, 0xa4, 0x9f, 0x25, 0x7c, 0x8f, 0xe1, 0xc3, 0xde, 0xff, 0xb8, 0x2b, 0x21, 0xfd, 0x82, 0xd5, + 0xc2, 0xc2, 0x49, 0x0d, 0x3a, 0x86, 0x15, 0xcf, 0x61, 0x29, 0x63, 0xe6, 0xc8, 0xdc, 0x4f, 0x70, + 0x59, 0x8f, 0x57, 0x3d, 0x0f, 0x93, 0x1d, 0xf4, 0x1e, 0x5c, 0x9f, 0xf2, 0xc6, 0x9e, 0xea, 0xc4, + 0xb2, 0x4e, 0xf9, 0x89, 0xb0, 0x53, 0x76, 0x55, 0xfb, 0xc6, 0x4a, 0x7e, 0x4f, 0x3f, 0xb1, 0x0b, + 0xe5, 0x70, 0x8e, 0x36, 0xf7, 0xf8, 0x6f, 0x41, 0xc9, 0xc6, 0x44, 0xd5, 0x0d, 0x25, 0x54, 0xc0, + 0x2a, 0x72, 0xa2, 0x28, 0x8b, 0x1d, 0xc1, 0x13, 0x73, 0x73, 0x35, 0xf4, 0x2a, 0xe4, 0xfd, 0x34, + 0x8f, 0x5b, 0xf5, 0x92, 0x02, 0x87, 0xcf, 0x2b, 0xfd, 0x36, 0xee, 0xab, 0x0c, 0x97, 0x4c, 0xda, + 0x90, 0xb1, 0xb1, 0x33, 0x1e, 0xf2, 0x22, 0x46, 0x79, 0xe7, 0xc5, 0xe5, 0xb2, 0x3c, 0x4a, 0x1d, + 0x0f, 0x89, 0x2c, 0x84, 0xa5, 0x47, 0x90, 0xe1, 0x14, 0x54, 0x80, 0xec, 0xc9, 0xc1, 0xde, 0xc1, + 0xe1, 0xbb, 0x07, 0xd5, 0x18, 0x02, 0xc8, 0x34, 0x5a, 0xad, 0xf6, 0x51, 0xb7, 0x1a, 0x47, 0x79, + 0x48, 0x37, 0x9a, 0x87, 0x72, 0xb7, 0x9a, 0xa0, 0x64, 0xb9, 0xfd, 0x76, 0xbb, 0xd5, 0xad, 0x26, + 0xd1, 0x0a, 0x94, 0x78, 0x5b, 0x79, 0x70, 0x28, 0xbf, 0xd3, 0xe8, 0x56, 0x53, 0x01, 0xd2, 0x71, + 0xfb, 0xe0, 0x7e, 0x5b, 0xae, 0xa6, 0xa5, 0xff, 0x82, 0x1b, 0x91, 0x79, 0xa1, 0x5f, 0x0f, 0x89, + 0x07, 0xea, 0x21, 0xd2, 0xe7, 0x09, 0xa8, 0x47, 0x27, 0x7b, 0xe8, 0xed, 0xa9, 0x8d, 0xef, 0x5c, + 0x21, 0x53, 0x9c, 0xda, 0x3d, 0xf7, 0x1c, 0xa7, 0x98, 0x68, 0x03, 0x9e, 0x7c, 0xf2, 0x20, 0x5f, + 0xa2, 0x9e, 0x83, 0x51, 0x99, 0x90, 0xc3, 0xd9, 0x3e, 0xc0, 0x1a, 0x51, 0xb8, 0xf7, 0xe4, 0x97, + 0x2e, 0x4f, 0xd9, 0x28, 0xf5, 0x98, 0x13, 0xa5, 0xf7, 0xaf, 0x64, 0xcb, 0x3c, 0xa4, 0xe5, 0x76, + 0x57, 0x7e, 0xaf, 0x9a, 0x44, 0x08, 0xca, 0xac, 0xa9, 0x1c, 0x1f, 0x34, 0x8e, 0x8e, 0x3b, 0x87, + 0xd4, 0x96, 0xd7, 0xa0, 0xe2, 0xda, 0xd2, 0x25, 0xa6, 0xa5, 0xe7, 0xe1, 0x7a, 0x44, 0xa6, 0x3a, + 0x5b, 0x77, 0x90, 0x7e, 0x15, 0x0f, 0x72, 0x87, 0xab, 0x14, 0x87, 0x90, 0x71, 0x88, 0x4a, 0xc6, + 0x8e, 0x30, 0xe2, 0xab, 0xcb, 0xa6, 0xae, 0x5b, 0x6e, 0xe3, 0x98, 0x89, 0xcb, 0x42, 0x8d, 0x74, + 0x0f, 0xca, 0xe1, 0x91, 0x68, 0x1b, 0xf8, 0x97, 0x28, 0x21, 0xbd, 0x07, 0x10, 0xa8, 0xa0, 0xae, + 0x42, 0xda, 0x36, 0xc7, 0x46, 0x9f, 0x2d, 0x2a, 0x2d, 0xf3, 0x0e, 0xba, 0x07, 0xe9, 0x73, 0x93, + 0xfb, 0x8c, 0xf9, 0x1f, 0xce, 0x43, 0x93, 0xe0, 0x40, 0xb9, 0x84, 0x73, 0x4b, 0x3a, 0xa0, 0xd9, + 0x2a, 0x56, 0xc4, 0x14, 0x6f, 0x86, 0xa7, 0x78, 0x3a, 0xb2, 0x1e, 0x36, 0x7f, 0xaa, 0x8f, 0x21, + 0xcd, 0xbc, 0x8d, 0x17, 0x9d, 0x44, 0xfa, 0xcc, 0xa2, 0xd3, 0x4f, 0x00, 0x54, 0x42, 0x6c, 0xbd, + 0x37, 0xf6, 0x27, 0xd8, 0x98, 0xef, 0xad, 0x1a, 0x2e, 0x5f, 0xf3, 0xa6, 0x70, 0x5b, 0xab, 0xbe, + 0x68, 0xc0, 0x75, 0x05, 0x14, 0x4a, 0x07, 0x50, 0x0e, 0xcb, 0xba, 0x09, 0x1f, 0x5f, 0x43, 0x38, + 0xe1, 0xe3, 0xf9, 0xbb, 0x48, 0xf8, 0xbc, 0x74, 0x31, 0xc9, 0x8b, 0xee, 0xac, 0x23, 0x7d, 0x1a, + 0x87, 0x5c, 0x77, 0x22, 0xee, 0x71, 0x44, 0xc1, 0xd7, 0x17, 0x4d, 0x04, 0xcb, 0x9b, 0xbc, 0x82, + 0x9c, 0xf4, 0xea, 0xd2, 0x6f, 0x79, 0x5f, 0x6a, 0x6a, 0x59, 0x7c, 0xee, 0xd6, 0xe7, 0x85, 0x77, + 0x7a, 0x03, 0xf2, 0x5e, 0xac, 0xa1, 0x38, 0xc4, 0x4d, 0x35, 0xe2, 0x22, 0x89, 0xf6, 0x93, 0x0c, + 0xcb, 0xfc, 0x48, 0x14, 0x50, 0x93, 0x32, 0xef, 0x48, 0x7d, 0xa8, 0x4c, 0x05, 0x2a, 0xf4, 0x06, + 0x64, 0xad, 0x71, 0x4f, 0x71, 0xcd, 0x33, 0x55, 0x31, 0x73, 0x33, 0xdc, 0x71, 0x6f, 0xa8, 0x6b, + 0x7b, 0xf8, 0xc2, 0x5d, 0x8c, 0x35, 0xee, 0xed, 0x71, 0x2b, 0xf2, 0x59, 0x12, 0xc1, 0x59, 0xce, + 0x21, 0xe7, 0x5e, 0x0a, 0xf4, 0xbf, 0x90, 0xf7, 0x62, 0xa0, 0xf7, 0x57, 0x29, 0x32, 0x78, 0x0a, + 0xf5, 0xbe, 0x08, 0x85, 0x4b, 0x2c, 0x7b, 0x12, 0x75, 0x42, 0x5e, 0x97, 0x48, 0xb0, 0xd3, 0xa9, + 0xf0, 0x81, 0x7d, 0x17, 0x06, 0x49, 0xbf, 0x8e, 0x43, 0x75, 0xfa, 0x56, 0xfe, 0x2b, 0x17, 0x40, + 0x9d, 0x22, 0xbd, 0xfd, 0x0a, 0xa6, 0x8b, 0xf0, 0xf0, 0x5f, 0x51, 0x2e, 0x51, 0x6a, 0xdb, 0x25, + 0x4a, 0x9f, 0x24, 0xa0, 0x10, 0xa8, 0x42, 0xa2, 0xff, 0x0e, 0x7c, 0x22, 0xe5, 0x39, 0xb9, 0x45, + 0x80, 0xd7, 0xff, 0x61, 0x11, 0xde, 0x58, 0xe2, 0xea, 0x1b, 0x8b, 0xfa, 0xf1, 0xe4, 0x16, 0x35, + 0x53, 0x57, 0x2e, 0x6a, 0xbe, 0x00, 0x88, 0x98, 0x44, 0x1d, 0x2a, 0xe7, 0x26, 0xd1, 0x8d, 0x33, + 0x85, 0x5f, 0x0d, 0x9e, 0xf1, 0x55, 0xd9, 0xc8, 0x43, 0x36, 0x70, 0xc4, 0x6e, 0xc9, 0x4f, 0xe3, + 0x90, 0xf3, 0x42, 0xf7, 0x55, 0xff, 0x3f, 0xac, 0x41, 0x46, 0x44, 0x27, 0xfe, 0x03, 0x42, 0xf4, + 0xe6, 0x56, 0x6f, 0xeb, 0x90, 0x1b, 0x61, 0xa2, 0xb2, 0xfc, 0x85, 0x43, 0x67, 0xaf, 0x7f, 0xf7, + 0x75, 0x28, 0x04, 0x7e, 0x05, 0x51, 0x3f, 0x71, 0xd0, 0x7e, 0xb7, 0x1a, 0xab, 0x67, 0x3f, 0xfd, + 0x62, 0x33, 0x79, 0x80, 0x3f, 0xa2, 0x5f, 0x98, 0xdc, 0x6e, 0x75, 0xda, 0xad, 0xbd, 0x6a, 0xbc, + 0x5e, 0xf8, 0xf4, 0x8b, 0xcd, 0xac, 0x8c, 0x59, 0xc1, 0xed, 0xee, 0x1e, 0x54, 0xa6, 0x0e, 0x26, + 0xec, 0xdf, 0x11, 0x94, 0xef, 0x9f, 0x1c, 0xed, 0xef, 0xb6, 0x1a, 0xdd, 0xb6, 0xf2, 0xf0, 0xb0, + 0xdb, 0xae, 0xc6, 0xd1, 0x75, 0xb8, 0xb6, 0xbf, 0xfb, 0xff, 0x9d, 0xae, 0xd2, 0xda, 0xdf, 0x6d, + 0x1f, 0x74, 0x95, 0x46, 0xb7, 0xdb, 0x68, 0xed, 0x55, 0x13, 0x3b, 0x7f, 0x03, 0xa8, 0x34, 0x9a, + 0xad, 0x5d, 0x1a, 0x9f, 0x75, 0x4d, 0x65, 0xa5, 0x8d, 0x16, 0xa4, 0x58, 0xf1, 0xe2, 0xd2, 0xc7, + 0x2d, 0xf5, 0xcb, 0xab, 0xb1, 0xe8, 0x01, 0xa4, 0x59, 0x5d, 0x03, 0x5d, 0xfe, 0xda, 0xa5, 0xbe, + 0xa0, 0x3c, 0x4b, 0x17, 0xc3, 0x3e, 0xa7, 0x4b, 0x9f, 0xbf, 0xd4, 0x2f, 0xaf, 0xd6, 0x22, 0x19, + 0xf2, 0x3e, 0xca, 0x58, 0xfc, 0x1c, 0xa4, 0xbe, 0x84, 0x77, 0x44, 0xfb, 0x90, 0x75, 0xa1, 0xec, + 0xa2, 0x07, 0x2a, 0xf5, 0x85, 0xe5, 0x54, 0x6a, 0x2e, 0x5e, 0x72, 0xb8, 0xfc, 0xb5, 0x4d, 0x7d, + 0x41, 0x6d, 0x18, 0xed, 0x42, 0x46, 0x64, 0xce, 0x0b, 0x1e, 0x9d, 0xd4, 0x17, 0x95, 0x47, 0xa9, + 0xd1, 0xfc, 0x62, 0xce, 0xe2, 0x37, 0x44, 0xf5, 0x25, 0xca, 0xde, 0xe8, 0x04, 0x20, 0x50, 0x60, + 0x58, 0xe2, 0x71, 0x50, 0x7d, 0x99, 0x72, 0x36, 0x3a, 0x84, 0x9c, 0x87, 0x9e, 0x16, 0x3e, 0xd5, + 0xa9, 0x2f, 0xae, 0x2b, 0xa3, 0x47, 0x50, 0x0a, 0xa3, 0x86, 0xe5, 0x1e, 0xe0, 0xd4, 0x97, 0x2c, + 0x18, 0x53, 0xfd, 0x61, 0x08, 0xb1, 0xdc, 0x83, 0x9c, 0xfa, 0x92, 0xf5, 0x63, 0xf4, 0x01, 0xac, + 0xcc, 0xa6, 0xf8, 0xcb, 0xbf, 0xcf, 0xa9, 0x5f, 0xa1, 0xa2, 0x8c, 0x46, 0x80, 0xe6, 0x40, 0x83, + 0x2b, 0x3c, 0xd7, 0xa9, 0x5f, 0xa5, 0xc0, 0x8c, 0xfa, 0x50, 0x99, 0xce, 0xb7, 0x97, 0x7d, 0xbe, + 0x53, 0x5f, 0xba, 0xd8, 0xcc, 0x67, 0x09, 0xe7, 0xe9, 0xcb, 0x3e, 0xe7, 0xa9, 0x2f, 0x5d, 0x7b, + 0x6e, 0x36, 0xbe, 0xfc, 0x66, 0x3d, 0xfe, 0xd5, 0x37, 0xeb, 0xf1, 0x3f, 0x7f, 0xb3, 0x1e, 0xff, + 0xec, 0xdb, 0xf5, 0xd8, 0x57, 0xdf, 0xae, 0xc7, 0xfe, 0xf8, 0xed, 0x7a, 0xec, 0x87, 0xcf, 0x9d, + 0xe9, 0x64, 0x30, 0xee, 0x6d, 0x69, 0xe6, 0x68, 0x5b, 0x33, 0x47, 0x98, 0xf4, 0x4e, 0x89, 0xdf, + 0xf0, 0xdf, 0x58, 0xf6, 0x32, 0x2c, 0x3e, 0xbe, 0xfc, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, + 0x12, 0xc9, 0xb6, 0x83, 0x29, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -6151,6 +6161,15 @@ func (m *ResponseCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ReplaceableTx) > 0 { + i -= len(m.ReplaceableTx) + copy(dAtA[i:], m.ReplaceableTx) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ReplaceableTx))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } if m.Type != 0 { i = encodeVarintTypes(dAtA, i, uint64(m.Type)) i-- @@ -8107,6 +8126,10 @@ func (m *ResponseCheckTx) Size() (n int) { if m.Type != 0 { n += 2 + sovTypes(uint64(m.Type)) } + l = len(m.ReplaceableTx) + if l > 0 { + n += 2 + l + sovTypes(uint64(l)) + } return n } @@ -13306,6 +13329,40 @@ func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { break } } + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplaceableTx", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReplaceableTx = append(m.ReplaceableTx[:0], dAtA[iNdEx:postIndex]...) + if m.ReplaceableTx == nil { + m.ReplaceableTx = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto index b2dc287dd..b376143a6 100644 --- a/proto/tendermint/abci/types.proto +++ b/proto/tendermint/abci/types.proto @@ -243,6 +243,8 @@ message ResponseCheckTx { uint64 gas_limit = 22; uint64 gas_price = 23; int32 type = 24; + // replaceable tx + bytes replaceable_tx = 25; } message ResponseDeliverTx { From 3b8a2be84f958039de80d707b44a7a2278e20ab3 Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Thu, 6 Mar 2025 22:25:14 +0800 Subject: [PATCH 3/7] impl tx replace --- mempool/v0/clist_mempool.go | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index 8b04d7063..38ed8ffde 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -5,6 +5,7 @@ import ( "errors" "sync" "sync/atomic" + "time" abci "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/config" @@ -221,9 +222,10 @@ func (mem *CListMempool) CheckTx( txSize := len(tx) - if err := mem.isFull(txSize); err != nil { - return err - } + // check mempool size when handling checkTx response in resCbFirstTime + // if err := mem.isFull(txSize); err != nil { + // return err + // } if txSize > mem.config.MaxTxBytes { return mempool.ErrTxTooLarge{ @@ -394,10 +396,22 @@ func (mem *CListMempool) resCbFirstTime( // Check mempool isn't full again to reduce the chance of exceeding the // limits. if err := mem.isFull(len(tx)); err != nil { - // remove from cache (mempool might have a space later) - mem.cache.Remove(tx) - mem.logger.Error(err.Error()) - return + if len(r.CheckTx.ReplaceableTx) > 0 { + replaceableTx := types.Tx(r.CheckTx.ReplaceableTx) + if e, ok := mem.txsMap.Load(replaceableTx.Key()); ok { + mem.removeTx(replaceableTx, e.(*clist.CElement), true) + } else { + // remove from cache (mempool might have a space later) + mem.cache.Remove(tx) + mem.logger.Error(err.Error()) + return + } + } else { + // remove from cache (mempool might have a space later) + mem.cache.Remove(tx) + mem.logger.Error(err.Error()) + return + } } // Check transaction not already in the mempool @@ -424,6 +438,7 @@ func (mem *CListMempool) resCbFirstTime( gasPrice: r.CheckTx.GasPrice, gasLimit: r.CheckTx.GasLimit, txType: r.CheckTx.Type, + timestamp: uint64(time.Now().UnixNano()), } memTx.senders.Store(peerID, true) mem.addTx(memTx) @@ -712,6 +727,7 @@ type mempoolTx struct { txType int32 gasPrice uint64 gasLimit uint64 + timestamp uint64 } // Height returns the height for this transaction From 66e7a3037323d5e694b54a1f68c2e1cec091bf98 Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Fri, 7 Mar 2025 18:24:08 +0800 Subject: [PATCH 4/7] update --- mempool/v0/clist_mempool.go | 355 ++++++++++++++++++++++++++++++++---- 1 file changed, 317 insertions(+), 38 deletions(-) diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index 38ed8ffde..17b37ca42 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -3,9 +3,14 @@ package v0 import ( "bytes" "errors" + "fmt" + "math" + "runtime" + "sort" + "strconv" + "strings" "sync" "sync/atomic" - "time" abci "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/config" @@ -19,6 +24,8 @@ import ( "github.com/cometbft/cometbft/types" ) +const pendingQueuePreallocationSize int = 10 + // CListMempool is an ordered in-memory pool for transactions before they are // proposed in a consensus round. Transaction validity is checked using the // CheckTx abci message before the transaction is added to the pool. The @@ -62,6 +69,9 @@ type CListMempool struct { logger log.Logger metrics *mempool.Metrics + + pending pendingPool + removed removedPool } var _ mempool.Mempool = &CListMempool{} @@ -152,12 +162,12 @@ func (mem *CListMempool) Unlock() { // Safe for concurrent use by multiple goroutines. func (mem *CListMempool) Size() int { - return mem.txs.Len() + return mem.txs.Len() - mem.removed.Size() } // Safe for concurrent use by multiple goroutines. func (mem *CListMempool) SizeBytes() int64 { - return atomic.LoadInt64(&mem.txsBytes) + return atomic.LoadInt64(&mem.txsBytes) - mem.removed.SizeBytes() } // Lock() must be help by the caller during execution. @@ -262,7 +272,8 @@ func (mem *CListMempool) CheckTx( return mempool.ErrTxInCache } - reqRes := mem.proxyAppConn.CheckTxAsync(abci.RequestCheckTx{Tx: tx}) + reqRes := mem.proxyAppConn.CheckTxAsync(abci.RequestCheckTx{Tx: tx}) // NOTE: app mempool insert + // Note: execute 'mem.reqResCb(tx, txInfo.SenderID, txInfo.SenderP2PID, cb)' immediately reqRes.SetCallback(mem.reqResCb(tx, txInfo.SenderID, txInfo.SenderP2PID, cb)) return nil @@ -310,7 +321,7 @@ func (mem *CListMempool) reqResCb( panic("recheck cursor is not nil in reqResCb") } - mem.resCbFirstTime(tx, peerID, peerP2PID, res) + mem.resCbFirstTime(tx, peerID, peerP2PID, res) // Note: mempool insert // update metrics mem.metrics.Size.Set(float64(mem.Size())) @@ -330,13 +341,17 @@ func (mem *CListMempool) addTx(memTx *mempoolTx) { mem.txsMap.Store(memTx.tx.Key(), e) atomic.AddInt64(&mem.txsBytes, int64(len(memTx.tx))) mem.metrics.TxSizeBytes.Observe(float64(len(memTx.tx))) + + mem.pending.Add(memTx) } // Called from: // - Update (lock held) if tx was committed // - resCbRecheck (lock not held) if tx was invalidated func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromCache bool) { - mem.txs.Remove(elem) + removed := mem.txs.Remove(elem) + memTx := removed.(*mempoolTx) + elem.DetachPrev() mem.txsMap.Delete(tx.Key()) atomic.AddInt64(&mem.txsBytes, int64(-len(tx))) @@ -344,6 +359,8 @@ func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromC if removeFromCache { mem.cache.Remove(tx) } + + mem.removed.Add(memTx) } // RemoveTxByKey removes a transaction from the mempool by its TxKey index. @@ -393,27 +410,6 @@ func (mem *CListMempool) resCbFirstTime( postCheckErr = mem.postCheck(tx, r.CheckTx) } if (r.CheckTx.Code == abci.CodeTypeOK) && postCheckErr == nil { - // Check mempool isn't full again to reduce the chance of exceeding the - // limits. - if err := mem.isFull(len(tx)); err != nil { - if len(r.CheckTx.ReplaceableTx) > 0 { - replaceableTx := types.Tx(r.CheckTx.ReplaceableTx) - if e, ok := mem.txsMap.Load(replaceableTx.Key()); ok { - mem.removeTx(replaceableTx, e.(*clist.CElement), true) - } else { - // remove from cache (mempool might have a space later) - mem.cache.Remove(tx) - mem.logger.Error(err.Error()) - return - } - } else { - // remove from cache (mempool might have a space later) - mem.cache.Remove(tx) - mem.logger.Error(err.Error()) - return - } - } - // Check transaction not already in the mempool if e, ok := mem.txsMap.Load(types.Tx(tx).Key()); ok { memTx := e.(*clist.CElement).Value.(*mempoolTx) @@ -428,6 +424,7 @@ func (mem *CListMempool) resCbFirstTime( return } + // make new mempoolTx memTx := &mempoolTx{ height: mem.height, gasWanted: r.CheckTx.GasWanted, @@ -438,18 +435,22 @@ func (mem *CListMempool) resCbFirstTime( gasPrice: r.CheckTx.GasPrice, gasLimit: r.CheckTx.GasLimit, txType: r.CheckTx.Type, - timestamp: uint64(time.Now().UnixNano()), } memTx.senders.Store(peerID, true) - mem.addTx(memTx) - mem.logger.Debug( - "added good transaction", - "tx", types.Tx(tx).Hash(), - "res", r, - "height", memTx.height, - "total", mem.Size(), - ) - mem.notifyTxsAvailable() + + if err := mem.tryToAppnedTx(memTx); err == nil { + mem.logger.Debug( + "added good transaction", + "tx", types.Tx(tx).Hash(), + "res", r, + "height", memTx.height, + "total", mem.Size(), + ) + + mem.notifyTxsAvailable() + } else { + mem.logger.Error(err.Error()) + } } else { // ignore bad transaction mem.logger.Debug( @@ -472,6 +473,42 @@ func (mem *CListMempool) resCbFirstTime( } } +func (mem *CListMempool) tryToAppnedTx(memTx *mempoolTx) error { + mem.updateMtx.RLock() + defer mem.updateMtx.RUnlock() + + lastNonce, err := mem.pending.GetLastNonce(memTx.signerAddress) + if err != nil { + return err + } + + if lastNonce > 0 { + if memTx.nonce != lastNonce+1 { + return fmt.Errorf("invalid nonce; got %d, expected %d", memTx.nonce, lastNonce+1) + } + } + + mem.addTx(memTx) + + // find and drop, if mempool is full + if err := mem.isFull(0); err != nil { + if mem.Size() > mem.config.Size { + mem.markRemovableTxs() + } + + if memTx.removed { + // new add memTx marked as removed, it means add failed, return error with reason "mempool is full" + // remove from cache (mempool might have a space later) + if e, ok := mem.txsMap.Load(memTx.tx.Key()); ok { + mem.removeTx(memTx.tx, e.(*clist.CElement), true) + } + return err + } + } + + return nil +} + // callback, which is called after the app rechecked the tx. // // The case where the app checks the tx for the first time is handled by the @@ -582,6 +619,11 @@ func (mem *CListMempool) ReapMaxBytesMaxGas(maxBytes, maxGas int64) types.Txs { for e := mem.txs.Front(); e != nil; e = e.Next() { memTx := e.Value.(*mempoolTx) + // skip removed tx + if memTx.removed { + continue + } + txs = append(txs, memTx.tx) dataSize := types.ComputeProtoSizeForTxs([]types.Tx{memTx.tx}) @@ -618,6 +660,10 @@ func (mem *CListMempool) ReapMaxTxs(max int) types.Txs { txs := make([]types.Tx, 0, cmtmath.MinInt(mem.txs.Len(), max)) for e := mem.txs.Front(); e != nil && len(txs) <= max; e = e.Next() { memTx := e.Value.(*mempoolTx) + // skip removed tx + if memTx.removed { + continue + } txs = append(txs, memTx.tx) } return txs @@ -666,6 +712,11 @@ func (mem *CListMempool) Update( } } + // clean txs marked as removed + if mem.removed.Size() > 0 { + mem.cleanUpMarkedRemovedTxs() + } + // Either recheck non-committed txs to see if they became invalid // or just notify there're some txs left. if mem.Size() > 0 { @@ -684,6 +735,7 @@ func (mem *CListMempool) Update( mem.metrics.Size.Set(float64(mem.Size())) mem.metrics.SizeBytes.Set(float64(mem.SizeBytes())) + mem.logger.Info("=====================================================================================================") return nil } @@ -700,6 +752,12 @@ func (mem *CListMempool) recheckTxs() { // NOTE: globalCb may be called concurrently. for e := mem.txs.Front(); e != nil; e = e.Next() { memTx := e.Value.(*mempoolTx) + + // skip removed tx + if memTx.removed { + continue + } + mem.proxyAppConn.CheckTxAsync(abci.RequestCheckTx{ Tx: memTx.tx, Type: abci.CheckTxType_Recheck, @@ -709,6 +767,89 @@ func (mem *CListMempool) recheckTxs() { mem.proxyAppConn.FlushAsync() } +func (mem *CListMempool) cleanUpMarkedRemovedTxs() { + mem.removed.lock.Lock() + defer mem.removed.lock.Unlock() + for i := range mem.removed.data { + memTx := mem.removed.data[i] + + if e, ok := mem.txsMap.Load(memTx.tx.Key()); ok { + elem := e.(*clist.CElement) + mem.txs.Remove(elem) + elem.DetachPrev() + mem.txsMap.Delete(memTx.tx.Key()) + atomic.AddInt64(&mem.txsBytes, int64(-len(memTx.tx))) + } + } + + for i := range mem.removed.data { + mem.pending.CleanUp(mem.removed.data[i].signerAddress) + } + + mem.removed.data = nil +} + +func (mem *CListMempool) markRemovableTxs() { + mem.logger.Info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) + mem.pending.lock.RLock() + defer mem.pending.lock.RUnlock() + totalPendingTxCnt := 0 + // Simulate the execution order based on reference nonce and gas price + cursorGrp := make(map[string]int, len(mem.pending.data)) + for key := range mem.pending.data { + cursorGrp[key] = 0 + totalPendingTxCnt += len(mem.pending.data[key]) + } + totalPendingTxCnt -= mem.removed.Size() + cnt := 0 + for cnt < totalPendingTxCnt { + var highestGasPrice uint64 + var selectedMemTx *mempoolTx + + for sender, txs := range mem.pending.data { + if cursor, exists := cursorGrp[sender]; exists { + if cursor < len(txs) { + thisTx := txs[cursor] + if !thisTx.removed { + if thisTx.txType == 0 { + highestGasPrice = math.MaxUint64 + selectedMemTx = thisTx + } else { + if highestGasPrice == 0 || thisTx.gasPrice > highestGasPrice { + highestGasPrice = thisTx.gasPrice + selectedMemTx = thisTx + } + } + } else { + + } + } + } + } + + if selectedMemTx == nil { + break + } + mem.logger.Info("tx selected", "sender", selectedMemTx.signerAddress, "nonce", selectedMemTx.nonce, "gid", getGoroutineID()) + + if cnt >= mem.config.Size { + txs := mem.pending.data[selectedMemTx.signerAddress] + for i := cursorGrp[selectedMemTx.signerAddress]; i < len(txs); i++ { + if !txs[i].removed { + mem.removed.Add(txs[i]) + mem.logger.Info("tx marked removed", "sender", txs[i].signerAddress, "nonce", txs[i].nonce, "gid", getGoroutineID()) + } + cursorGrp[selectedMemTx.signerAddress]++ + cnt++ + } + } else { + cursorGrp[selectedMemTx.signerAddress]++ + cnt++ + } + } + mem.logger.Info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) +} + //-------------------------------------------------------------------------------- // mempoolTx is a transaction that successfully ran @@ -727,10 +868,148 @@ type mempoolTx struct { txType int32 gasPrice uint64 gasLimit uint64 - timestamp uint64 + + removed bool } // Height returns the height for this transaction func (memTx *mempoolTx) Height() int64 { return atomic.LoadInt64(&memTx.height) } + +// -------------------------------------------------------------------------------- +type removedPool struct { + lock sync.RWMutex + data []*mempoolTx +} + +// Safe for concurrent use by multiple goroutines. +func (rp *removedPool) Size() int { + rp.lock.RLock() + defer rp.lock.RUnlock() + + return len(rp.data) +} + +// Safe for concurrent use by multiple goroutines. +func (rp *removedPool) SizeBytes() int64 { + rp.lock.RLock() + defer rp.lock.RUnlock() + + var size int64 + for _, tx := range rp.data { + size += int64(len(tx.tx)) + } + + return size +} + +func (rp *removedPool) Add(tx *mempoolTx) { + rp.lock.Lock() + defer rp.lock.Unlock() + + if !tx.removed { + tx.removed = true + if rp.data == nil { + rp.data = make([]*mempoolTx, 0, pendingQueuePreallocationSize) + } + rp.data = append(rp.data, tx) + } +} + +// -------------------------------------------------------------------------------- +type pendingPool struct { + lock sync.RWMutex + data map[string][]*mempoolTx +} + +// Safe for concurrent use by multiple goroutines. +func (pp *pendingPool) Size() int { + pp.lock.RLock() + defer pp.lock.RUnlock() + + size := 0 + + for _, txs := range pp.data { + size += len(txs) + } + + return size +} + +func (pp *pendingPool) Add(tx *mempoolTx) { + pp.lock.Lock() + defer pp.lock.Unlock() + + if pp.data == nil { + pp.data = make(map[string][]*mempoolTx) + } + + sender := tx.signerAddress + if _, exists := pp.data[sender]; !exists { + pp.data[sender] = make([]*mempoolTx, 0, pendingQueuePreallocationSize) + } + pp.data[sender] = append(pp.data[sender], tx) + + if len(pp.data[sender]) > 1 { + sort.Slice(pp.data[sender], func(i, j int) bool { + return pp.data[sender][i].nonce < pp.data[sender][j].nonce + }) + } +} + +func (pp *pendingPool) CleanUp(sender string) { + pp.lock.Lock() + defer pp.lock.Unlock() + + if _, exists := pp.data[sender]; exists { + txs := pp.data[sender] + newTxs := make([]*mempoolTx, 0, len(txs)) + for i := range txs { + if !txs[i].removed { + newTxs = append(newTxs, txs[i]) + } + } + if len(newTxs) == 0 { + delete(pp.data, sender) + } else { + pp.data[sender] = newTxs + } + } +} + +func (pp *pendingPool) CanAppend(sender string) bool { + pp.lock.RLock() + defer pp.lock.RUnlock() + + if _, exists := pp.data[sender]; exists { + return !pp.data[sender][len(pp.data[sender])-1].removed + } + + return true +} + +func (pp *pendingPool) GetLastNonce(sender string) (uint64, error) { + pp.lock.RLock() + defer pp.lock.RUnlock() + + if _, exists := pp.data[sender]; exists { + for i := len(pp.data[sender]) - 1; i >= 0; i-- { + if !pp.data[sender][i].removed { + return pp.data[sender][i].nonce, nil + } + } + return 0, errors.New("invalid nonce") + } + return 0, nil +} + +func getGoroutineID() int { + var buf [64]byte + n := runtime.Stack(buf[:], false) + stack := string(buf[:n]) + + idField := strings.Fields(strings.TrimPrefix(stack, "goroutine "))[0] + id, _ := strconv.Atoi(idField) + return id +} From c1b2d25dae617aadc35f0f296850e62b856b5552 Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Fri, 7 Mar 2025 20:51:44 +0800 Subject: [PATCH 5/7] update --- mempool/v0/clist_mempool.go | 183 +++++++++++++++++++++++++----------- 1 file changed, 130 insertions(+), 53 deletions(-) diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index 17b37ca42..e92d42f38 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -192,6 +192,9 @@ func (mem *CListMempool) Flush() { mem.txsMap.Delete(key) return true }) + + mem.removed.Flush() + mem.pending.Flush() } // TxsFront returns the first transaction in the ordered list for peer @@ -232,11 +235,6 @@ func (mem *CListMempool) CheckTx( txSize := len(tx) - // check mempool size when handling checkTx response in resCbFirstTime - // if err := mem.isFull(txSize); err != nil { - // return err - // } - if txSize > mem.config.MaxTxBytes { return mempool.ErrTxTooLarge{ Max: mem.config.MaxTxBytes, @@ -244,6 +242,38 @@ func (mem *CListMempool) CheckTx( } } + memSize := mem.Size() + txsBytes := mem.SizeBytes() + recheckFull := mem.recheckFull.Load() + + if recheckFull { + return mempool.ErrMempoolIsFull{ + NumTxs: memSize, + MaxTxs: mem.config.Size, + TxsBytes: txsBytes, + MaxTxsBytes: mem.config.MaxTxsBytes, + } + } + + if int64(txSize)+txsBytes > mem.config.MaxTxsBytes { + return mempool.ErrMempoolIsFull{ + NumTxs: memSize, + MaxTxs: mem.config.Size, + TxsBytes: txsBytes, + MaxTxsBytes: mem.config.MaxTxsBytes, + } + } + + // Note: always allow to append new tx + // if memSize >= mem.config.Size { + // return mempool.ErrMempoolIsFull{ + // NumTxs: memSize, + // MaxTxs: mem.config.Size, + // TxsBytes: txsBytes, + // MaxTxsBytes: mem.config.MaxTxsBytes, + // } + // } + if mem.preCheck != nil { if err := mem.preCheck(tx); err != nil { return mempool.ErrPreCheck{ @@ -274,6 +304,7 @@ func (mem *CListMempool) CheckTx( reqRes := mem.proxyAppConn.CheckTxAsync(abci.RequestCheckTx{Tx: tx}) // NOTE: app mempool insert // Note: execute 'mem.reqResCb(tx, txInfo.SenderID, txInfo.SenderP2PID, cb)' immediately + // mem.logger.Info("Debug>> mempool status: CheckTx", "txSize", memSize, "txBytes", txsBytes, "gid", getGoroutineID()) reqRes.SetCallback(mem.reqResCb(tx, txInfo.SenderID, txInfo.SenderP2PID, cb)) return nil @@ -360,7 +391,7 @@ func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromC mem.cache.Remove(tx) } - mem.removed.Add(memTx) + mem.pending.Remove(memTx) } // RemoveTxByKey removes a transaction from the mempool by its TxKey index. @@ -403,6 +434,7 @@ func (mem *CListMempool) resCbFirstTime( peerP2PID p2p.ID, res *abci.Response, ) { + // mem.logger.Info("Debug>> mempool status: resCbFirstTime", "txSize", mem.Size(), "txBytes", mem.SizeBytes(), "gid", getGoroutineID()) switch r := res.Value.(type) { case *abci.Response_CheckTx: var postCheckErr error @@ -410,6 +442,36 @@ func (mem *CListMempool) resCbFirstTime( postCheckErr = mem.postCheck(tx, r.CheckTx) } if (r.CheckTx.Code == abci.CodeTypeOK) && postCheckErr == nil { + // Check mempool isn't full again to reduce the chance of exceeding the + // limits. + memSize := mem.Size() + txsBytes := mem.SizeBytes() + recheckFull := mem.recheckFull.Load() + + if recheckFull { + // remove from cache (mempool might have a space later) + mem.cache.Remove(tx) + mem.logger.Error(mempool.ErrMempoolIsFull{ + NumTxs: memSize, + MaxTxs: mem.config.Size, + TxsBytes: txsBytes, + MaxTxsBytes: mem.config.MaxTxsBytes, + }.Error()) + return + } + + if int64(len(tx))+txsBytes > mem.config.MaxTxsBytes { + // remove from cache (mempool might have a space later) + mem.cache.Remove(tx) + mem.logger.Error(mempool.ErrMempoolIsFull{ + NumTxs: memSize, + MaxTxs: mem.config.Size, + TxsBytes: txsBytes, + MaxTxsBytes: mem.config.MaxTxsBytes, + }.Error()) + return + } + // Check transaction not already in the mempool if e, ok := mem.txsMap.Load(types.Tx(tx).Key()); ok { memTx := e.(*clist.CElement).Value.(*mempoolTx) @@ -474,36 +536,33 @@ func (mem *CListMempool) resCbFirstTime( } func (mem *CListMempool) tryToAppnedTx(memTx *mempoolTx) error { - mem.updateMtx.RLock() - defer mem.updateMtx.RUnlock() - - lastNonce, err := mem.pending.GetLastNonce(memTx.signerAddress) - if err != nil { - return err - } + mem.pending.CleanUp(memTx.signerAddress) + // lastNonce, err := mem.pending.GetLastNonce(memTx.signerAddress) + // if err != nil { + // mem.logger.Error("failed to get last nonce", "err", err.Error()) + // return err + // } - if lastNonce > 0 { - if memTx.nonce != lastNonce+1 { - return fmt.Errorf("invalid nonce; got %d, expected %d", memTx.nonce, lastNonce+1) - } - } + // if lastNonce > 0 { + // if memTx.nonce != lastNonce+1 { + // return fmt.Errorf("invalid nonce; got %d, expected %d", memTx.nonce, lastNonce+1) + // } + // } mem.addTx(memTx) // find and drop, if mempool is full - if err := mem.isFull(0); err != nil { - if mem.Size() > mem.config.Size { - mem.markRemovableTxs() - } + if mem.Size() > mem.config.Size { + mem.markRemovableTxs() + } - if memTx.removed { - // new add memTx marked as removed, it means add failed, return error with reason "mempool is full" - // remove from cache (mempool might have a space later) - if e, ok := mem.txsMap.Load(memTx.tx.Key()); ok { - mem.removeTx(memTx.tx, e.(*clist.CElement), true) - } - return err + if memTx.removed { + // new add memTx marked as removed, it means add failed, return error with reason "mempool is full" + // remove from cache (mempool might have a space later) + if e, ok := mem.txsMap.Load(memTx.tx.Key()); ok { + mem.removeTx(memTx.tx, e.(*clist.CElement), true) } + return fmt.Errorf("gas price is too low") } return nil @@ -917,6 +976,12 @@ func (rp *removedPool) Add(tx *mempoolTx) { } } +func (rp *removedPool) Flush() { + rp.lock.Lock() + defer rp.lock.Unlock() + rp.data = nil +} + // -------------------------------------------------------------------------------- type pendingPool struct { lock sync.RWMutex @@ -958,6 +1023,21 @@ func (pp *pendingPool) Add(tx *mempoolTx) { } } +func (pp *pendingPool) Remove(tx *mempoolTx) { + pp.lock.Lock() + defer pp.lock.Unlock() + + sender := tx.signerAddress + if _, exists := pp.data[sender]; exists { + for i := range pp.data[sender] { + if pp.data[sender][i] == tx { + pp.data[sender] = append(pp.data[sender][:i], pp.data[sender][i+1:]...) + break + } + } + } +} + func (pp *pendingPool) CleanUp(sender string) { pp.lock.Lock() defer pp.lock.Unlock() @@ -978,30 +1058,27 @@ func (pp *pendingPool) CleanUp(sender string) { } } -func (pp *pendingPool) CanAppend(sender string) bool { - pp.lock.RLock() - defer pp.lock.RUnlock() - - if _, exists := pp.data[sender]; exists { - return !pp.data[sender][len(pp.data[sender])-1].removed - } - - return true -} - -func (pp *pendingPool) GetLastNonce(sender string) (uint64, error) { - pp.lock.RLock() - defer pp.lock.RUnlock() - - if _, exists := pp.data[sender]; exists { - for i := len(pp.data[sender]) - 1; i >= 0; i-- { - if !pp.data[sender][i].removed { - return pp.data[sender][i].nonce, nil - } - } - return 0, errors.New("invalid nonce") - } - return 0, nil +// func (pp *pendingPool) GetLastNonce(sender string) (uint64, error) { +// pp.lock.RLock() +// defer pp.lock.RUnlock() + +// if _, exists := pp.data[sender]; exists { +// if len(pp.data[sender]) > 0 { +// for i := len(pp.data[sender]) - 1; i >= 0; i-- { +// if !pp.data[sender][i].removed { +// return pp.data[sender][i].nonce, nil +// } +// } +// return 0, errors.New("invalid nonce") +// } +// } +// return 0, nil +// } + +func (pp *pendingPool) Flush() { + pp.lock.Lock() + defer pp.lock.Unlock() + pp.data = nil } func getGoroutineID() int { From 95ea2922fb7aafde12eb9dbd8797711a65dc055c Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Fri, 7 Mar 2025 22:58:28 +0800 Subject: [PATCH 6/7] update --- mempool/v0/clist_mempool.go | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index e92d42f38..c9378c177 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -5,12 +5,10 @@ import ( "errors" "fmt" "math" - "runtime" "sort" - "strconv" - "strings" "sync" "sync/atomic" + "time" abci "github.com/cometbft/cometbft/abci/types" "github.com/cometbft/cometbft/config" @@ -24,7 +22,10 @@ import ( "github.com/cometbft/cometbft/types" ) -const pendingQueuePreallocationSize int = 10 +const ( + pendingQueuePreallocationSize int = 10 + overflowEliminationRate int = 3 // in percentage +) // CListMempool is an ordered in-memory pool for transactions before they are // proposed in a consensus round. Transaction validity is checked using the @@ -553,7 +554,9 @@ func (mem *CListMempool) tryToAppnedTx(memTx *mempoolTx) error { // find and drop, if mempool is full if mem.Size() > mem.config.Size { + startAt := time.Now() mem.markRemovableTxs() + mem.logger.Info("markRemovableTxs done", "costed", fmt.Sprint(time.Since(startAt).Milliseconds())) } if memTx.removed { @@ -849,9 +852,12 @@ func (mem *CListMempool) cleanUpMarkedRemovedTxs() { } func (mem *CListMempool) markRemovableTxs() { - mem.logger.Info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) + // mem.logger.Info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) mem.pending.lock.RLock() defer mem.pending.lock.RUnlock() + + targetCnt := calTargetSize(mem.config.Size) + removedCnt := 0 totalPendingTxCnt := 0 // Simulate the execution order based on reference nonce and gas price cursorGrp := make(map[string]int, len(mem.pending.data)) @@ -889,14 +895,14 @@ func (mem *CListMempool) markRemovableTxs() { if selectedMemTx == nil { break } - mem.logger.Info("tx selected", "sender", selectedMemTx.signerAddress, "nonce", selectedMemTx.nonce, "gid", getGoroutineID()) - if cnt >= mem.config.Size { + if cnt >= targetCnt { txs := mem.pending.data[selectedMemTx.signerAddress] for i := cursorGrp[selectedMemTx.signerAddress]; i < len(txs); i++ { if !txs[i].removed { mem.removed.Add(txs[i]) - mem.logger.Info("tx marked removed", "sender", txs[i].signerAddress, "nonce", txs[i].nonce, "gid", getGoroutineID()) + removedCnt++ + // mem.logger.Info("tx marked removed", "sender", txs[i].signerAddress, "nonce", txs[i].nonce) } cursorGrp[selectedMemTx.signerAddress]++ cnt++ @@ -906,7 +912,8 @@ func (mem *CListMempool) markRemovableTxs() { cnt++ } } - mem.logger.Info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) + mem.logger.Info("markRemovableTxs done", "removedCnt", removedCnt, "totalPendingTxCnt", totalPendingTxCnt, "targetCnt", targetCnt) + // mem.logger.Info("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<", "gid", getGoroutineID(), "pendingSize", mem.pending.Size(), "removedSize", mem.removed.Size()) } //-------------------------------------------------------------------------------- @@ -1081,12 +1088,6 @@ func (pp *pendingPool) Flush() { pp.data = nil } -func getGoroutineID() int { - var buf [64]byte - n := runtime.Stack(buf[:], false) - stack := string(buf[:n]) - - idField := strings.Fields(strings.TrimPrefix(stack, "goroutine "))[0] - id, _ := strconv.Atoi(idField) - return id +func calTargetSize(mempoolSize int) int { + return mempoolSize * (100 - overflowEliminationRate) / 100 } From 20feb74c90946396be63075b2061f5d36a8fe24b Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Sat, 8 Mar 2025 03:24:21 +0800 Subject: [PATCH 7/7] add eliminatedTx to AppConnMempool --- abci/client/client.go | 1 + abci/client/grpc_client.go | 4 + abci/client/local_client.go | 8 + abci/client/mocks/client.go | 308 +++++- abci/client/socket_client.go | 4 + abci/example/kvstore/kvstore.go | 4 + abci/example/kvstore/persistent_kvstore.go | 4 + abci/types/application.go | 9 + abci/types/mocks/application.go | 87 +- abci/types/types.pb.go | 1030 +++++++++++++++----- mempool/v0/clist_mempool.go | 9 + proto/tendermint/abci/types.proto | 9 + proxy/app_conn.go | 7 + rpc/grpc/types.pb.go | 1 + 14 files changed, 1178 insertions(+), 307 deletions(-) diff --git a/abci/client/client.go b/abci/client/client.go index 043bc7333..28bcfd4f1 100644 --- a/abci/client/client.go +++ b/abci/client/client.go @@ -60,6 +60,7 @@ type Client interface { LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) ProcessProposalSync(types.RequestProcessProposal) (*types.ResponseProcessProposal, error) + EliminatedTx(*types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) } //---------------------------------------- diff --git a/abci/client/grpc_client.go b/abci/client/grpc_client.go index a1aa072a9..07ffa7653 100644 --- a/abci/client/grpc_client.go +++ b/abci/client/grpc_client.go @@ -310,6 +310,10 @@ func (cli *grpcClient) ProcessProposalAsync(params types.RequestProcessProposal) return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ProcessProposal{ProcessProposal: res}}) } +func (cli *grpcClient) EliminatedTx(*types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) { + panic("not implemented") +} + // finishAsyncCall creates a ReqRes for an async call, and immediately populates it // with the response. We don't complete it until it's been ordered via the channel. func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes { diff --git a/abci/client/local_client.go b/abci/client/local_client.go index a30640c20..8c93ad633 100644 --- a/abci/client/local_client.go +++ b/abci/client/local_client.go @@ -342,6 +342,14 @@ func (app *localClient) ProcessProposalSync(req types.RequestProcessProposal) (* return &res, nil } +func (app *localClient) EliminatedTx(req *types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) { + app.mtx.Lock() + defer app.mtx.Unlock() + + res := app.Application.EliminatedTx(req) + return &res, nil +} + //------------------------------------------------------- func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes { diff --git a/abci/client/mocks/client.go b/abci/client/mocks/client.go index eaced64b5..337da2ff4 100644 --- a/abci/client/mocks/client.go +++ b/abci/client/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery. DO NOT EDIT. +// Code generated by mockery v2.52.1. DO NOT EDIT. package mocks @@ -20,6 +20,10 @@ type Client struct { func (_m *Client) ApplySnapshotChunkAsync(_a0 types.RequestApplySnapshotChunk) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ApplySnapshotChunkAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -36,7 +40,15 @@ func (_m *Client) ApplySnapshotChunkAsync(_a0 types.RequestApplySnapshotChunk) * func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ApplySnapshotChunkSync") + } + var r0 *types.ResponseApplySnapshotChunk + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok { r0 = rf(_a0) } else { @@ -45,7 +57,6 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (* } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestApplySnapshotChunk) error); ok { r1 = rf(_a0) } else { @@ -59,6 +70,10 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (* func (_m *Client) BeginBlockAsync(_a0 types.RequestBeginBlock) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for BeginBlockAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -75,7 +90,15 @@ func (_m *Client) BeginBlockAsync(_a0 types.RequestBeginBlock) *abcicli.ReqRes { func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for BeginBlockSync") + } + var r0 *types.ResponseBeginBlock + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) (*types.ResponseBeginBlock, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *types.ResponseBeginBlock); ok { r0 = rf(_a0) } else { @@ -84,7 +107,6 @@ func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBe } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestBeginBlock) error); ok { r1 = rf(_a0) } else { @@ -98,6 +120,10 @@ func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBe func (_m *Client) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for CheckTxAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -114,7 +140,15 @@ func (_m *Client) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes { func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for CheckTxSync") + } + var r0 *types.ResponseCheckTx + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestCheckTx) (*types.ResponseCheckTx, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *types.ResponseCheckTx); ok { r0 = rf(_a0) } else { @@ -123,7 +157,6 @@ func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx, } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestCheckTx) error); ok { r1 = rf(_a0) } else { @@ -133,10 +166,14 @@ func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx, return r0, r1 } -// CommitAsync provides a mock function with given fields: +// CommitAsync provides a mock function with no fields func (_m *Client) CommitAsync() *abcicli.ReqRes { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for CommitAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok { r0 = rf() @@ -149,11 +186,19 @@ func (_m *Client) CommitAsync() *abcicli.ReqRes { return r0 } -// CommitSync provides a mock function with given fields: +// CommitSync provides a mock function with no fields func (_m *Client) CommitSync() (*types.ResponseCommit, error) { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for CommitSync") + } + var r0 *types.ResponseCommit + var r1 error + if rf, ok := ret.Get(0).(func() (*types.ResponseCommit, error)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() *types.ResponseCommit); ok { r0 = rf() } else { @@ -162,7 +207,6 @@ func (_m *Client) CommitSync() (*types.ResponseCommit, error) { } } - var r1 error if rf, ok := ret.Get(1).(func() error); ok { r1 = rf() } else { @@ -176,6 +220,10 @@ func (_m *Client) CommitSync() (*types.ResponseCommit, error) { func (_m *Client) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for DeliverTxAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -192,7 +240,15 @@ func (_m *Client) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes { func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for DeliverTxSync") + } + var r0 *types.ResponseDeliverTx + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) (*types.ResponseDeliverTx, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *types.ResponseDeliverTx); ok { r0 = rf(_a0) } else { @@ -201,7 +257,6 @@ func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeli } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestDeliverTx) error); ok { r1 = rf(_a0) } else { @@ -215,6 +270,10 @@ func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeli func (_m *Client) EchoAsync(msg string) *abcicli.ReqRes { ret := _m.Called(msg) + if len(ret) == 0 { + panic("no return value specified for EchoAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(string) *abcicli.ReqRes); ok { r0 = rf(msg) @@ -231,7 +290,15 @@ func (_m *Client) EchoAsync(msg string) *abcicli.ReqRes { func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) { ret := _m.Called(msg) + if len(ret) == 0 { + panic("no return value specified for EchoSync") + } + var r0 *types.ResponseEcho + var r1 error + if rf, ok := ret.Get(0).(func(string) (*types.ResponseEcho, error)); ok { + return rf(msg) + } if rf, ok := ret.Get(0).(func(string) *types.ResponseEcho); ok { r0 = rf(msg) } else { @@ -240,7 +307,6 @@ func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(string) error); ok { r1 = rf(msg) } else { @@ -250,10 +316,44 @@ func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) { return r0, r1 } +// EliminatedTx provides a mock function with given fields: _a0 +func (_m *Client) EliminatedTx(_a0 *types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for EliminatedTx") + } + + var r0 *types.ResponseEliminatedTx + var r1 error + if rf, ok := ret.Get(0).(func(*types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(*types.RequestEliminatedTx) *types.ResponseEliminatedTx); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ResponseEliminatedTx) + } + } + + if rf, ok := ret.Get(1).(func(*types.RequestEliminatedTx) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // EndBlockAsync provides a mock function with given fields: _a0 func (_m *Client) EndBlockAsync(_a0 types.RequestEndBlock) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for EndBlockAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -270,7 +370,15 @@ func (_m *Client) EndBlockAsync(_a0 types.RequestEndBlock) *abcicli.ReqRes { func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlock, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for EndBlockSync") + } + var r0 *types.ResponseEndBlock + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestEndBlock) (*types.ResponseEndBlock, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *types.ResponseEndBlock); ok { r0 = rf(_a0) } else { @@ -279,7 +387,6 @@ func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlo } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestEndBlock) error); ok { r1 = rf(_a0) } else { @@ -289,10 +396,14 @@ func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlo return r0, r1 } -// Error provides a mock function with given fields: +// Error provides a mock function with no fields func (_m *Client) Error() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Error") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -303,10 +414,14 @@ func (_m *Client) Error() error { return r0 } -// FlushAsync provides a mock function with given fields: +// FlushAsync provides a mock function with no fields func (_m *Client) FlushAsync() *abcicli.ReqRes { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for FlushAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok { r0 = rf() @@ -319,10 +434,14 @@ func (_m *Client) FlushAsync() *abcicli.ReqRes { return r0 } -// FlushSync provides a mock function with given fields: +// FlushSync provides a mock function with no fields func (_m *Client) FlushSync() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for FlushSync") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -337,6 +456,10 @@ func (_m *Client) FlushSync() error { func (_m *Client) InfoAsync(_a0 types.RequestInfo) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for InfoAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestInfo) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -353,7 +476,15 @@ func (_m *Client) InfoAsync(_a0 types.RequestInfo) *abcicli.ReqRes { func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for InfoSync") + } + var r0 *types.ResponseInfo + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestInfo) (*types.ResponseInfo, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestInfo) *types.ResponseInfo); ok { r0 = rf(_a0) } else { @@ -362,7 +493,6 @@ func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) { } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestInfo) error); ok { r1 = rf(_a0) } else { @@ -376,6 +506,10 @@ func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) { func (_m *Client) InitChainAsync(_a0 types.RequestInitChain) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for InitChainAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestInitChain) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -392,7 +526,15 @@ func (_m *Client) InitChainAsync(_a0 types.RequestInitChain) *abcicli.ReqRes { func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInitChain, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for InitChainSync") + } + var r0 *types.ResponseInitChain + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestInitChain) (*types.ResponseInitChain, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestInitChain) *types.ResponseInitChain); ok { r0 = rf(_a0) } else { @@ -401,7 +543,6 @@ func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInit } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestInitChain) error); ok { r1 = rf(_a0) } else { @@ -411,10 +552,14 @@ func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInit return r0, r1 } -// IsRunning provides a mock function with given fields: +// IsRunning provides a mock function with no fields func (_m *Client) IsRunning() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for IsRunning") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -429,6 +574,10 @@ func (_m *Client) IsRunning() bool { func (_m *Client) ListSnapshotsAsync(_a0 types.RequestListSnapshots) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ListSnapshotsAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -445,7 +594,15 @@ func (_m *Client) ListSnapshotsAsync(_a0 types.RequestListSnapshots) *abcicli.Re func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ListSnapshotsSync") + } + var r0 *types.ResponseListSnapshots + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) (*types.ResponseListSnapshots, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *types.ResponseListSnapshots); ok { r0 = rf(_a0) } else { @@ -454,7 +611,6 @@ func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.Resp } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestListSnapshots) error); ok { r1 = rf(_a0) } else { @@ -468,6 +624,10 @@ func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.Resp func (_m *Client) LoadSnapshotChunkAsync(_a0 types.RequestLoadSnapshotChunk) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for LoadSnapshotChunkAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -484,7 +644,15 @@ func (_m *Client) LoadSnapshotChunkAsync(_a0 types.RequestLoadSnapshotChunk) *ab func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for LoadSnapshotChunkSync") + } + var r0 *types.ResponseLoadSnapshotChunk + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok { r0 = rf(_a0) } else { @@ -493,7 +661,6 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*ty } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestLoadSnapshotChunk) error); ok { r1 = rf(_a0) } else { @@ -507,6 +674,10 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*ty func (_m *Client) OfferSnapshotAsync(_a0 types.RequestOfferSnapshot) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for OfferSnapshotAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -523,7 +694,15 @@ func (_m *Client) OfferSnapshotAsync(_a0 types.RequestOfferSnapshot) *abcicli.Re func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for OfferSnapshotSync") + } + var r0 *types.ResponseOfferSnapshot + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok { r0 = rf(_a0) } else { @@ -532,7 +711,6 @@ func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.Resp } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestOfferSnapshot) error); ok { r1 = rf(_a0) } else { @@ -542,10 +720,14 @@ func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.Resp return r0, r1 } -// OnReset provides a mock function with given fields: +// OnReset provides a mock function with no fields func (_m *Client) OnReset() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for OnReset") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -556,10 +738,14 @@ func (_m *Client) OnReset() error { return r0 } -// OnStart provides a mock function with given fields: +// OnStart provides a mock function with no fields func (_m *Client) OnStart() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for OnStart") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -570,7 +756,7 @@ func (_m *Client) OnStart() error { return r0 } -// OnStop provides a mock function with given fields: +// OnStop provides a mock function with no fields func (_m *Client) OnStop() { _m.Called() } @@ -579,6 +765,10 @@ func (_m *Client) OnStop() { func (_m *Client) PrepareProposalAsync(_a0 types.RequestPrepareProposal) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for PrepareProposalAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -595,7 +785,15 @@ func (_m *Client) PrepareProposalAsync(_a0 types.RequestPrepareProposal) *abcicl func (_m *Client) PrepareProposalSync(_a0 types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for PrepareProposalSync") + } + var r0 *types.ResponsePrepareProposal + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *types.ResponsePrepareProposal); ok { r0 = rf(_a0) } else { @@ -604,7 +802,6 @@ func (_m *Client) PrepareProposalSync(_a0 types.RequestPrepareProposal) (*types. } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestPrepareProposal) error); ok { r1 = rf(_a0) } else { @@ -618,6 +815,10 @@ func (_m *Client) PrepareProposalSync(_a0 types.RequestPrepareProposal) (*types. func (_m *Client) ProcessProposalAsync(_a0 types.RequestProcessProposal) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ProcessProposalAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -634,7 +835,15 @@ func (_m *Client) ProcessProposalAsync(_a0 types.RequestProcessProposal) *abcicl func (_m *Client) ProcessProposalSync(_a0 types.RequestProcessProposal) (*types.ResponseProcessProposal, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ProcessProposalSync") + } + var r0 *types.ResponseProcessProposal + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) (*types.ResponseProcessProposal, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *types.ResponseProcessProposal); ok { r0 = rf(_a0) } else { @@ -643,7 +852,6 @@ func (_m *Client) ProcessProposalSync(_a0 types.RequestProcessProposal) (*types. } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestProcessProposal) error); ok { r1 = rf(_a0) } else { @@ -657,6 +865,10 @@ func (_m *Client) ProcessProposalSync(_a0 types.RequestProcessProposal) (*types. func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for QueryAsync") + } + var r0 *abcicli.ReqRes if rf, ok := ret.Get(0).(func(types.RequestQuery) *abcicli.ReqRes); ok { r0 = rf(_a0) @@ -673,7 +885,15 @@ func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes { func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error) { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for QuerySync") + } + var r0 *types.ResponseQuery + var r1 error + if rf, ok := ret.Get(0).(func(types.RequestQuery) (*types.ResponseQuery, error)); ok { + return rf(_a0) + } if rf, ok := ret.Get(0).(func(types.RequestQuery) *types.ResponseQuery); ok { r0 = rf(_a0) } else { @@ -682,7 +902,6 @@ func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error } } - var r1 error if rf, ok := ret.Get(1).(func(types.RequestQuery) error); ok { r1 = rf(_a0) } else { @@ -692,10 +911,14 @@ func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error return r0, r1 } -// Quit provides a mock function with given fields: +// Quit provides a mock function with no fields func (_m *Client) Quit() <-chan struct{} { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Quit") + } + var r0 <-chan struct{} if rf, ok := ret.Get(0).(func() <-chan struct{}); ok { r0 = rf() @@ -708,10 +931,14 @@ func (_m *Client) Quit() <-chan struct{} { return r0 } -// Reset provides a mock function with given fields: +// Reset provides a mock function with no fields func (_m *Client) Reset() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Reset") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -732,10 +959,14 @@ func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) { _m.Called(_a0) } -// Start provides a mock function with given fields: +// Start provides a mock function with no fields func (_m *Client) Start() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Start") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -746,10 +977,14 @@ func (_m *Client) Start() error { return r0 } -// Stop provides a mock function with given fields: +// Stop provides a mock function with no fields func (_m *Client) Stop() error { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Stop") + } + var r0 error if rf, ok := ret.Get(0).(func() error); ok { r0 = rf() @@ -760,10 +995,14 @@ func (_m *Client) Stop() error { return r0 } -// String provides a mock function with given fields: +// String provides a mock function with no fields func (_m *Client) String() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for String") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -774,13 +1013,12 @@ func (_m *Client) String() string { return r0 } -type mockConstructorTestingTNewClient interface { +// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClient(t interface { mock.TestingT Cleanup(func()) -} - -// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewClient(t mockConstructorTestingTNewClient) *Client { +}) *Client { mock := &Client{} mock.Mock.Test(t) diff --git a/abci/client/socket_client.go b/abci/client/socket_client.go index 9861603fb..8f59ec2be 100644 --- a/abci/client/socket_client.go +++ b/abci/client/socket_client.go @@ -430,6 +430,10 @@ func (cli *socketClient) ProcessProposalSync(req types.RequestProcessProposal) ( return reqres.Response.GetProcessProposal(), cli.Error() } +func (cli *socketClient) EliminatedTx(*types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) { + panic("not implemented") +} + //---------------------------------------- func (cli *socketClient) queueRequest(req *types.Request) *ReqRes { diff --git a/abci/example/kvstore/kvstore.go b/abci/example/kvstore/kvstore.go index 6f11ce66e..81f5ec94c 100644 --- a/abci/example/kvstore/kvstore.go +++ b/abci/example/kvstore/kvstore.go @@ -281,3 +281,7 @@ func (app *Application) ProcessProposal( } return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT} } + +func (app *Application) EliminatedTx(req *types.RequestEliminatedTx) types.ResponseEliminatedTx { + panic("not implement") +} diff --git a/abci/example/kvstore/persistent_kvstore.go b/abci/example/kvstore/persistent_kvstore.go index e06bfcff8..f3eec15b6 100644 --- a/abci/example/kvstore/persistent_kvstore.go +++ b/abci/example/kvstore/persistent_kvstore.go @@ -360,3 +360,7 @@ func (app *PersistentKVStoreApplication) substPrepareTx(blockData [][]byte, maxT } return txs } + +func (app *PersistentKVStoreApplication) EliminatedTx(req *types.RequestEliminatedTx) types.ResponseEliminatedTx { + panic("not implement") +} diff --git a/abci/types/application.go b/abci/types/application.go index 68ff8a4af..73405c777 100644 --- a/abci/types/application.go +++ b/abci/types/application.go @@ -17,6 +17,7 @@ type Application interface { // Mempool Connection CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool + EliminatedTx(*RequestEliminatedTx) ResponseEliminatedTx // Consensus Connection InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from CometBFT @@ -58,6 +59,10 @@ func (BaseApplication) CheckTx(req RequestCheckTx) ResponseCheckTx { return ResponseCheckTx{Code: CodeTypeOK} } +func (BaseApplication) EliminatedTx(req *RequestEliminatedTx) ResponseEliminatedTx { + return ResponseEliminatedTx{} +} + func (BaseApplication) Commit() ResponseCommit { return ResponseCommit{} } @@ -146,6 +151,10 @@ func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (* return &res, nil } +func (app *GRPCApplication) EliminatedTx(ctx context.Context, req *RequestEliminatedTx) (*ResponseEliminatedTx, error) { + return &ResponseEliminatedTx{}, nil +} + func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) { res := app.app.Query(*req) return &res, nil diff --git a/abci/types/mocks/application.go b/abci/types/mocks/application.go index 3debc63c0..9c9bf7a53 100644 --- a/abci/types/mocks/application.go +++ b/abci/types/mocks/application.go @@ -1,4 +1,4 @@ -// Code generated by mockery. DO NOT EDIT. +// Code generated by mockery v2.52.1. DO NOT EDIT. package mocks @@ -16,6 +16,10 @@ type Application struct { func (_m *Application) ApplySnapshotChunk(_a0 types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ApplySnapshotChunk") + } + var r0 types.ResponseApplySnapshotChunk if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk); ok { r0 = rf(_a0) @@ -30,6 +34,10 @@ func (_m *Application) ApplySnapshotChunk(_a0 types.RequestApplySnapshotChunk) t func (_m *Application) BeginBlock(_a0 types.RequestBeginBlock) types.ResponseBeginBlock { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for BeginBlock") + } + var r0 types.ResponseBeginBlock if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) types.ResponseBeginBlock); ok { r0 = rf(_a0) @@ -44,6 +52,10 @@ func (_m *Application) BeginBlock(_a0 types.RequestBeginBlock) types.ResponseBeg func (_m *Application) CheckTx(_a0 types.RequestCheckTx) types.ResponseCheckTx { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for CheckTx") + } + var r0 types.ResponseCheckTx if rf, ok := ret.Get(0).(func(types.RequestCheckTx) types.ResponseCheckTx); ok { r0 = rf(_a0) @@ -54,10 +66,14 @@ func (_m *Application) CheckTx(_a0 types.RequestCheckTx) types.ResponseCheckTx { return r0 } -// Commit provides a mock function with given fields: +// Commit provides a mock function with no fields func (_m *Application) Commit() types.ResponseCommit { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Commit") + } + var r0 types.ResponseCommit if rf, ok := ret.Get(0).(func() types.ResponseCommit); ok { r0 = rf() @@ -72,6 +88,10 @@ func (_m *Application) Commit() types.ResponseCommit { func (_m *Application) DeliverTx(_a0 types.RequestDeliverTx) types.ResponseDeliverTx { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for DeliverTx") + } + var r0 types.ResponseDeliverTx if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) types.ResponseDeliverTx); ok { r0 = rf(_a0) @@ -82,10 +102,32 @@ func (_m *Application) DeliverTx(_a0 types.RequestDeliverTx) types.ResponseDeliv return r0 } +// EliminatedTx provides a mock function with given fields: _a0 +func (_m *Application) EliminatedTx(_a0 *types.RequestEliminatedTx) types.ResponseEliminatedTx { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for EliminatedTx") + } + + var r0 types.ResponseEliminatedTx + if rf, ok := ret.Get(0).(func(*types.RequestEliminatedTx) types.ResponseEliminatedTx); ok { + r0 = rf(_a0) + } else { + r0 = ret.Get(0).(types.ResponseEliminatedTx) + } + + return r0 +} + // EndBlock provides a mock function with given fields: _a0 func (_m *Application) EndBlock(_a0 types.RequestEndBlock) types.ResponseEndBlock { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for EndBlock") + } + var r0 types.ResponseEndBlock if rf, ok := ret.Get(0).(func(types.RequestEndBlock) types.ResponseEndBlock); ok { r0 = rf(_a0) @@ -100,6 +142,10 @@ func (_m *Application) EndBlock(_a0 types.RequestEndBlock) types.ResponseEndBloc func (_m *Application) Info(_a0 types.RequestInfo) types.ResponseInfo { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for Info") + } + var r0 types.ResponseInfo if rf, ok := ret.Get(0).(func(types.RequestInfo) types.ResponseInfo); ok { r0 = rf(_a0) @@ -114,6 +160,10 @@ func (_m *Application) Info(_a0 types.RequestInfo) types.ResponseInfo { func (_m *Application) InitChain(_a0 types.RequestInitChain) types.ResponseInitChain { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for InitChain") + } + var r0 types.ResponseInitChain if rf, ok := ret.Get(0).(func(types.RequestInitChain) types.ResponseInitChain); ok { r0 = rf(_a0) @@ -128,6 +178,10 @@ func (_m *Application) InitChain(_a0 types.RequestInitChain) types.ResponseInitC func (_m *Application) ListSnapshots(_a0 types.RequestListSnapshots) types.ResponseListSnapshots { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ListSnapshots") + } + var r0 types.ResponseListSnapshots if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) types.ResponseListSnapshots); ok { r0 = rf(_a0) @@ -142,6 +196,10 @@ func (_m *Application) ListSnapshots(_a0 types.RequestListSnapshots) types.Respo func (_m *Application) LoadSnapshotChunk(_a0 types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for LoadSnapshotChunk") + } + var r0 types.ResponseLoadSnapshotChunk if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk); ok { r0 = rf(_a0) @@ -156,6 +214,10 @@ func (_m *Application) LoadSnapshotChunk(_a0 types.RequestLoadSnapshotChunk) typ func (_m *Application) OfferSnapshot(_a0 types.RequestOfferSnapshot) types.ResponseOfferSnapshot { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for OfferSnapshot") + } + var r0 types.ResponseOfferSnapshot if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) types.ResponseOfferSnapshot); ok { r0 = rf(_a0) @@ -170,6 +232,10 @@ func (_m *Application) OfferSnapshot(_a0 types.RequestOfferSnapshot) types.Respo func (_m *Application) PrepareProposal(_a0 types.RequestPrepareProposal) types.ResponsePrepareProposal { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for PrepareProposal") + } + var r0 types.ResponsePrepareProposal if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) types.ResponsePrepareProposal); ok { r0 = rf(_a0) @@ -184,6 +250,10 @@ func (_m *Application) PrepareProposal(_a0 types.RequestPrepareProposal) types.R func (_m *Application) ProcessProposal(_a0 types.RequestProcessProposal) types.ResponseProcessProposal { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for ProcessProposal") + } + var r0 types.ResponseProcessProposal if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) types.ResponseProcessProposal); ok { r0 = rf(_a0) @@ -198,6 +268,10 @@ func (_m *Application) ProcessProposal(_a0 types.RequestProcessProposal) types.R func (_m *Application) Query(_a0 types.RequestQuery) types.ResponseQuery { ret := _m.Called(_a0) + if len(ret) == 0 { + panic("no return value specified for Query") + } + var r0 types.ResponseQuery if rf, ok := ret.Get(0).(func(types.RequestQuery) types.ResponseQuery); ok { r0 = rf(_a0) @@ -208,13 +282,12 @@ func (_m *Application) Query(_a0 types.RequestQuery) types.ResponseQuery { return r0 } -type mockConstructorTestingTNewApplication interface { +// NewApplication creates a new instance of Application. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewApplication(t interface { mock.TestingT Cleanup(func()) -} - -// NewApplication creates a new instance of Application. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewApplication(t mockConstructorTestingTNewApplication) *Application { +}) *Application { mock := &Application{} mock.Mock.Test(t) diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index 3523e8172..4e90c4a67 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -121,7 +121,7 @@ func (x ResponseOfferSnapshot_Result) String() string { } func (ResponseOfferSnapshot_Result) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{30, 0} + return fileDescriptor_252557cfdd89a31a, []int{31, 0} } type ResponseApplySnapshotChunk_Result int32 @@ -158,7 +158,7 @@ func (x ResponseApplySnapshotChunk_Result) String() string { } func (ResponseApplySnapshotChunk_Result) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{32, 0} + return fileDescriptor_252557cfdd89a31a, []int{33, 0} } type ResponseProcessProposal_ProposalStatus int32 @@ -186,7 +186,7 @@ func (x ResponseProcessProposal_ProposalStatus) String() string { } func (ResponseProcessProposal_ProposalStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{34, 0} + return fileDescriptor_252557cfdd89a31a, []int{35, 0} } type Request struct { @@ -207,6 +207,7 @@ type Request struct { // *Request_ApplySnapshotChunk // *Request_PrepareProposal // *Request_ProcessProposal + // *Request_EliminatedTx Value isRequest_Value `protobuf_oneof:"value"` } @@ -297,6 +298,9 @@ type Request_PrepareProposal struct { type Request_ProcessProposal struct { ProcessProposal *RequestProcessProposal `protobuf:"bytes,17,opt,name=process_proposal,json=processProposal,proto3,oneof" json:"process_proposal,omitempty"` } +type Request_EliminatedTx struct { + EliminatedTx *RequestEliminatedTx `protobuf:"bytes,18,opt,name=eliminated_tx,json=eliminatedTx,proto3,oneof" json:"eliminated_tx,omitempty"` +} func (*Request_Echo) isRequest_Value() {} func (*Request_Flush) isRequest_Value() {} @@ -314,6 +318,7 @@ func (*Request_LoadSnapshotChunk) isRequest_Value() {} func (*Request_ApplySnapshotChunk) isRequest_Value() {} func (*Request_PrepareProposal) isRequest_Value() {} func (*Request_ProcessProposal) isRequest_Value() {} +func (*Request_EliminatedTx) isRequest_Value() {} func (m *Request) GetValue() isRequest_Value { if m != nil { @@ -434,6 +439,13 @@ func (m *Request) GetProcessProposal() *RequestProcessProposal { return nil } +func (m *Request) GetEliminatedTx() *RequestEliminatedTx { + if x, ok := m.GetValue().(*Request_EliminatedTx); ok { + return x.EliminatedTx + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Request) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -453,6 +465,7 @@ func (*Request) XXX_OneofWrappers() []interface{} { (*Request_ApplySnapshotChunk)(nil), (*Request_PrepareProposal)(nil), (*Request_ProcessProposal)(nil), + (*Request_EliminatedTx)(nil), } } @@ -876,6 +889,50 @@ func (m *RequestCheckTx) GetType() CheckTxType { return CheckTxType_New } +type RequestEliminatedTx struct { + Txs [][]byte `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"` +} + +func (m *RequestEliminatedTx) Reset() { *m = RequestEliminatedTx{} } +func (m *RequestEliminatedTx) String() string { return proto.CompactTextString(m) } +func (*RequestEliminatedTx) ProtoMessage() {} +func (*RequestEliminatedTx) Descriptor() ([]byte, []int) { + return fileDescriptor_252557cfdd89a31a, []int{8} +} +func (m *RequestEliminatedTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestEliminatedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestEliminatedTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RequestEliminatedTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestEliminatedTx.Merge(m, src) +} +func (m *RequestEliminatedTx) XXX_Size() int { + return m.Size() +} +func (m *RequestEliminatedTx) XXX_DiscardUnknown() { + xxx_messageInfo_RequestEliminatedTx.DiscardUnknown(m) +} + +var xxx_messageInfo_RequestEliminatedTx proto.InternalMessageInfo + +func (m *RequestEliminatedTx) GetTxs() [][]byte { + if m != nil { + return m.Txs + } + return nil +} + type RequestDeliverTx struct { Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` } @@ -884,7 +941,7 @@ func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} } func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) } func (*RequestDeliverTx) ProtoMessage() {} func (*RequestDeliverTx) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{8} + return fileDescriptor_252557cfdd89a31a, []int{9} } func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -928,7 +985,7 @@ func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} } func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) } func (*RequestEndBlock) ProtoMessage() {} func (*RequestEndBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{9} + return fileDescriptor_252557cfdd89a31a, []int{10} } func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -971,7 +1028,7 @@ func (m *RequestCommit) Reset() { *m = RequestCommit{} } func (m *RequestCommit) String() string { return proto.CompactTextString(m) } func (*RequestCommit) ProtoMessage() {} func (*RequestCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{10} + return fileDescriptor_252557cfdd89a31a, []int{11} } func (m *RequestCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1008,7 +1065,7 @@ func (m *RequestListSnapshots) Reset() { *m = RequestListSnapshots{} } func (m *RequestListSnapshots) String() string { return proto.CompactTextString(m) } func (*RequestListSnapshots) ProtoMessage() {} func (*RequestListSnapshots) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{11} + return fileDescriptor_252557cfdd89a31a, []int{12} } func (m *RequestListSnapshots) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1047,7 +1104,7 @@ func (m *RequestOfferSnapshot) Reset() { *m = RequestOfferSnapshot{} } func (m *RequestOfferSnapshot) String() string { return proto.CompactTextString(m) } func (*RequestOfferSnapshot) ProtoMessage() {} func (*RequestOfferSnapshot) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{12} + return fileDescriptor_252557cfdd89a31a, []int{13} } func (m *RequestOfferSnapshot) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1101,7 +1158,7 @@ func (m *RequestLoadSnapshotChunk) Reset() { *m = RequestLoadSnapshotChu func (m *RequestLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } func (*RequestLoadSnapshotChunk) ProtoMessage() {} func (*RequestLoadSnapshotChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{13} + return fileDescriptor_252557cfdd89a31a, []int{14} } func (m *RequestLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1162,7 +1219,7 @@ func (m *RequestApplySnapshotChunk) Reset() { *m = RequestApplySnapshotC func (m *RequestApplySnapshotChunk) String() string { return proto.CompactTextString(m) } func (*RequestApplySnapshotChunk) ProtoMessage() {} func (*RequestApplySnapshotChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{14} + return fileDescriptor_252557cfdd89a31a, []int{15} } func (m *RequestApplySnapshotChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1231,7 +1288,7 @@ func (m *RequestPrepareProposal) Reset() { *m = RequestPrepareProposal{} func (m *RequestPrepareProposal) String() string { return proto.CompactTextString(m) } func (*RequestPrepareProposal) ProtoMessage() {} func (*RequestPrepareProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{15} + return fileDescriptor_252557cfdd89a31a, []int{16} } func (m *RequestPrepareProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1333,7 +1390,7 @@ func (m *RequestProcessProposal) Reset() { *m = RequestProcessProposal{} func (m *RequestProcessProposal) String() string { return proto.CompactTextString(m) } func (*RequestProcessProposal) ProtoMessage() {} func (*RequestProcessProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{16} + return fileDescriptor_252557cfdd89a31a, []int{17} } func (m *RequestProcessProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1438,6 +1495,7 @@ type Response struct { // *Response_ApplySnapshotChunk // *Response_PrepareProposal // *Response_ProcessProposal + // *Response_EliminatedTx Value isResponse_Value `protobuf_oneof:"value"` } @@ -1445,7 +1503,7 @@ func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{17} + return fileDescriptor_252557cfdd89a31a, []int{18} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1531,6 +1589,9 @@ type Response_PrepareProposal struct { type Response_ProcessProposal struct { ProcessProposal *ResponseProcessProposal `protobuf:"bytes,18,opt,name=process_proposal,json=processProposal,proto3,oneof" json:"process_proposal,omitempty"` } +type Response_EliminatedTx struct { + EliminatedTx *ResponseEliminatedTx `protobuf:"bytes,19,opt,name=eliminated_tx,json=eliminatedTx,proto3,oneof" json:"eliminated_tx,omitempty"` +} func (*Response_Exception) isResponse_Value() {} func (*Response_Echo) isResponse_Value() {} @@ -1549,6 +1610,7 @@ func (*Response_LoadSnapshotChunk) isResponse_Value() {} func (*Response_ApplySnapshotChunk) isResponse_Value() {} func (*Response_PrepareProposal) isResponse_Value() {} func (*Response_ProcessProposal) isResponse_Value() {} +func (*Response_EliminatedTx) isResponse_Value() {} func (m *Response) GetValue() isResponse_Value { if m != nil { @@ -1676,6 +1738,13 @@ func (m *Response) GetProcessProposal() *ResponseProcessProposal { return nil } +func (m *Response) GetEliminatedTx() *ResponseEliminatedTx { + if x, ok := m.GetValue().(*Response_EliminatedTx); ok { + return x.EliminatedTx + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Response) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -1696,6 +1765,7 @@ func (*Response) XXX_OneofWrappers() []interface{} { (*Response_ApplySnapshotChunk)(nil), (*Response_PrepareProposal)(nil), (*Response_ProcessProposal)(nil), + (*Response_EliminatedTx)(nil), } } @@ -1708,7 +1778,7 @@ func (m *ResponseException) Reset() { *m = ResponseException{} } func (m *ResponseException) String() string { return proto.CompactTextString(m) } func (*ResponseException) ProtoMessage() {} func (*ResponseException) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{18} + return fileDescriptor_252557cfdd89a31a, []int{19} } func (m *ResponseException) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1752,7 +1822,7 @@ func (m *ResponseEcho) Reset() { *m = ResponseEcho{} } func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } func (*ResponseEcho) ProtoMessage() {} func (*ResponseEcho) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{19} + return fileDescriptor_252557cfdd89a31a, []int{20} } func (m *ResponseEcho) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1795,7 +1865,7 @@ func (m *ResponseFlush) Reset() { *m = ResponseFlush{} } func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } func (*ResponseFlush) ProtoMessage() {} func (*ResponseFlush) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{20} + return fileDescriptor_252557cfdd89a31a, []int{21} } func (m *ResponseFlush) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1836,7 +1906,7 @@ func (m *ResponseInfo) Reset() { *m = ResponseInfo{} } func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } func (*ResponseInfo) ProtoMessage() {} func (*ResponseInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{21} + return fileDescriptor_252557cfdd89a31a, []int{22} } func (m *ResponseInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1910,7 +1980,7 @@ func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} } func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } func (*ResponseInitChain) ProtoMessage() {} func (*ResponseInitChain) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{22} + return fileDescriptor_252557cfdd89a31a, []int{23} } func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1977,7 +2047,7 @@ func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } func (*ResponseQuery) ProtoMessage() {} func (*ResponseQuery) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{23} + return fileDescriptor_252557cfdd89a31a, []int{24} } func (m *ResponseQuery) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2077,7 +2147,7 @@ func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} } func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } func (*ResponseBeginBlock) ProtoMessage() {} func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{24} + return fileDescriptor_252557cfdd89a31a, []int{25} } func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2141,7 +2211,7 @@ func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } func (*ResponseCheckTx) ProtoMessage() {} func (*ResponseCheckTx) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{25} + return fileDescriptor_252557cfdd89a31a, []int{26} } func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2304,7 +2374,7 @@ func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } func (*ResponseDeliverTx) ProtoMessage() {} func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{26} + return fileDescriptor_252557cfdd89a31a, []int{27} } func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2399,7 +2469,7 @@ func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} } func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } func (*ResponseEndBlock) ProtoMessage() {} func (*ResponseEndBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{27} + return fileDescriptor_252557cfdd89a31a, []int{28} } func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2459,7 +2529,7 @@ func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } func (*ResponseCommit) ProtoMessage() {} func (*ResponseCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{28} + return fileDescriptor_252557cfdd89a31a, []int{29} } func (m *ResponseCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2510,7 +2580,7 @@ func (m *ResponseListSnapshots) Reset() { *m = ResponseListSnapshots{} } func (m *ResponseListSnapshots) String() string { return proto.CompactTextString(m) } func (*ResponseListSnapshots) ProtoMessage() {} func (*ResponseListSnapshots) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{29} + return fileDescriptor_252557cfdd89a31a, []int{30} } func (m *ResponseListSnapshots) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2554,7 +2624,7 @@ func (m *ResponseOfferSnapshot) Reset() { *m = ResponseOfferSnapshot{} } func (m *ResponseOfferSnapshot) String() string { return proto.CompactTextString(m) } func (*ResponseOfferSnapshot) ProtoMessage() {} func (*ResponseOfferSnapshot) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{30} + return fileDescriptor_252557cfdd89a31a, []int{31} } func (m *ResponseOfferSnapshot) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2598,7 +2668,7 @@ func (m *ResponseLoadSnapshotChunk) Reset() { *m = ResponseLoadSnapshotC func (m *ResponseLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } func (*ResponseLoadSnapshotChunk) ProtoMessage() {} func (*ResponseLoadSnapshotChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{31} + return fileDescriptor_252557cfdd89a31a, []int{32} } func (m *ResponseLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2644,7 +2714,7 @@ func (m *ResponseApplySnapshotChunk) Reset() { *m = ResponseApplySnapsho func (m *ResponseApplySnapshotChunk) String() string { return proto.CompactTextString(m) } func (*ResponseApplySnapshotChunk) ProtoMessage() {} func (*ResponseApplySnapshotChunk) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{32} + return fileDescriptor_252557cfdd89a31a, []int{33} } func (m *ResponseApplySnapshotChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2702,7 +2772,7 @@ func (m *ResponsePrepareProposal) Reset() { *m = ResponsePrepareProposal func (m *ResponsePrepareProposal) String() string { return proto.CompactTextString(m) } func (*ResponsePrepareProposal) ProtoMessage() {} func (*ResponsePrepareProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{33} + return fileDescriptor_252557cfdd89a31a, []int{34} } func (m *ResponsePrepareProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2746,7 +2816,7 @@ func (m *ResponseProcessProposal) Reset() { *m = ResponseProcessProposal func (m *ResponseProcessProposal) String() string { return proto.CompactTextString(m) } func (*ResponseProcessProposal) ProtoMessage() {} func (*ResponseProcessProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{34} + return fileDescriptor_252557cfdd89a31a, []int{35} } func (m *ResponseProcessProposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2782,6 +2852,42 @@ func (m *ResponseProcessProposal) GetStatus() ResponseProcessProposal_ProposalSt return ResponseProcessProposal_UNKNOWN } +type ResponseEliminatedTx struct { +} + +func (m *ResponseEliminatedTx) Reset() { *m = ResponseEliminatedTx{} } +func (m *ResponseEliminatedTx) String() string { return proto.CompactTextString(m) } +func (*ResponseEliminatedTx) ProtoMessage() {} +func (*ResponseEliminatedTx) Descriptor() ([]byte, []int) { + return fileDescriptor_252557cfdd89a31a, []int{36} +} +func (m *ResponseEliminatedTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseEliminatedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResponseEliminatedTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ResponseEliminatedTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseEliminatedTx.Merge(m, src) +} +func (m *ResponseEliminatedTx) XXX_Size() int { + return m.Size() +} +func (m *ResponseEliminatedTx) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseEliminatedTx.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseEliminatedTx proto.InternalMessageInfo + type CommitInfo struct { Round int32 `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"` Votes []VoteInfo `protobuf:"bytes,2,rep,name=votes,proto3" json:"votes"` @@ -2791,7 +2897,7 @@ func (m *CommitInfo) Reset() { *m = CommitInfo{} } func (m *CommitInfo) String() string { return proto.CompactTextString(m) } func (*CommitInfo) ProtoMessage() {} func (*CommitInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{35} + return fileDescriptor_252557cfdd89a31a, []int{37} } func (m *CommitInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2846,7 +2952,7 @@ func (m *ExtendedCommitInfo) Reset() { *m = ExtendedCommitInfo{} } func (m *ExtendedCommitInfo) String() string { return proto.CompactTextString(m) } func (*ExtendedCommitInfo) ProtoMessage() {} func (*ExtendedCommitInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{36} + return fileDescriptor_252557cfdd89a31a, []int{38} } func (m *ExtendedCommitInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2901,7 +3007,7 @@ func (m *Event) Reset() { *m = Event{} } func (m *Event) String() string { return proto.CompactTextString(m) } func (*Event) ProtoMessage() {} func (*Event) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{37} + return fileDescriptor_252557cfdd89a31a, []int{39} } func (m *Event) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2955,7 +3061,7 @@ func (m *EventAttribute) Reset() { *m = EventAttribute{} } func (m *EventAttribute) String() string { return proto.CompactTextString(m) } func (*EventAttribute) ProtoMessage() {} func (*EventAttribute) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{38} + return fileDescriptor_252557cfdd89a31a, []int{40} } func (m *EventAttribute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3019,7 +3125,7 @@ func (m *TxResult) Reset() { *m = TxResult{} } func (m *TxResult) String() string { return proto.CompactTextString(m) } func (*TxResult) ProtoMessage() {} func (*TxResult) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{39} + return fileDescriptor_252557cfdd89a31a, []int{41} } func (m *TxResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3087,7 +3193,7 @@ func (m *Validator) Reset() { *m = Validator{} } func (m *Validator) String() string { return proto.CompactTextString(m) } func (*Validator) ProtoMessage() {} func (*Validator) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{40} + return fileDescriptor_252557cfdd89a31a, []int{42} } func (m *Validator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3140,7 +3246,7 @@ func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} } func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) } func (*ValidatorUpdate) ProtoMessage() {} func (*ValidatorUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{41} + return fileDescriptor_252557cfdd89a31a, []int{43} } func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3193,7 +3299,7 @@ func (m *VoteInfo) Reset() { *m = VoteInfo{} } func (m *VoteInfo) String() string { return proto.CompactTextString(m) } func (*VoteInfo) ProtoMessage() {} func (*VoteInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{42} + return fileDescriptor_252557cfdd89a31a, []int{44} } func (m *VoteInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3246,7 +3352,7 @@ func (m *ExtendedVoteInfo) Reset() { *m = ExtendedVoteInfo{} } func (m *ExtendedVoteInfo) String() string { return proto.CompactTextString(m) } func (*ExtendedVoteInfo) ProtoMessage() {} func (*ExtendedVoteInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{43} + return fileDescriptor_252557cfdd89a31a, []int{45} } func (m *ExtendedVoteInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3314,7 +3420,7 @@ func (m *Misbehavior) Reset() { *m = Misbehavior{} } func (m *Misbehavior) String() string { return proto.CompactTextString(m) } func (*Misbehavior) ProtoMessage() {} func (*Misbehavior) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{44} + return fileDescriptor_252557cfdd89a31a, []int{46} } func (m *Misbehavior) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3390,7 +3496,7 @@ func (m *Snapshot) Reset() { *m = Snapshot{} } func (m *Snapshot) String() string { return proto.CompactTextString(m) } func (*Snapshot) ProtoMessage() {} func (*Snapshot) Descriptor() ([]byte, []int) { - return fileDescriptor_252557cfdd89a31a, []int{45} + return fileDescriptor_252557cfdd89a31a, []int{47} } func (m *Snapshot) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3468,6 +3574,7 @@ func init() { proto.RegisterType((*RequestQuery)(nil), "tendermint.abci.RequestQuery") proto.RegisterType((*RequestBeginBlock)(nil), "tendermint.abci.RequestBeginBlock") proto.RegisterType((*RequestCheckTx)(nil), "tendermint.abci.RequestCheckTx") + proto.RegisterType((*RequestEliminatedTx)(nil), "tendermint.abci.RequestEliminatedTx") proto.RegisterType((*RequestDeliverTx)(nil), "tendermint.abci.RequestDeliverTx") proto.RegisterType((*RequestEndBlock)(nil), "tendermint.abci.RequestEndBlock") proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.RequestCommit") @@ -3495,6 +3602,7 @@ func init() { proto.RegisterType((*ResponseApplySnapshotChunk)(nil), "tendermint.abci.ResponseApplySnapshotChunk") proto.RegisterType((*ResponsePrepareProposal)(nil), "tendermint.abci.ResponsePrepareProposal") proto.RegisterType((*ResponseProcessProposal)(nil), "tendermint.abci.ResponseProcessProposal") + proto.RegisterType((*ResponseEliminatedTx)(nil), "tendermint.abci.ResponseEliminatedTx") proto.RegisterType((*CommitInfo)(nil), "tendermint.abci.CommitInfo") proto.RegisterType((*ExtendedCommitInfo)(nil), "tendermint.abci.ExtendedCommitInfo") proto.RegisterType((*Event)(nil), "tendermint.abci.Event") @@ -3511,201 +3619,205 @@ func init() { func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) } var fileDescriptor_252557cfdd89a31a = []byte{ - // 3095 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xbb, 0x73, 0x23, 0xc7, - 0xd1, 0xc7, 0xfb, 0xd1, 0x78, 0x72, 0x8e, 0xe2, 0xe1, 0xa0, 0x13, 0x49, 0xed, 0x95, 0xa4, 0xbb, - 0x93, 0x44, 0xea, 0xa3, 0xbe, 0xd3, 0xa3, 0xf4, 0xe9, 0xfb, 0x04, 0xe0, 0x70, 0x1f, 0x28, 0x52, - 0x24, 0xbd, 0x04, 0x4f, 0x25, 0x3f, 0x6e, 0xb5, 0x58, 0x0c, 0x89, 0xd5, 0x01, 0xbb, 0xab, 0xdd, - 0x01, 0x05, 0x2a, 0xb4, 0xca, 0x55, 0x2e, 0x95, 0xcb, 0xa5, 0x50, 0x89, 0x02, 0x07, 0xfe, 0x1f, - 0x1c, 0x39, 0x72, 0xa0, 0xc0, 0x81, 0x02, 0x07, 0x8e, 0x64, 0x97, 0x94, 0xf9, 0x1f, 0x70, 0xe0, - 0xc0, 0xae, 0x79, 0xec, 0x0b, 0xc0, 0x12, 0xa0, 0xe4, 0x72, 0x95, 0xcb, 0xd9, 0x4c, 0x4f, 0x77, - 0xcf, 0x4c, 0xcf, 0x6c, 0x77, 0xff, 0x7a, 0x07, 0x9e, 0x24, 0xd8, 0xe8, 0x63, 0x7b, 0xa4, 0x1b, - 0x64, 0x5b, 0xed, 0x69, 0xfa, 0x36, 0xb9, 0xb0, 0xb0, 0xb3, 0x65, 0xd9, 0x26, 0x31, 0x51, 0xc5, - 0x1f, 0xdc, 0xa2, 0x83, 0xf5, 0xa7, 0x02, 0xdc, 0x9a, 0x7d, 0x61, 0x11, 0x73, 0xdb, 0xb2, 0x4d, - 0xf3, 0x94, 0xf3, 0xd7, 0x6f, 0x06, 0x86, 0x99, 0x9e, 0xa0, 0xb6, 0xd0, 0xa8, 0x10, 0x7e, 0x8c, - 0x2f, 0xdc, 0xd1, 0xa7, 0x66, 0x64, 0x2d, 0xd5, 0x56, 0x47, 0xee, 0xf0, 0xc6, 0x99, 0x69, 0x9e, - 0x0d, 0xf1, 0x36, 0xeb, 0xf5, 0xc6, 0xa7, 0xdb, 0x44, 0x1f, 0x61, 0x87, 0xa8, 0x23, 0x4b, 0x30, - 0xac, 0x9e, 0x99, 0x67, 0x26, 0x6b, 0x6e, 0xd3, 0x16, 0xa7, 0x4a, 0x7f, 0xcf, 0x41, 0x56, 0xc6, - 0x1f, 0x8e, 0xb1, 0x43, 0xd0, 0x0e, 0xa4, 0xb0, 0x36, 0x30, 0x6b, 0xf1, 0xcd, 0xf8, 0xed, 0xc2, - 0xce, 0xcd, 0xad, 0xa9, 0xcd, 0x6d, 0x09, 0xbe, 0xb6, 0x36, 0x30, 0x3b, 0x31, 0x99, 0xf1, 0xa2, - 0x7b, 0x90, 0x3e, 0x1d, 0x8e, 0x9d, 0x41, 0x2d, 0xc1, 0x84, 0x9e, 0x8a, 0x12, 0x7a, 0x40, 0x99, - 0x3a, 0x31, 0x99, 0x73, 0xd3, 0xa9, 0x74, 0xe3, 0xd4, 0xac, 0x25, 0x2f, 0x9f, 0x6a, 0xd7, 0x38, - 0x65, 0x53, 0x51, 0x5e, 0xd4, 0x04, 0xd0, 0x0d, 0x9d, 0x28, 0xda, 0x40, 0xd5, 0x8d, 0x5a, 0x9a, - 0x49, 0x3e, 0x1d, 0x2d, 0xa9, 0x93, 0x16, 0x65, 0xec, 0xc4, 0xe4, 0xbc, 0xee, 0x76, 0xe8, 0x72, - 0x3f, 0x1c, 0x63, 0xfb, 0xa2, 0x96, 0xb9, 0x7c, 0xb9, 0x3f, 0xa0, 0x4c, 0x74, 0xb9, 0x8c, 0x1b, - 0xb5, 0xa1, 0xd0, 0xc3, 0x67, 0xba, 0xa1, 0xf4, 0x86, 0xa6, 0xf6, 0xb8, 0x96, 0x65, 0xc2, 0x52, - 0x94, 0x70, 0x93, 0xb2, 0x36, 0x29, 0x67, 0x27, 0x26, 0x43, 0xcf, 0xeb, 0xa1, 0xff, 0x81, 0x9c, - 0x36, 0xc0, 0xda, 0x63, 0x85, 0x4c, 0x6a, 0x39, 0xa6, 0x63, 0x23, 0x4a, 0x47, 0x8b, 0xf2, 0x75, - 0x27, 0x9d, 0x98, 0x9c, 0xd5, 0x78, 0x93, 0xee, 0xbf, 0x8f, 0x87, 0xfa, 0x39, 0xb6, 0xa9, 0x7c, - 0xfe, 0xf2, 0xfd, 0xdf, 0xe7, 0x9c, 0x4c, 0x43, 0xbe, 0xef, 0x76, 0xd0, 0xff, 0x41, 0x1e, 0x1b, - 0x7d, 0xb1, 0x0d, 0x60, 0x2a, 0x36, 0x23, 0xcf, 0xd9, 0xe8, 0xbb, 0x9b, 0xc8, 0x61, 0xd1, 0x46, - 0xaf, 0x41, 0x46, 0x33, 0x47, 0x23, 0x9d, 0xd4, 0x0a, 0x4c, 0x7a, 0x3d, 0x72, 0x03, 0x8c, 0xab, - 0x13, 0x93, 0x05, 0x3f, 0x3a, 0x80, 0xf2, 0x50, 0x77, 0x88, 0xe2, 0x18, 0xaa, 0xe5, 0x0c, 0x4c, - 0xe2, 0xd4, 0x8a, 0x4c, 0xc3, 0x33, 0x51, 0x1a, 0xf6, 0x75, 0x87, 0x1c, 0xbb, 0xcc, 0x9d, 0x98, - 0x5c, 0x1a, 0x06, 0x09, 0x54, 0x9f, 0x79, 0x7a, 0x8a, 0x6d, 0x4f, 0x61, 0xad, 0x74, 0xb9, 0xbe, - 0x43, 0xca, 0xed, 0xca, 0x53, 0x7d, 0x66, 0x90, 0x80, 0x7e, 0x04, 0xd7, 0x86, 0xa6, 0xda, 0xf7, - 0xd4, 0x29, 0xda, 0x60, 0x6c, 0x3c, 0xae, 0x95, 0x99, 0xd2, 0x3b, 0x91, 0x8b, 0x34, 0xd5, 0xbe, - 0xab, 0xa2, 0x45, 0x05, 0x3a, 0x31, 0x79, 0x65, 0x38, 0x4d, 0x44, 0x8f, 0x60, 0x55, 0xb5, 0xac, - 0xe1, 0xc5, 0xb4, 0xf6, 0x0a, 0xd3, 0x7e, 0x37, 0x4a, 0x7b, 0x83, 0xca, 0x4c, 0xab, 0x47, 0xea, - 0x0c, 0x15, 0x75, 0xa1, 0x6a, 0xd9, 0xd8, 0x52, 0x6d, 0xac, 0x58, 0xb6, 0x69, 0x99, 0x8e, 0x3a, - 0xac, 0x55, 0x99, 0xee, 0xe7, 0xa2, 0x74, 0x1f, 0x71, 0xfe, 0x23, 0xc1, 0xde, 0x89, 0xc9, 0x15, - 0x2b, 0x4c, 0xe2, 0x5a, 0x4d, 0x0d, 0x3b, 0x8e, 0xaf, 0x75, 0x65, 0x91, 0x56, 0xc6, 0x1f, 0xd6, - 0x1a, 0x22, 0x35, 0xb3, 0x90, 0x3e, 0x57, 0x87, 0x63, 0xfc, 0x76, 0x2a, 0x97, 0xaa, 0xa6, 0xa5, - 0xe7, 0xa0, 0x10, 0x70, 0x2c, 0xa8, 0x06, 0xd9, 0x11, 0x76, 0x1c, 0xf5, 0x0c, 0x33, 0x3f, 0x94, - 0x97, 0xdd, 0xae, 0x54, 0x86, 0x62, 0xd0, 0x99, 0x48, 0x9f, 0xc5, 0x3d, 0x49, 0xea, 0x27, 0xa8, - 0xe4, 0x39, 0xb6, 0x1d, 0xdd, 0x34, 0x5c, 0x49, 0xd1, 0x45, 0xb7, 0xa0, 0xc4, 0x6e, 0xbc, 0xe2, - 0x8e, 0x53, 0x67, 0x95, 0x92, 0x8b, 0x8c, 0xf8, 0x50, 0x30, 0x6d, 0x40, 0xc1, 0xda, 0xb1, 0x3c, - 0x96, 0x24, 0x63, 0x01, 0x6b, 0xc7, 0x72, 0x19, 0x9e, 0x86, 0x22, 0xdd, 0xa9, 0xc7, 0x91, 0x62, - 0x93, 0x14, 0x28, 0x4d, 0xb0, 0x48, 0xbf, 0x4f, 0x40, 0x75, 0xda, 0x01, 0xa1, 0xd7, 0x20, 0x45, - 0x7d, 0xb1, 0x70, 0xab, 0xf5, 0x2d, 0xee, 0xa8, 0xb7, 0x5c, 0x47, 0xbd, 0xd5, 0x75, 0x1d, 0x75, - 0x33, 0xf7, 0xe5, 0xd7, 0x1b, 0xb1, 0xcf, 0xfe, 0xb4, 0x11, 0x97, 0x99, 0x04, 0xba, 0x41, 0xfd, - 0x85, 0xaa, 0x1b, 0x8a, 0xde, 0x67, 0x4b, 0xce, 0x53, 0x67, 0xa0, 0xea, 0xc6, 0x6e, 0x1f, 0xed, - 0x43, 0x55, 0x33, 0x0d, 0x07, 0x1b, 0xce, 0xd8, 0x51, 0x78, 0x20, 0x10, 0xce, 0x34, 0xe4, 0x12, - 0x78, 0x78, 0x69, 0xb9, 0x9c, 0x47, 0x8c, 0x51, 0xae, 0x68, 0x61, 0x02, 0x7a, 0x00, 0x70, 0xae, - 0x0e, 0xf5, 0xbe, 0x4a, 0x4c, 0xdb, 0xa9, 0xa5, 0x36, 0x93, 0x73, 0xfd, 0xc2, 0x43, 0x97, 0xe5, - 0xc4, 0xea, 0xab, 0x04, 0x37, 0x53, 0x74, 0xb9, 0x72, 0x40, 0x12, 0x3d, 0x0b, 0x15, 0xd5, 0xb2, - 0x14, 0x87, 0xa8, 0x04, 0x2b, 0xbd, 0x0b, 0x82, 0x1d, 0xe6, 0xa7, 0x8b, 0x72, 0x49, 0xb5, 0xac, - 0x63, 0x4a, 0x6d, 0x52, 0x22, 0x7a, 0x06, 0xca, 0xd4, 0x27, 0xeb, 0xea, 0x50, 0x19, 0x60, 0xfd, - 0x6c, 0x40, 0x98, 0x3f, 0x4e, 0xca, 0x25, 0x41, 0xed, 0x30, 0xa2, 0xd4, 0xf7, 0x4e, 0x9c, 0xf9, - 0x63, 0x84, 0x20, 0xd5, 0x57, 0x89, 0xca, 0x2c, 0x59, 0x94, 0x59, 0x9b, 0xd2, 0x2c, 0x95, 0x0c, - 0x84, 0x7d, 0x58, 0x1b, 0xad, 0x41, 0x46, 0xa8, 0x4d, 0x32, 0xb5, 0xa2, 0x87, 0x56, 0x21, 0x6d, - 0xd9, 0xe6, 0x39, 0x66, 0x47, 0x97, 0x93, 0x79, 0x47, 0xfa, 0x24, 0x01, 0x2b, 0x33, 0x9e, 0x9b, - 0xea, 0x1d, 0xa8, 0xce, 0xc0, 0x9d, 0x8b, 0xb6, 0xd1, 0x2b, 0x54, 0xaf, 0xda, 0xc7, 0xb6, 0x88, - 0x76, 0xb5, 0x59, 0x53, 0x77, 0xd8, 0xb8, 0x30, 0x8d, 0xe0, 0x46, 0x7b, 0x50, 0x1d, 0xaa, 0x0e, - 0x51, 0xb8, 0x27, 0x54, 0x02, 0x91, 0xef, 0xc9, 0x19, 0x23, 0x73, 0xbf, 0x49, 0x2f, 0xb4, 0x50, - 0x52, 0xa6, 0xa2, 0x3e, 0x15, 0x9d, 0xc0, 0x6a, 0xef, 0xe2, 0x63, 0xd5, 0x20, 0xba, 0x81, 0x95, - 0x99, 0x53, 0x9b, 0x0d, 0xa5, 0xef, 0xe8, 0x4e, 0x0f, 0x0f, 0xd4, 0x73, 0xdd, 0x74, 0x97, 0x75, - 0xcd, 0x93, 0xf7, 0x4e, 0xd4, 0x91, 0x64, 0x28, 0x87, 0x43, 0x0f, 0x2a, 0x43, 0x82, 0x4c, 0xc4, - 0xfe, 0x13, 0x64, 0x82, 0x5e, 0x82, 0x14, 0xdd, 0x23, 0xdb, 0x7b, 0x79, 0xce, 0x44, 0x42, 0xae, - 0x7b, 0x61, 0x61, 0x99, 0x71, 0x4a, 0x92, 0xf7, 0x35, 0x78, 0xe1, 0x68, 0x5a, 0xab, 0x74, 0x07, - 0x2a, 0x53, 0xf1, 0x26, 0x70, 0x7c, 0xf1, 0xe0, 0xf1, 0x49, 0x15, 0x28, 0x85, 0x82, 0x8b, 0xb4, - 0x06, 0xab, 0xf3, 0x62, 0x85, 0x34, 0xf0, 0xe8, 0x21, 0x9f, 0x8f, 0xee, 0x41, 0xce, 0x0b, 0x16, - 0xfc, 0x6b, 0xbc, 0x31, 0xb3, 0x0b, 0x97, 0x59, 0xf6, 0x58, 0xe9, 0x67, 0x48, 0x6f, 0x35, 0xbb, - 0x0e, 0x09, 0xb6, 0xf0, 0xac, 0x6a, 0x59, 0x1d, 0xd5, 0x19, 0x48, 0xef, 0x43, 0x2d, 0x2a, 0x10, - 0x4c, 0x6d, 0x23, 0xe5, 0xdd, 0xc2, 0x35, 0xc8, 0x9c, 0x9a, 0xf6, 0x48, 0x25, 0x4c, 0x59, 0x49, - 0x16, 0x3d, 0x7a, 0x3b, 0x79, 0x50, 0x48, 0x32, 0x32, 0xef, 0x48, 0x0a, 0xdc, 0x88, 0x0c, 0x06, - 0x54, 0x44, 0x37, 0xfa, 0x98, 0xdb, 0xb3, 0x24, 0xf3, 0x8e, 0xaf, 0x88, 0x2f, 0x96, 0x77, 0xe8, - 0xb4, 0x0e, 0xdb, 0x2b, 0xd3, 0x9f, 0x97, 0x45, 0x4f, 0xfa, 0x3c, 0x09, 0x6b, 0xf3, 0x43, 0x02, - 0xda, 0x84, 0xe2, 0x48, 0x9d, 0x28, 0x64, 0x22, 0xbe, 0x65, 0x7e, 0x1c, 0x30, 0x52, 0x27, 0xdd, - 0x09, 0xff, 0x90, 0xab, 0x90, 0x24, 0x13, 0xa7, 0x96, 0xd8, 0x4c, 0xde, 0x2e, 0xca, 0xb4, 0x89, - 0x4e, 0x60, 0x65, 0x68, 0x6a, 0xea, 0x50, 0x09, 0xdc, 0x78, 0x71, 0xd9, 0x6f, 0xcd, 0x18, 0xbb, - 0x3d, 0x61, 0x94, 0xfe, 0xcc, 0xa5, 0xaf, 0x30, 0x1d, 0xfb, 0xde, 0xcd, 0x47, 0xf7, 0xa1, 0x30, - 0xf2, 0x2f, 0xf2, 0x15, 0x2e, 0x7b, 0x50, 0x2c, 0x70, 0x24, 0xe9, 0x90, 0x63, 0x70, 0x5d, 0x74, - 0xe6, 0xca, 0x2e, 0xfa, 0x25, 0x58, 0x35, 0xf0, 0x84, 0x04, 0x3e, 0x44, 0x7e, 0x4f, 0xb2, 0xcc, - 0xf4, 0x88, 0x8e, 0xf9, 0x1f, 0x19, 0xbd, 0x32, 0xe8, 0x0e, 0x0b, 0xaa, 0x96, 0xe9, 0x60, 0x5b, - 0x51, 0xfb, 0x7d, 0x1b, 0x3b, 0x0e, 0x4b, 0x06, 0x8b, 0x2c, 0x52, 0x32, 0x7a, 0x83, 0x93, 0xa5, - 0x9f, 0x07, 0x8f, 0x26, 0x14, 0x44, 0x5d, 0xc3, 0xc7, 0x7d, 0xc3, 0x1f, 0xc3, 0xaa, 0x90, 0xef, - 0x87, 0x6c, 0x9f, 0x58, 0xd6, 0xd1, 0x20, 0x57, 0x3c, 0xda, 0xec, 0xc9, 0xef, 0x66, 0x76, 0xd7, - 0x97, 0xa6, 0x02, 0xbe, 0xf4, 0xdf, 0xec, 0x28, 0xfe, 0x90, 0x87, 0x9c, 0x8c, 0x1d, 0x8b, 0x06, - 0x4e, 0xd4, 0x84, 0x3c, 0x9e, 0x68, 0xd8, 0x22, 0x6e, 0xae, 0x31, 0x1f, 0x0c, 0x70, 0xee, 0xb6, - 0xcb, 0x49, 0x33, 0x71, 0x4f, 0x0c, 0xbd, 0x2c, 0xc0, 0x56, 0x34, 0x6e, 0x12, 0xe2, 0x41, 0xb4, - 0xf5, 0x8a, 0x8b, 0xb6, 0x92, 0x91, 0xc9, 0x37, 0x97, 0x9a, 0x82, 0x5b, 0x2f, 0x0b, 0xb8, 0x95, - 0x5a, 0x30, 0x59, 0x08, 0x6f, 0xb5, 0x42, 0x78, 0x2b, 0xb3, 0x60, 0x9b, 0x11, 0x80, 0xeb, 0x15, - 0x17, 0x70, 0x65, 0x17, 0xac, 0x78, 0x0a, 0x71, 0x3d, 0x08, 0x23, 0xae, 0x5c, 0x84, 0x03, 0x71, - 0xa5, 0x23, 0x21, 0xd7, 0x9b, 0x01, 0xc8, 0x95, 0x8f, 0xc4, 0x3b, 0x5c, 0xc9, 0x1c, 0xcc, 0xd5, - 0x0a, 0x61, 0x2e, 0x58, 0x60, 0x83, 0x08, 0xd0, 0xf5, 0x56, 0x10, 0x74, 0x15, 0x22, 0x71, 0x9b, - 0x38, 0xef, 0x79, 0xa8, 0xeb, 0x75, 0x0f, 0x75, 0x15, 0x23, 0x61, 0xa3, 0xd8, 0xc3, 0x34, 0xec, - 0x3a, 0x9c, 0x81, 0x5d, 0x1c, 0x26, 0x3d, 0x1b, 0xa9, 0x62, 0x01, 0xee, 0x3a, 0x9c, 0xc1, 0x5d, - 0xe5, 0x05, 0x0a, 0x17, 0x00, 0xaf, 0x1f, 0xcf, 0x07, 0x5e, 0xd1, 0xd0, 0x48, 0x2c, 0x73, 0x39, - 0xe4, 0xa5, 0x44, 0x20, 0x2f, 0x8e, 0x8e, 0x9e, 0x8f, 0x54, 0xbf, 0x34, 0xf4, 0x3a, 0x99, 0x03, - 0xbd, 0x38, 0x48, 0xba, 0x1d, 0xa9, 0x7c, 0x09, 0xec, 0x75, 0x32, 0x07, 0x7b, 0xa1, 0x85, 0x6a, - 0xaf, 0x02, 0xbe, 0xd2, 0xd5, 0x8c, 0x74, 0x87, 0xa6, 0xbe, 0x53, 0x7e, 0x8a, 0xe6, 0x0f, 0xd8, - 0xb6, 0x4d, 0x5b, 0xc0, 0x28, 0xde, 0x91, 0x6e, 0xd3, 0x64, 0xdc, 0xf7, 0x49, 0x97, 0x00, 0x35, - 0x96, 0xa7, 0x05, 0xfc, 0x90, 0xf4, 0x9b, 0xb8, 0x2f, 0xcb, 0x72, 0xd8, 0x60, 0x22, 0x9f, 0x17, - 0x89, 0x7c, 0x00, 0xbe, 0x25, 0xc2, 0xf0, 0x6d, 0x03, 0x0a, 0x34, 0xff, 0x9a, 0x42, 0x66, 0xaa, - 0xe5, 0x21, 0xb3, 0xbb, 0xb0, 0xc2, 0x22, 0x1e, 0x07, 0x79, 0x22, 0xac, 0xa4, 0x58, 0x58, 0xa9, - 0xd0, 0x01, 0xfe, 0x41, 0xf1, 0xf8, 0xf2, 0x22, 0x5c, 0x0b, 0xf0, 0x7a, 0x79, 0x1d, 0x87, 0x29, - 0x55, 0x8f, 0xbb, 0x21, 0x12, 0xbc, 0xdf, 0xc5, 0x7d, 0x0b, 0xf9, 0x90, 0x6e, 0x1e, 0xfa, 0x8a, - 0xff, 0x93, 0xd0, 0x57, 0xe2, 0x3b, 0xa3, 0xaf, 0x60, 0x9e, 0x9a, 0x0c, 0xe7, 0xa9, 0x7f, 0x8d, - 0xfb, 0x67, 0xe2, 0x61, 0x29, 0xcd, 0xec, 0x63, 0x91, 0x39, 0xb2, 0x36, 0x4d, 0x2a, 0x86, 0xe6, - 0x99, 0xc8, 0x0f, 0x69, 0x93, 0x72, 0x79, 0x81, 0x23, 0x2f, 0xe2, 0x82, 0x97, 0x74, 0xf2, 0xc0, - 0x2d, 0x92, 0xce, 0x2a, 0x24, 0x1f, 0x63, 0x5e, 0x57, 0x2b, 0xca, 0xb4, 0x49, 0xf9, 0xd8, 0x55, - 0x13, 0x01, 0x98, 0x77, 0xd0, 0x6b, 0x90, 0x67, 0x15, 0x51, 0xc5, 0xb4, 0x1c, 0xe1, 0xd6, 0x43, - 0xb9, 0x09, 0x2f, 0x7c, 0x6e, 0x1d, 0x51, 0x9e, 0x43, 0xcb, 0x91, 0x73, 0x96, 0x68, 0x05, 0x32, - 0x86, 0x7c, 0x28, 0x63, 0xb8, 0x09, 0x79, 0xba, 0x7a, 0xc7, 0x52, 0x35, 0xcc, 0x5c, 0x74, 0x5e, - 0xf6, 0x09, 0xd2, 0x23, 0x40, 0xb3, 0x41, 0x02, 0x75, 0x20, 0x83, 0xcf, 0xb1, 0x41, 0x78, 0x06, - 0x55, 0xd8, 0x59, 0x9b, 0x4d, 0x4d, 0xe9, 0x70, 0xb3, 0x46, 0x8d, 0xfc, 0x97, 0xaf, 0x37, 0xaa, - 0x9c, 0xfb, 0x05, 0x73, 0xa4, 0x13, 0x3c, 0xb2, 0xc8, 0x85, 0x2c, 0xe4, 0xa5, 0x5f, 0xa6, 0x28, - 0x80, 0x09, 0x05, 0x90, 0xb9, 0xb6, 0x75, 0xaf, 0x7c, 0x22, 0x80, 0x5d, 0x97, 0xb3, 0xf7, 0x3a, - 0xc0, 0x99, 0xea, 0x28, 0x1f, 0xa9, 0x06, 0xc1, 0x7d, 0x61, 0xf4, 0x00, 0x05, 0xd5, 0x21, 0x47, - 0x7b, 0x63, 0x07, 0xf7, 0x05, 0x8c, 0xf6, 0xfa, 0x81, 0x7d, 0x66, 0xbf, 0xdf, 0x3e, 0xc3, 0x56, - 0xce, 0x4d, 0x59, 0x39, 0x00, 0x2e, 0xf2, 0x41, 0x70, 0x41, 0xd7, 0x66, 0xd9, 0xba, 0x69, 0xeb, - 0xe4, 0x82, 0x1d, 0x4d, 0x52, 0xf6, 0xfa, 0xe8, 0x16, 0x94, 0x46, 0x78, 0x64, 0x99, 0xe6, 0x50, - 0xe1, 0xee, 0xa6, 0xc0, 0x44, 0x8b, 0x82, 0xd8, 0xa6, 0x34, 0xf4, 0x0c, 0x94, 0x1d, 0xfd, 0xcc, - 0x08, 0x24, 0x68, 0xab, 0x8c, 0xab, 0xc4, 0xa9, 0x22, 0x3d, 0xa3, 0x77, 0xcd, 0x30, 0x0d, 0x0d, - 0xd7, 0x9e, 0x60, 0xce, 0x81, 0x77, 0xd0, 0x93, 0x90, 0xa7, 0x96, 0x18, 0xea, 0x34, 0x72, 0xae, - 0xb1, 0x11, 0x6a, 0x9a, 0x7d, 0xda, 0x77, 0x07, 0x2d, 0x5b, 0xd7, 0x70, 0xed, 0xba, 0x37, 0x78, - 0x44, 0xfb, 0xf4, 0x1c, 0x18, 0xd6, 0xad, 0x6d, 0xc6, 0x6f, 0xa7, 0x39, 0x9a, 0xa5, 0x4b, 0xb1, - 0xb1, 0x35, 0x54, 0x35, 0xac, 0xf6, 0x86, 0x98, 0xe6, 0x03, 0x37, 0x78, 0x6d, 0x23, 0x40, 0xed, - 0x4e, 0xa4, 0x9f, 0x25, 0x7c, 0x8f, 0xe1, 0xc3, 0xde, 0xff, 0xb8, 0x2b, 0x21, 0xfd, 0x82, 0xd5, - 0xc2, 0xc2, 0x49, 0x0d, 0x3a, 0x86, 0x15, 0xcf, 0x61, 0x29, 0x63, 0xe6, 0xc8, 0xdc, 0x4f, 0x70, - 0x59, 0x8f, 0x57, 0x3d, 0x0f, 0x93, 0x1d, 0xf4, 0x1e, 0x5c, 0x9f, 0xf2, 0xc6, 0x9e, 0xea, 0xc4, - 0xb2, 0x4e, 0xf9, 0x89, 0xb0, 0x53, 0x76, 0x55, 0xfb, 0xc6, 0x4a, 0x7e, 0x4f, 0x3f, 0xb1, 0x0b, - 0xe5, 0x70, 0x8e, 0x36, 0xf7, 0xf8, 0x6f, 0x41, 0xc9, 0xc6, 0x44, 0xd5, 0x0d, 0x25, 0x54, 0xc0, - 0x2a, 0x72, 0xa2, 0x28, 0x8b, 0x1d, 0xc1, 0x13, 0x73, 0x73, 0x35, 0xf4, 0x2a, 0xe4, 0xfd, 0x34, - 0x8f, 0x5b, 0xf5, 0x92, 0x02, 0x87, 0xcf, 0x2b, 0xfd, 0x36, 0xee, 0xab, 0x0c, 0x97, 0x4c, 0xda, - 0x90, 0xb1, 0xb1, 0x33, 0x1e, 0xf2, 0x22, 0x46, 0x79, 0xe7, 0xc5, 0xe5, 0xb2, 0x3c, 0x4a, 0x1d, - 0x0f, 0x89, 0x2c, 0x84, 0xa5, 0x47, 0x90, 0xe1, 0x14, 0x54, 0x80, 0xec, 0xc9, 0xc1, 0xde, 0xc1, - 0xe1, 0xbb, 0x07, 0xd5, 0x18, 0x02, 0xc8, 0x34, 0x5a, 0xad, 0xf6, 0x51, 0xb7, 0x1a, 0x47, 0x79, - 0x48, 0x37, 0x9a, 0x87, 0x72, 0xb7, 0x9a, 0xa0, 0x64, 0xb9, 0xfd, 0x76, 0xbb, 0xd5, 0xad, 0x26, - 0xd1, 0x0a, 0x94, 0x78, 0x5b, 0x79, 0x70, 0x28, 0xbf, 0xd3, 0xe8, 0x56, 0x53, 0x01, 0xd2, 0x71, - 0xfb, 0xe0, 0x7e, 0x5b, 0xae, 0xa6, 0xa5, 0xff, 0x82, 0x1b, 0x91, 0x79, 0xa1, 0x5f, 0x0f, 0x89, - 0x07, 0xea, 0x21, 0xd2, 0xe7, 0x09, 0xa8, 0x47, 0x27, 0x7b, 0xe8, 0xed, 0xa9, 0x8d, 0xef, 0x5c, - 0x21, 0x53, 0x9c, 0xda, 0x3d, 0xf7, 0x1c, 0xa7, 0x98, 0x68, 0x03, 0x9e, 0x7c, 0xf2, 0x20, 0x5f, - 0xa2, 0x9e, 0x83, 0x51, 0x99, 0x90, 0xc3, 0xd9, 0x3e, 0xc0, 0x1a, 0x51, 0xb8, 0xf7, 0xe4, 0x97, - 0x2e, 0x4f, 0xd9, 0x28, 0xf5, 0x98, 0x13, 0xa5, 0xf7, 0xaf, 0x64, 0xcb, 0x3c, 0xa4, 0xe5, 0x76, - 0x57, 0x7e, 0xaf, 0x9a, 0x44, 0x08, 0xca, 0xac, 0xa9, 0x1c, 0x1f, 0x34, 0x8e, 0x8e, 0x3b, 0x87, - 0xd4, 0x96, 0xd7, 0xa0, 0xe2, 0xda, 0xd2, 0x25, 0xa6, 0xa5, 0xe7, 0xe1, 0x7a, 0x44, 0xa6, 0x3a, - 0x5b, 0x77, 0x90, 0x7e, 0x15, 0x0f, 0x72, 0x87, 0xab, 0x14, 0x87, 0x90, 0x71, 0x88, 0x4a, 0xc6, - 0x8e, 0x30, 0xe2, 0xab, 0xcb, 0xa6, 0xae, 0x5b, 0x6e, 0xe3, 0x98, 0x89, 0xcb, 0x42, 0x8d, 0x74, - 0x0f, 0xca, 0xe1, 0x91, 0x68, 0x1b, 0xf8, 0x97, 0x28, 0x21, 0xbd, 0x07, 0x10, 0xa8, 0xa0, 0xae, - 0x42, 0xda, 0x36, 0xc7, 0x46, 0x9f, 0x2d, 0x2a, 0x2d, 0xf3, 0x0e, 0xba, 0x07, 0xe9, 0x73, 0x93, - 0xfb, 0x8c, 0xf9, 0x1f, 0xce, 0x43, 0x93, 0xe0, 0x40, 0xb9, 0x84, 0x73, 0x4b, 0x3a, 0xa0, 0xd9, - 0x2a, 0x56, 0xc4, 0x14, 0x6f, 0x86, 0xa7, 0x78, 0x3a, 0xb2, 0x1e, 0x36, 0x7f, 0xaa, 0x8f, 0x21, - 0xcd, 0xbc, 0x8d, 0x17, 0x9d, 0x44, 0xfa, 0xcc, 0xa2, 0xd3, 0x4f, 0x00, 0x54, 0x42, 0x6c, 0xbd, - 0x37, 0xf6, 0x27, 0xd8, 0x98, 0xef, 0xad, 0x1a, 0x2e, 0x5f, 0xf3, 0xa6, 0x70, 0x5b, 0xab, 0xbe, - 0x68, 0xc0, 0x75, 0x05, 0x14, 0x4a, 0x07, 0x50, 0x0e, 0xcb, 0xba, 0x09, 0x1f, 0x5f, 0x43, 0x38, - 0xe1, 0xe3, 0xf9, 0xbb, 0x48, 0xf8, 0xbc, 0x74, 0x31, 0xc9, 0x8b, 0xee, 0xac, 0x23, 0x7d, 0x1a, - 0x87, 0x5c, 0x77, 0x22, 0xee, 0x71, 0x44, 0xc1, 0xd7, 0x17, 0x4d, 0x04, 0xcb, 0x9b, 0xbc, 0x82, - 0x9c, 0xf4, 0xea, 0xd2, 0x6f, 0x79, 0x5f, 0x6a, 0x6a, 0x59, 0x7c, 0xee, 0xd6, 0xe7, 0x85, 0x77, - 0x7a, 0x03, 0xf2, 0x5e, 0xac, 0xa1, 0x38, 0xc4, 0x4d, 0x35, 0xe2, 0x22, 0x89, 0xf6, 0x93, 0x0c, - 0xcb, 0xfc, 0x48, 0x14, 0x50, 0x93, 0x32, 0xef, 0x48, 0x7d, 0xa8, 0x4c, 0x05, 0x2a, 0xf4, 0x06, - 0x64, 0xad, 0x71, 0x4f, 0x71, 0xcd, 0x33, 0x55, 0x31, 0x73, 0x33, 0xdc, 0x71, 0x6f, 0xa8, 0x6b, - 0x7b, 0xf8, 0xc2, 0x5d, 0x8c, 0x35, 0xee, 0xed, 0x71, 0x2b, 0xf2, 0x59, 0x12, 0xc1, 0x59, 0xce, - 0x21, 0xe7, 0x5e, 0x0a, 0xf4, 0xbf, 0x90, 0xf7, 0x62, 0xa0, 0xf7, 0x57, 0x29, 0x32, 0x78, 0x0a, - 0xf5, 0xbe, 0x08, 0x85, 0x4b, 0x2c, 0x7b, 0x12, 0x75, 0x42, 0x5e, 0x97, 0x48, 0xb0, 0xd3, 0xa9, - 0xf0, 0x81, 0x7d, 0x17, 0x06, 0x49, 0xbf, 0x8e, 0x43, 0x75, 0xfa, 0x56, 0xfe, 0x2b, 0x17, 0x40, - 0x9d, 0x22, 0xbd, 0xfd, 0x0a, 0xa6, 0x8b, 0xf0, 0xf0, 0x5f, 0x51, 0x2e, 0x51, 0x6a, 0xdb, 0x25, - 0x4a, 0x9f, 0x24, 0xa0, 0x10, 0xa8, 0x42, 0xa2, 0xff, 0x0e, 0x7c, 0x22, 0xe5, 0x39, 0xb9, 0x45, - 0x80, 0xd7, 0xff, 0x61, 0x11, 0xde, 0x58, 0xe2, 0xea, 0x1b, 0x8b, 0xfa, 0xf1, 0xe4, 0x16, 0x35, - 0x53, 0x57, 0x2e, 0x6a, 0xbe, 0x00, 0x88, 0x98, 0x44, 0x1d, 0x2a, 0xe7, 0x26, 0xd1, 0x8d, 0x33, - 0x85, 0x5f, 0x0d, 0x9e, 0xf1, 0x55, 0xd9, 0xc8, 0x43, 0x36, 0x70, 0xc4, 0x6e, 0xc9, 0x4f, 0xe3, - 0x90, 0xf3, 0x42, 0xf7, 0x55, 0xff, 0x3f, 0xac, 0x41, 0x46, 0x44, 0x27, 0xfe, 0x03, 0x42, 0xf4, - 0xe6, 0x56, 0x6f, 0xeb, 0x90, 0x1b, 0x61, 0xa2, 0xb2, 0xfc, 0x85, 0x43, 0x67, 0xaf, 0x7f, 0xf7, - 0x75, 0x28, 0x04, 0x7e, 0x05, 0x51, 0x3f, 0x71, 0xd0, 0x7e, 0xb7, 0x1a, 0xab, 0x67, 0x3f, 0xfd, - 0x62, 0x33, 0x79, 0x80, 0x3f, 0xa2, 0x5f, 0x98, 0xdc, 0x6e, 0x75, 0xda, 0xad, 0xbd, 0x6a, 0xbc, - 0x5e, 0xf8, 0xf4, 0x8b, 0xcd, 0xac, 0x8c, 0x59, 0xc1, 0xed, 0xee, 0x1e, 0x54, 0xa6, 0x0e, 0x26, - 0xec, 0xdf, 0x11, 0x94, 0xef, 0x9f, 0x1c, 0xed, 0xef, 0xb6, 0x1a, 0xdd, 0xb6, 0xf2, 0xf0, 0xb0, - 0xdb, 0xae, 0xc6, 0xd1, 0x75, 0xb8, 0xb6, 0xbf, 0xfb, 0xff, 0x9d, 0xae, 0xd2, 0xda, 0xdf, 0x6d, - 0x1f, 0x74, 0x95, 0x46, 0xb7, 0xdb, 0x68, 0xed, 0x55, 0x13, 0x3b, 0x7f, 0x03, 0xa8, 0x34, 0x9a, - 0xad, 0x5d, 0x1a, 0x9f, 0x75, 0x4d, 0x65, 0xa5, 0x8d, 0x16, 0xa4, 0x58, 0xf1, 0xe2, 0xd2, 0xc7, - 0x2d, 0xf5, 0xcb, 0xab, 0xb1, 0xe8, 0x01, 0xa4, 0x59, 0x5d, 0x03, 0x5d, 0xfe, 0xda, 0xa5, 0xbe, - 0xa0, 0x3c, 0x4b, 0x17, 0xc3, 0x3e, 0xa7, 0x4b, 0x9f, 0xbf, 0xd4, 0x2f, 0xaf, 0xd6, 0x22, 0x19, - 0xf2, 0x3e, 0xca, 0x58, 0xfc, 0x1c, 0xa4, 0xbe, 0x84, 0x77, 0x44, 0xfb, 0x90, 0x75, 0xa1, 0xec, - 0xa2, 0x07, 0x2a, 0xf5, 0x85, 0xe5, 0x54, 0x6a, 0x2e, 0x5e, 0x72, 0xb8, 0xfc, 0xb5, 0x4d, 0x7d, - 0x41, 0x6d, 0x18, 0xed, 0x42, 0x46, 0x64, 0xce, 0x0b, 0x1e, 0x9d, 0xd4, 0x17, 0x95, 0x47, 0xa9, - 0xd1, 0xfc, 0x62, 0xce, 0xe2, 0x37, 0x44, 0xf5, 0x25, 0xca, 0xde, 0xe8, 0x04, 0x20, 0x50, 0x60, - 0x58, 0xe2, 0x71, 0x50, 0x7d, 0x99, 0x72, 0x36, 0x3a, 0x84, 0x9c, 0x87, 0x9e, 0x16, 0x3e, 0xd5, - 0xa9, 0x2f, 0xae, 0x2b, 0xa3, 0x47, 0x50, 0x0a, 0xa3, 0x86, 0xe5, 0x1e, 0xe0, 0xd4, 0x97, 0x2c, - 0x18, 0x53, 0xfd, 0x61, 0x08, 0xb1, 0xdc, 0x83, 0x9c, 0xfa, 0x92, 0xf5, 0x63, 0xf4, 0x01, 0xac, - 0xcc, 0xa6, 0xf8, 0xcb, 0xbf, 0xcf, 0xa9, 0x5f, 0xa1, 0xa2, 0x8c, 0x46, 0x80, 0xe6, 0x40, 0x83, - 0x2b, 0x3c, 0xd7, 0xa9, 0x5f, 0xa5, 0xc0, 0x8c, 0xfa, 0x50, 0x99, 0xce, 0xb7, 0x97, 0x7d, 0xbe, - 0x53, 0x5f, 0xba, 0xd8, 0xcc, 0x67, 0x09, 0xe7, 0xe9, 0xcb, 0x3e, 0xe7, 0xa9, 0x2f, 0x5d, 0x7b, - 0x6e, 0x36, 0xbe, 0xfc, 0x66, 0x3d, 0xfe, 0xd5, 0x37, 0xeb, 0xf1, 0x3f, 0x7f, 0xb3, 0x1e, 0xff, - 0xec, 0xdb, 0xf5, 0xd8, 0x57, 0xdf, 0xae, 0xc7, 0xfe, 0xf8, 0xed, 0x7a, 0xec, 0x87, 0xcf, 0x9d, - 0xe9, 0x64, 0x30, 0xee, 0x6d, 0x69, 0xe6, 0x68, 0x5b, 0x33, 0x47, 0x98, 0xf4, 0x4e, 0x89, 0xdf, - 0xf0, 0xdf, 0x58, 0xf6, 0x32, 0x2c, 0x3e, 0xbe, 0xfc, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, - 0x12, 0xc9, 0xb6, 0x83, 0x29, 0x00, 0x00, + // 3159 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcb, 0x73, 0x2b, 0xc5, + 0xd5, 0xd7, 0xfb, 0x71, 0xf4, 0x74, 0xdb, 0xf8, 0xea, 0x8a, 0x8b, 0x6d, 0xe6, 0x7e, 0x70, 0x1f, + 0x80, 0xcd, 0x67, 0xbe, 0xcb, 0xa3, 0xf8, 0xf8, 0x3e, 0x2c, 0x5d, 0xdd, 0xc8, 0xd8, 0xd8, 0xce, + 0x58, 0xbe, 0x14, 0x21, 0xb9, 0xc3, 0x68, 0xd4, 0xb6, 0x86, 0x2b, 0xcd, 0x0c, 0x33, 0x2d, 0x23, + 0xb3, 0x0c, 0x95, 0xaa, 0x14, 0x95, 0x4a, 0xb1, 0x64, 0xc3, 0x22, 0xa9, 0xca, 0xff, 0x90, 0x55, + 0x56, 0x59, 0xb0, 0x60, 0xc1, 0x92, 0x15, 0x49, 0xc1, 0x2e, 0xff, 0x40, 0xb6, 0xa9, 0x7e, 0xcc, + 0x4b, 0xd2, 0x58, 0x32, 0xa4, 0x52, 0x95, 0xca, 0x6e, 0xfa, 0xf4, 0x39, 0xa7, 0xbb, 0x4f, 0x77, + 0x9f, 0x73, 0x7e, 0x67, 0x1a, 0x9e, 0x24, 0xd8, 0xe8, 0x61, 0x7b, 0xa8, 0x1b, 0x64, 0x4b, 0xed, + 0x6a, 0xfa, 0x16, 0xb9, 0xb0, 0xb0, 0xb3, 0x69, 0xd9, 0x26, 0x31, 0x51, 0xc5, 0xef, 0xdc, 0xa4, + 0x9d, 0xf5, 0xa7, 0x02, 0xdc, 0x9a, 0x7d, 0x61, 0x11, 0x73, 0xcb, 0xb2, 0x4d, 0xf3, 0x94, 0xf3, + 0xd7, 0x6f, 0x04, 0xba, 0x99, 0x9e, 0xa0, 0xb6, 0x50, 0xaf, 0x10, 0x7e, 0x8c, 0x2f, 0xdc, 0xde, + 0xa7, 0xa6, 0x64, 0x2d, 0xd5, 0x56, 0x87, 0x6e, 0xf7, 0xfa, 0x99, 0x69, 0x9e, 0x0d, 0xf0, 0x16, + 0x6b, 0x75, 0x47, 0xa7, 0x5b, 0x44, 0x1f, 0x62, 0x87, 0xa8, 0x43, 0x4b, 0x30, 0xac, 0x9c, 0x99, + 0x67, 0x26, 0xfb, 0xdc, 0xa2, 0x5f, 0x9c, 0x2a, 0x7d, 0x95, 0x87, 0xac, 0x8c, 0x3f, 0x1c, 0x61, + 0x87, 0xa0, 0x6d, 0x48, 0x61, 0xad, 0x6f, 0xd6, 0xe2, 0x1b, 0xf1, 0xdb, 0x85, 0xed, 0x1b, 0x9b, + 0x13, 0x8b, 0xdb, 0x14, 0x7c, 0x2d, 0xad, 0x6f, 0xb6, 0x63, 0x32, 0xe3, 0x45, 0xf7, 0x20, 0x7d, + 0x3a, 0x18, 0x39, 0xfd, 0x5a, 0x82, 0x09, 0x3d, 0x15, 0x25, 0xf4, 0x80, 0x32, 0xb5, 0x63, 0x32, + 0xe7, 0xa6, 0x43, 0xe9, 0xc6, 0xa9, 0x59, 0x4b, 0x5e, 0x3e, 0xd4, 0xae, 0x71, 0xca, 0x86, 0xa2, + 0xbc, 0xa8, 0x01, 0xa0, 0x1b, 0x3a, 0x51, 0xb4, 0xbe, 0xaa, 0x1b, 0xb5, 0x34, 0x93, 0x7c, 0x3a, + 0x5a, 0x52, 0x27, 0x4d, 0xca, 0xd8, 0x8e, 0xc9, 0x79, 0xdd, 0x6d, 0xd0, 0xe9, 0x7e, 0x38, 0xc2, + 0xf6, 0x45, 0x2d, 0x73, 0xf9, 0x74, 0x7f, 0x4a, 0x99, 0xe8, 0x74, 0x19, 0x37, 0x6a, 0x41, 0xa1, + 0x8b, 0xcf, 0x74, 0x43, 0xe9, 0x0e, 0x4c, 0xed, 0x71, 0x2d, 0xcb, 0x84, 0xa5, 0x28, 0xe1, 0x06, + 0x65, 0x6d, 0x50, 0xce, 0x76, 0x4c, 0x86, 0xae, 0xd7, 0x42, 0xff, 0x0b, 0x39, 0xad, 0x8f, 0xb5, + 0xc7, 0x0a, 0x19, 0xd7, 0x72, 0x4c, 0xc7, 0x7a, 0x94, 0x8e, 0x26, 0xe5, 0xeb, 0x8c, 0xdb, 0x31, + 0x39, 0xab, 0xf1, 0x4f, 0xba, 0xfe, 0x1e, 0x1e, 0xe8, 0xe7, 0xd8, 0xa6, 0xf2, 0xf9, 0xcb, 0xd7, + 0x7f, 0x9f, 0x73, 0x32, 0x0d, 0xf9, 0x9e, 0xdb, 0x40, 0xff, 0x0f, 0x79, 0x6c, 0xf4, 0xc4, 0x32, + 0x80, 0xa9, 0xd8, 0x88, 0xdc, 0x67, 0xa3, 0xe7, 0x2e, 0x22, 0x87, 0xc5, 0x37, 0x7a, 0x15, 0x32, + 0x9a, 0x39, 0x1c, 0xea, 0xa4, 0x56, 0x60, 0xd2, 0x6b, 0x91, 0x0b, 0x60, 0x5c, 0xed, 0x98, 0x2c, + 0xf8, 0xd1, 0x01, 0x94, 0x07, 0xba, 0x43, 0x14, 0xc7, 0x50, 0x2d, 0xa7, 0x6f, 0x12, 0xa7, 0x56, + 0x64, 0x1a, 0x9e, 0x89, 0xd2, 0xb0, 0xaf, 0x3b, 0xe4, 0xd8, 0x65, 0x6e, 0xc7, 0xe4, 0xd2, 0x20, + 0x48, 0xa0, 0xfa, 0xcc, 0xd3, 0x53, 0x6c, 0x7b, 0x0a, 0x6b, 0xa5, 0xcb, 0xf5, 0x1d, 0x52, 0x6e, + 0x57, 0x9e, 0xea, 0x33, 0x83, 0x04, 0xf4, 0x1e, 0x2c, 0x0f, 0x4c, 0xb5, 0xe7, 0xa9, 0x53, 0xb4, + 0xfe, 0xc8, 0x78, 0x5c, 0x2b, 0x33, 0xa5, 0x77, 0x22, 0x27, 0x69, 0xaa, 0x3d, 0x57, 0x45, 0x93, + 0x0a, 0xb4, 0x63, 0xf2, 0xd2, 0x60, 0x92, 0x88, 0x1e, 0xc1, 0x8a, 0x6a, 0x59, 0x83, 0x8b, 0x49, + 0xed, 0x15, 0xa6, 0xfd, 0x6e, 0x94, 0xf6, 0x1d, 0x2a, 0x33, 0xa9, 0x1e, 0xa9, 0x53, 0x54, 0xd4, + 0x81, 0xaa, 0x65, 0x63, 0x4b, 0xb5, 0xb1, 0x62, 0xd9, 0xa6, 0x65, 0x3a, 0xea, 0xa0, 0x56, 0x65, + 0xba, 0x6f, 0x45, 0xe9, 0x3e, 0xe2, 0xfc, 0x47, 0x82, 0xbd, 0x1d, 0x93, 0x2b, 0x56, 0x98, 0xc4, + 0xb5, 0x9a, 0x1a, 0x76, 0x1c, 0x5f, 0xeb, 0xd2, 0x3c, 0xad, 0x8c, 0x3f, 0xac, 0x35, 0x44, 0x42, + 0x7b, 0x50, 0xc2, 0x03, 0x7d, 0xa8, 0x1b, 0x2a, 0xc1, 0x3d, 0x7a, 0x94, 0x11, 0x53, 0xf9, 0x5f, + 0x91, 0xe7, 0xd0, 0x63, 0x66, 0xa7, 0xb9, 0x88, 0x03, 0xed, 0x46, 0x16, 0xd2, 0xe7, 0xea, 0x60, + 0x84, 0xdf, 0x4a, 0xe5, 0x52, 0xd5, 0xb4, 0x74, 0x0b, 0x0a, 0x01, 0x2f, 0x85, 0x6a, 0x90, 0x1d, + 0x62, 0xc7, 0x51, 0xcf, 0x30, 0x73, 0x6a, 0x79, 0xd9, 0x6d, 0x4a, 0x65, 0x28, 0x06, 0x3d, 0x93, + 0xf4, 0x59, 0xdc, 0x93, 0xa4, 0x4e, 0x87, 0x4a, 0x9e, 0x63, 0xdb, 0xd1, 0x4d, 0xc3, 0x95, 0x14, + 0x4d, 0x74, 0x13, 0x4a, 0xec, 0xfa, 0x28, 0x6e, 0x3f, 0xf5, 0x7c, 0x29, 0xb9, 0xc8, 0x88, 0x0f, + 0x05, 0xd3, 0x3a, 0x14, 0xac, 0x6d, 0xcb, 0x63, 0x49, 0x32, 0x16, 0xb0, 0xb6, 0x2d, 0x97, 0xe1, + 0x69, 0x28, 0xd2, 0x35, 0x7a, 0x1c, 0x29, 0x36, 0x48, 0x81, 0xd2, 0x04, 0x8b, 0xf4, 0x55, 0x02, + 0xaa, 0x93, 0xde, 0x0c, 0xbd, 0x0a, 0x29, 0xea, 0xd8, 0x85, 0x8f, 0xae, 0x6f, 0x72, 0xaf, 0xbf, + 0xe9, 0x7a, 0xfd, 0xcd, 0x8e, 0xeb, 0xf5, 0x1b, 0xb9, 0x2f, 0xbf, 0x5d, 0x8f, 0x7d, 0xf6, 0x97, + 0xf5, 0xb8, 0xcc, 0x24, 0xd0, 0x75, 0xea, 0x7c, 0x54, 0xdd, 0x50, 0xf4, 0x1e, 0x9b, 0x72, 0x9e, + 0x7a, 0x16, 0x55, 0x37, 0x76, 0x7b, 0x68, 0x1f, 0xaa, 0x9a, 0x69, 0x38, 0xd8, 0x70, 0x46, 0x8e, + 0xc2, 0xa3, 0x8a, 0xf0, 0xcc, 0x21, 0xff, 0xc2, 0x63, 0x55, 0xd3, 0xe5, 0x3c, 0x62, 0x8c, 0x72, + 0x45, 0x0b, 0x13, 0xd0, 0x03, 0x80, 0x73, 0x75, 0xa0, 0xf7, 0x54, 0x62, 0xda, 0x4e, 0x2d, 0xb5, + 0x91, 0x9c, 0xe9, 0x64, 0x1e, 0xba, 0x2c, 0x27, 0x56, 0x4f, 0x25, 0xb8, 0x91, 0xa2, 0xd3, 0x95, + 0x03, 0x92, 0xe8, 0x59, 0xa8, 0xa8, 0x96, 0xa5, 0x38, 0x44, 0x25, 0x58, 0xe9, 0x5e, 0x10, 0xec, + 0x30, 0xa7, 0x5f, 0x94, 0x4b, 0xaa, 0x65, 0x1d, 0x53, 0x6a, 0x83, 0x12, 0xd1, 0x33, 0x50, 0xa6, + 0x0e, 0x5e, 0x57, 0x07, 0x4a, 0x1f, 0xeb, 0x67, 0x7d, 0xc2, 0x9c, 0x7b, 0x52, 0x2e, 0x09, 0x6a, + 0x9b, 0x11, 0xa5, 0x9e, 0xb7, 0xe3, 0xcc, 0xb9, 0x23, 0x04, 0xa9, 0x9e, 0x4a, 0x54, 0x66, 0xc9, + 0xa2, 0xcc, 0xbe, 0x29, 0xcd, 0x52, 0x49, 0x5f, 0xd8, 0x87, 0x7d, 0xa3, 0x55, 0xc8, 0x08, 0xb5, + 0x49, 0xa6, 0x56, 0xb4, 0xd0, 0x0a, 0xa4, 0x2d, 0xdb, 0x3c, 0xc7, 0x6c, 0xeb, 0x72, 0x32, 0x6f, + 0x48, 0x9f, 0x24, 0x60, 0x69, 0x2a, 0x0c, 0x50, 0xbd, 0x7d, 0xd5, 0xe9, 0xbb, 0x63, 0xd1, 0x6f, + 0xf4, 0x32, 0xd5, 0xab, 0xf6, 0xb0, 0x2d, 0x42, 0x67, 0x6d, 0xda, 0xd4, 0x6d, 0xd6, 0x2f, 0x4c, + 0x23, 0xb8, 0xd1, 0x1e, 0x54, 0x07, 0xaa, 0x43, 0x14, 0xee, 0x56, 0x95, 0x40, 0x18, 0x7d, 0x72, + 0xca, 0xc8, 0xdc, 0x09, 0xd3, 0x03, 0x2d, 0x94, 0x94, 0xa9, 0xa8, 0x4f, 0x45, 0x27, 0xb0, 0xd2, + 0xbd, 0xf8, 0x58, 0x35, 0x88, 0x6e, 0x60, 0x65, 0x6a, 0xd7, 0xa6, 0xe3, 0xf2, 0xdb, 0xba, 0xd3, + 0xc5, 0x7d, 0xf5, 0x5c, 0x37, 0xdd, 0x69, 0x2d, 0x7b, 0xf2, 0xde, 0x8e, 0x3a, 0x92, 0x0c, 0xe5, + 0x70, 0x1c, 0x43, 0x65, 0x48, 0x90, 0xb1, 0x58, 0x7f, 0x82, 0x8c, 0xd1, 0x8b, 0x90, 0xa2, 0x6b, + 0x64, 0x6b, 0x2f, 0xcf, 0x18, 0x48, 0xc8, 0x75, 0x2e, 0x2c, 0x2c, 0x33, 0x4e, 0xe9, 0x16, 0x2c, + 0xcf, 0x70, 0x08, 0xa8, 0x0a, 0x49, 0x32, 0x76, 0x6a, 0xf1, 0x8d, 0xe4, 0xed, 0xa2, 0x4c, 0x3f, + 0x25, 0xc9, 0xbb, 0x36, 0x5e, 0x10, 0x9c, 0x1c, 0x5e, 0xba, 0x03, 0x95, 0x89, 0x28, 0x17, 0xd8, + 0xe7, 0x78, 0x70, 0x9f, 0xa5, 0x0a, 0x94, 0x42, 0x21, 0x4d, 0x5a, 0x85, 0x95, 0x59, 0x11, 0x4a, + 0xea, 0x7b, 0xf4, 0x50, 0xa4, 0x41, 0xf7, 0x20, 0xe7, 0x85, 0x28, 0x7e, 0x6d, 0xaf, 0x4f, 0x2d, + 0xd7, 0x65, 0x96, 0x3d, 0x56, 0x7a, 0x5f, 0xe9, 0xf1, 0x67, 0xe7, 0x26, 0xc1, 0x26, 0x9e, 0x55, + 0x2d, 0xab, 0xad, 0x3a, 0x7d, 0xe9, 0x7d, 0xa8, 0x45, 0x85, 0x9f, 0x89, 0x65, 0xa4, 0xbc, 0xe3, + 0xba, 0x0a, 0x99, 0x53, 0xd3, 0x1e, 0xaa, 0x84, 0x29, 0x2b, 0xc9, 0xa2, 0x45, 0x8f, 0x31, 0x0f, + 0x45, 0x49, 0x46, 0xe6, 0x0d, 0x49, 0x81, 0xeb, 0x91, 0x21, 0x88, 0x8a, 0xe8, 0x46, 0x0f, 0x73, + 0x7b, 0x96, 0x64, 0xde, 0xf0, 0x15, 0xf1, 0xc9, 0xf2, 0x06, 0x1d, 0xd6, 0x61, 0x6b, 0x65, 0xfa, + 0xf3, 0xb2, 0x68, 0x49, 0x9f, 0x27, 0x61, 0x75, 0x76, 0x20, 0x42, 0x1b, 0x50, 0x1c, 0xaa, 0x63, + 0x85, 0x8c, 0xc5, 0xa5, 0xe7, 0xdb, 0x01, 0x43, 0x75, 0xdc, 0x19, 0xf3, 0x1b, 0x2f, 0xf6, 0x3c, + 0xe1, 0xed, 0x39, 0x3a, 0x81, 0xa5, 0x81, 0xa9, 0xa9, 0x03, 0x25, 0x70, 0x35, 0xc4, 0xad, 0xb8, + 0x39, 0x65, 0xec, 0xd6, 0x98, 0x51, 0x7a, 0x53, 0xb7, 0xa3, 0xc2, 0x74, 0xec, 0x7b, 0x57, 0x04, + 0xdd, 0x87, 0xc2, 0xd0, 0x3f, 0xf1, 0x57, 0xb8, 0x15, 0x41, 0xb1, 0xc0, 0x96, 0xa4, 0x43, 0x1e, + 0xc4, 0xf5, 0xe5, 0x99, 0x2b, 0xfb, 0xf2, 0x17, 0x61, 0xc5, 0xc0, 0x63, 0x12, 0xb8, 0xb1, 0xfc, + 0x9c, 0x64, 0x99, 0xe9, 0x11, 0xed, 0xf3, 0x6f, 0x23, 0x3d, 0x32, 0xe8, 0x0e, 0x0b, 0xe5, 0x96, + 0xe9, 0x60, 0x5b, 0x51, 0x7b, 0x3d, 0x1b, 0x3b, 0x0e, 0x4b, 0x41, 0x8b, 0x2c, 0x3e, 0x33, 0xfa, + 0x0e, 0x27, 0x4b, 0xbf, 0x0e, 0x6e, 0x4d, 0x38, 0x74, 0x4f, 0x5d, 0x36, 0x74, 0x0c, 0x2b, 0x42, + 0xbe, 0x17, 0xb2, 0x7d, 0x62, 0x51, 0x8f, 0x84, 0x5c, 0xf1, 0x68, 0xb3, 0x27, 0x7f, 0x98, 0xd9, + 0x5d, 0xa7, 0x9b, 0x0a, 0x38, 0xdd, 0x7f, 0xb3, 0xad, 0xf8, 0x3d, 0x40, 0x4e, 0xc6, 0x8e, 0x45, + 0x23, 0x2c, 0x6a, 0x40, 0x1e, 0x8f, 0x35, 0x6c, 0x11, 0x37, 0x29, 0x99, 0x0d, 0x41, 0x38, 0x77, + 0xcb, 0xe5, 0xa4, 0xf9, 0xbf, 0x27, 0x86, 0x5e, 0x12, 0x10, 0x2f, 0x1a, 0xad, 0x09, 0xf1, 0x20, + 0xc6, 0x7b, 0xd9, 0xc5, 0x78, 0xc9, 0xc8, 0x94, 0x9f, 0x4b, 0x4d, 0x80, 0xbc, 0x97, 0x04, 0xc8, + 0x4b, 0xcd, 0x19, 0x2c, 0x84, 0xf2, 0x9a, 0x21, 0x94, 0x97, 0x99, 0xb3, 0xcc, 0x08, 0x98, 0xf7, + 0xb2, 0x0b, 0xf3, 0xb2, 0x73, 0x66, 0x3c, 0x81, 0xf3, 0x1e, 0x84, 0x71, 0x5e, 0x2e, 0xc2, 0x81, + 0xb8, 0xd2, 0x91, 0x40, 0xef, 0x8d, 0x00, 0xd0, 0xcb, 0x47, 0xa2, 0x2c, 0xae, 0x64, 0x06, 0xd2, + 0x6b, 0x86, 0x90, 0x1e, 0xcc, 0xb1, 0x41, 0x04, 0xd4, 0x7b, 0x33, 0x08, 0xf5, 0x0a, 0x91, 0x68, + 0x51, 0xec, 0xf7, 0x2c, 0xac, 0xf7, 0x9a, 0x87, 0xf5, 0x8a, 0x91, 0x60, 0x55, 0xac, 0x61, 0x12, + 0xec, 0x1d, 0x4e, 0x81, 0x3d, 0x0e, 0xce, 0x9e, 0x8d, 0x54, 0x31, 0x07, 0xed, 0x1d, 0x4e, 0xa1, + 0xbd, 0xf2, 0x1c, 0x85, 0x73, 0xe0, 0xde, 0xcf, 0x67, 0xc3, 0xbd, 0x68, 0x40, 0x26, 0xa6, 0xb9, + 0x18, 0xde, 0x53, 0x22, 0xf0, 0x1e, 0xc7, 0x64, 0xcf, 0x45, 0xaa, 0x5f, 0x18, 0xf0, 0x9d, 0xcc, + 0x00, 0x7c, 0x1c, 0x9a, 0xdd, 0x8e, 0x54, 0xbe, 0x00, 0xe2, 0x3b, 0x99, 0x81, 0xf8, 0xd0, 0x5c, + 0xb5, 0x73, 0x21, 0xdf, 0xfe, 0x24, 0xe4, 0x5b, 0x8e, 0x84, 0xea, 0xe2, 0x3c, 0x2e, 0x88, 0xf9, + 0xd2, 0xd5, 0x8c, 0x74, 0x87, 0x66, 0xdc, 0x13, 0x5e, 0x8f, 0x66, 0x23, 0xd8, 0xb6, 0x4d, 0x5b, + 0xa0, 0x37, 0xde, 0x90, 0x6e, 0x53, 0x0c, 0xe0, 0x7b, 0xb8, 0x4b, 0xf0, 0x21, 0xcb, 0xfa, 0x02, + 0x5e, 0x4d, 0xfa, 0x63, 0xdc, 0x97, 0x65, 0xa9, 0x73, 0x10, 0x3f, 0xe4, 0x05, 0x7e, 0x08, 0xa0, + 0xc6, 0x44, 0x18, 0x35, 0xae, 0x43, 0x81, 0x66, 0x73, 0x13, 0x80, 0x50, 0xb5, 0x3c, 0x40, 0x78, + 0x17, 0x96, 0x58, 0xfc, 0xe4, 0xd8, 0x52, 0x04, 0xa9, 0x14, 0x0b, 0x52, 0x15, 0xda, 0xc1, 0xaf, + 0x27, 0x8f, 0x56, 0x2f, 0xc0, 0x72, 0x80, 0xd7, 0xcb, 0x12, 0x39, 0x3a, 0xaa, 0x7a, 0xdc, 0x3b, + 0x22, 0x5d, 0xfc, 0x73, 0xdc, 0xb7, 0x90, 0x8f, 0x24, 0x67, 0x81, 0xbe, 0xf8, 0x3f, 0x09, 0xf4, + 0x25, 0x7e, 0x30, 0xe8, 0x0b, 0x66, 0xbd, 0xc9, 0x70, 0xd6, 0xfb, 0xf7, 0xb8, 0xbf, 0x27, 0x1e, + 0x84, 0xd3, 0xcc, 0x1e, 0x16, 0x79, 0x28, 0xfb, 0xa6, 0x29, 0xca, 0xc0, 0x3c, 0x13, 0xd9, 0x26, + 0xfd, 0xa4, 0x5c, 0x5e, 0x18, 0xca, 0x8b, 0x28, 0xe3, 0xa5, 0xb0, 0x3c, 0x0d, 0x10, 0x29, 0x6c, + 0x15, 0x92, 0x8f, 0x31, 0xaf, 0x0d, 0x16, 0x65, 0xfa, 0x49, 0xf9, 0xd8, 0x51, 0x13, 0xe1, 0x9c, + 0x37, 0xd0, 0xab, 0x90, 0x67, 0x55, 0x5d, 0xc5, 0xb4, 0x1c, 0x11, 0x24, 0x42, 0x99, 0x0e, 0x2f, + 0xde, 0x6e, 0x1e, 0x51, 0x9e, 0x43, 0xcb, 0x91, 0x73, 0x96, 0xf8, 0x0a, 0xe4, 0x1f, 0xf9, 0x50, + 0xfe, 0x71, 0x03, 0xf2, 0x74, 0xf6, 0x8e, 0xa5, 0x6a, 0x98, 0x39, 0xfc, 0xbc, 0xec, 0x13, 0xa4, + 0x47, 0x80, 0xa6, 0x43, 0x0e, 0x6a, 0x43, 0x06, 0x9f, 0x63, 0x83, 0xf0, 0x7c, 0xac, 0xb0, 0xbd, + 0x3a, 0x9d, 0xe8, 0xd2, 0xee, 0x46, 0x8d, 0x1a, 0xf9, 0x6f, 0xdf, 0xae, 0x57, 0x39, 0xf7, 0xf3, + 0xe6, 0x50, 0x27, 0x78, 0x68, 0x91, 0x0b, 0x59, 0xc8, 0x4b, 0xbf, 0x4d, 0x51, 0x38, 0x14, 0x0a, + 0x47, 0x33, 0x6d, 0xeb, 0x1e, 0xf9, 0x44, 0x00, 0x32, 0x2f, 0x66, 0xef, 0x35, 0x80, 0x33, 0xd5, + 0x51, 0x3e, 0x52, 0x0d, 0x82, 0x7b, 0xc2, 0xe8, 0x01, 0x0a, 0xaa, 0x43, 0x8e, 0xb6, 0x46, 0x0e, + 0xee, 0x09, 0xf4, 0xee, 0xb5, 0x03, 0xeb, 0xcc, 0xfe, 0xb8, 0x75, 0x86, 0xad, 0x9c, 0x9b, 0xb0, + 0x72, 0x00, 0xaa, 0xe4, 0x83, 0x50, 0x85, 0xce, 0xcd, 0xb2, 0x75, 0xd3, 0xd6, 0xc9, 0x05, 0xdb, + 0x9a, 0xa4, 0xec, 0xb5, 0xd1, 0x4d, 0x28, 0x0d, 0xf1, 0xd0, 0x32, 0xcd, 0x81, 0xc2, 0xdd, 0x4d, + 0x81, 0x89, 0x16, 0x05, 0xb1, 0x45, 0x69, 0xe8, 0x19, 0x28, 0x3b, 0xfa, 0x99, 0x11, 0x48, 0xf7, + 0x56, 0x18, 0x57, 0x89, 0x53, 0x45, 0xb2, 0x47, 0xcf, 0x9a, 0x61, 0x1a, 0x1a, 0xae, 0x3d, 0xc1, + 0x9c, 0x03, 0x6f, 0xa0, 0x27, 0x21, 0x4f, 0x2d, 0x41, 0xfd, 0x1f, 0xa9, 0xad, 0xb2, 0x1e, 0x6a, + 0x9a, 0x7d, 0xda, 0x76, 0x3b, 0x2d, 0x5b, 0xd7, 0x70, 0xed, 0x9a, 0xd7, 0x79, 0x44, 0xdb, 0x74, + 0x1f, 0x18, 0xc4, 0xae, 0x6d, 0xc4, 0x6f, 0xa7, 0x39, 0x88, 0xa6, 0x53, 0xb1, 0xb1, 0x35, 0x50, + 0x35, 0xac, 0x76, 0x07, 0x98, 0x7a, 0xe2, 0xeb, 0xbc, 0xa4, 0x12, 0xa0, 0x76, 0xc6, 0xd2, 0xaf, + 0x12, 0xbe, 0xc7, 0xf0, 0x41, 0xf4, 0x7f, 0xdc, 0x91, 0x90, 0x7e, 0xc3, 0x4a, 0x70, 0xe1, 0x14, + 0x09, 0x1d, 0xc3, 0x92, 0xe7, 0xb0, 0x94, 0x11, 0x73, 0x64, 0xee, 0x15, 0x5c, 0xd4, 0xe3, 0x55, + 0xcf, 0xc3, 0x64, 0x07, 0xbd, 0x0b, 0xd7, 0x26, 0xbc, 0xb1, 0xa7, 0x3a, 0xb1, 0xa8, 0x53, 0x7e, + 0x22, 0xec, 0x94, 0x5d, 0xd5, 0xbe, 0xb1, 0x92, 0x3f, 0xd2, 0x4f, 0xec, 0x42, 0x39, 0x9c, 0xf1, + 0xcd, 0xdc, 0xfe, 0x9b, 0x50, 0xb2, 0x31, 0x51, 0x75, 0x43, 0x09, 0xd5, 0xcd, 0x8a, 0x9c, 0x28, + 0xaa, 0x71, 0x47, 0xf0, 0xc4, 0xcc, 0xcc, 0x0f, 0xbd, 0x02, 0x79, 0x3f, 0x69, 0xe4, 0x56, 0xbd, + 0xa4, 0x5c, 0xe2, 0xf3, 0x4a, 0x7f, 0x8a, 0xfb, 0x2a, 0xc3, 0x05, 0x98, 0x16, 0x64, 0x6c, 0xec, + 0x8c, 0x06, 0xbc, 0x24, 0x52, 0xde, 0x7e, 0x61, 0xb1, 0x9c, 0x91, 0x52, 0x47, 0x03, 0x22, 0x0b, + 0x61, 0xe9, 0x11, 0x64, 0x38, 0x05, 0x15, 0x20, 0x7b, 0x72, 0xb0, 0x77, 0x70, 0xf8, 0xce, 0x41, + 0x35, 0x86, 0x00, 0x32, 0x3b, 0xcd, 0x66, 0xeb, 0xa8, 0x53, 0x8d, 0xa3, 0x3c, 0xa4, 0x77, 0x1a, + 0x87, 0x72, 0xa7, 0x9a, 0xa0, 0x64, 0xb9, 0xf5, 0x56, 0xab, 0xd9, 0xa9, 0x26, 0xd1, 0x12, 0x94, + 0xf8, 0xb7, 0xf2, 0xe0, 0x50, 0x7e, 0x7b, 0xa7, 0x53, 0x4d, 0x05, 0x48, 0xc7, 0xad, 0x83, 0xfb, + 0x2d, 0xb9, 0x9a, 0x96, 0xfe, 0x1b, 0xae, 0x47, 0x66, 0x99, 0x7e, 0x75, 0x25, 0x1e, 0xa8, 0xae, + 0x48, 0x9f, 0x27, 0xa0, 0x1e, 0x9d, 0x3a, 0xa2, 0xb7, 0x26, 0x16, 0xbe, 0x7d, 0x85, 0xbc, 0x73, + 0x62, 0xf5, 0xdc, 0x73, 0x9c, 0x62, 0xa2, 0xf5, 0x79, 0x2a, 0xcb, 0x83, 0x7c, 0x89, 0x7a, 0x0e, + 0x46, 0x65, 0x42, 0x0e, 0x67, 0xfb, 0x00, 0x6b, 0x44, 0xe1, 0xde, 0x93, 0x1f, 0xba, 0x3c, 0x65, + 0xa3, 0xd4, 0x63, 0x4e, 0x94, 0xde, 0xbf, 0x92, 0x2d, 0xf3, 0x90, 0x96, 0x5b, 0x1d, 0xf9, 0xdd, + 0x6a, 0x12, 0x21, 0x28, 0xb3, 0x4f, 0xe5, 0xf8, 0x60, 0xe7, 0xe8, 0xb8, 0x7d, 0x48, 0x6d, 0xb9, + 0x0c, 0x15, 0xd7, 0x96, 0x2e, 0x31, 0x2d, 0x3d, 0x07, 0xd7, 0x22, 0xf2, 0xde, 0x19, 0x25, 0xc3, + 0xdf, 0xc5, 0x83, 0xdc, 0xe1, 0xdc, 0xf5, 0x10, 0x32, 0x0e, 0x51, 0xc9, 0xc8, 0x11, 0x46, 0x7c, + 0x65, 0xd1, 0x44, 0x78, 0xd3, 0xfd, 0x38, 0x66, 0xe2, 0xb2, 0x50, 0x23, 0xdd, 0x83, 0x72, 0xb8, + 0x27, 0xda, 0x06, 0xfe, 0x21, 0x4a, 0xf0, 0xb2, 0xe3, 0x74, 0x76, 0x2c, 0xbd, 0x0b, 0x10, 0x28, + 0xe8, 0xae, 0x40, 0xda, 0x36, 0x47, 0x46, 0x8f, 0x4d, 0x36, 0x2d, 0xf3, 0x06, 0xba, 0x07, 0xe9, + 0x73, 0x93, 0xfb, 0x92, 0xd9, 0x17, 0xea, 0xa1, 0x49, 0x70, 0xa0, 0x28, 0xc3, 0xb9, 0x25, 0x1d, + 0xd0, 0x74, 0xad, 0x2c, 0x62, 0x88, 0x37, 0xc2, 0x43, 0x3c, 0x1d, 0x59, 0x75, 0x9b, 0x3d, 0xd4, + 0xc7, 0x90, 0x66, 0x5e, 0xc8, 0x8b, 0x5a, 0x22, 0xad, 0x66, 0x51, 0xeb, 0x17, 0x00, 0x2a, 0x21, + 0xb6, 0xde, 0x1d, 0xf9, 0x03, 0xac, 0xcf, 0xf6, 0x62, 0x3b, 0x2e, 0x5f, 0xe3, 0x86, 0x70, 0x67, + 0x2b, 0xbe, 0x68, 0xc0, 0xa5, 0x05, 0x14, 0x4a, 0x07, 0x50, 0x0e, 0xcb, 0xba, 0x89, 0x20, 0x9f, + 0x43, 0x38, 0x11, 0xe4, 0x79, 0xbd, 0x48, 0x04, 0xbd, 0x34, 0x32, 0xc9, 0xff, 0x01, 0xb0, 0x86, + 0xf4, 0x69, 0x1c, 0x72, 0x9d, 0xb1, 0x38, 0xdf, 0x11, 0x65, 0x65, 0x5f, 0x34, 0x11, 0x2c, 0xa2, + 0xf2, 0x3a, 0x75, 0xd2, 0x2b, 0x93, 0xbf, 0xe9, 0xdd, 0xe0, 0xd4, 0xa2, 0x55, 0x00, 0xf7, 0x77, + 0x81, 0xf0, 0x5a, 0xaf, 0x43, 0xde, 0x8b, 0x41, 0x14, 0x9f, 0xb8, 0x29, 0x48, 0x5c, 0x24, 0xd7, + 0x7e, 0xf2, 0x61, 0x99, 0x1f, 0x89, 0x32, 0x6d, 0x52, 0xe6, 0x0d, 0xa9, 0x07, 0x95, 0x89, 0x00, + 0x86, 0x5e, 0x87, 0xac, 0x35, 0xea, 0x2a, 0xae, 0x79, 0x26, 0xea, 0x72, 0x6e, 0xe6, 0x3b, 0xea, + 0x0e, 0x74, 0x6d, 0x0f, 0x5f, 0xb8, 0x93, 0xb1, 0x46, 0xdd, 0x3d, 0x6e, 0x45, 0x3e, 0x4a, 0x22, + 0x38, 0xca, 0x39, 0xe4, 0xdc, 0x43, 0x81, 0xfe, 0x0f, 0xf2, 0x5e, 0x6c, 0xf4, 0x7e, 0x72, 0x45, + 0x06, 0x55, 0xa1, 0xde, 0x17, 0xa1, 0x30, 0x8a, 0x65, 0x55, 0xa2, 0x1a, 0xc9, 0xab, 0x1f, 0x09, + 0xb6, 0x3b, 0x15, 0xde, 0xb1, 0xef, 0xc2, 0x23, 0xe9, 0x0f, 0x71, 0xa8, 0x4e, 0x9e, 0xca, 0x7f, + 0xe5, 0x04, 0xa8, 0xb3, 0xa4, 0xa7, 0x5f, 0xc1, 0x74, 0x12, 0x1e, 0x2e, 0x2c, 0xca, 0x25, 0x4a, + 0x6d, 0xb9, 0x44, 0xe9, 0x93, 0x04, 0x14, 0x02, 0xb5, 0x4e, 0xf4, 0x3f, 0x81, 0x2b, 0x52, 0x9e, + 0x91, 0x73, 0x04, 0x78, 0xfd, 0xff, 0x27, 0xe1, 0x85, 0x25, 0xae, 0xbe, 0xb0, 0xa8, 0xff, 0x60, + 0x6e, 0xe9, 0x34, 0x75, 0xe5, 0xd2, 0xe9, 0xf3, 0x80, 0x88, 0x49, 0xd4, 0x81, 0x72, 0x6e, 0x12, + 0xdd, 0x38, 0x53, 0xf8, 0xd1, 0xe0, 0x99, 0x60, 0x95, 0xf5, 0x3c, 0x64, 0x1d, 0x47, 0xec, 0x94, + 0xfc, 0x32, 0x0e, 0x39, 0x2f, 0xa4, 0x5f, 0xf5, 0x2f, 0xc7, 0x2a, 0x64, 0x44, 0xd4, 0xe2, 0xbf, + 0x39, 0x44, 0x6b, 0x66, 0x8d, 0xb8, 0x0e, 0xb9, 0x21, 0x26, 0x2a, 0xcb, 0x6b, 0x38, 0xa4, 0xf6, + 0xda, 0x77, 0x5f, 0x83, 0x42, 0xe0, 0xcf, 0x14, 0xf5, 0x13, 0x07, 0xad, 0x77, 0xaa, 0xb1, 0x7a, + 0xf6, 0xd3, 0x2f, 0x36, 0x92, 0x07, 0xf8, 0x23, 0x7a, 0xc3, 0xe4, 0x56, 0xb3, 0xdd, 0x6a, 0xee, + 0x55, 0xe3, 0xf5, 0xc2, 0xa7, 0x5f, 0x6c, 0x64, 0x65, 0xcc, 0xca, 0x7a, 0x77, 0xf7, 0xa0, 0x32, + 0xb1, 0x31, 0x61, 0xbf, 0x8f, 0xa0, 0x7c, 0xff, 0xe4, 0x68, 0x7f, 0xb7, 0xb9, 0xd3, 0x69, 0x29, + 0x0f, 0x0f, 0x3b, 0xad, 0x6a, 0x1c, 0x5d, 0x83, 0xe5, 0xfd, 0xdd, 0x9f, 0xb4, 0x3b, 0x4a, 0x73, + 0x7f, 0xb7, 0x75, 0xd0, 0x51, 0x76, 0x3a, 0x9d, 0x9d, 0xe6, 0x5e, 0x35, 0xb1, 0xfd, 0x4d, 0x01, + 0x2a, 0x3b, 0x8d, 0xe6, 0x2e, 0x8d, 0xdb, 0xba, 0xa6, 0xb2, 0x92, 0x47, 0x13, 0x52, 0xac, 0xa8, + 0x71, 0xe9, 0xc3, 0x9d, 0xfa, 0xe5, 0x35, 0x5f, 0xf4, 0x00, 0xd2, 0xac, 0xde, 0x81, 0x2e, 0x7f, + 0xc9, 0x53, 0x9f, 0x53, 0x04, 0xa6, 0x93, 0x61, 0xd7, 0xe9, 0xd2, 0xa7, 0x3d, 0xf5, 0xcb, 0x6b, + 0xc2, 0x48, 0x86, 0xbc, 0x8f, 0x3e, 0xe6, 0x3f, 0x75, 0xa9, 0x2f, 0xe0, 0x1d, 0xd1, 0x3e, 0x64, + 0x5d, 0x88, 0x3b, 0xef, 0xf1, 0x4d, 0x7d, 0x6e, 0xd1, 0x96, 0x9a, 0x8b, 0x97, 0x22, 0x2e, 0x7f, + 0x49, 0x54, 0x9f, 0x53, 0x81, 0x46, 0xbb, 0x90, 0x11, 0x19, 0xf5, 0x9c, 0x07, 0x35, 0xf5, 0x79, + 0x45, 0x58, 0x6a, 0x34, 0xbf, 0xc8, 0x33, 0xff, 0x7d, 0x54, 0x7d, 0x81, 0xe2, 0x3a, 0x3a, 0x01, + 0x08, 0x14, 0x1e, 0x16, 0x78, 0xf8, 0x54, 0x5f, 0xa4, 0x68, 0x8e, 0x0e, 0x21, 0xe7, 0xa1, 0xaa, + 0xb9, 0xcf, 0x90, 0xea, 0xf3, 0xab, 0xd7, 0xe8, 0x11, 0x94, 0xc2, 0x68, 0x62, 0xb1, 0xc7, 0x45, + 0xf5, 0x05, 0xcb, 0xd2, 0x54, 0x7f, 0x18, 0x5a, 0x2c, 0xf6, 0xd8, 0xa8, 0xbe, 0x60, 0x95, 0x1a, + 0x7d, 0x00, 0x4b, 0xd3, 0xa9, 0xff, 0xe2, 0x6f, 0x8f, 0xea, 0x57, 0xa8, 0x5b, 0xa3, 0x21, 0xa0, + 0x19, 0x90, 0xe1, 0x0a, 0x4f, 0x91, 0xea, 0x57, 0x29, 0x63, 0xa3, 0x1e, 0x54, 0x26, 0xf3, 0xf0, + 0x45, 0x9f, 0x26, 0xd5, 0x17, 0x2e, 0x69, 0xf3, 0x51, 0xc2, 0xf9, 0xfb, 0xa2, 0x4f, 0x95, 0xea, + 0x0b, 0x57, 0xb8, 0xd1, 0x7b, 0x50, 0x0c, 0xbd, 0x41, 0x58, 0xe8, 0xe9, 0x52, 0x7d, 0xb1, 0x6a, + 0x77, 0x63, 0xe7, 0xcb, 0xef, 0xd6, 0xe2, 0x5f, 0x7f, 0xb7, 0x16, 0xff, 0xeb, 0x77, 0x6b, 0xf1, + 0xcf, 0xbe, 0x5f, 0x8b, 0x7d, 0xfd, 0xfd, 0x5a, 0xec, 0x9b, 0xef, 0xd7, 0x62, 0x3f, 0xbb, 0x75, + 0xa6, 0x93, 0xfe, 0xa8, 0xbb, 0xa9, 0x99, 0xc3, 0x2d, 0xcd, 0x1c, 0x62, 0xd2, 0x3d, 0x25, 0xfe, + 0x87, 0xff, 0x38, 0xb5, 0x9b, 0x61, 0xc1, 0xf7, 0xa5, 0x7f, 0x04, 0x00, 0x00, 0xff, 0xff, 0xf1, + 0x62, 0xb9, 0x02, 0xbc, 0x2a, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3736,6 +3848,7 @@ type ABCIApplicationClient interface { ApplySnapshotChunk(ctx context.Context, in *RequestApplySnapshotChunk, opts ...grpc.CallOption) (*ResponseApplySnapshotChunk, error) PrepareProposal(ctx context.Context, in *RequestPrepareProposal, opts ...grpc.CallOption) (*ResponsePrepareProposal, error) ProcessProposal(ctx context.Context, in *RequestProcessProposal, opts ...grpc.CallOption) (*ResponseProcessProposal, error) + EliminatedTx(ctx context.Context, in *RequestEliminatedTx, opts ...grpc.CallOption) (*ResponseEliminatedTx, error) } type aBCIApplicationClient struct { @@ -3890,6 +4003,15 @@ func (c *aBCIApplicationClient) ProcessProposal(ctx context.Context, in *Request return out, nil } +func (c *aBCIApplicationClient) EliminatedTx(ctx context.Context, in *RequestEliminatedTx, opts ...grpc.CallOption) (*ResponseEliminatedTx, error) { + out := new(ResponseEliminatedTx) + err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/EliminatedTx", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // ABCIApplicationServer is the server API for ABCIApplication service. type ABCIApplicationServer interface { Echo(context.Context, *RequestEcho) (*ResponseEcho, error) @@ -3908,6 +4030,7 @@ type ABCIApplicationServer interface { ApplySnapshotChunk(context.Context, *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) PrepareProposal(context.Context, *RequestPrepareProposal) (*ResponsePrepareProposal, error) ProcessProposal(context.Context, *RequestProcessProposal) (*ResponseProcessProposal, error) + EliminatedTx(context.Context, *RequestEliminatedTx) (*ResponseEliminatedTx, error) } // UnimplementedABCIApplicationServer can be embedded to have forward compatible implementations. @@ -3962,6 +4085,9 @@ func (*UnimplementedABCIApplicationServer) PrepareProposal(ctx context.Context, func (*UnimplementedABCIApplicationServer) ProcessProposal(ctx context.Context, req *RequestProcessProposal) (*ResponseProcessProposal, error) { return nil, status.Errorf(codes.Unimplemented, "method ProcessProposal not implemented") } +func (*UnimplementedABCIApplicationServer) EliminatedTx(ctx context.Context, req *RequestEliminatedTx) (*ResponseEliminatedTx, error) { + return nil, status.Errorf(codes.Unimplemented, "method EliminatedTx not implemented") +} func RegisterABCIApplicationServer(s grpc1.Server, srv ABCIApplicationServer) { s.RegisterService(&_ABCIApplication_serviceDesc, srv) @@ -4255,6 +4381,25 @@ func _ABCIApplication_ProcessProposal_Handler(srv interface{}, ctx context.Conte return interceptor(ctx, in, info, handler) } +func _ABCIApplication_EliminatedTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RequestEliminatedTx) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ABCIApplicationServer).EliminatedTx(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/tendermint.abci.ABCIApplication/EliminatedTx", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ABCIApplicationServer).EliminatedTx(ctx, req.(*RequestEliminatedTx)) + } + return interceptor(ctx, in, info, handler) +} + +var ABCIApplication_serviceDesc = _ABCIApplication_serviceDesc var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ ServiceName: "tendermint.abci.ABCIApplication", HandlerType: (*ABCIApplicationServer)(nil), @@ -4323,6 +4468,10 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ MethodName: "ProcessProposal", Handler: _ABCIApplication_ProcessProposal_Handler, }, + { + MethodName: "EliminatedTx", + Handler: _ABCIApplication_EliminatedTx_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "tendermint/abci/types.proto", @@ -4700,6 +4849,29 @@ func (m *Request_ProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } +func (m *Request_EliminatedTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Request_EliminatedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EliminatedTx != nil { + { + size, err := m.EliminatedTx.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} func (m *RequestEcho) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4865,12 +5037,12 @@ func (m *RequestInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - n18, err18 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) - if err18 != nil { - return 0, err18 + n19, err19 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) + if err19 != nil { + return 0, err19 } - i -= n18 - i = encodeVarintTypes(dAtA, i, uint64(n18)) + i -= n19 + i = encodeVarintTypes(dAtA, i, uint64(n19)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil @@ -5027,6 +5199,38 @@ func (m *RequestCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *RequestEliminatedTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RequestEliminatedTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RequestEliminatedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Txs) > 0 { + for iNdEx := len(m.Txs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Txs[iNdEx]) + copy(dAtA[i:], m.Txs[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Txs[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *RequestDeliverTx) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5287,12 +5491,12 @@ func (m *RequestPrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x3a } - n22, err22 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) - if err22 != nil { - return 0, err22 + n23, err23 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) + if err23 != nil { + return 0, err23 } - i -= n22 - i = encodeVarintTypes(dAtA, i, uint64(n22)) + i -= n23 + i = encodeVarintTypes(dAtA, i, uint64(n23)) i-- dAtA[i] = 0x32 if m.Height != 0 { @@ -5375,12 +5579,12 @@ func (m *RequestProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x3a } - n24, err24 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) - if err24 != nil { - return 0, err24 + n25, err25 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) + if err25 != nil { + return 0, err25 } - i -= n24 - i = encodeVarintTypes(dAtA, i, uint64(n24)) + i -= n25 + i = encodeVarintTypes(dAtA, i, uint64(n25)) i-- dAtA[i] = 0x32 if m.Height != 0 { @@ -5826,6 +6030,29 @@ func (m *Response_ProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } +func (m *Response_EliminatedTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Response_EliminatedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EliminatedTx != nil { + { + size, err := m.EliminatedTx.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} func (m *ResponseException) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -6589,20 +6816,20 @@ func (m *ResponseApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, err } } if len(m.RefetchChunks) > 0 { - dAtA47 := make([]byte, len(m.RefetchChunks)*10) - var j46 int + dAtA49 := make([]byte, len(m.RefetchChunks)*10) + var j48 int for _, num := range m.RefetchChunks { for num >= 1<<7 { - dAtA47[j46] = uint8(uint64(num)&0x7f | 0x80) + dAtA49[j48] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j46++ + j48++ } - dAtA47[j46] = uint8(num) - j46++ + dAtA49[j48] = uint8(num) + j48++ } - i -= j46 - copy(dAtA[i:], dAtA47[:j46]) - i = encodeVarintTypes(dAtA, i, uint64(j46)) + i -= j48 + copy(dAtA[i:], dAtA49[:j48]) + i = encodeVarintTypes(dAtA, i, uint64(j48)) i-- dAtA[i] = 0x12 } @@ -6674,6 +6901,29 @@ func (m *ResponseProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *ResponseEliminatedTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResponseEliminatedTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResponseEliminatedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func (m *CommitInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7090,12 +7340,12 @@ func (m *Misbehavior) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x28 } - n52, err52 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) - if err52 != nil { - return 0, err52 + n54, err54 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) + if err54 != nil { + return 0, err54 } - i -= n52 - i = encodeVarintTypes(dAtA, i, uint64(n52)) + i -= n54 + i = encodeVarintTypes(dAtA, i, uint64(n54)) i-- dAtA[i] = 0x22 if m.Height != 0 { @@ -7388,6 +7638,18 @@ func (m *Request_ProcessProposal) Size() (n int) { } return n } +func (m *Request_EliminatedTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EliminatedTx != nil { + l = m.EliminatedTx.Size() + n += 2 + l + sovTypes(uint64(l)) + } + return n +} func (m *RequestEcho) Size() (n int) { if m == nil { return 0 @@ -7527,6 +7789,21 @@ func (m *RequestCheckTx) Size() (n int) { return n } +func (m *RequestEliminatedTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Txs) > 0 { + for _, b := range m.Txs { + l = len(b) + n += 1 + l + sovTypes(uint64(l)) + } + } + return n +} + func (m *RequestDeliverTx) Size() (n int) { if m == nil { return 0 @@ -7920,6 +8197,18 @@ func (m *Response_ProcessProposal) Size() (n int) { } return n } +func (m *Response_EliminatedTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EliminatedTx != nil { + l = m.EliminatedTx.Size() + n += 2 + l + sovTypes(uint64(l)) + } + return n +} func (m *ResponseException) Size() (n int) { if m == nil { return 0 @@ -8306,6 +8595,15 @@ func (m *ResponseProcessProposal) Size() (n int) { return n } +func (m *ResponseEliminatedTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func (m *CommitInfo) Size() (n int) { if m == nil { return 0 @@ -9107,6 +9405,41 @@ func (m *Request) Unmarshal(dAtA []byte) error { } m.Value = &Request_ProcessProposal{v} iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EliminatedTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &RequestEliminatedTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Request_EliminatedTx{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -10092,6 +10425,88 @@ func (m *RequestCheckTx) Unmarshal(dAtA []byte) error { } return nil } +func (m *RequestEliminatedTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestEliminatedTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestEliminatedTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Txs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Txs = append(m.Txs, make([]byte, postIndex-iNdEx)) + copy(m.Txs[len(m.Txs)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *RequestDeliverTx) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -11922,6 +12337,41 @@ func (m *Response) Unmarshal(dAtA []byte) error { } m.Value = &Response_ProcessProposal{v} iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EliminatedTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ResponseEliminatedTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &Response_EliminatedTx{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -14477,6 +14927,56 @@ func (m *ResponseProcessProposal) Unmarshal(dAtA []byte) error { } return nil } +func (m *ResponseEliminatedTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseEliminatedTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseEliminatedTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *CommitInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/mempool/v0/clist_mempool.go b/mempool/v0/clist_mempool.go index c9378c177..e4d2dedad 100644 --- a/mempool/v0/clist_mempool.go +++ b/mempool/v0/clist_mempool.go @@ -832,6 +832,9 @@ func (mem *CListMempool) recheckTxs() { func (mem *CListMempool) cleanUpMarkedRemovedTxs() { mem.removed.lock.Lock() defer mem.removed.lock.Unlock() + + eliminatedTxs := make([][]byte, 0, len(mem.removed.data)) + for i := range mem.removed.data { memTx := mem.removed.data[i] @@ -842,6 +845,8 @@ func (mem *CListMempool) cleanUpMarkedRemovedTxs() { mem.txsMap.Delete(memTx.tx.Key()) atomic.AddInt64(&mem.txsBytes, int64(-len(memTx.tx))) } + + eliminatedTxs = append(eliminatedTxs, memTx.tx) } for i := range mem.removed.data { @@ -849,6 +854,10 @@ func (mem *CListMempool) cleanUpMarkedRemovedTxs() { } mem.removed.data = nil + + _, _ = mem.proxyAppConn.EliminatedTx(&abci.RequestEliminatedTx{ + Txs: eliminatedTxs, + }) } func (mem *CListMempool) markRemovableTxs() { diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto index b376143a6..cb306d7cb 100644 --- a/proto/tendermint/abci/types.proto +++ b/proto/tendermint/abci/types.proto @@ -37,6 +37,7 @@ message Request { RequestApplySnapshotChunk apply_snapshot_chunk = 15; RequestPrepareProposal prepare_proposal = 16; RequestProcessProposal process_proposal = 17; + RequestEliminatedTx eliminated_tx = 18; } reserved 4; } @@ -88,6 +89,10 @@ message RequestCheckTx { CheckTxType type = 2; } +message RequestEliminatedTx { + repeated bytes txs = 1; +} + message RequestDeliverTx { bytes tx = 1; } @@ -171,6 +176,7 @@ message Response { ResponseApplySnapshotChunk apply_snapshot_chunk = 16; ResponsePrepareProposal prepare_proposal = 17; ResponseProcessProposal process_proposal = 18; + ResponseEliminatedTx eliminated_tx = 19; } reserved 5; } @@ -324,6 +330,8 @@ message ResponseProcessProposal { } } +message ResponseEliminatedTx {} + //---------------------------------------- // Misc. @@ -450,4 +458,5 @@ service ABCIApplication { returns (ResponseApplySnapshotChunk); rpc PrepareProposal(RequestPrepareProposal) returns (ResponsePrepareProposal); rpc ProcessProposal(RequestProcessProposal) returns (ResponseProcessProposal); + rpc EliminatedTx(RequestEliminatedTx) returns (ResponseEliminatedTx); } diff --git a/proxy/app_conn.go b/proxy/app_conn.go index 0afea91bf..e92a2d629 100644 --- a/proxy/app_conn.go +++ b/proxy/app_conn.go @@ -36,6 +36,8 @@ type AppConnMempool interface { FlushAsync() *abcicli.ReqRes FlushSync() error + + EliminatedTx(*types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) } type AppConnQuery interface { @@ -159,6 +161,11 @@ func (app *appConnMempool) CheckTxSync(req types.RequestCheckTx) (*types.Respons return app.appConn.CheckTxSync(req) } +func (app *appConnMempool) EliminatedTx(req *types.RequestEliminatedTx) (*types.ResponseEliminatedTx, error) { + defer addTimeSample(app.metrics.MethodTimingSeconds.With("method", "eliminated_tx", "type", "sync"))() + return app.appConn.EliminatedTx(req) +} + //------------------------------------------------ // Implements AppConnQuery (subset of abcicli.Client) diff --git a/rpc/grpc/types.pb.go b/rpc/grpc/types.pb.go index d52c53869..22f5d22f9 100644 --- a/rpc/grpc/types.pb.go +++ b/rpc/grpc/types.pb.go @@ -329,6 +329,7 @@ func _BroadcastAPI_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +var BroadcastAPI_serviceDesc = _BroadcastAPI_serviceDesc var _BroadcastAPI_serviceDesc = grpc.ServiceDesc{ ServiceName: "tendermint.rpc.grpc.BroadcastAPI", HandlerType: (*BroadcastAPIServer)(nil),